反向传播法其实是神经网络的底子了,比如说都让其均值为0等

 

日前在看深度学习的事物,一初阶看的吴恩达的UFLDL教程,有中文版就一贯看了,后来发现有点地方一连不是很显著,又去看英文版,然后又找了些资料看,才察觉,普通话版的译员在翻译的时候会对简易的公式推导过程举办补偿,不过补充的又是错的,难怪觉得有问题。反向传播法其实是神经网络的基础了,不过众三个人在学的时候总是会遇上有的题目,或者看到大篇的公式觉得似乎很难就退缩了,其实不难,就是一个链式求导法则反复用。如若不想看公式,可以一直把数值带进去,实际的测算一下,体会一下这一个进度之后再来推导公式,那样就会以为很简单了。

5.

  说到神经网络,我们收看那几个图应该不生疏:

 学科中的一些术语:

图片 1

  Model representation:

 

  其实就是指学习到的函数的表明方式,可以用矩阵表示。

  那是百里挑一的三层神经网络的着力构成,Layer L1是输入层,Layer
L2是带有层,Layer
L3是带有层,我们今日手里有一堆数据{x1,x2,x3,…,xn},输出也是一堆数据{y1,y2,y3,…,yn},现在要她们在蕴涵层做某种变换,让你把多少灌进去后收获你指望的出口。借使您愿意您的出口和原来输入一样,那么就是最广泛的自编码模型(Auto-Encoder)。可能有人会问,为何要输入输出都相同吧?有怎样用啊?其实选择挺广的,在图像识别,文本分类等等都会用到,我会专门再写一篇Auto-Encoder的篇章来注解,包含一些变种之类的。假如你的输出和原有输入差距,那么就是很广阔的人工神经网络了,相当于让原来数据经过一个映射来赢得大家想要的输出数据,也就是大家前天要讲的话题。

  Vectorized implementation:

  本文直接举一个事例,带入数值演示反向传播法的进度,公式的演绎等到下次写Auto-Encoder的时候再写,其实也很粗略,感兴趣的同学可以协调演绎下试试:)(注:本文如若你曾经领会基本的神经网络构成,假使完全不懂,可以参考Poll写的笔记:[Mechine
Learning & Algorithm]
神经网络基础

  指定是函数表明式的矢量完成。

  若是,你有如此一个网络层:

  Feature scaling:

图片 2

  指是将特色的每一维都开展一个规格变化,比如说都让其均值为0等。

  第一层是输入层,包涵四个神经元i1,i2,和截距项b1;第二层是富含层,蕴涵几个神经元h1,h2和截距项b2,第三层是输出o1,o2,每条线上标的wi是层与层之间连接的权重,激活函数大家默许为sigmoid函数。

  Normal equations:

  现在对她们赋上初值,如下图:

  那里指的是多元线性回归中参数解的矩阵方式,这些解方程称为normal
equations.

图片 3

  Optimization objective:

  其中,输入数据  i1=0.05,i2=0.10;

  指的是索要优化的对象函数,比如说logistic中loss
function表达式的公式推导。或者多元线性回归中蕴藏规则性的靶子函数。

     输出数据 o1=0.01,o2=0.99;

  Gradient Descent、Newton’s Method:

     开端权重  w1=0.15,w2=0.20,w3=0.25,w4=0.30;

  都是求目的函数最小值的办法。

           w5=0.40,w6=0.45,w7=0.50,w8=0.88

  Common variations:

 

  指的是规则项表明格局的多样性。

  目的:给出输入数据i1,i2(0.05和0.10),使出口尽可能与原本输出o1,o2(0.01和0.99)接近。

4.

 

前向传输 (Feed-Forward前向报告)

  Step 1 前向传播

BP网络练习初始此前,对网络的权重和偏置值举办起首化,权重取[-1,1]中间的一个随便数,偏置取[0,1]间的一个随机数。神经网络的训练包括数次的迭代进程,每一遍迭代(磨练)进程都选用陶冶集的兼具样本。

  1.输入层—->隐含层:

每一轮陶冶成功后判断练习样本的分类正确率和最大训练次数是或不是满意设定条件,假使满意则为止磨炼,不满足则此前向传输进入到逆向传输阶段。

  总计神经元h1的输入加权和:

3.

图片 4

上图中隐藏层只画了一层,但其层数并从未范围,传统的神经网络学习经历认为一层就丰盛好,而近年来的深度学习观点认为在早晚限制内,层数愈多,模型的叙说和还原能力越强。

神经元h1的输出o1:(此处用到激活函数为sigmoid函数):

偏置结点是为了描述操练多少中一贯不的性状,偏置结点对于下一层的每一个结点的权重的例外而生产分化的偏置,于是可以认为偏置是每一个结点(除输入层外)的习性。

图片 5

教练一个BP神经网络,实际上就是在外面输入样本的激励下持续调整网络的权重和偏置那四个参数,以使网络的输出不断接近年来望的输出,BP神经网络的教练进程分两片段:

 

  • 前向传输,逐层波浪式的传递输出值;
  • 逆向反馈,反向逐层调整权重和偏置;

 

 

  同理,可计算出神经元h2的出口o2:

BP神经网络层与层之间的关联是经过激活函数来讲述的,激活函数相当于生物学中细胞体中的细胞核,是对输入信号的处理单元。激活函数必须满意各方可导的口径,BP中常用的激活函数是Sigmoid。

  图片 6

 

 

2.

  2.隐含层—->输出层:

BP神经网络操练

     
那部分应该说是全方位BP神经网络形成的引擎,驱动着样本陶冶进程的举办。由BP神经网络的中央模型知道,反馈学习机制包括两大一部分,一是BP神经网络暴发预测的结果,二是经过预测的结果和样本的标准结果进行比对,然后对神经细胞举办误差量的核查。因而,大家用三个函数来表示那样的多个进程,陶冶进程中还对平均误差
e 进行督查,若果达到了设定的精度即可成功磨炼。由于不必然可以到达预期设定的精度须求,俺们抬高一个训练次数的参数,如果次数高达也退出教练

  总结输出层神经元o1和o2的值:

开始化BP神经网络

     
开始化紧如果关联五个方面的功效,一方面是对读取的磨炼样本数据开展归一化处理,归一化处理就是指的就是将数据转换成0~1之间。在BP神经网络理论里面,并不曾对那一个举行须要,然而实在施行进度中,归一化处理是不可或缺的。因为理论模型没考虑到,BP神经网络没有的速率问题,一般的话神经元的输出对于0~1之间的数额非凡敏感,归一化可以肯定进步练习功能。可以用以下公式来对其进展归一化,其中
加个常数A 是为着幸免出现 0 的情况(0不能为分母)。

       y=(x-MinValue+A)/(MaxValue-MinValue+A)

      一派,就是对神经细胞的权重进行早先化了,数据归一到了(0~1)之间,那么权重开头化为(-1~1)之间的多少,其它对改良量赋值为0。已毕参考代码如下:

 

  图片 7

部分多少的定义

   首先,大家介绍些下文中讲述的次第里面的有些第一数据的定义。

#define Data  820
#define In 2
#define Out 1
#define Neuron 45
#define TrainC 5500

      Data 用来表示曾经知道的数码样本的数码,也就是陶冶样本的数额。In
表示对于每个样本有微微个输入变量; Out
表示对于每个样本有些许个出口变量。Neuron 代表神经元的数据,TrainC
来代表训练的次数。再来大家看对神经网络描述的数量定义,来看上面那张图中间的数据类型都是
double 型。

参考:

http://www.cnblogs.com/jzhlin/archive/2012/07/30/bp_c.html

1.转文:

转载自:

图片 8

一文弄懂神经网络中的反向传播法——BackPropagation

方今在看深度学习的东西,一起头看的吴恩达的UFLDL教程,有中文版就一向看了,后来意识有些地点总是否很鲜明,又去看英文版,然后又找了些资料看,才发觉,中文版的译员在翻译的时候会对简易的公式推导进程举办补缺,不过补充的又是错的,难怪觉得有题目。反向传播法其实是神经网络的底蕴了,可是洋洋人在学的时候总是会蒙受有的题目,或者看到大篇的公式觉得好像很难就退缩了,其实简单,就是一个链式求导法则一再用。如若不想看公式,可以平素把数值带进去,实际的乘除一下,体会一下那么些历程之后再来推导公式,那样就会认为很简单了。

  说到神经网络,大家收看这么些图应该不生疏:

图片 9

 

  那是独立的三层神经网络的中坚组成,Layer L1是输入层,Layer
L2是包涵层,Layer
L3是带有层,大家现在手里有一堆数据{x1,x2,x3,…,xn},输出也是一堆数据{y1,y2,y3,…,yn},现在要她们在蕴藏层做某种变换,让您把数据灌进去后获得你指望的出口。如果您愿意您的输出和原有输入一样,那么就是最广大的自编码模型(Auto-Encoder)。可能有人会问,为何要输入输出都如出一辙啊?有何样用啊?其实采纳挺广的,在图像识别,文本分类等等都会用到,我会专门再写一篇Auto-Encoder的小说来证实,包蕴部分变种之类的。如若你的出口和原始输入不均等,那么就是很常见的人工神经网络了,相当于让原来数据通过一个映射来取得大家想要的输出数据,也就是大家前几天要讲的话题。

  本文间接举一个事例,带入数值演示反向传播法的经过,公式的演绎等到下次写Auto-Encoder的时候再写,其实也很粗略,感兴趣的同桌可以自己演绎下试试:)(注:本文假如你已经领悟基本的神经网络构成,如若完全不懂,可以参考Poll写的笔记:[Mechine
Learning & Algorithm]
神经网络基础

  假若,你有这么一个网络层:

图片 10

  第一层是输入层,包含四个神经元i1,i2,和截距项b1;第二层是富含层,蕴含三个神经元h1,h2和截距项b2,第三层是输出o1,o2,每条线上标的wi是层与层之间三番五次的权重,激活函数大家默许为sigmoid函数。

  现在对她们赋上初值,如下图:

图片 11

  其中,输入数据  i1=0.05,i2=0.10;

     输出数据 o1=0.01,o2=0.99;

     起首权重  w1=0.15,w2=0.20,w3=0.25,w4=0.30;

           w5=0.40,w6=0.45,w7=0.50,w8=0.55

 

  目的:给出输入数据i1,i2(0.05和0.10),使输出尽可能与原来输出o1,o2(0.01和0.99)接近。

 

  Step 1 前向传来

  1.输入层—->隐含层:

  总结神经元h1的输入加权和:

图片 12

神经元h1的输出o1:(此处用到激活函数为sigmoid函数):

图片 13

 

 

  同理,可计算出神经元h2的输出o2:

  图片 14

 

  2.隐含层—->输出层:

  总结输出层神经元o1和o2的值:

  图片 15

图片 16

 

如此那般前向传播的经过就停止了,大家获取输出值为[0.75136079 ,
0.772928465],与实际值[0.01 ,
0.99]距离还很远,现在大家对误差举行反向传来,更新权值,重新统计输出。

 

Step 2 反向传来

1.划算总误差

总误差:(square error)

图片 17

然而有三个出口,所以个别总结o1和o2的误差,总误差为两者之和:

图片 18

图片 19

图片 20

 

2.隐含层—->输出层的权值更新:

以权重参数w5为例,即使大家想精通w5对全体误差发生了不怎么影响,可以用一体化误差对w5求偏导求出:(链式法则)

图片 21

上边的图可以更直观的看领悟误差是什么反向传来的:

图片 22

现行我们来分别总括每个式子的值:

计算图片 23

图片 24

计算图片 25

图片 26

(这一步实际上就是对sigmoid函数求导,比较不难,能够友善演绎一下)

 

计算图片 27

图片 28

最后三者相乘:

图片 29

如此大家就总括出全体误差E(total)对w5的偏导值。

回过头来再看看上边的公式,我们发现:

图片 30

为了表达方便,用图片 31来代表输出层的误差:

图片 32

于是,全体误差E(total)对w5的偏导公式可以写成:

图片 33

如果输出层误差计为负的话,也可以写成:

图片 34

末段大家来更新w5的值:

图片 35

(其中,图片 36是读书速率,那里大家取0.5)

同理,可更新w6,w7,w8:

图片 37

 

3.隐含层—->隐含层的权值更新:

 方法其实与地点说的基本上,然则有个地点必要变一下,在上文总计总误差对w5的偏导时,是从out(o1)—->net(o1)—->w5,不过在隐含层之间的权值更新时,是out(h1)—->net(h1)—->w1,而out(h1)会接受E(o1)和E(o2)五个地点传来的误差,所以这些地点几个都要总括。

 

图片 38

 

计算图片 39

图片 40

先计算图片 41

图片 42

图片 43

图片 44

图片 45

同理,计算出:

          图片 46

两岸相加拿到总值:

图片 47

再计算图片 48

图片 49

再计算图片 50

图片 51

末段,三者相乘:

图片 52

 为了简化公式,用sigma(h1)表示隐含层单元h1的误差:

图片 53

最后,更新w1的权值:

图片 54

同理,额可更新w2,w3,w4的权值:

图片 55

 

  那样误差反向传播法就完了了,最后大家再把立异的权值重新统计,不停地迭代,在那个例子中率先次迭代将来,总误差E(total)由0.298371109下滑至0.291027924。迭代10000次后,总误差为0.000035085,输出为[0.015912196,0.984065734](原输入为[0.01,0.99]),注明效果依旧不错的。

 

 

诸如此类前向传播的经过就截至了,咱们收获输出值为[0.75136079 ,
0.772928465],与实际值[0.01 ,
0.99]相距还很远,现在我们对误差举办反向传来,更新权值,重新总计输出。

 

Step 2 反向传播

1.划算总误差

总误差:(square error)

图片 56

然则有多个出口,所以个别统计o1和o2的误差,总误差为双方之和:

图片 57

图片 58

图片 59

 

2.隐含层—->输出层的权值更新:

以权重参数w5为例,若是大家想精通w5对总体误差爆发了不怎么影响,可以用全部误差对w5求偏导求出:(链式法则)

图片 60

上边的图可以更直观的看领会误差是何许反向传播的:

图片 61

今天我们来分别计算每个式子的值:

计算图片 62

图片 63

计算图片 64

图片 65

(这一步实际上就是对sigmoid函数求导,比较简单,能够团结推导一下)

 

计算图片 66

图片 67

最终三者相乘:

图片 68

如此大家就计算出完全误差E(total)对w5的偏导值。

回过头来再看看下边的公式,大家发现:

图片 69

为了发挥方便,用图片 70来代表输出层的误差:

图片 71

之所以,全体误差E(total)对w5的偏导公式可以写成:

图片 72

要是输出层误差计为负的话,也足以写成:

图片 73

最终大家来更新w5的值:

图片 74

(其中,图片 75是学习速率,那里我们取0.5)

同理,可更新w6,w7,w8:

图片 76

 

3.隐含层—->隐含层的权值更新:

 方法其实与地点说的大都,不过有个地方要求变一下,在上文计算总误差对w5的偏导时,是从out(o1)—->net(o1)—->w5,但是在隐含层之间的权值更新时,是out(h1)—->net(h1)—->w1,而out(h1)会接受E(o1)和E(o2)五个地方传来的误差,所以那些地方七个都要总计。

 

图片 77

 

计算图片 78

图片 79

先计算图片 80

图片 81

图片 82

图片 83

图片 84

同理,计算出:

          图片 85

两者相加得到总值:

图片 86

再计算图片 87

图片 88

再计算图片 89

图片 90

终极,三者相乘:

图片 91

 为了简化公式,用sigma(h1)表示隐含层单元h1的误差:

图片 92

最后,更新w1的权值:

图片 93

同理,额可更新w2,w3,w4的权值:

图片 94

 

  那样误差反向传播法就完事了,最终大家再把立异的权值重新总括,不停地迭代,在这些事例中率先次迭代之后,总误差E(total)由0.298371109跌落至0.291027924。迭代10000次后,总误差为0.000035085,输出为[0.015912196,0.984065734](原输入为[0.01,0.99]),声明作用仍然不错的。

 

代码(Python):

图片 95

  1 #coding:utf-8
  2 import random
  3 import math
  4 
  5 #
  6 #   参数解释:
  7 #   "pd_" :偏导的前缀
  8 #   "d_" :导数的前缀
  9 #   "w_ho" :隐含层到输出层的权重系数索引
 10 #   "w_ih" :输入层到隐含层的权重系数的索引
 11 
 12 class NeuralNetwork:
 13     LEARNING_RATE = 0.5
 14 
 15     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):
 16         self.num_inputs = num_inputs
 17 
 18         self.hidden_layer = NeuronLayer(num_hidden, hidden_layer_bias)
 19         self.output_layer = NeuronLayer(num_outputs, output_layer_bias)
 20 
 21         self.init_weights_from_inputs_to_hidden_layer_neurons(hidden_layer_weights)
 22         self.init_weights_from_hidden_layer_neurons_to_output_layer_neurons(output_layer_weights)
 23 
 24     def init_weights_from_inputs_to_hidden_layer_neurons(self, hidden_layer_weights):
 25         weight_num = 0
 26         for h in range(len(self.hidden_layer.neurons)):
 27             for i in range(self.num_inputs):
 28                 if not hidden_layer_weights:
 29                     self.hidden_layer.neurons[h].weights.append(random.random())
 30                 else:
 31                     self.hidden_layer.neurons[h].weights.append(hidden_layer_weights[weight_num])
 32                 weight_num += 1
 33 
 34     def init_weights_from_hidden_layer_neurons_to_output_layer_neurons(self, output_layer_weights):
 35         weight_num = 0
 36         for o in range(len(self.output_layer.neurons)):
 37             for h in range(len(self.hidden_layer.neurons)):
 38                 if not output_layer_weights:
 39                     self.output_layer.neurons[o].weights.append(random.random())
 40                 else:
 41                     self.output_layer.neurons[o].weights.append(output_layer_weights[weight_num])
 42                 weight_num += 1
 43 
 44     def inspect(self):
 45         print('------')
 46         print('* Inputs: {}'.format(self.num_inputs))
 47         print('------')
 48         print('Hidden Layer')
 49         self.hidden_layer.inspect()
 50         print('------')
 51         print('* Output Layer')
 52         self.output_layer.inspect()
 53         print('------')
 54 
 55     def feed_forward(self, inputs):
 56         hidden_layer_outputs = self.hidden_layer.feed_forward(inputs)
 57         return self.output_layer.feed_forward(hidden_layer_outputs)
 58 
 59     def train(self, training_inputs, training_outputs):
 60         self.feed_forward(training_inputs)
 61 
 62         # 1. 输出神经元的值
 63         pd_errors_wrt_output_neuron_total_net_input = [0] * len(self.output_layer.neurons)
 64         for o in range(len(self.output_layer.neurons)):
 65 
 66             # ∂E/∂zⱼ
 67             pd_errors_wrt_output_neuron_total_net_input[o] = self.output_layer.neurons[o].calculate_pd_error_wrt_total_net_input(training_outputs[o])
 68 
 69         # 2. 隐含层神经元的值
 70         pd_errors_wrt_hidden_neuron_total_net_input = [0] * len(self.hidden_layer.neurons)
 71         for h in range(len(self.hidden_layer.neurons)):
 72 
 73             # dE/dyⱼ = Σ ∂E/∂zⱼ * ∂z/∂yⱼ = Σ ∂E/∂zⱼ * wᵢⱼ
 74             d_error_wrt_hidden_neuron_output = 0
 75             for o in range(len(self.output_layer.neurons)):
 76                 d_error_wrt_hidden_neuron_output += pd_errors_wrt_output_neuron_total_net_input[o] * self.output_layer.neurons[o].weights[h]
 77 
 78             # ∂E/∂zⱼ = dE/dyⱼ * ∂zⱼ/∂
 79             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()
 80 
 81         # 3. 更新输出层权重系数
 82         for o in range(len(self.output_layer.neurons)):
 83             for w_ho in range(len(self.output_layer.neurons[o].weights)):
 84 
 85                 # ∂Eⱼ/∂wᵢⱼ = ∂E/∂zⱼ * ∂zⱼ/∂wᵢⱼ
 86                 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)
 87 
 88                 # Δw = α * ∂Eⱼ/∂wᵢ
 89                 self.output_layer.neurons[o].weights[w_ho] -= self.LEARNING_RATE * pd_error_wrt_weight
 90 
 91         # 4. 更新隐含层的权重系数
 92         for h in range(len(self.hidden_layer.neurons)):
 93             for w_ih in range(len(self.hidden_layer.neurons[h].weights)):
 94 
 95                 # ∂Eⱼ/∂wᵢ = ∂E/∂zⱼ * ∂zⱼ/∂wᵢ
 96                 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)
 97 
 98                 # Δw = α * ∂Eⱼ/∂wᵢ
 99                 self.hidden_layer.neurons[h].weights[w_ih] -= self.LEARNING_RATE * pd_error_wrt_weight
