Python神经网络编程

神经元

生物学中的神经元是如何工作的？它接收一个生物电输入，然后输出另一个电信号。但关键是，它的输入和输出是非线性的。接收到电信号后，神经元不会立即反应，而是会抑制输入，直到输入增强，强大到可以触发输出。函数图像类似这样：

image

这就是sigmoid激活函数，也是比较典型的一个神经元的输出。

S(x)=\frac{1}{1+e^{-x}}

神经网络

image

神经网络就是把很多个神经元连接在一起。后一层每个神经元的输入都是前一层所有神经元的输出的加权和。

正向传播

第一层仅表示输入信号。也就是说，输入节点不对输入值应用激活函数。假设输入节点为784个。

第二层我们设计成200个节点，每个节点都与前一层相连，那么有784x200个参数，是一个矩阵。用矩阵点乘计算加权和，然后经过sigmoid函数处理就得到第二层的输出。以后每一层都是如此。

这个重复的过程可以总结成下面的公式：

O = S(W \cdot I)

其中 I 表示输入， W 是参数， O 表示输出。

损失函数

损失函数就是误差函数，损失函数的值越大，说明神经网络的误差越大；损失函数的值越小，说明神经网络的误差越小。

结果与目标值相减，即可得到误差。例如第k个输出节点的误差：

e_k = t_k - o_k

损失函数是所有输出节点误差的和，但是我们不能单纯的将所有输出节点的误差相加，因为误差有正有负，会相互抵消的，所以我们使用平均平方差作为误差函数：

E=\frac{1}{n} \sum_{k=1}^n\left(t_k - o_k\right)^2

反向传播

这一节里有很多符号，有必要先明确一下。从节点j连接到节点k， w_{j, k} 表示参数， o_j 表示节点j的输出， o_k 表示节点k的输出。注意： o_j 和 o_k 不在同一层。

现在我们需要根据误差，反向更新神经网络的参数。例如我们现在更新参数 w_{j, k} ，可以把损失函数对 w_{j, k} 求偏导数：

\frac{\partial E}{\partial w_{j, k}}=\frac{\partial E}{\partial o_k} \cdot \frac{\partial o_k}{\partial w_{j, k}}

其中 \frac{\partial E}{\partial o_k} ，因为对第k个输出求偏导，所以其他累加项都可以看作常数，求导为零。并且我们忽略偏导数前面的常数，因为所有参数都缩小常数倍对结果没有影响，所以有：

\frac{\partial E}{\partial o_k}=-\left(t_k-o_k\right)=-e_k

对sigmoid函数求导：

S^{\prime}(x)=\frac{e^{-x}}{\left(1+e^{-x}\right)^2}=S(x)(1-S(x))

所以有：

\frac{\partial o_k}{\partial w_{j, k}} =\frac{\partial}{\partial w_{j, k}} S\left(\Sigma_j w_{j, k} \cdot o_j\right)=S\left(\Sigma_j w_{j, k} \cdot o_j\right)\left(1-S\left(\Sigma_j w_{j, k} \cdot o_j\right)\right) \cdot o_j

整理上述内容可得：

\frac{\partial E}{\partial w_{j, k}}=-e_k \cdot S\left(\Sigma_j w_{j, k} \cdot o_j\right)\left(1-S\left(\Sigma_j w_{j, k} \cdot o_j\right)\right) \cdot o_j

根据偏导数的几何意义，偏导数越大说明调整 w_{i j} 对减小总体误差E的帮助越大。那么我们让对减小总体误差E的帮助越大的参数调整的时候多调整一些，帮助小的则小调整一些：

\text { new } w_{j, k}=\text { old } w_{j, k}-\alpha \cdot \frac{\partial E}{\partial w_{j, k}}

其中 \alpha 是学习率。

\text { new } w_{j, k}=\text { old } w_{j, k}+\Delta w_{j, k}

其中：

\Delta w_{j, k} = \alpha \cdot e_k \cdot S\left(\Sigma_j w_{j, k} \cdot o_j\right)\left(1-S\left(\Sigma_j w_{j, k} \cdot o_j\right)\right) \cdot o_j

这是一个参数的计算公式，我们要把所有的参数都更新，要转化成矩阵的形式：

\Delta W_{j, k}=\alpha \cdot E_k \cdot O_k\left(1-O_k\right) \cdot O_j^{\top}

这个公式看起来有些怪，或许表达方式有些问题，但一时也没有比较好的表达方式，需要一些时间理解。 \Delta W_{j, k} 是j节点和k节点所在层之间的参数矩阵； E_k 是k节点所在层的误差； O_k 是k节点所在层的输出； O_j 是j节点所在层的输出。或许这个公式把j,k去掉会好一点：

\Delta W=\alpha \cdot E \cdot O\left(1-O\right) \cdot I^{\top}

输入值

仔细观察下图的S激活函数。你可以发现，如果输入变大，激活函数就会变得非常平坦。

image

这意味着，我们应该尽量保持小的输入。计算机处理非常小或非常大的数字时，可能会丧失精度，因此，使用非常小的值也会出现问题。

