神经网络模型及反向传播代码完全解析

代码来源：https://www.cnblogs.com/charlotte77/p/5629865.html
我对源代码做了大量的注解，希望有助于大家理解，请搭配原文食用

#coding:utf-8
#与文章 https://www.cnblogs.com/charlotte77/p/5629865.html 中的步骤搭配使用
#该模型具有泛用性，即可以添加任意多的隐藏层，但需要修改train部分代码来连接新加入的层和原有的层，使其能够正常地向前和向后传递
import random
import math
#   参数解释：
#   "pd_" ：偏导的前缀
#   "d_" ：导数的前缀
#   "w_ho" ：隐含层到输出层的权重系数索引
#   "w_ih" ：输入层到隐含层的权重系数的索引

class NeuralNetwork:
    LEARNING_RATE = 0.5#学习速度

    def __init__(self, num_inputs, num_hidden, num_outputs, hidden_layer_weights = None, hidden_layer_bias = None, output_layer_weights = None, output_layer_bias = None):
        #python中，放在类名下面的是类变量，可以通过类名直接调用；放在__init__()下面的是成员变量
        self.num_inputs = num_inputs#输入，是一个数组

        self.hidden_layer = NeuronLayer(num_hidden, hidden_layer_bias)##声明了隐藏层和输出层
        self.output_layer = NeuronLayer(num_outputs, output_layer_bias)

        self.init_weights_from_inputs_to_hidden_layer_neurons(hidden_layer_weights)#初始化输入层和隐藏层之间的权重
        self.init_weights_from_hidden_layer_neurons_to_output_layer_neurons(output_layer_weights)#声明了隐藏层和输出层之间的权重

    def init_weights_from_inputs_to_hidden_layer_neurons(self, hidden_layer_weights):
        #hidden_layer_weights是个数组
        weight_num = 0#用来在hidden_layer_weights数组中寻址的
        for h in range(len(self.hidden_layer.neurons)):#对于每一个隐藏层的节点
            for i in range(self.num_inputs):#对隐藏层节点一一对应
                if not hidden_layer_weights:#如果hidden_layer_weights数组为空的话，就随机初始化
                    self.hidden_layer.neurons[h].weights.append(random.random())
                else:#在第h个节点中加入权重
                    self.hidden_layer.neurons[h].weights.append(hidden_layer_weights[weight_num])
                weight_num += 1

    def init_weights_from_hidden_layer_neurons_to_output_layer_neurons(self, output_layer_weights):
        weight_num = 0
        for o in range(len(self.output_layer.neurons)):
            for h in range(len(self.hidden_layer.neurons)):
                if not output_layer_weights:
                    self.output_layer.neurons[o].weights.append(random.random())
                else:
                    self.output_layer.neurons[o].weights.append(output_layer_weights[weight_num])
                weight_num += 1

    def inspect(self):
        print('------')
        print('* Inputs: {}'.format(self.num_inputs))
        print('------')
        print('Hidden Layer')
        self.hidden_layer.inspect()
        print('------')
        print('* Output Layer')
        self.output_layer.inspect()
        print('------')

    def feed_forward(self, inputs):
        hidden_layer_outputs = self.hidden_layer.feed_forward(inputs)#得到隐藏层的输出
        return self.output_layer.feed_forward(hidden_layer_outputs)#返回输出层的输出

    def train(self, training_inputs, training_outputs):
        self.feed_forward(training_inputs)#先进行前向传播

        # 1. 输出神经元的值
        pd_errors_wrt_output_neuron_total_net_input = [0] * len(self.output_layer.neurons)#初始化输出数组
        for i in range(len(self.output_layer.neurons)):
            # ∂Etotal/∂net输出，是总的误差对该节点的输入求导
            pd_errors_wrt_output_neuron_total_net_input[i] = self.output_layer.neurons[i].calculate_pd_error_wrt_total_net_input(training_outputs[i])

        # 2. 隐含层神经元的值
        pd_errors_wrt_hidden_neuron_total_net_input = [0] * len(self.hidden_layer.neurons)
        for h in range(len(self.hidden_layer.neurons)):

            # dE/dyⱼ = Σ ∂E/∂zⱼ * ∂z/∂yⱼ = Σ ∂E/∂zⱼ * wᵢⱼ
            d_error_wrt_hidden_neuron_output = 0
            for o in range(len(self.output_layer.neurons)):
                #∂Etotal/∂net输出*输出层与隐藏层之间的weight，也即∂net输出/∂out隐藏，隐藏层目标节点对各个输出的节点的求导之和
                d_error_wrt_hidden_neuron_output += pd_errors_wrt_output_neuron_total_net_input[o] * self.output_layer.neurons[o].weights[h]

            #∂Etotal/∂net输出*∂net输出/∂out隐藏=输出层与隐藏层之间的weight * ∂out隐/∂net隐，用于更新隐藏层权重
            pd_errors_wrt_hidden_neuron_total_net_input[h] = d_error_wrt_hidden_neuron_output * self.hidden_layer.neurons[h].calculate_pd_total_net_input_wrt_input()

        # 3. 更新输出层权重系数
        for o in range(len(self.output_layer.neurons)):#更新每一个节点
            for w_ho in range(len(self.output_layer.neurons[o].weights)):#更新每一个节点的1每一个权重

                # ∂Eⱼ/∂wᵢⱼ =  ∂Etotal/∂net输出 * ∂net输出/∂wᵢⱼ
                pd_error_wrt_weight = pd_errors_wrt_output_neuron_total_net_input[o] * self.output_layer.neurons[o].calculate_pd_total_net_input_wrt_weight(w_ho)

                # Δw = α * ∂Eⱼ/∂wᵢ
                self.output_layer.neurons[o].weights[w_ho] -= self.LEARNING_RATE * pd_error_wrt_weight

        # 4. 更新隐含层的权重系数
        for h in range(len(self.hidden_layer.neurons)):
            for w_ih in range(len(self.hidden_layer.neurons[h].weights)):

                # ∂Eⱼ/∂wᵢ = ∂E/∂zⱼ * ∂zⱼ/∂wᵢ
                #，这里的Z表示隐藏层的输入
                pd_error_wrt_weight = pd_errors_wrt_hidden_neuron_total_net_input[h] * self.hidden_layer.neurons[h].calculate_pd_total_net_input_wrt_weight(w_ih)

                # Δw = α * ∂Eⱼ/∂wᵢ
                self.hidden_layer.neurons[h].weights[w_ih] -= self.LEARNING_RATE * pd_error_wrt_weight

    def calculate_total_error(self, training_sets):
        total_error = 0
        for t in range(len(training_sets)):
            training_inputs, training_outputs = training_sets[t]
            self.feed_forward(training_inputs)
            for o in range(len(training_outputs)):
                total_error += self.output_layer.neurons[o].calculate_error(training_outputs[o])
        return total_error

