机器学习-随机梯度降低（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]);  
                }  
            }  
        }  
    }