批量梯度下降是一種對引數的update進行累積，然後批量更新的一種方式。用於在已知整個訓練集時的一種訓練方式，但對於大規模資料並不合適。

隨機梯度下降是一種對引數隨著樣本訓練，一個一個的及時update的方式。常用於大規模訓練集，當往往容易收斂到區域性最優解。

詳細參見：Andrew Ng 的Machine Learning的課件（見參考1）

可能存在的改進

1）樣本可靠度，特徵完備性的驗證

      例如可能存在一些outlier，這種outlier可能是測量誤差，也有可能是未考慮樣本特徵，例如有一件衣服色彩評分1分，料子1分，確可以賣到10000萬元，原來是上面有一個姚明的簽名，這個特徵沒有考慮，所以出現了訓練的誤差，識別樣本中outlier產生的原因。

2）批量梯度下降方法的改進

3）隨機梯度下降方法的改進

      找到一個合適的訓練路徑（學習順序），去最大可能的找到全域性最優解

4）假設合理性的檢驗

     H（X)是否合理的檢驗

5）維度放大

    維度放大和過擬合問題，維度過大對訓練集擬合會改善，對測試集的適用性會變差，如果找到合理的方法？

下面是我做的一個實驗

假定有這樣一個對衣服估價的訓練樣本，程式碼中matrix表示，第一列表示色彩的評分，第二列表示對料子質地的評分，例如第一個樣本1,4表示這件衣服色彩打1分，料子打4分。我們需要訓練的是theta，其表示在衣服的估價中，色彩和料子的權重，這個權重是未知量，是需要訓練的，訓練的依據是這四個樣本的真實價格已知，分別為19元，...20元。

通過批量梯度下降和隨機梯度下降的方法均可得到theta_C={3,4}T

/*
Matrix_A
1   4
2   5
5   1
4   2
theta_C

?

?
Matrix_A*theta_C
19
26
19
20
*/

批量梯度下降法：

1. #include "stdio.h"
2. int main(void)  
3. {  
4.         float matrix[4][2]={{1,4},{2,5},{5,1},{4,2}};  
5.         float result[4]={19,26,19,20};  
6.         float theta[2]={2,5};                   
   //initialized theta {2,5}, we use the algorithm to get {3,4} to fit the model
7.         float learning_rate = 0.01;  
8.         float loss = 1000.0;                    //set a loss big enough
9.         for(int i = 0;i<100&&loss>0.0001;++i)  
10.         {  
11.                 float error_sum = 0.0;  
12.                 for(int j = 0;j<4;++j)  
13.                 {  
14.                         float h = 0.0;  
15.                         for(int k=0;k<2;++k)  
16.                         {  
17.                                 h += matrix[j][k]*theta[k];  
18.                         }  
19.                         error_sum = result[j]-h;  
20.                         for(int k=0;k<2;++k)  
21.                         {  
22.                                 theta[k] += learning_rate*(error_sum)*matrix[j][k];  
23.                         }  
24.                 }  
25.                 printf("*************************************\n");  
26.                 printf("theta now: %f,%f\n",theta[0],theta[1]);  
27.                 loss = 0.0;  
28.                 for(int j = 0;j<4;++j)  
29.                 {  
30.                         float sum=0.0;  
31.                         for(int k = 0;k<2;++k)  
32.                         {  
33.                                 sum += matrix[j][k]*theta[k];  
34.                         }  
35.                         loss += (sum-result[j])*(sum-result[j]);  
36.                 }  
37.                 printf("loss  now: %f\n",loss);  
38.         }  
39.         return 0;  
40. }  

1. int main(void)  
2. {  
3.         float matrix[4][2]={{1,4},{2,5},{5,1},{4,2}};  
4.         float result[4]={19,26,19,20};  
5.         float theta[2]={2,5};  
6.         float loss = 10.0;  
7.         for(int i =0 ;i<100&&loss>0.001;++i)  
8.         {  
9.                 float error_sum=0.0;  
10.                 int j=i%4;  
11.                 {  
12.                         float h = 0.0;  
13.                         for(int k=0;k<2;++k)  
14.                         {  
15.                                 h += matrix[j][k]*theta[k];  
16.                         }  
17.                         error_sum = result[j]-h;  
18.                         for(int k=0;k<2;++k)  
19.                         {  
20.                                 theta[k] = theta[k]+0.01*(error_sum)*matrix[j][k];  
21.                         }  
22.                 }  
23.                 printf("%f,%f\n",theta[0],theta[1]);  
24.                 float loss = 0.0;  
25.                 for(int j = 0;j<4;++j)  
26.                 {  
27.                         float sum=0.0;  
28.                         for(int k = 0;k<2;++k)  
29.                         {  
30.                                 sum += matrix[j][k]*theta[k];  
31.                         }  
32.                         loss += (sum-result[j])*(sum-result[j]);  
33.                 }  
34.                 printf("%f\n",loss);  
35.         }  
36.         return 0;  
37. }  

參考：

【2】http://www.cnblogs.com/rocketfan/archive/2011/02/27/1966325.html

【3】http://www.dsplog.com/2011/10/29/batch-gradient-descent/

【4】http://ygc.name/2011/03/22/machine-learning-ex2-linear-regression/