MLP(多層神經網絡)介紹

http://blog.csdn.net/cxf7394373/article/details/6061372

寫在前面的

       接觸神經網絡(ANN)的時間很長了，以前也只是學了學原理，做過一個BPN的練習，沒有系統的總結過，最近看Torch的源碼，對MLP有了更多的了解，寫寫自己學到的東西吧，算是做了一次總結！

ANN的特點

高度的並行性

人工神經網絡是由許多相同的簡單處理單元並聯組合而成，雖然每個單元的功能簡單，但大量簡單單元的並行活動，使其對信息的處理能力與效果驚人。

高度的非線性全局作用

神經網絡系統是由大量簡單神經元構成的，每個神經元接受大量其他神經元的輸入，通過非線性輸入、輸出關系，產生輸出影響其它神經元。網絡就是這樣互相制約相互影響，實現從輸入狀態空間到輸出狀態空間非線性映射的。網絡的演化遵從全局性作用原則，從輸入狀態演化到終態而輸出。從全局觀點來看，網絡整體性能不是網絡局部性能的簡單迭加，而表現某種集體性行為；而電腦遵從串行式局域性操作原則，每一步計算與上一步計算緊密相關，並對下一步產生影響，問題是通過算法逐步進行處理的。

良好的容錯性與聯想記憶功能

人工神經網絡通過自身的網絡結構能夠實現對信息的記憶，而所記憶的信息是存儲在神經元之間的權值中。從單個權值中看不出所儲存的信息內容，因而是分布式的存儲方式。這使得網絡具有良好的容錯性，並能進行聚類分析、特征提取、缺損模式復原等模式信息處理工作。

十分強的自適應、自學習功能人工神經網絡可以通過訓練和學習來獲得網絡的權值與結構，呈現出很強的自學習能力和對環境的自適應能力。

ANN分類

 

BPN(Back Propagation Net)

 在這裡我介紹一下反向傳播網絡BPN---帶動量項的誤差反傳。反向傳播神經網絡是對非線性可微分函數進行權值訓練的多層網絡，是前向神經網絡的一種。BP網絡主要用於：

1)函數逼近與預測分析：用輸入矢量和相應的輸出矢量訓練一個網絡，逼近一個函數或預測未知信息；

2)模式識別：用一個特定的輸出矢量將它與輸入矢量聯系起來；

3)分類：把輸入矢量以所定義的合適方式進行分類；

4)數據壓縮：減少輸出矢量維數以便於傳輸與存儲。

比如，一個三層BPN結構如下：

由輸入層、隱含層和輸出層三層組成。其中每一層的單元與與之相鄰層的所有單元連接，同一層的單元之間沒有連接。當一對學習樣本提供給網絡後，神經元的激活值從輸入層經各中間層向輸出層傳播，在輸出層的各神經元獲得網絡的輸入響應。接下來，按照減少目標輸出與實際誤差的方向，從輸出層經過各中間層逐層修正各連接權值，最後回到輸入層。

 

 

感知器(Perception)類型

linear----線性感知器

tanh----雙曲正切函數

sigmoid----雙曲函數

softmax----1/(e(net) * e(wi*xi- shift))

log-softmax---- log(1/(e(net) * e(wi*xi)))

exp----指數函數

softplus----log(1+ e(wi*xi))

梯度下降

Delta學習方法

增量梯度下降

MLP的缺陷

1. 網絡的隱含節點個數選取問題至今仍是一個 世界難題（Google, Elsevier, CNKI）；

2. 停止閾值、學習率、動量常數需要采用」trial-and-error」法，極其耗時（動手實驗）；

3. 學習速度慢；

4. 容易陷入局部極值，學習不夠充分。

應用舉例

[c-sharp]  view plain copy

