汉语版的译者在翻译的时候会对简易的公式推导进度进展填补,比如说都让其均值为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

相关文章