一个好的建议是将输入范围控制在0.0到1.0。输入为0，更新参数表达式就会等于0，从而造成学习能力的丧
失，因此在某些情况下，我们会将输入加上一个小小的偏移，如0.01，避免输入0带来麻烦。

目标值

sigmoid激活函数只能输出0到1之间的数，永远达不到0，也永远达不到1。如果我们的目标值超出这个范围，那么会使权重无限增加，以获得越来越大的输出，直到权重超出计算机所能表示的极限。因此我们可以将目标值范围设置为0.01～0.99。

随机初始权重

与输入和输出一样，同样的道理也适用于初始权重的设置。由于大的初始权重会造成大的信号传递给激活函数，导致网络饱和，从而降低网络学习到更好的权重的能力，因此应该避免大的初始权重值。

数学家所得到的经验规则是，在一个节点传入链接数量平方根倒数的大致范围内随机采样。其核心思想是，如果很多信号进入一个节点，并且这些信号的表现已经不错了，那么在对这些信号进行组合并应用激活函数时，权重应该支持保持这些表现良好的信号。

image

import numpy
import sys
from torchvision import datasets

def sigmoid(x):
  return 1 / (1 + numpy.exp(-x))

class NeuralNetwork:
    def __init__(self) :
        self.weights_h1 = numpy.random.normal(0.0, pow(784, -0.5), (200, 784))      
        self.weights_o1 = numpy.random.normal(0.0, pow(200, -0.5), (10, 200))

        self.learning_rate = 0.1

    # train the neural network
    def train(self, inputs_list, targets_list) :
        # convert inputs list to 2d array
        inputs = numpy.array(inputs_list, ndmin=2).T
        targets = numpy.array(targets_list, ndmin=2).T

        # calculate signals into hidden layer
        hidden_inputs = numpy.dot(self.weights_h1, inputs)
        # print(inputs.shape,self.weights_h1.shape,hidden_inputs.shape)
        # calculate the signals emerging from hidden layer
        hidden_outputs = sigmoid(hidden_inputs)

        # calculate signals into final output layer
        final_inputs = numpy.dot(self.weights_o1, hidden_outputs)
        # calculate the signals emerging from final output layer
        final_outputs = sigmoid(final_inputs)

        # output layer error is the (target - actual) 
        output_errors = targets - final_outputs
        # hidden layer error is the output_errors, split by weights, recombined at hidden nodes
        hidden_errors = numpy.dot(self.weights_o1.T, output_errors)

        # update the weights for the links between the hidden and output layers
        self.weights_o1 += self.learning_rate * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs))

        # update the weights for the links between the input and hidden layers
        self.weights_h1 += self.learning_rate * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs))


    def query(self, inputs_list) :
        # convert inputs list to 2d array
        inputs = numpy.array(inputs_list, ndmin = 2).T

        # calculate signals into hidden layer
        hidden_inputs = numpy.dot(self.weights_h1, inputs)
        # calculate the signals emerging from hidden layer 
        hidden_outputs = sigmoid(hidden_inputs)

        # calculate signals into final output layer
        final_inputs = numpy.dot(self.weights_o1, hidden_outputs)
        # calculate the signals emergin from final output layer
        final_outputs = sigmoid(final_inputs)

        return final_outputs 
    
# create instance of neural network
n = NeuralNetwork()

# load the mnist training data CSV file into a list
dataset1 = datasets.MNIST('../data', train=True, download=True)
dataset2 = datasets.MNIST('../data', train=False, download=True)
# train the neural network
# epochs is the number of times the training data set is used for training
epochs = 5

for e in range(epochs):
    print('epochs: {}'.format(e))
    for record in dataset1:
        # scale and shift the inputs
        inputs = (numpy.array(record[0],numpy.float32).ravel() / 255.0 * 0.99) + 0.01
        # create the target output values (all 0.01, except the desired label which is 0.99)
        targets = numpy.zeros(10) + 0.01
        # all_values[0] is the target label for this record
        targets[int(record[1])] = 0.99
        n.train(inputs, targets)
        

# test the neural network
# scorecard for how well the network performs, initially empty 
scorecard = []

# go through all the records in the test data set
for record in dataset2:
    # correct answer is first value
    correct_label = int(record[1])
    # scale and shift the inputs
    inputs = (numpy.array(record[0],numpy.float32).ravel() / 255.0 * 0.99) + 0.01
     # query the network
    outputs = n.query(inputs)
    # the index of the highest value corresponds to the label 
    label = numpy.argmax(outputs)
    # append correct or incorrect to list
    if (label == correct_label):
        # network's answer matches correct answer, add 1 to scorecard
        scorecard.append(1)
    else:# network's answer doesn't match correct answer, add 0 to scorecard
        scorecard.append(0)

# calculate the performance score, the fraction of correct answers
scorecard_array = numpy.asarray(scorecard)
print('Accuracy: {}/{} ({:.0f}%)'.format(
     scorecard_array.sum(), scorecard_array.size,
        100. * scorecard_array.sum() / scorecard_array.size))
posted @ 2025/02/22 00:52:37