100 
101     def calculate_total_error(self, training_sets):
102         total_error = 0
103         for t in range(len(training_sets)):
104             training_inputs, training_outputs = training_sets[t]
105             self.feed_forward(training_inputs)
106             for o in range(len(training_outputs)):
107                 total_error += self.output_layer.neurons[o].calculate_error(training_outputs[o])
108         return total_error
109 
110 class NeuronLayer:
111     def __init__(self, num_neurons, bias):
112 
113         # 同一层的神经元共享一个截距项b
114         self.bias = bias if bias else random.random()
115 
116         self.neurons = []
117         for i in range(num_neurons):
118             self.neurons.append(Neuron(self.bias))
119 
120     def inspect(self):
121         print('Neurons:', len(self.neurons))
122         for n in range(len(self.neurons)):
123             print(' Neuron', n)
124             for w in range(len(self.neurons[n].weights)):
125                 print('  Weight:', self.neurons[n].weights[w])
126             print('  Bias:', self.bias)
127 
128     def feed_forward(self, inputs):
129         outputs = []
130         for neuron in self.neurons:
131             outputs.append(neuron.calculate_output(inputs))
132         return outputs
133 
134     def get_outputs(self):
135         outputs = []
136         for neuron in self.neurons:
137             outputs.append(neuron.output)
138         return outputs
139 
140 class Neuron:
141     def __init__(self, bias):
142         self.bias = bias
143         self.weights = []
144 
145     def calculate_output(self, inputs):
146         self.inputs = inputs
147         self.output = self.squash(self.calculate_total_net_input())
148         return self.output
149 
150     def calculate_total_net_input(self):
151         total = 0
152         for i in range(len(self.inputs)):
153             total += self.inputs[i] * self.weights[i]
154         return total + self.bias
155 
156     # 激活函数sigmoid
157     def squash(self, total_net_input):
158         return 1 / (1 + math.exp(-total_net_input))
159 
160 
161     def calculate_pd_error_wrt_total_net_input(self, target_output):
162         return self.calculate_pd_error_wrt_output(target_output) * self.calculate_pd_total_net_input_wrt_input();
163 
164     # 每一个神经元的误差是由平方差公式计算的
165     def calculate_error(self, target_output):
166         return 0.5 * (target_output - self.output) ** 2
167 
168     
169     def calculate_pd_error_wrt_output(self, target_output):
170         return -(target_output - self.output)
171 
172     
173     def calculate_pd_total_net_input_wrt_input(self):
174         return self.output * (1 - self.output)
175 
176 
177     def calculate_pd_total_net_input_wrt_weight(self, index):
178         return self.inputs[index]
179 
180 
181 # 文中的例子:
182 
183 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)
184 for i in range(10000):
185     nn.train([0.05, 0.1], [0.01, 0.09])
186     print(i, round(nn.calculate_total_error([[[0.05, 0.1], [0.01, 0.09]]]), 9))
187 
188 
189 #另外一个例子,可以把上面的例子注释掉再运行一下:
190 
191 # training_sets = [
192 #     [[0, 0], [0]],
193 #     [[0, 1], [1]],
194 #     [[1, 0], [1]],
195 #     [[1, 1], [0]]
196 # ]
197 
198 # nn = NeuralNetwork(len(training_sets[0][0]), 5, len(training_sets[0][1]))
199 # for i in range(10000):
200 #     training_inputs, training_outputs = random.choice(training_sets)
201 #     nn.train(training_inputs, training_outputs)
202 #     print(i, nn.calculate_total_error(training_sets))

