機器學習-隨機梯度降低（Stochastic gradient descent）和 批量梯度降低（Batch gradient descent ）

梯度降低（GD）是最小化風險函數、損失函數的一種經常使用方法，隨機梯度降低和批量梯度降低是兩種迭代求解思路，下面從公式和實現的角度對二者進行分析，若有哪一個方面寫的不對，但願網友糾正。

下面的h(x)是要擬合的函數，J(theta)損失函數，theta是參數，要迭代求解的值，theta求解出來了那最終要擬合的函數h(theta)就出來了。其中m是訓練集的記錄條數，i是參數的個數。

一、批量梯度降低的求解思路以下：

（1）將J(theta)對theta求偏導，獲得每一個theta對應的的梯度

（2）因爲是要最小化風險函數，因此按每一個參數theta的梯度負方向，來更新每一個theta

（3）從上面公式能夠注意到，它獲得的是一個全局最優解，可是每迭代一步，都要用到訓練集全部的數據，若是m很大，那麼可想而知這種方法的迭代速度！！因此，這就引入了另一種方法，隨機梯度降低。

二、隨機梯度降低的求解思路以下：

（1）上面的風險函數能夠寫成以下這種形式，損失函數對應的是訓練集中每一個樣本的粒度，而上面批量梯度降低對應的是全部的訓練樣本：

（2）每一個樣本的損失函數，對theta求偏導獲得對應梯度，來更新theta

（3）隨機梯度降低是經過每一個樣原本迭代更新一次，若是樣本量很大的狀況（例如幾十萬），那麼可能只用其中幾萬條或者幾千條的樣本，就已經將theta迭代到最優解了，對比上面的批量梯度降低，迭代一次須要用到十幾萬訓練樣本，一次迭代不可能最優，若是迭代10次的話就須要遍歷訓練樣本10次。可是，SGD伴隨的一個問題是噪音較BGD要多，使得SGD並非每次迭代都向着總體最優化方向。

三、對於上面的linear regression問題，與批量梯度降低對比，隨機梯度降低求解的會是最優解嗎？

（1）批量梯度降低---最小化全部訓練樣本的損失函數，使得最終求解的是全局的最優解，即求解的參數是使得風險函數最小。

（2）隨機梯度降低---最小化每條樣本的損失函數，雖然不是每次迭代獲得的損失函數都向着全局最優方向， 可是大的總體的方向是向全局最優解的，最終的結果每每是在全局最優解附近。

四、梯度降低用來求最優解，哪些問題能夠求得全局最優？哪些問題可能局部最優解？

對於上面的linear regression問題，最優化問題對theta的分佈是unimodal，即從圖形上面看只有一個peak，因此梯度降低最終求得的是全局最優解。然而對於multimodal的問題，由於存在多個peak值，頗有可能梯度降低的最終結果是局部最優。

 五、隨機梯度和批量梯度的實現差異

之前一篇博文中NMF實現爲例，列出二者的實現差異（注：其實對應Python的代碼要直觀的多，之後要練習多寫python！）

    // 隨機梯度降低，更新參數  
    public void updatePQ_stochastic(double alpha, double beta) {  
        for (int i = 0; i < M; i++) {  
            ArrayList<Feature> Ri = this.dataset.getDataAt(i).getAllFeature();  
            for (Feature Rij : Ri) {  
                // eij=Rij.weight-PQ for updating P and Q  
                double PQ = 0;  
                for (int k = 0; k < K; k++) {  
                    PQ += P[i][k] * Q[k][Rij.dim];  
                }  
                double eij = Rij.weight - PQ;  
      
                // update Pik and Qkj  
                for (int k = 0; k < K; k++) {  
                    double oldPik = P[i][k];  
                    P[i][k] += alpha  
                            * (2 * eij * Q[k][Rij.dim] - beta * P[i][k]);  
                    Q[k][Rij.dim] += alpha  
                            * (2 * eij * oldPik - beta * Q[k][Rij.dim]);  
                }  
            }  
        }  
    }  
      
    // 批量梯度降低，更新參數  
    public void updatePQ_batch(double alpha, double beta) {  
      
        for (int i = 0; i < M; i++) {  
            ArrayList<Feature> Ri = this.dataset.getDataAt(i).getAllFeature();  
      
            for (Feature Rij : Ri) {  
                // Rij.error=Rij.weight-PQ for updating P and Q  
                double PQ = 0;  
                for (int k = 0; k < K; k++) {  
                    PQ += P[i][k] * Q[k][Rij.dim];  
                }  
                Rij.error = Rij.weight - PQ;  
            }  
        }  
      
        for (int i = 0; i < M; i++) {  
            ArrayList<Feature> Ri = this.dataset.getDataAt(i).getAllFeature();  
            for (Feature Rij : Ri) {  
                for (int k = 0; k < K; k++) {  
                    // 對參數更新的累積項  
                    double eq_sum = 0;  
                    double ep_sum = 0;  
      
                    for (int ki = 0; ki < M; ki++) {// 固定k和j以後,對全部i項加和  
                        ArrayList<Feature> tmp = this.dataset.getDataAt(i).getAllFeature();  
                        for (Feature Rj : tmp) {  
                            if (Rj.dim == Rij.dim)  
                                ep_sum += P[ki][k] * Rj.error;  
                        }  
                    }  
                    for (Feature Rj : Ri) {// 固定k和i以後,對多有j項加和  
                        eq_sum += Rj.error * Q[k][Rj.dim];  
                    }  
      
                    // 對參數更新  
                    P[i][k] += alpha * (2 * eq_sum - beta * P[i][k]);  
                    Q[k][Rij.dim] += alpha * (2 * ep_sum - beta * Q[k][Rij.dim]);  
                }  
            }  
        }  
    }