手写神经网络 （来源：《Python神经网络编程》）

3层神经网络（输入层，隐藏层，输出层）

权重更新公式的推导

1. 误差函数，对目标值和实际值之差的平方进行求和，此处对所有n个输出节点$$\frac{\partial E}{\partial w_{j,k}}=\frac{\partial }{\partial w_{j,k}}\sum _n{\left(t_n-o_n\right)}^2$$
2. 节点$n$的输出$o_n$只取决于连接到这个节点的连接，以此简化公式$$\frac{\partial E}{\partial w_{j,k}}=\frac{\partial }{\partial w_{j,k}}{\left(t_k-o_k\right)}^2$$
3. 使用链式法则$$\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 w_{j,k}}=-2\left(t_k-o_k\right)\cdot \frac{\partial o_k}{\partial w_{j,k}}$$
4. 因为$\frac{\partial o_k}{\partial w_{j,k}}=sigmoid\left({\sum }_j^{}{w}_{j,k}\cdot o_j\right)$并且$\frac{\partial }{\partial x}sigmoid\left(x\right)=sigmoid\left(x\right)\left(1-sigmoid\left(x\right)\right)$,进而可以推出$$\frac{\partial E}{\partial w_{j,k}}=-\left(e_j\right)\cdot sigmoid\left(\sum _i{w}_{j,k}\cdot o_i\right)\left(1-sigmoid\left(\sum _i{w}_{j,k}\cdot o_i\right)\right)\cdot o_i$$
5. 将上述公式集合学习率$\alpha$和矩阵运算$$\left(\begin{array}{ccc}\Delta w_{1,1}& \Delta w_{2,1}& ...\\ \Delta w_{1,2}& \Delta w_{2,2}& ...\\ ...& ...& ...\end{array}\right)=\left(\begin{array}{c}{E}_1\ast S_1\left(1-S_1\right)\\ E_2\ast S_2\left(1-S_2\right)\\ ...\end{array}\right)\cdot \left(\begin{array}{ccc}{O}_1& O_2& ...\end{array}\right)$$可以得到
   $$\Delta w_{j,k}=\alpha \cdot E_k\cdot O_k\left(1-O_k\right)\cdot O_j^T$$

import scipy.special
import numpy as np
import matplotlib.pyplot as plt

#神经网络定义
class NeuralNetwork:
    
    #初始化神经网络
    def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
        #网络节点设置
        self.inodes = inputnodes
        self.hnodes = hiddennodes
        self.onodes = outputnodes
        #权重初始化设置
        #输入层与隐藏层之间的权重
        self.wih = np.random.normal(0.0, pow(self.hnodes, -0.5), (self.hnodes, self.inodes))
        #隐藏层与输出层之间的权重
        self.who = np.random.normal(0.0, pow(self.onodes, -0.5), (self.onodes, self.hnodes))
        #学习率设置
        self.lr = learningrate
        #激活函数:sigmoid函数
        self.activation_function = lambda x: scipy.special.expit(x)
        
    #神经网络的训练函数
    def train(self, inputs_list, targets_list):
        #格式转化
        inputs = np.array(inputs_list, ndmin=2).T
        targets = np.array(targets_list, ndmin=2).T
        #计算出到达隐藏层的值
        hidden_inputs = np.dot(self.wih, inputs)
        #激活函数
        hidden_outputs = self.activation_function(hidden_inputs)
        #计算出到达输出层的值
        final_inputs = np.dot(self.who, hidden_outputs)
        #激活函数
        final_outputs = self.activation_function(final_inputs)
        #计算输出层误差
        output_errors = targets - final_outputs
        #计算隐藏层误差
        hidden_errors = np.dot(self.who.T, output_errors)
        #更新连接权重
        self.who += self.lr * np.dot((output_errors * final_outputs * (1.0 - final_outputs)), np.transpose(hidden_outputs))
        self.wih += self.lr * np.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), np.transpose(inputs))
            
    #查询函数
    def query(self, inputs_list):
        #格式转化
        inputs = np.array(inputs_list, ndmin=2).T
        #计算出到达隐藏层的值
        hidden_inputs = np.dot(self.wih, inputs)
        #激活函数
        hidden_outputs = self.activation_function(hidden_inputs)
        #计算出到达输出层的值
        final_inputs = np.dot(self.who, hidden_outputs)
        #激活函数
        final_outputs = self.activation_function(final_inputs)
        return final_outputs

#神经网络的节点配置
input_nodes = 784
hidden_nodes = 200
output_nodes = 10
#学习率配置
learning_rate = 0.1
#实例化神经网络
n = NeuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate)

#加载训练数据集
training_data_file = open("F:\Python\dataset\mnist\mnist_train.csv", 'r')
training_data_list = training_data_file.readlines()
training_data_file.close()
#加载测试数据集
test_data_file = open("F:\Python\dataset\mnist\mnist_test.csv", 'r')
test_data_list = test_data_file.readlines()
test_data_file.close()

#训练神经网络
#epoch配置
epochs = 5
for e in range(epochs):
    print("epoch:", e)
    for record in training_data_list:
        #数据格式转换
        all_values = record.split(',')
        #将数值范围从0~255缩小至0.01~1.0
        #之所以选择这个范围，是因为避免0值输入（会导致权重更新失败，等值输入和0值权重也会导致失败）
        #输出应该在激活函数能够生成的值的范围内，逻辑S函数不可能生成小于等于0或大于等于1的值
        #将训练目标值设置在有限范围之外，将会驱使产生越来越大的权重，导致网络饱和
        inputs = (np.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01
        targets = np.zeros(output_nodes) + 0.01
        targets[int(all_values[0])] = 0.99
        #训练
        n.train(inputs, targets)

#测试
scorecard = []
for record in test_data_list:
    #数据格式转换
        all_values = record.split(',')
        correct_label = int(all_values[0])
        inputs = (np.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01
        #通过NeuralNetwork的query函数预测结果
        outputs = n.query(inputs)
        label = np.argmax(outputs)
        if (label == correct_label):
            scorecard.append(1)
        else:
            scorecard.append(0)

#准确率计算
scorecard_array = np.asarray(scorecard)
print("performance = ", scorecard_array.sum() / scorecard_array.size)