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

上图中隐藏层只画了一层,但其层数并不曾范围,传统的神经网络学习经验认为一层就足足好,而方今的深度学习观点认为在自然范围内,层数更加多,模型的讲述和回复能力越强。

 

偏置结点是为了描述训练多少中尚无的表征,偏置结点对于下一层的每一个结点的权重的例外而生产分歧的偏置,于是可以认为偏置是每一个结点(除输入层外)的习性。

365体育网投 1

  指的是规则项表达形式的多样性。

  365体育网投 2

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

最后,更新w1的权值:

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

365体育网投 3

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

近些年在看深度学习的东西,一起初看的吴恩达的UFLDL教程,有普通话版就径直看了,后来意识有些地点总是还是不是很扎眼,又去看英文版,然后又找了些资料看,才发觉,普通话版的翻译在翻译的时候会对简易的公式推导进程进展填补,可是补充的又是错的,难怪觉得有题目。反向传播法其实是神经网络的功底了,不过洋洋人在学的时候总是会遇见有些题材,或者看到大篇的公式觉得好像很难就退缩了,其实简单,就是一个链式求导法则一再用。假使不想看公式,可以直接把数值带进去,实际的臆度一下,体会一下以此历程之后再来推导公式,那样就会认为很简单了。

  说到神经网络,我们看来那么些图应该不陌生:

365体育网投 4

 

  那是第超级的三层神经网络的为主组成,Layer L1是输入层,Layer