图片 96

 

  

  末了写到那里就得了了,现在还不会用latex编辑数学公式,本来都平昔想写在草稿纸上然后扫描了传上来,然而觉得太影响阅读体验了。以后会用公式编辑器后再重把公式重新编写四遍。稳重使用的是sigmoid激活函数,实际还有二种差别的激活函数可以挑选,具体的可以参考文献[3],最后推荐一个在线演示神经网络变化的网址:http://www.emergentmind.com/neural-network,可以自己填输入输出,然后观看每一次迭代权值的变化,很好玩~如果有错误的或者不懂的欢迎留言:)

 

参考文献:

1.Poll的笔记:[Mechine Learning & Algorithm]
神经网络基础
http://www.cnblogs.com/maybe2030/p/5597716.html\#3457159

2.Rachel_Zhang:http://blog.csdn.net/abcjennifer/article/details/7758797

3.http://www.cedar.buffalo.edu/%7Esrihari/CSE574/Chap5/Chap5.3-BackProp.pdf

4.https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/

 

 

(转)

 

 

只要您愿意花几块钱请自己喝杯茶的话,可以用手机扫描下方的二维码,通过
支付宝 捐赠。我会尽力写出更好的文章。 
(捐赠不显示捐赠者的个人音讯,如要求,请阐明你的联系格局) 
Thank you for your kindly donation!

 

 图片 97

相关文章