ソースコード：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))