L2是含有层,Layer
L3是富含层,大家明日手里有一堆数据{x1,x2,x3,…,xn},输出也是一堆数据{y1,y2,y3,…,yn},现在要他们在包涵层做某种变换,让您把数据灌进去后取得你希望的输出。假若您期望您的出口和原有输入一样,那么就是最普遍的自编码模型(Auto-Encoder)。可能有人会问,为啥要输入输出都平等吗?有如何用啊?其实采用挺广的,在图像识别,文本分类等等都会用到,我会专门再写一篇Auto-Encoder的篇章来表达,包罗一些变种之类的。纵然你的输出和原来输入不相同等,那么就是很宽泛的人工神经网络了,相当于让原本数据经过一个辉映来赢得大家想要的输出数据,也就是大家前些天要讲的话题。

  本文直接举一个例证,带入数值演示反向传播法的历程,公式的推理等到下次写Auto-Encoder的时候再写,其实也很粗略,感兴趣的同窗可以协调推导下试试:)(注:本文若是你曾经知道基本的神经网络构成,若是完全不懂,可以参考Poll写的笔记:[Mechine
Learning & Algorithm]
神经网络基础

  假诺,你有那般一个网络层:

365体育网投 5

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

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

365体育网投 6

  其中,输入数据  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的输入加权和:

365体育网投 7

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

365体育网投 8

 

 

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

  365体育网投 9

 

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

  计算输出层神经元o1和o2的值:

  365体育网投 10

365体育网投 11

 

这么前向传播的进程就终止了,大家赢得输出值为[0.75136079 ,
0.772928465],与实际值[0.01 ,
0.99]离开还很远,现在我们对误差进行反向传来,更新权值,重新总结输出。

 

Step 2 反向传播

1.计算总误差

总误差:(square error)

365体育网投 12

只是有四个出口,所以个别计算o1和o2的误差,总误差为双方之和:

365体育网投 13

365体育网投 14

365体育网投 15

 

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

以权重参数w5为例,如若大家想知道w5对全体误差爆发了不怎么影响,可以用一体化误差对w5求偏导求出:(链式法则)

365体育网投 16

下边的图可以更直观的看了然误差是哪些反向传播的:

365体育网投 17

方今大家来分别总括每个式子的值:

计算365体育网投 18

365体育网投 19

计算365体育网投 20

365体育网投 21

(这一步实际上就是对sigmoid函数求导,相比简单,可以自己演绎一下)

 

计算365体育网投 22

365体育网投 23

最终三者相乘:

365体育网投 24

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

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

365体育网投 25

为了发挥方便,用365体育网投 26来代表输出层的误差:

365体育网投 27

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

365体育网投 28

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

365体育网投 29

末尾我们来更新w5的值:

365体育网投 30

(其中,365体育网投 31是学习速率,那里大家取0.5)

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

365体育网投 32

 

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

 方法其实与地方说的大多,可是有个地点要求变一下,在上文总结总误差对w5的偏导时,是从out(o1)—->net(o1)—->w5,不过在隐含层之间的权值更新时,是out(h1)—->net(h1)—->w1,而out(h1)会接受E(o1)和E(o2)八个位置传来的误差,所以这几个地方三个都要总括。

 

365体育网投 33

 

计算365体育网投 34

365体育网投 35

先计算365体育网投 36

365体育网投 37

365体育网投 38

365体育网投 39

365体育网投 40

同理,计算出:

          365体育网投 41

双方相加得到总值:

365体育网投 42

再计算365体育网投 43

365体育网投 44

再计算365体育网投 45

365体育网投 46

最后,三者相乘:

365体育网投 47

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

365体育网投 48

最后,更新w1的权值:

365体育网投 49

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

365体育网投 50

 

  那样误差反向传播法就马到功成了,最终我们再把创新的权值重新计算,不停地迭代,在那个事例中率先次迭代从此,总误差E(total)由0.298371109下降至0.291027924。迭代10000次后,总误差为0.000035085,输出为[0.015912196,0.984065734](原输入为[0.01,0.99]),阐明效果依旧不错的。

 

365体育网投 51

  Common variations:

365体育网投 52

  Vectorized implementation:

计算365体育网投 53

BP神经网络层与层之间的关系是透过激活函数来叙述的,激活函数约等于生物学中细胞体中的细胞核,是对输入信号的处理单元。激活函数必须知足各方可导的标准,BP中常用的激活函数是Sigmoid。

365体育网投 54

每一轮训练完毕后判断陶冶样本的归类正确率和最大练习次数是还是不是满足设定标准,如若满意则甘休训练,不满足则之前向传输进入到逆向传输阶段。

365体育网投 55

  Gradient Descent、Newton’s Method:

365体育网投 56

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

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

3.

  本文直接举一个例子,带入数值演示反向传播法的长河,公式的推理等到下次写Auto-Encoder的时候再写,其实也很简短,感兴趣的同班可以自己推导下试试:)(注:本文借使你曾经清楚基本的神经网络构成,借使完全不懂,能够参照Poll写的笔记:[Mechine
Learning & Algorithm]
神经网络基础

  指定是函数表达式的矢量完结。

计算365体育网投 57

 

365体育网投 58

 

那般大家就计算出整体误差E(total)对w5的偏导值。

 学科中的一些术语:

方今大家来分别统计每个式子的值:

  都是求目的函数最小值的章程。

1.计量总误差

4.

365体育网投 59

5.

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

  Model representation:

365体育网投 60

BP神经网络磨炼

     
那部分应当说是任何BP神经网络形成的发动机,驱动着样本练习进度的实施。由BP神经网络的主题模型知道,反馈学习机制包罗两大一部分,一是BP神经网络发出预测的结果,二是透过预测的结果和样本的可信结果开展比对,然后对神经细胞举行误差量的匡正。因此,我们用八个函数来代表那样的多个经过,磨炼进程中还对平均误差
e 进行监察,假使达到了设定的精度即可形成操练。由于不肯定可以到达预期设定的精度必要,我们添加一个教练次数的参数,假诺次数达到也脱离教练

  同理,可总括出神经元h2的出口o2:

  Optimization objective:

365体育网投 61

 

  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))

2.

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

  Feature scaling:

 

部分数额的概念

   首先,大家介绍些下文中讲述的次序里面的片段要害数据的概念。

#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.转文:

转载自:

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

  指的是必要优化的目标函数,比如说logistic中loss
function表达式的公式推导。或者多元线性回归中包括规则性的对象函数。

365体育网投 62

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

总误差:(square error)

BP网络陶冶伊始从前,对网络的权重和偏置值举办初步化,权重取[-1,1]中间的一个肆意数,偏置取[0,1]间的一个随机数。神经网络的教练包蕴多次的迭代进程,每四回迭代(磨炼)进程都选用训练集的具有样本。

365体育网投 63

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

同理,计算出:

  Normal equations:

 

