最近在看深度學習的東西，一開始看的吳恩達的UFLDL教程，有中文版就直接看了（點選這裡文章第三部分觀看）；後來發現有些地方總是不是很明確，又去看英文版，然後又找了些資料看，才發現，中文版的譯者在翻譯的時候會對省略的公式推導過程進行補充，但是補充的又是錯的，難怪覺得有問題。
反向傳播法其實是神經網路的基礎了，但是很多人在學的時候總是會遇到一些問題，或者看到大篇的公式覺得好像很難就退縮了，其實不難，就是一個鏈式求導法則反覆用。如果不想看公式，可以直接把數值帶進去，實際的計算一下，體會一下這個過程之後再來推導公式，這樣就會覺得很容易了。
說到神經網路，大家看到這個圖應該不陌生：
這是典型的三層神經網路的基本構成，Layer L1是輸入層（input layer），Layer L2是隱含層（hidden layer），Layer L3是輸出層（output layer）。
我們現在手裡有一堆資料{x1，x2，x3，。。。，xn}，輸出也是一堆資料{y1，y2，y3，。。。，yn}，現在要它們在隱含層做某種變換，讓你把資料灌進去後得到你期望的輸出。
如果你希望你的輸出和原始輸入一樣，那麼就是最常見的自編碼模型（Auto-Encoder）。
可能有人會問，為什麼要輸入輸出都一樣呢？有什麼用啊？
其實應用挺廣的，在影象識別，文字分類等等都會用到，我會專門再寫一篇Auto-Encoder的文章來說明，包括一些變種之類的。如果你的輸出和原始輸入不一樣，那麼就是很常見的人工神經網路了，相當於讓原始資料透過一個對映來得到我們想要的輸出資料，也就是我們今天要講的話題。
本文直接舉一個例子，帶入數值演示反向傳播法的過程，公式的推導等到下次寫Auto-Encoder的時候再寫，其實也很簡單，感興趣的同學可以自己推導下試試：）（注：本文假設你已經懂得基本的神經網路構成，如果完全不懂，可以參考Poll寫的筆記：［Mechine Learning & Algorithm］ 神經網路基礎）
假設，你有這樣一個網路層：
第一層是輸入層，包含兩個神經元i1，i2，和截距項b1；第二層是隱含層，包含兩個神經元h1，h2和截距項b2，第三層是輸出o1，o2，每條線上標的wi是層與層之間連線的權重，啟用函式我們預設為sigmoid函式。
現在對他們賦上初值，如下圖：
其中，輸入資料 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的輸入加權和：
神經元h1的輸出o1：（此處用到啟用函式為sigmoid函式）：
同理，可計算出神經元h2的輸出o2：
2.隱含層---->輸出層：
計算輸出層神經元o1和o2的值：
這樣前向傳播的過程就結束了，我們得到輸出值為［0。75136079 ， 0。772928465］，與實際值［0。01 ， 0。99］相差還很遠，現在我們對誤差進行反向傳播，更新權值，重新計算輸出。
Step 2 反向傳播
1.計算總誤差
總誤差：（square error）
但是有兩個輸出，所以分別計算o1和o2的誤差，總誤差為兩者之和：
2.隱含層---->輸出層的權值更新：
以權重引數w5為例，如果我們想知道w5對整體誤差產生了多少影響，可以用整體誤差對w5求偏導求出：（鏈式法則）
下面的圖可以更直觀的看清楚誤差是怎樣反向傳播的：
現在我們來分別計算每個式子的值：
計算 ：
計算 ：
（這一步實際上就是對sigmoid函式求導，比較簡單，可以自己推導一下）
計算 ：
最後三者相乘：
這樣我們就計算出整體誤差E（total）對w5的偏導值。
回過頭來再看看上面的公式，我們發現：
為了表達方便，用 來表示輸出層的誤差：
因此，整體誤差E（total）對w5的偏導公式可以寫成：
如果輸出層誤差計為負的話，也可以寫成：
最後我們來更新w5的值：
（其中， 是學習速率，這裡我們取0。5）
同理，可更新w6，w7，w8：
3.隱含層---->隱含層的權值更新：
方法其實與上面說的差不多，但是有個地方需要變一下，在上文計算總誤差對w5的偏導時，是從out（o1）——>net（o1）——>w5，但是在隱含層之間的權值更新時，是out（h1）——>net（h1）——>w1，而out（h1）會接受E（o1）和E（o2）兩個地方傳來的誤差，所以這個地方兩個都要計算。
計算 ：
先計算 ：
同理，計算出：
兩者相加得到總值：
再計算 ：
再計算 ：
最後，三者相乘：
為了簡化公式，用sigma（h1）表示隱含層單元h1的誤差：
最後，更新w1的權值：
同理，額可更新w2，w3，w4的權值：
這樣誤差反向傳播法就完成了，最後我們再把更新的權值重新計算，不停地迭代，在這個例子中第一次迭代之後，總誤差E（total）由0。298371109下降至0。291027924。迭代10000次後，總誤差為0。000035085，輸出為［0。015912196，0。984065734］（原輸入為［0。01，0。99］），證明效果還是不錯的。
Python原始碼：
#coding：utf-8import randomimport 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）： 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）： 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（‘* 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 o in range（len（self。output_layer。neurons））： # ∂E/∂zⱼ 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。 隱含層神經元的值 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））： d_error_wrt_hidden_neuron_output += pd_errors_wrt_output_neuron_total_net_input［o］ * self。output_layer。neurons［o］。weights［h］ # ∂E/∂zⱼ = dE/dyⱼ * ∂zⱼ/∂ 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））： # ∂Eⱼ/∂wᵢⱼ = ∂E/∂zⱼ * ∂zⱼ/∂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ᵢ 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_errorclass 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）） def inspect（self）： 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 outputsclass Neuron： def __init__（self， bias）： self。bias = bias self。weights = ［］ def calculate_output（self， inputs）： self。inputs = inputs 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）） 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 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］# 文中的例子：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）for i in range（10000）： nn。train（［0。05， 0。1］， ［0。01， 0。09］） 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））
最後寫到這裡就結束了，現在還不會用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/
ⓝ
MaiweiE-com|WeChat ID:Yida_Zhang2
推薦閱讀
（點選標題可跳轉閱讀）
常用啟用函式（激勵函式）理解與總結
機器學習中的最最佳化演算法總結
電子資訊行業最該讀的經典著作推薦
你想要的高畫質電子書都在這裡！免費下載！
有了這些珍藏的實用工具/學習網站，自學更快樂！
△微信掃一掃關注「邁微電子研發社」公眾號
