各种梯度下降、学习率、爬山

目录

一，问题实例

二，梯度下降 Gradient Descent

三，学习率

四，随机梯度下降 SGD

五，自适应学习率

AdaGrad（自适应梯度下降）

Momentum（带动量的梯度下降）

RMSProp（Root Mean Square Prop）

Adam（Adaptive Moment Estimation）

六，爬山算法

1，问题实例

2，暴力求解

3，首选爬山算法

4，最陡爬山算法

5，不同的搜索起点

七，投影梯度下降

---

一，问题实例

求函数 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算法能适应的初始学习率的范围也很广。

六，爬山算法

爬山算法相当于梯度下降的简化版，只在搜索空间/搜索精度较小的情况下适应。

如图像处理，搜索空间/搜索精度大约10^3的数量级，而其他领域超过10^6是很正常的，这种就不适合用爬山。

1，问题实例

求解函数的最大值。

我们可以用python画出图像

from matplotlib import pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D

def func(X, Y, x_move=0, y_move=0):
    def mul(X, Y, alis=1):
        return alis * np.exp(-(X * X + Y * Y))

    return mul(X, Y) + mul(X - x_move, Y - y_move, 2)


def show(X, Y):
    fig = plt.figure()
    ax = Axes3D(fig)
    X, Y = np.meshgrid(X, Y)
    Z = func(X, Y, 5, 5)
    plt.title("demo_hill_climbing")
    ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='rainbow', )
    ax.set_xlabel('x label', color='r')
    ax.set_ylabel('y label', color='g')
    ax.set_zlabel('z label', color='b')
    plt.show()

if __name__ == '__main__':
    X = np.arange(-5, 10, 0.1)
    Y = np.arange(-5, 10, 0.1)

    show(X,Y)

2，暴力求解

求整数级自变量的最大值

double f(double x, double y)
{
	double a = -x * x - y * y;
	double b = -(x - 5)*(x - 5) - (y - 5)*(y - 5);
	return exp(a) + 2 * exp(b);
}

int main()
{
	double ans = 0;
	for (int i = -5; i <= 10; i++)for (int j = -5; j <= 10; j++) {
		if (ans < f(i, j)) {
			ans = f(i, j);
			cout << i << " " << j << " " << ans<<endl;
		}
	}
	cout << ans;
	return 0;
}

输出：

......省略前面若干行
-3 0 0.00012341
-2 -2 0.000335463
-2 -1 0.00673795
-2 0 0.0183156
-1 -1 0.135335
-1 0 0.367879
0 0 1
5 5 2

即（5,5）附近是第一高峰，（0,0）附近是第二高峰。

算法缺陷：

（1）计算量大，效率低

（2）要想求更精确的值，更加复杂

3，首选爬山算法

首选爬山算法就是每次选择4个邻居，从中选择最优的点，一直持续下去，直到爬到某个山顶。

int dx[] = { 0, 1, -1, 0, 0 };
int dy[] = { 0, 0, 0, 1, -1 };

int main()
{
	double x = 1, y = 5, d = 0.1;
	while (true)
	{
		int ansDir = 0;
		for (int dire = 1; dire < sizeof(dx) / sizeof(dx[0]); dire++)
		{
			if (f(x + d * dx[dire], y + d * dy[dire]) > f(x + d * dx[ansDir], y + d * dy[ansDir]))ansDir = dire;
		}
		x += d * dx[ansDir], y += d * dy[ansDir];
		cout << x << " " << y << " " << f(x, y) << endl;
		if (ansDir == 0)break;
	}
	return 0;
}

输出：

