【Machine Learning實驗1】batch gradient descent（批量梯度下降） 和 stochastic gradient descent（隨機梯度下降）

原文：http://blog.csdn.net/pennyliang/article/details/6998517

批量梯度下降是一種對參數的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
*/

批量梯度下降法：

#include "stdio.h"

int main(void)
{
        float matrix[4][2]={{1,4},{2,5},{5,1},{4,2}};
        float result[4]={19,26,19,20};
        float theta[2]={2,5};                   //initialized theta {2,5}, we use the algorithm to get {3,4} to fit the model
        float learning_rate = 0.01;
        float loss = 1000.0;                    //set a loss big enough

        for(int i = 0;i<100&&loss>0.0001;++i)
        {
                float error_sum = 0.0;
                for(int j = 0;j<4;++j)
                {
                        float h = 0.0;
                        for(int k=0;k<2;++k)
                        {
                                h += matrix[j][k]*theta[k];
                        }
                        error_sum = result[j]-h;
                        for(int k=0;k<2;++k)
                        {
                                theta[k] += learning_rate*(error_sum)*matrix[j][k];  //注意，原文這裏有錯誤
                        }
                }
                printf("*************************************\n");
                printf("theta now: %f,%f\n",theta[0],theta[1]);
                loss = 0.0;
                for(int j = 0;j<4;++j)
                {
                        float sum=0.0;
                        for(int k = 0;k<2;++k)
                        {


                                sum += matrix[j][k]*theta[k];
                        }
                        loss += (sum-result[j])*(sum-result[j]);
                }
                printf("loss  now: %f\n",loss);
        }
        return 0;
}

隨機梯度下降法

int main(void)
{
        float matrix[4][2]={{1,4},{2,5},{5,1},{4,2}};
        float result[4]={19,26,19,20};
        float theta[2]={2,5};
        float loss = 10.0;
        for(int i =0 ;i<100&&loss>0.001;++i)
        {
                float error_sum=0.0;
                int j=i%4;
                {
                        float h = 0.0;
                        for(int k=0;k<2;++k)
                        {
                                h += matrix[j][k]*theta[k];

                        }
                        error_sum = result[j]-h;
                        for(int k=0;k<2;++k)
                        {
                                theta[k] = theta[k]+0.01*(error_sum)*matrix[j][k];
                        }
                }
                printf("%f,%f\n",theta[0],theta[1]);
                float loss = 0.0;
                for(int j = 0;j<4;++j)
                {
                        float sum=0.0;
                        for(int k = 0;k<2;++k)
                        {

                                sum += matrix[j][k]*theta[k];
                        }
                        loss += (sum-result[j])*(sum-result[j]);
                }
                printf("%f\n",loss);
        }
        return 0;
}

#include "stdio.h"

//貼出修改錯誤後的代碼
int main(void)
{
        float matrix[4][2]={{1,4},{2,5},{5,1},{4,2}};
        float result[4]={19,26,19,20};
        float theta[2]={2,5};  //initialized theta {2,5}, we use the algorithm to get {3,4} to fit the model
        float learning_rate = 0.001;//leaning_rate cann't be too big
        float loss = 1000.0; //set a loss big enough
        float error_sum[2]={0,0};
        for(int i = 0;i<1000&&loss>0.0001;++i)
        {
            for(int j = 0;j<4;++j)
            {
                float h=0;
                for(int k=0;k<2;++k)
                {
                        h += matrix[j][k]*theta[k];    
                }
                for(int k=0;k<2;++k)
                {    
                        error_sum[k] += (result[j]-h)*matrix[j][k];
                }            
                
                if(j==3)
                {
                    for(int k=0;k<2;++k)
                    {
                        theta[k] += learning_rate*(error_sum[k]);
                    }
                }
            }
            printf("*************************************\n");
            printf("theta now: %f,%f\n",theta[0],theta[1]);
            printf("i: %d\n",i);
            loss = 0.0;
            for(int j = 0;j<4;++j)
            {
                float sum=0.0;
                for(int k = 0;k<2;++k)
                {
                    sum += matrix[j][k]*theta[k];
                }
                loss += (sum-result[j])*(sum-result[j]);
            }
            printf("loss ?now: %f\n",loss);
        }
        return 0;
}

參考：

【1】http://www.stanford.edu/class/cs229/notes/cs229-notes1.pdf 

【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/