1.基本组成
输入层（特征向量）
隐藏层
输出层
每层由神经元或单元组成；
输入层由训练集的样本特征向量传入；
经过连接点的权重传入下一层，上一层的加权求和，然后根据非线性方程转化为下一层的输入；
对于多层神经网络，理论上如果有足够多的隐藏层和足够多的的训练样本，可以拟合出任意方程
2.设计神经网络结构
包括确定网络层数，每层的节点个数；
特征向量在被传入输入层之前要进行标准化到0-1之间，为了加速训练过程；
神经网络既可以用来解决分类问题，也可以解决回归问题；
输出层的单元数十类别的个数；
一般通过交叉验证的方法确定隐藏层的个数和节点的个数
3.反向传播
通过迭代处理训练集中的样本；
对比经过神经网络后输出层的预测值和真实值；
从输出层经过隐藏层反向传播到输入层，以最小化误差更新连接权重
4.算法过程
初始化权重和偏置：随机初始化在-1到1之间的值，每个节点有一个偏向；
每个训练样本执行以下步骤：
有输入层前向传播，根据初始化的参数及激活函数，计算出节点的输出，直到输出层；
反向传播计算误差，更新权重和偏置；
终止条件：权重的更新低于某个阈值、预测的错误率低于某个阈值、达到预设的循环次数
5.代码及注释
# -*- coding: utf-8 -*-
from neural_network import NeuralNetwork
def run_main():
"""
主函数
"""
# 输入层：2个节点
# 隐含层：2个节点
# 输出层：2个节点
# 初始化各层的权重和偏置
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)
# 训练网络（这里只用一个样本作为训练作为示例）
sample_input = [0.05, 0.1]
sample_output = [0.01, 0.99]
# 迭代10000次训练网络
print('训练神经网络')
for i in range(10000):
# 提供输入和输出
nn.fit(sample_input, sample_output)
# 输出误差
# 会看到随着迭代的增多，误差是变小的
print('{}次迭代，误差：{}'.format(i + 1, nn.calculate_total_error([[sample_input, sample_output]])))
# 测试网络（这里选取一个和训练样本接近的样本）
print('测试神经网络:')
test_sample = [0.049, 0.11]
print('训练样本:', sample_input, sample_output)
print()
print('输入样本:', test_sample)
print('预测结果:', nn.feed_forward(test_sample))
if __name__ == '__main__':
run_main()
neural_network.py
# -*- coding: utf-8 -*-
import random
import math
#
# "pd_" : 偏导数
# "d_" : 导数
# "_wrt_" : "with respect to" 对于变量
# "w_ho" : 由隐含层(h)到输出层(o)的weights的索引
# "w_ih" : 由输入层(i)到隐含层(h)的weights的索引
class NeuralNetwork(object):
"""
神经网络类
"""
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 # 输出层神经元偏置
):
# 输入层
self.num_inputs = num_inputs
# 隐含层
self.hidden_layer = Layer(num_hidden, hidden_layer_bias)
# 输出层
self.output_layer = Layer(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):
"""
初始化从输入层到隐含层的权重
"""
weight_num = 0
for h in range(len(self.hidden_layer.neurons)):
for i in range(self.num_inputs):
if not hidden_layer_weights:
self.hidden_layer.neurons[h].weights.append(random.random())
else:
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('* 输入层: {}'.format(self.num_inputs))
print('------')
print('隐含层')
self.hidden_layer.inspect()
print('------')
print('* 输出层')
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 fit(self, training_inputs, training_outputs):
"""
根据输入输出训练网络
"""
# 前向传播
self.feed_forward(training_inputs)
# 1. 输出层神经元error计算
pd_errors_wrt_output_neuron_total_net_input = [0] * len(self.output_layer.neurons)
for o in range(len(self.output_layer.neurons)):
# 求偏导
pd_errors_wrt_output_neuron_total_net_input[o] = \
self.output_layer.neurons[o].calculate_pd_error_wrt_total_net_input(training_outputs[o])
# 2. 隐含层神经元erro计算
pd_errors_wrt_hidden_neuron_total_net_input = [0] * len(self.hidden_layer.neurons)
for h in range(len(self.hidden_layer.neurons)):
d_error_wrt_hidden_neuron_output = 0
for o in range(len(self.output_layer.neurons)):
d_error_wrt_hidden_neuron_output += \
pd_errors_wrt_output_neuron_total_net_input[o] * self.output_layer.neurons[o].weights[h]
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)):
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)
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)):
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)
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 Layer:
"""
网络层类
"""
def __init__(self, num_neurons, bias):
# 同一层神经元的偏置都一致
self.bias = bias if bias else random.random()
self.neurons = []
for i in range(num_neurons):
self.neurons.append(Neuron(self.bias))
def inspect(self):
"""
信息输出
"""
print('神经元:', len(self.neurons))
for n in range(len(self.neurons)):
print(' 神经元', n)
for w in range(len(self.neurons[n].weights)):
print(' 权重:', self.neurons[n].weights[w])
print(' 偏置:', 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(object):
"""
神经元节点
"""
def __init__(self, bias):
self.bias = bias
self.weights = []
def calculate_output(self, inputs):
"""
计算输出
"""
self.inputs = inputs
# 激活函数
self.output = self.activate(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
def activate(self, total_net_input):
"""
逻辑回归激活函数
"""
return 1 / (1 + math.exp(-total_net_input))
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();
# The error for each neuron is calculated by the Mean Square Error method:
def calculate_error(self, target_output):
"""
计算每个神经元节点的误差（均方误差)
"""
return 0.5 * (target_output - self.output) ** 2
def calculate_pd_error_wrt_output(self, target_output):
"""
计算相对于输出的误差偏导数
"""
return -(target_output - self.output)
def calculate_pd_total_net_input_wrt_input(self):
"""
计算相对于输入的总体偏导数
"""
return self.output * (1 - self.output)
def calculate_pd_total_net_input_wrt_weight(self, index):
"""
计算相对于权重的整体输入的偏导数
"""
return self.inputs[index]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
