代码来源: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))
原文地址:https://www.cnblogs.com/jiading/p/11621236.html
时间: 2024-10-08 08:56:23