先河化BP神经网络

     
开首化首如若涉嫌八个地点的机能,一方面是对读取的磨炼样本数据开展归一化处理,归一化处理就是指的就是将数据转换成0~1之间。在BP神经网络理论里面,并不曾对那个进行必要,可是事实上施行进程中,归一化处理是必需的。因为理论模型没考虑到,BP神经网络没有的速率问题,一般的话神经元的出口对于0~1之间的数量极度灵活,归一化可以明显增加教练功能。可以用以下公式来对其展开归一化,其中
加个常数A 是为着幸免出现 0 的景况(0不能为分母)。

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

      一头,就是对神经细胞的权重进行初叶化了,数据归一到了(0~1)之间,那么权重初叶化为(-1~1)之间的数码,其它对纠正量赋值为0。完毕参考代码如下:

 

先计算365体育网投 64

教练一个BP神经网络,实际上就是在外面输入样本的激发下持续调整网络的权重和偏置那多少个参数,以使网络的输出不断接方今望的出口,BP神经网络的教练进程分两局地:

 

(转)

假使您愿意花几块钱请自己喝杯茶的话,可以用手机扫描下方的二维码,通过
支付宝 捐赠。我会竭尽全力写出更好的稿子。 
(捐赠不出示捐赠者的个人音信,如要求,请评释你的联系情势) 
Thank you for your kindly donation!

365体育网投 65

 

365体育网投 66

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

365体育网投 67

365体育网投 68

末段三者相乘:

365体育网投 69

为了发挥方便,用365体育网投 70来代表输出层的误差:

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

最后,三者相乘:

365体育网投 71

365体育网投 72

365体育网投 73

365体育网投 74

再计算365体育网投 75

365体育网投 76

          365体育网投 77

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

计算365体育网投 78

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

     初叶权重  w1=0.15,w2=0.20,w3=0.25,w4=0.30;

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

365体育网投 79

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

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

不久前在看深度学习的事物,一先河看的吴恩达的UFLDL教程,有普通话版就直接看了,后来发现有点地点一连不是很显眼,又去看英文版,然后又找了些资料看,才察觉,汉语版的译者在翻译的时候会对简易的公式推导进度进展增补,然则补充的又是错的,难怪觉得有问题。反向传播法其实是神经网络的根底了,不过众多少人在学的时候总是会遭逢有的题目,或者看到大篇的公式觉得好像很难就退缩了,其实不难,就是一个链式求导法则反复用。即使不想看公式,可以直接把数值带进去,实际的统计一下,体会一下以此进度之后再来推导公式,那样就会以为很容易了。

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

 

365体育网投 80

 

末段大家来更新w5的值:

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

365体育网投 81

365体育网投 82

这么前向传来的进度就甘休了,大家获得输出值为[0.75136079 ,
0.772928465],与实际值[0.01 ,
0.99]相差还很远,现在我们对误差进行反向传来,更新权值,重新计算输出。

 

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

代码(Python):

  这样误差反向传播法就已毕了,最终我们再把革新的权值重新统计,不停地迭代,在这些事例中率先次迭代过后,总误差E(total)由0.298371109大跌至0.291027924。迭代10000次后,总误差为0.000035085,输出为[0.015912196,0.984065734](原输入为[0.01,0.99]),注脚功能如故不错的。

 

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

 

365体育网投 83

 

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

  第一层是输入层,包涵五个神经元i1,i2,和截距项b1;第二层是包罗层,包涵多个神经元h1,h2和截距项b2,第三层是输出o1,o2,每条线上标的wi是层与层之间延续的权重,激活函数咱们默许为sigmoid函数。

参考文献:

365体育网投 84

 

再计算365体育网投 85

365体育网投 86

  365体育网投 87

  借使,你有如此一个网络层:

 

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

 

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

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

 

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

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

(其中,365体育网投 88是学习速率,那里大家取0.5)

 

 365体育网投 89

365体育网投 90

 

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

只是有七个出口,所以个别统计o1和o2的误差,总误差为双方之和:

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

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

 

 

365体育网投 91

365体育网投 92

365体育网投 93

Step 2 反向传播

计算365体育网投 94

 

 

  Step 1 前向传播

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

(这一步实际上就是对sigmoid函数求导,相比较简单,可以自己演绎一下)

二者相加获得总值:

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

365体育网投 95

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

  说到神经网络,大家看来那些图应该不陌生:

  

 

365体育网投 96

365体育网投 97

相关文章