class NeuronLayer:##定义了神经网络模型的一层
    def __init__(self, num_neurons, bias):

        # 同一层的神经元共享一个截距项b，这是初始化，之后可以通过反向传播进行更新
        # 这种直接将偏置设计为节点的成员变量也挺好的，比较省事
        self.bias = bias if bias else random.random()

        self.neurons = []
        for i in range(num_neurons):
            self.neurons.append(Neuron(self.bias))#初始化layer，在数组中加入num_neurons个节点对象，并初始化一样的截距

    def inspect(self):#学到了！自下而上设计一个inspect函数，可以通过调用高级的inspect方法直接打印出所有的有用信息，便于调试
        print('Neurons:', len(self.neurons))
        for n in range(len(self.neurons)):
            print(' Neuron', n)
            for w in range(len(self.neurons[n].weights)):
                print('  Weight:', self.neurons[n].weights[w])
            print('  Bias:', self.bias)

    def feed_forward(self, inputs):
        outputs = []
        for neuron in self.neurons:
            outputs.append(neuron.calculate_output(inputs))#对每一个节点计算结果并将一层的结果储存到一个数组中
        return outputs

    def get_outputs(self):
        outputs = []
        for neuron in self.neurons:
            outputs.append(neuron.output)
        return outputs

class Neuron:#节点对象
    def __init__(self, bias):
        self.bias = bias#设置节点的偏置
        self.weights = []#空数组，等待插入，插入的顺序就是从上到下

    def calculate_output(self, inputs):
        self.inputs = inputs#这里的input是个数组
        self.output = self.squash(self.calculate_total_net_input())
        return self.output

    def calculate_total_net_input(self):#计算总的输入
        total = 0
        for i in range(len(self.inputs)):
            total += self.inputs[i] * self.weights[i]
        return total + self.bias#将计算结果加上偏置节点

    # 激活函数sigmoid
    def squash(self, total_net_input):
        return 1 / (1 + math.exp(-total_net_input))

    #∂Etotal/∂net=∂Etotal/∂out *∂out/∂net（用于输出层）
    def calculate_pd_error_wrt_total_net_input(self, target_output):
        return self.calculate_pd_error_wrt_output(target_output) * self.calculate_pd_total_net_input_wrt_input();

    # 每一个神经元的误差是由平方差公式计算的
    #这是一个计算该节点误差的通用公式（用于任何层）
    def calculate_error(self, target_output):
        return 0.5 * (target_output - self.output) ** 2

    #∂Etotal/∂out，是总的误差对输出层的节点求导（用于输出层）
    def calculate_pd_error_wrt_output(self, target_output):
        return -(target_output - self.output)

    #∂out/∂net，是该节点的输出对该节点的输入求导（用于任何层）
    def calculate_pd_total_net_input_wrt_input(self):
        return self.output * (1 - self.output)

    #∂net/∂w,net是下一层的输入，w是这个过程中的参数，这里的input指的就是输入到该节点的值（用于要更新的层）
    def calculate_pd_total_net_input_wrt_weight(self, index):
        return self.inputs[index]


# 文中的例子:

nn = NeuralNetwork(2, 2, 2, hidden_layer_weights=[0.15, 0.2, 0.25, 0.3], hidden_layer_bias=0.35, output_layer_weights=[0.4, 0.45, 0.5, 0.55], output_layer_bias=0.6)
#2个输入数据，2个隐藏节点，2个输出节点，初始化了输入节点和隐藏节点之间的权重为[0.15, 0.2, 0.25, 0.3]，设置
for i in range(10000):#重复训练，一次训练是一次正向传播+一次反向传播
    #一次反向传播相当于对每个参数做了一次梯度下降，但是一次梯度下降显然不能达到最优化结果，所以需要多次运行
    #对于我们这个非常简单的问题，1000次运行可以达到0.0058的误差率，10000次就能达到10的-5次方的地步了
    nn.train([0.05, 0.1], [0.01, 0.09])#输入训练集的x和y向量
    print(i, round(nn.calculate_total_error([[[0.05, 0.1], [0.01, 0.09]]]), 9))


#另外一个例子，可以把上面的例子注释掉再运行一下:

# training_sets = [
#     [[0, 0], [0]],
#     [[0, 1], [1]],
#     [[1, 0], [1]],
#     [[1, 1], [0]]
# ]

# nn = NeuralNetwork(len(training_sets[0][0]), 5, len(training_sets[0][1]))
# for i in range(10000):
#     training_inputs, training_outputs = random.choice(training_sets)
#     nn.train(training_inputs, training_outputs)
#     print(i, nn.calculate_total_error(training_sets))