1. static void Main(string[] args)  
2.         {  
3.             int row = 2;//訓練樣例的數目  
4.             int n_in = 2;//輸入值的個數  
5.             int n_out = 1;//輸出值的個數  
6.             int n_hidden = 1;//隱含層單元個個數  
7.   
8.             double eta = 0.3;//學習速率  
9.             double alfa = 0.9;//動量項  
10.             int [,] t_ex = new int[row,n_in + n_out];//訓練樣例  
11.               
12.             //賦初值 訓練樣例  
13.             t_ex[0, 0] = 1;  
14.             t_ex[0, 1] = 0;  
15.             t_ex[0, 2] = 1;  
16.             t_ex[1, 0] = 0;  
17.             t_ex[1, 1] = 1;  
18.             t_ex[1, 2] = 0;  
19.   
20.             double[] Delta_Out = new double[n_out];//輸出單元誤差  
21.             double[] Delta_Hidden = new double[n_hidden];//隱藏單元誤差  
22.   
23.             double[] O_Out = new double[n_out];//輸出單元的輸出  
24.             double[] O_Hidden = new double[n_hidden];//隱含單元的輸出  
25.   
26.             double[,] W_Out = new double[n_out,n_hidden + 1];//輸出單元的權值  
27.             double[,] W_Hidden = new double[n_hidden,n_in + 1];//隱含單元的權值  
28.   
29.             double[,] Delta_W_Out = new double[n_out,n_hidden + 1];//輸出單元的權值差  
30.             double[,] Delta_W_Hidden = new double[n_hidden,n_in + 1];//隱含單元的權值差  
31.             //初始化所有網絡權值為0.1  
32.             for (int i = 0; i < n_out;i++ )  
33.             {  
34.                 for (int j = 0;j < n_hidden + 1;j++)  
35.                 {  
36.                     W_Out[i,j] = 0.1;  
37.                     Delta_W_Out[i,j] = 0;  
38.                 }  
39.             }  
40.             for (int i = 0; i < n_hidden; i++)  
41.             {  
42.                 for (int j = 0; j < n_in + 1;j++ )  
43.                 {  
44.                     W_Hidden[i,j] = 0.1;  
45.                     Delta_W_Hidden[i,j] = 0;  
46.                 }  
47.             }  
48.             //迭代進行訓練  
49.             bool over = true;  
50.             int itera_time = 0;//迭代次數  
51.   
52.             while (over)  
53.             {  
54.                 //進行訓練  
55.                 for (int i = 0; i < row;i++ )  
56.                 {  
57.                     //計算隱含層單元的輸出  
58.                     double net = 0;  
59.                     for (int j = 0; j < n_hidden; j++)  
60.                     {  
61.                         net = W_Hidden[j, 0];  
62.                         //計算輸出值  
63.                         for (int r = 1; r < n_in + 1; r++)  
64.                         {  
65.                             net += W_Hidden[j, r] * t_ex[i, r - 1];  
66.                         }  
67.                         O_Hidden[j] = 1.0 / (1 + Math.Exp(-net));  
68.                     }  
69.                     //計算輸出層單元的輸出  
70.                     for (int j = 0; j < n_out;j++ )  
71.                     {  
72.                         net = W_Out[j,0];  
73.                         for (int r = 1; r < n_hidden + 1;r++ )  
74.                         {  
75.                             net += W_Out[j,r] * O_Hidden[r - 1];  
76.                         }  
77.                         O_Out[j] = 1.0 / (1 + Math.Exp(-net));  
78.                     }  
79.                     //計算輸出層單元的誤差項  
80.                     for (int j = 0; j < n_out;j++ )  
81.                     {  
82.                         Delta_Out[j] = O_Out[j] * (1 - O_Out[j]) * (t_ex[i,n_in + j] - O_Out[j]);  
83.                     }  
84.                     //計算隱含層單元的誤差項  
85.                     for (int j = 0;j < n_hidden;j++)  
86.                     {  
87.                         double sum_weight = 0;  
88.                         for (int k = 0;k < n_out;k++)  
89.                         {  
90.                             for (int h = 0;h < n_hidden + 1;h++)  
91.                             {  
92.                                 sum_weight += Delta_Out[k] * W_Out[k,h];  
93.                             }  
94.                         }  
95.                         Delta_Hidden[j] = O_Hidden[j] * (1 - O_Hidden[j]) * sum_weight;  
96.                     }  
97.                     //更新每個網絡單元的權值  
98.                     //更新輸出層的權值  
99.                     for (int j = 0;j < n_out;j++)  
100.                     {  
101.                         Delta_W_Out[j, 0] = eta * Delta_Out[j] + alfa * Delta_W_Out[j, 0];  
102.                         W_Out[j, 0] = W_Out[j, 0] + Delta_W_Out[j, 0];  
103.                            
104.                         for (int k = 1; k < n_hidden + 1;k++ )  
105.                         {  
106.                             Delta_W_Out[j, k] = eta * Delta_Out[j] * O_Hidden[k - 1] + alfa * Delta_W_Out[j, k];  
107.                             W_Out[j, k] = W_Out[j, k] + Delta_W_Out[j, k];          
108.                         }  
109.                     }  
110.                     //更新隱含層的權值  
111.                     for (int j = 0; j < n_hidden; j++)  
112.                     {  
113.                         Delta_W_Hidden[j, 0] = eta * Delta_Hidden[j] + alfa * Delta_W_Hidden[j, 0];  
114.                         W_Hidden[j, 0] = W_Hidden[j, 0] + Delta_W_Hidden[j, 0];   
115.                         for (int k = 1; k < n_in + 1;k++ )  
116.                         {  
117.                             Delta_W_Hidden[j, k] = eta * Delta_Hidden[j] * t_ex[i, k - 1] + alfa * Delta_W_Hidden[j, k];  
118.                             W_Hidden[j, k] = W_Hidden[j, k] + Delta_W_Hidden[j, k];                    
119.                         }  
120.                     }  
121.                 }  
122.   
123.                 //訓練1000次結束循環  
124.                 itera_time++;  
125.                 if (itera_time == 1000)over = false;  
126.             }  
127.   
128.             //輸出訓練後的權值  
129.             Console.WriteLine("輸出層權值：");  
130.             for (int i = 0; i < n_out; i++)  
131.             {  
132.                 for (int j = 0; j < n_hidden + 1;j++ )  
133.                 {  
134.                     Console.WriteLine(W_Out[i,j]);  
135.                 }  
136.             }  
137.             Console.WriteLine("隱含層權值：");  
138.             for (int i = 0; i < n_hidden; i++)  
139.             {  
140.                 for (int j = 0; j < n_in + 1;j++ )  
141.                 {  
142.                     Console.WriteLine(W_Hidden[i,j]);  
143.                 }      
144.             }  
145.          }  
146.     }