1.1 5 4.95923e-07
1.2 5 1.07107e-06
1.3 5 2.26746e-06
1.4 5 4.70515e-06
1.5 5 9.57024e-06
1.6 5 1.90803e-05
1.7 5 3.72875e-05
1.8 5 7.14257e-05
1.9 5 0.00013411
2 5 0.00024682
2.1 5 0.00044526
2.2 5 0.000787338
2.3 5 0.00136466
2.4 5 0.00231846
2.5 5 0.00386091
2.6 5 0.00630222
2.7 5 0.0100835
2.8 5 0.0158141
2.9 5 0.0243104
3 5 0.0366313
3.1 5 0.0541037
3.2 5 0.0783278
3.3 5 0.111152
3.4 5 0.154609
3.5 5 0.210798
3.6 5 0.281717
3.7 5 0.369039
3.8 5 0.473856
3.9 5 0.596395
4 5 0.735759
4.1 5 0.889716
4.2 5 1.05458
4.3 5 1.22525
4.4 5 1.39535
4.5 5 1.5576
4.6 5 1.70429
4.7 5 1.82786
4.8 5 1.92158
4.9 5 1.9801
5 5 2
5 5 2

4，最陡爬山算法

每次不只是选择四邻居，每次选择一个邻域内的所有点，从中选择最优的点。

int main()
{
	double x = 1, y = 5, d = 0.1;
	while (true)
	{
		int ai = 0, aj = 0;
		for (int i = -3; i < 3; i++)for (int j = -3; j < 3; j++)
		{
			if (f(x + d * i, y + d * j) > f(x + d * ai, y + d * aj))ai = i, aj = j;
		}
		x += d * ai, y += d * aj;
		cout << x << " " << y << " " << f(x, y) << endl;
		if (ai == 0 && aj == 0)break;
	}
	return 0;
}

输出：

1.2 5 1.07107e-06
1.4 5 4.70515e-06
1.6 5 1.90803e-05
1.8 5 7.14257e-05
2 5 0.00024682
2.2 5 0.000787338
2.4 5 0.00231846
2.6 5 0.00630222
2.8 5 0.0158141
3 5 0.0366313
3.2 5 0.0783278
3.4 5 0.154609
3.6 5 0.281717
3.8 5 0.473856
4 5 0.735759
4.2 5 1.05458
4.4 5 1.39535
4.6 5 1.70429
4.8 5 1.92158
5 5 2
5 5 2

迭代次数少一些，但是每次迭代的计算量大一些。

5，不同的搜索起点

如果搜索起点换成（1,1）：

int main()
{
	double x = 1, y = 1, d = 0.1;
	while (true)
	{
		int ansDir = 0;
		for (int dire = 1; dire < sizeof(dx) / sizeof(dx[0]); dire++)
		{
			if (f(x + d * dx[dire], y + d * dy[dire]) > f(x + d * dx[ansDir], y + d * dy[ansDir]))ansDir = dire;
		}
		x += d * dx[ansDir], y += d * dy[ansDir];
		cout << x << " " << y << " " << f(x, y) << endl;
		if (ansDir == 0)break;
	}
	return 0;
}

输出结果：

0.9 1 0.163654
0.9 0.9 0.197899
0.8 0.9 0.23457
0.8 0.8 0.278037
0.7 0.8 0.323033
0.7 0.7 0.375311
0.6 0.7 0.427415
0.6 0.6 0.486752
0.5 0.6 0.543351
0.5 0.5 0.606531
0.4 0.5 0.66365
0.4 0.4 0.726149
0.3 0.4 0.778801
0.3 0.3 0.83527
0.2 0.3 0.878095
0.2 0.2 0.923116
0.1 0.2 0.951229
0.1 0.1 0.980199
1.38778e-16 0.1 0.99005
1.38778e-16 1.38778e-16 1
1.38778e-16 1.38778e-16 1

求出来的局部最优解（0,0）不是全局最优解，即使是最陡爬山算法也会走到这个点。

要想尽量避免这种情况，需要其他算法。

七，投影梯度下降

投影梯度下降用于解决带凸约束的光滑凸优化问题。

投影梯度下降可以理解成近端梯度下降的一种特例。