[zz]随机梯度下降（Stochastic gradient descent）和 批量梯度下降（Batch gradient descent ）的公式对比、实现对比 (Understand completely?)

http://blog.csdn.net/lilyth_lilyth/article/details/8973972

随机梯度下降是通过每个样本来迭代更新一次，如果样本量很大的情况（例如几十万），那么可能只用其中几万条或者几千条的样本，就已经将theta迭代到最优解了，对比上面的批量梯度下降(batch gradient descent)，迭代一次需要用到十几万训练样本，一次迭代不可能最优，如果迭代10次的话就需要遍历训练样本10次。但是，SGD伴随的一个问题是噪音较BGD要多，使得SGD并不是每次迭代都向着整体最优化方向。

随机梯度和批量梯度的实现差别

以前一篇博文中NMF实现为例，列出两者的实现差别（注：其实对应python的代码要直观的多，以后要练习多写python！）

 

[java]  view plain copy

1. // 随机梯度下降，更新参数  
2. public void updatePQ_stochastic(double alpha, double beta) {  
3.     for (int i = 0; i < M; i++) {  
4.         ArrayList<Feature> Ri = this.dataset.getDataAt(i).getAllFeature();  
5.         for (Feature Rij : Ri) {  
6.             // eij=Rij.weight-PQ for updating P and Q  
7.             double PQ = 0;  
8.             for (int k = 0; k < K; k++) {  
9.                 PQ += P[i][k] * Q[k][Rij.dim];  
10.             }  
11.             double eij = Rij.weight - PQ;  
12.   
13.             // update Pik and Qkj  
14.             for (int k = 0; k < K; k++) {  
15.                 double oldPik = P[i][k];  
16.                 P[i][k] += alpha  
17.                         * (2 * eij * Q[k][Rij.dim] - beta * P[i][k]);  
18.                 Q[k][Rij.dim] += alpha  
19.                         * (2 * eij * oldPik - beta * Q[k][Rij.dim]);  
20.             }  
21.         }  
22.     }  
23. }  
24.   
25. // 批量梯度下降，更新参数  
26. public void updatePQ_batch(double alpha, double beta) {  
27.   
28.     for (int i = 0; i < M; i++) {  
29.         ArrayList<Feature> Ri = this.dataset.getDataAt(i).getAllFeature();  
30.   
31.         for (Feature Rij : Ri) {  
32.             // Rij.error=Rij.weight-PQ for updating P and Q  
33.             double PQ = 0;  
34.             for (int k = 0; k < K; k++) {  
35.                 PQ += P[i][k] * Q[k][Rij.dim];  
36.             }  
37.             Rij.error = Rij.weight - PQ;  
38.         }  
39.     }  
40.   
41.     for (int i = 0; i < M; i++) {  
42.         ArrayList<Feature> Ri = this.dataset.getDataAt(i).getAllFeature();  
43.         for (Feature Rij : Ri) {  
44.             for (int k = 0; k < K; k++) {  
45.                 // 对参数更新的累积项  
46.                 double eq_sum = 0;  
47.                 double ep_sum = 0;  
48.   
49.                 for (int ki = 0; ki < M; ki++) {// 固定k和j之后,对所有i项加和  
50.                     ArrayList<Feature> tmp = this.dataset.getDataAt(i).getAllFeature();  
51.                     for (Feature Rj : tmp) {  
52.                         if (Rj.dim == Rij.dim)  
53.                             ep_sum += P[ki][k] * Rj.error;  
54.                     }  
55.                 }  
56.                 for (Feature Rj : Ri) {// 固定k和i之后,对多有j项加和  
57.                     eq_sum += Rj.error * Q[k][Rj.dim];  
58.                 }  
59.   
60.                 // 对参数更新  
61.                 P[i][k] += alpha * (2 * eq_sum - beta * P[i][k]);  

自我理解 ：http://blog.csdn.net/lilyth_lilyth/article/details/8973972 ,该网址的其余部分绝对绝对不必看，看NG的Coursera课程Machine learning的Lecture17即可