介绍
在“运行神经网络”一章中，我们用 Python 代码编写了一个名为“神经网络”的类。此类的实例是具有三层的网络。当我们实例化此类的 ANN 时，层之间的权重矩阵是自动随机选择的。甚至可以在某些输入上运行这样的 ANN，但自然而然地，除了用于测试目的之外，它没有多大意义。这样的人工神经网络不能提供正确的分类结果。事实上，分类结果并没有适应预期的结果。权重矩阵的值必须根据分类任务进行设置。我们需要改进权重值，这意味着我们必须训练我们的网络。为了训练它，我们必须在train方法。如果您不了解反向传播并想了解它，我们建议您返回神经网络中的反向传播一章。
在了解并希望理解反向传播之后，您就可以完全理解该train方法了。
train使用输入向量和目标向量调用该方法。向量的形状可以是一维的，但它们会自动变成正确的二维形状，即reshape(input_vector.size, 1)和reshape(target_vector.size, 1)。之后我们调用run方法来获取网络的结果output_vector_network = self.run(input_vector)。此输出可能与target_vector.?我们计算出output_error减去网络的输出output_vector_network从target_vector。
从scipy.special import expit as activation_function from scipy.stats import truncnorm导入numpy 作为 np
def truncated_normal ( mean = 0 , sd = 1 , low = 0 , upp = 10 ):
return truncnorm (
( low - mean ) / sd , ( upp - mean ) / sd , loc = mean , scale = sd )
类 神经网络：
def __init__ ( self ,
no_of_in_nodes ,
no_of_out_nodes ,
no_of_hidden_??nodes ,
learning_rate ):
self 。no_of_in_nodes = no_of_in_nodes
self 。no_of_out_nodes = no_of_out_nodes
self 。no_of_hidden_??nodes = no_of_hidden_??nodes
self 。learning_rate = learning_rate
self . create_weight_matrices ()
def create_weight_matrices ( self ):
""" 一种初??始化神经网络权重矩阵的方法"""
rad = 1 / np . SQRT （自我。no_of_in_nodes ）
X = truncated_normal （平均值= 0 ， SD = 1 ， 低= -弧度， UPP =弧度）
自我。weights_in_hidden = X 。房车（（自我。no_of_hidden_??nodes ，
self 。no_of_in_nodes ))
rad = 1 / np 。SQRT （自我。no_of_hidden_??nodes ）
X = truncated_normal （平均值= 0 ， SD = 1 ， 低= -弧度， UPP =弧度）
自我。weights_hidden_??out = X 。RVS （（自我。no_of_out_nodes ，
自我。no_of_hidden_??nodes ))
def train ( self , input_vector , target_vector ):
"""
input_vector 和 target_vector 可以是元组、列表或 ndarrays
"""
# 确保向量具有正确的形状
input_vector = np . 数组（input_vector ）
input_vector = input_vector 。reshape ( input_vector . size , 1 )
target_vector = np 。数组（target_vector ）。重塑（目标向量。大小， 1 ）
output_vector_hidden = activation_function （自我。weights_in_hidden @ input_vector ）
output_vector_network = activation_function （自我。weights_hidden_??out @ output_vector_hidden ）
output_error = target_vector - output_vector_network
tmp = output_error * output_vector_network * ( 1.0 - output_vector_network )
self 。weights_hidden_??out += self 。learning_rate * ( tmp @ output_vector_hidden . T )
# 计算隐藏错误：
hidden_??errors = self . weights_hidden_??out 。? @ output_error
＃更新的权重：
TMP = hidden_??errors * output_vector_hidden * （1.0 - output_vector_hidden ）
自我。weights_in_hidden += self 。learning_rate * ( tmp @ input_vector . T )
def run ( self , input_vector ):
"""
使用输入向量 'input_vector' 运行网络
。'input_vector' 可以是元组、列表或 ndarray
"""
# 确保 input_vector 是列向量：
input_vector = np 。数组（input_vector ）
input_vector = input_vector 。reshape ( input_vector . size , 1 )
input4hidden = activation_function ( self . weights_in_hidden @ input_vector )
output_vector_network = activation_function ( self . weights_hidden_??out @ input4hidden )
return output_vector_network
DEF 评估（自， 数据， 标签）：
“”，”
计数的频率的实际结果对应于
目标的结果。
结果被认为是正确的，如果该索引
的最大值对应于与索引‘1’
中one-hot 表示，
例如
res = [0.1, 0.132, 0.875]
labels[i] = [0, 0, 1]
"""
Corrects , wrongs = 0 , 0
for i in range ( len ( data)):
res = self 。运行（数据[ i ]）
res_max = res 。argmax ()
如果 res_max == 标签[ i ] 。argmax ():
更正 += 1
else :
错误 += 1
返回 更正, 错误
输出：
覆盖neural_networks1.py
我们假设您将前面的代码保存在一个名为neural_networks1.py.?在接下来的示例中，我们将在此名称下使用它。
为了测试这个神经网络类，我们需要训练和测试数据。我们使用make_blobsfrom创建数据sklearn.datasets。
从 sklearn.datasets 导入 make_blobs
N_SAMPLES次 = 500个
blob_centers = （[ 2 ， 6 ]， [ 6 ， 2 ]， [ 7 ， 7 ]）
n_classes = LEN （blob_centers ）
数据， 标签 = make_blobs （N_SAMPLES次= N_SAMPLES次，
中心= blob_centers ，
random_state = 7 ）
让我们可视化之前创建的数据：
导入 matplotlib.pyplot 作为 plt
颜色 = ( 'green' , 'red' , "yellow" )
fig , ax = plt . 子图()
用于 n_class 在 范围（n_classes ）：
斧。分散（数据[标签== n_class ][:, 0 ],
数据[标签== n_class ][:, 1 ],
c =颜色[ n_class ],
s = 40 ,
label = str ( n_class )）
标签被错误地表示。它们在一维向量中：
标签[: 7 ]
输出：
数组([2, 2, 1, 0, 2, 0, 1])
我们需要每个标签的单热表示。所以标签表示为
| 标签 | One-Hot 表示 |
|---|---|
| 0 | (1, 0, 0) |
| 1 | (0, 1, 0) |
| 2 | (0, 0, 1) |
我们可以使用以下命令轻松更改标签：
将 numpy 导入为 np
标签 = np 。人气指数（n_classes ） == 标签。重塑（标签。大小， 1 ）
标签 = 标签。astype ( np . float64 )
标签[: 7 ]
输出：
数组([[0., 0., 1.],
[0., 0., 1.],
[0., 1., 0.],
[1., 0., 0.],
[0., 0., 1.],
[1., 0., 0.],
[0., 1., 0.]])
我们现在准备好创建一个训练和一个测试数据集：
从 sklearn.model_selection 导入 train_test_split
res = train_test_split ( data , labels ,
train_size = 0.8 ,
test_size = 0.2 ,
random_state = 42 )
train_data , test_data , train_labels , test_labels = res
train_labels [: 10 ]
输出：
数组([[0., 0., 1.],
[0., 1., 0.],
[1., 0., 0.],
[0., 0., 1.],
[0., 0., 1.],
[1., 0., 0.],
[0., 1., 0.],
[1., 0., 0.],
[1., 0., 0.],
[0., 0., 1.]])
我们创建了一个具有两个输入节点和三个输出节点的神经网络。每个类一个输出节点：
从 neural_networks1 导入 NeuralNetwork
simple_network = NeuralNetwork （no_of_in_nodes = 2 ，
no_of_out_nodes = 3 ，
no_of_hidden_??nodes = 5 ，
learning_rate = 0.3 ）
下一步包括使用我们的训练样本data和labels来自我们的训练样本来训练我们的网络：
对于 我 在 范围（LEN （train_data ））：
simple_network 。火车( train_data [ i ], train_labels [ i ])
我们现在必须检查我们的网络学习得如何。为此，我们将使用评估函数：
simple_network 。评估（train_data ， train_labels ）
输出：
(391, 9)
带有偏置节点的神经网络
我们在“简单神经网络”一章中已经介绍了偏置节点的基本思想和必要性，其中我们专注于非常简单的线性可分数据集。我们了解到偏置节点是一个总是返回相同输出的节点。换句话说：它是一个不依赖于某些输入并且没有任何输入的节点。偏置节点的值通常设置为 1，但也可以设置为其他值。除了零，出于明显的原因，这毫无意义。如果一个神经网络在给定的层中没有偏置节点，那么当特征值为0时，它将无法在下一层产生与0不同的输出。 一般来说，我们可以说偏置节点用于增加网络的灵活性以适应数据。通常，每一层不会有超过一个偏置节点。唯一的例外是输出层，因为向该层添加偏置节点是没有意义的。
下图显示了我们之前使用的三层神经网络的前两层：
我们可以从这张图中看到，我们的权重矩阵需要一个额外的列，并且必须将偏差值添加到输入向量中：
同样，隐藏层和输出层之间的权重矩阵的情况类似：
对应的矩阵也是如此：
以下是一个完整的 Python 类，使用偏置节点实现我们的网络：
进口 numpy的 是 NP
从 scipy.stats 导入 truncnorm
从 scipy.special 进口 expit 为 activation_function
def truncated_normal ( mean = 0 , sd = 1 , low = 0 , upp = 10 ):
return truncnorm (
( low - mean ) / sd , ( upp - mean ) / sd , loc = mean , scale = sd )
类 神经网络：
def __init__ ( self ,
no_of_in_nodes ,
no_of_out_nodes ,
no_of_hidden_??nodes ,
learning_rate ,
bias = None ):
self 。no_of_in_nodes = no_of_in_nodes
self 。no_of_hidden_??nodes = no_of_hidden_??nodes
self 。no_of_out_nodes = no_of_out_nodes
self 。learning_rate = learning_rate
self . 偏见 = 偏见
自我。create_weight_matrices ()
def create_weight_matrices ( self ):
""" 一种
用可选偏置节点
初始化神经网络权重矩阵的方法""" bias_node = 1 if self . 偏置 否则 0
rad = 1 / np 。sqrt ( self . no_of_in_nodes + bias_node )
X = truncated_normal ( mean = 0 , sd = 1 , low =- rad , upp = rad )
自我。weights_in_hidden = X 。rvs (( self . no_of_hidden_??nodes ,
self . no_of_in_nodes + bias_node ))
rad = 1 / np 。sqrt ( self . no_of_hidden_??nodes + bias_node )
X = truncated_normal ( mean = 0 , sd = 1 , low =- rad , upp = rad )
自我。weights_hidden_??out = X 。RVS （（自我。no_of_out_nodes ，
自我。no_of_hidden_??nodes + bias_node ））
def train ( self , input_vector , target_vector ):
""" input_vector 和 target_vector 可以是元组、列表或 ndarray """
# 确保向量具有正确的形状
input_vector = np . 数组（input_vector ）
input_vector = input_vector 。reshape ( input_vector . size , 1 )
如果 self 。偏置:
# 在 input_vector 的末尾添加偏置节点
input_vector = np . 串连（ （input_vector ， [[自我。偏压]]） ）
target_vector = NP. 数组（target_vector ）。重塑（目标向量。大小， 1 ）
output_vector_hidden = activation_function （自我。weights_in_hidden @ input_vector ）
如果 自我。偏差：
output_vector_hidden = np 。串连（ （output_vector_hidden ， [[自我。偏压]]） ）
output_vector_network = activation_function （自我。weights_hidden_??out @ output_vector_hidden ）
output_error = target_vector - output_vector_network
# 更新权重：
tmp = output_error * output_vector_network * ( 1.0 - output_vector_network )
self . weights_hidden_??out += self 。learning_rate * ( tmp @ output_vector_hidden . T )
# 计算隐藏错误：
hidden_??errors = self . weights_hidden_??out 。? @ output_error
＃更新的权重：
TMP = hidden_??errors * output_vector_hidden * （1.0 - output_vector_hidden ）
如果 自我。偏差:
x = ( tmp @input_vector . T )[: - 1 ,:] # 最后一行被截断，
否则:
x = tmp @ input_vector .?
自我。weights_in_hidden += self 。学习率 * x
def run ( self , input_vector ):
"""
使用输入向量 'input_vector' 运行网络
。'input_vector' 可以是元组、列表或 ndarray
"""
# 确保 input_vector 是列向量：
input_vector = np 。数组（input_vector ）
input_vector = input_vector 。reshape ( input_vector . size , 1 )
如果 self 。bias :
# 在 inpuy_vector 的末尾添加偏置节点
输入向量 = np 。连接( ( input_vector , [[ 1 ]]) )
input4hidden = activation_function ( self . weights_in_hidden @ input_vector )
如果 self 。偏差：
input4hidden = np 。连接( ( input4hidden , [[ 1 ]]) )
output_vector_network = activation_function ( self .weights_hidden_??out @ input4hidden )
返回 output_vector_network
DEF 评估（自， 数据， 标签）：
校正， 过错 = 0 ， 0
为 我 在 范围（len个（数据））：
RES = 自我。运行（数据[ i ]）
res_max = res 。argmax ()
如果 res_max == 标签[ i ] 。argmax ():
更正 += 1
否则：
错误 += 1
返回 更正， 错误
我们可以再次使用我们之前创建的类来测试我们的分类器：
从 neural_networks2 进口 NeuralNetwork
simple_network = NeuralNetwork （no_of_in_nodes = 2 ，
no_of_out_nodes = 3 ，
no_of_hidden_??nodes = 5 ，
learning_rate = 0.1 ，
偏压= 1 ）
对于 我 在 范围（LEN （train_data ））：
simple_network 。火车( train_data [ i ], train_labels [ i ])
simple_network 。评估（train_data ， train_labels ）
输出：
(301, 99)
锻炼
我们在“数据创建”一章strange_flowers.txt中在文件夹中创建了一个文件data。创建一个神经网络来对“花”进行分类：
数据如下所示：
0.000,240.000,100.000,3.020
253.000,99.000,13.000,3.875
202.000,107.000,6.000,4.1
186.000,84.000,6.000,4.068
0.000,244.000,103.000,3.386
0.000,246.000,98.000,2.955
241.000,103.000,3.000,4.049
236.000,104.000,12.000,3.087
244.000,109.000,1.000,3.111
253.000,97.000,8.000,3.752
231.000,92.000,1.000,3.488
0.000,250.000,103.000,3.379解决方案：
将 numpy 导入为 np
c = np 。loadtxt ( "data/strange_flowers.txt" , delimiter = " " )
数据 = c [:, : - 1 ]
n_classes = 数据。形状[ 1 ]
标签 = c [:, - 1 ]
数据[: 5 ]
输出：
数组([[255., 104., 12., 4.04],
[241. , 102. , 2. , 3.6 ],
[250. , 109. , 6. , 3.53],
[249. , 89. , 3. , 3.79],
[253. , 106. , 0. , 3.53]])
标签 = np 。人气指数（1 ， n_classes + 1 ） == 标签。重塑（标签。大小， 1 ）
标签 = 标签。astype ( np . float64 )
标签[: 3 ]
输出：
数组([[1., 0., 0., 0.],
[1., 0., 0., 0.],
[1., 0., 0., 0.]])
我们需要缩放我们的数据，因为未缩放的输入数据会导致学习过程缓慢或不稳定。我们将使用scale来自的函数sklearn/preprocessing。它沿任何轴标准化数据集。它以均值和组件方式为中心，以单位方差为中心。
从 sklearn 导入 预处理
数据 = 预处理。规模（数据）
数据[：5 ]
数据。形状
标签。形状
输出：
(795, 4)
从 sklearn.model_selection 导入 train_test_split
res = train_test_split ( data , labels ,
train_size = 0.8 ,
test_size = 0.2 ,
random_state = 42 )
train_data , test_data , train_labels , test_labels = res
train_labels [: 10 ]
输出：
数组([[0., 1., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 1., 0., 0.],
[1., 0., 0., 0.],
[1., 0., 0., 0.],
[0., 0., 1., 0.],
[0., 1., 0., 0.]])
从 neural_networks2 进口 NeuralNetwork
simple_network = NeuralNetwork （no_of_in_nodes = 4 ，
no_of_out_nodes = 4 ，
no_of_hidden_??nodes = 20 ，
learning_rate = 0.3 ）
对于 我 在 范围（LEN （train_data ））：
simple_network 。火车( train_data [ i ], train_labels [ i ])
simple_network 。评估（train_data ， train_labels ）
输出：
(618, 18)