目录
RMSProp（Root Mean Square Prop）
Adam（Adaptive Moment Estimation）
一，问题实例
求函数 func(X, Y)=X*X + Y*Y*2的最小值。
double f(double x, double y)
{
return x * x + y * y* 2;
}虽然最小值显然是f(0,0)=0，但是同样可以用梯度下降算法来求，
而对于一些复杂的函数就很难求出最小值，只能用梯度下降算法求近似局部最小值了。
二，梯度下降 Gradient Descent
代码：
int main()
{
double x = 10, y = 10, eta = 0.1, d = 0.01;
for (int i = 0; i < 20; i++) {
double dfx = (f(x + d, y) - f(x, y)) / d;
double dfy = (f(x, y + d) - f(x, y)) / d;
x -= eta * dfx;
y -= eta * dfy;
cout << x << " " << y << " " << f(x, y) << endl;
}
return 0;
}输出：
7.999 5.998 135.936
6.3982 3.5968 66.8109
5.11756 2.15608 35.4868
4.09305 1.29165 20.0898
3.27344 0.772989 11.9104
2.61775 0.461793 7.27912
2.0932 0.275076 4.53282
1.67356 0.163046 2.85397
1.33785 0.0958273 1.8082
1.06928 0.0554964 1.14952
0.854423 0.0312978 0.731998
0.682538 0.0167787 0.466422
0.545031 0.00806722 0.297189
0.435025 0.00284033 0.189262
0.34702 -0.000295799 0.120423
0.276616 -0.00217748 0.0765257
0.220293 -0.00330649 0.0485507
0.175234 -0.00398389 0.0307387
0.139187 -0.00439034 0.0194116
0.11035 -0.0046342 0.01222
大概需要20-50次迭代
三，学习率
上面的η (eta)就是学习率。
如果学习率调为0.01，大概需要200次迭代，因为函数在（0,0）附近很平缓，所以需要的迭代次数很多。
如果学习率调为0.3，只需要10次迭代：
3.997 -2.006 24.0241
1.5958 0.3952 2.85894
0.63532 -0.08504 0.418095
0.251128 0.011008 0.0633076
0.0974512 -0.0082016 0.00963127
0.0359805 -0.00435968 0.00133261
0.0113922 -0.00512806 0.000182376
0.00155688 -0.00497439 5.19129e-05
-0.00237725 -0.00500512 5.57538e-05
-0.0039509 -0.00499898 6.55891e-05
如果学习率继续调大，一旦超过某个值（这个例子中大概是0.5）就会出现极端恶劣的情况：
左右徘徊，甚至直接变成发散的，没能收敛。
所以，对于梯度下降算法，如何选择学习率是个重要且困难的事情。
而且，学习率不能是一个值通用所有特征，不同的参数需要不同的学习率。
四，随机梯度下降 SGD
SGD算法是每次从样本中随机抽出一组，训练后按梯度更新一次。
随机梯度下降算法通常还有三种不同的应用方式，它们分别是SGD、Batch-SGD、Mini-Batch SGD
a.SGD是最基本的随机梯度下降，它是指每次参数更新只使用一个样本，这样可能导致更新较慢；
b.Batch-SGD是批随机梯度下降，它是指每次参数更新使用所有样本，即把所有样本都代入计算一遍，然后取它们的参数更新均值，来对参数进行一次性更新，这种更新方式较为粗糙；
c.Mini-Batch-SGD是小批量随机梯度下降，它是指每次参数更新使用一小批样本。
五，自适应学习率
无论是梯度下降还是随机梯度下降，都面临一个问题，学习率如果太小需要的迭代次数太多，如果太大可能左右徘徊很难接近局部最优解。
AdaGrad（自适应梯度下降）
ada就是自适应的意思。
看到不同的博主有不同的讲解，第一种：
在梯度下降的基础上，新增一个变量记录每次迭代的梯度的平方和dsum。
每次进行梯度更新时，梯度除以sqrt(dsum)即可。
int main()
{
double x = 10, y = 10, eta = 10, d = 0.01;
double dsum = 0;
for (int i = 0; i < 20; i++) {
double dfx = (f(x + d, y) - f(x, y)) / d;
double dfy = (f(x, y + d) - f(x, y)) / d;
dsum += dfx * dfx + dfy * dfy;
x -= eta * dfx / sqrt(dsum);
y -= eta * dfy / sqrt(dsum);
cout << x << " " << y << " " << f(x, y) << endl;
}
return 0;
}如果设定的初始学习率是1，那还是有学习率太小的问题。
但是如果学习率大一些，从10到1000都可以，在20次迭代内都可以到很好的结果。
以上面的代码（10）为例：
5.52786 1.05573 32.7864
3.13717 0.139068 9.8805
1.79191 0.0157085 3.21145
1.02487 -0.00197106 1.05037
0.585676 -0.00455448 0.343058
0.333859 -0.00493435 0.111511
0.189412 -0.00499032 0.0359266
0.106542 -0.00499857 0.0114011
0.0589963 -0.00499979 0.00353056
0.0317176 -0.00499997 0.001056
0.0160666 -0.005 0.000308134
0.00708685 -0.005 0.000100223
0.00193479 -0.005 5.37434e-05
-0.00102119 -0.005 5.10428e-05
-0.00271718 -0.005 5.7383e-05
-0.00369024 -0.005 6.36179e-05
-0.00424853 -0.005 6.805e-05
-0.00456885 -0.005 7.08744e-05
-0.00475263 -0.005 7.25875e-05
-0.00485807 -0.005 7.36009e-05
可以看出来收敛非常快。
第二种：
各个维度单独算梯度的平方和dsum*，每次进行梯度更新时，各个维度的梯度除以各自的sqrt(dsum*)
int main()
{
double x = 10, y = 10, eta = 1000, d = 0.01;
double dsumx = 0, dsumy = 0;
for (int i = 0; i < 20; i++) {
double dfx = (f(x + d, y) - f(x, y)) / d;
double dfy = (f(x, y + d) - f(x, y)) / d;
dsumx = dsumx + dfx * dfx;
dsumy = dsumy + dfy * dfy;
x -= eta * dfx / sqrt(dsumx);
y -= eta * dfy / sqrt(dsumy);
cout << x << " " << y << " " << f(x, y) << endl;
}
return 0;
}在本文的例子中，这种方法效果更好。
Momentum（带动量的梯度下降）
在梯度下降的基础上，新增一个变量把每次迭代的梯度累积求和，同时采用衰减率对累积的和进行衰减。
int main()
{
double x = 10, y = 10, eta = 1, d = 0.01;
double dsumx = 0, dsumy = 0, gamma = 0.9;
for (int i = 0; i < 200; i++) {
double dfx = (f(x + d, y) - f(x, y)) / d;
double dfy = (f(x, y + d) - f(x, y)) / d;
dsumx = dsumx * gamma + dfx * (1 - gamma);
dsumy = dsumy * gamma + dfy * (1 - gamma);
x -= eta * dsumx;
y -= eta * dsumy;
cout << x << " " << y << " " << f(x, y) << endl;
}
return 0;
}当学习率较大时，还是会发生左右徘徊甚至不能收敛的情况。
RMSProp（Root Mean Square Prop）
RMSProp是像AdaGrad一样计算梯度的累积平方和，又像Momentum一样做衰减。
int main()
{
double x = 10, y = 10, eta = 1000, d = 0.01;
double dsumx = 0, dsumy = 0, gamma = 0.999;
for (int i = 0; i < 50; i++) {
double dfx = (f(x + d, y) - f(x, y)) / d;
double dfy = (f(x, y + d) - f(x, y)) / d;
dsumx = dsumx * gamma + dfx * dfx * (1 - gamma);
dsumy = dsumy * gamma + dfy * dfy * (1 - gamma);
x -= eta * dfx / sqrt(dsumx);
y -= eta * dfy / sqrt(dsumy);
cout << x << " " << y << " " << f(x, y) << endl;
}
return 0;
}RMSProp能适应的初始学习率的范围比AdaGrad和Momentum要广。
Adam（Adaptive Moment Estimation）
Adam算法是将Momentum算法和RMSProp算法结合起来。
int main()
{
double x = 10, y = 10, eta = 1, d = 0.01;
double dsumx1 = 0, dsumy1 = 0, gamma1 = 0.9, gt1 = 1;
double dsumx2 = 0, dsumy2 = 0, gamma2 = 0.999, gt2 = 1;
for (int i = 0; i < 200; i++) {
double dfx = (f(x + d, y) - f(x, y)) / d;
double dfy = (f(x, y + d) - f(x, y)) / d;
dsumx1 = dsumx1 * gamma1 + dfx * (1 - gamma1);
dsumy1 = dsumy1 * gamma1 + dfy * (1 - gamma1);
dsumx2 = dsumx2 * gamma2 + dfx * dfx * (1 - gamma2);
dsumy2 = dsumy2 * gamma2 + dfy * dfy * (1 - gamma2);
gt1 *= gamma1, gt2 *= gamma2;
x -= eta * dsumx1 / (1 - gt1) / sqrt(dsumx2 / (1 - gt2));
y -= eta * dsumy1 / (1 - gt1) / sqrt(dsumy2 / (1 - gt2));
cout << x << " " << y << " " << f(x, y) << endl;
}
return 0;
}Adam算法能适应的初始学习率的范围也很广。