import numpy as np
from matplotlib import pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
def func(x, y):
return x * x / 20 + y * y
def paint_loss_func():
x = np.linspace(-50, 50, 100) # x的绘制范围是-50到50,从改区间均匀取100个数
y = np.linspace(-50, 50, 100) # y的绘制范围是-50到50,从改区间均匀取100个数
X, Y = np.meshgrid(x, y)
Z = func(X, Y)
fig = plt.figure() # figsize=(10, 10))
ax = Axes3D(fig)
plt.xlabel('x')
plt.ylabel('y')
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='rainbow')
plt.show()
paint_loss_func()
这个梯度的特征是,y轴方向上大,x轴方向上小。换句话说, 就是y轴方向的坡度大,而x轴方向的坡度小。这里需要注意的是,虽然式 (6.2)的最小值在(x, y)= (0, 0)处,但是图6-2中的梯度在很多地方并没有指向(0,0)。
# coding: utf-8
import numpy as np
import matplotlib.pyplot as plt
from collections import OrderedDict
class SGD:
"""随机梯度下降法(Stochastic Gradient Descent)"""
def __init__(self, lr=0.01):
self.lr = lr
def update(self, params, grads):
for key in params.keys():
params[key] -= self.lr * grads[key]
class Momentum:
"""Momentum SGD"""
def __init__(self, lr=0.01, momentum=0.9):
self.lr = lr
self.momentum = momentum
self.v = None
def update(self, params, grads):
if self.v is None:
self.v = {}
for key, val in params.items():
self.v[key] = np.zeros_like(val)
for key in params.keys():
self.v[key] = self.momentum * self.v[key] - self.lr * grads[key]
params[key] += self.v[key]
class Nesterov:
"""Nesterov's Accelerated Gradient (http://arxiv.org/abs/1212.0901)"""
def __init__(self, lr=0.01, momentum=0.9):
self.lr = lr
self.momentum = momentum
self.v = None
def update(self, params, grads):
if self.v is None:
self.v = {}
for key, val in params.items():
self.v[key] = np.zeros_like(val)
for key in params.keys():
self.v[key] *= self.momentum
self.v[key] -= self.lr * grads[key]
params[key] += self.momentum * self.momentum * self.v[key]
params[key] -= (1 + self.momentum) * self.lr * grads[key]
class AdaGrad:
"""AdaGrad"""
def __init__(self, lr=0.01):
self.lr = lr
self.h = None
def update(self, params, grads):
if self.h is None:
self.h = {}
for key, val in params.items():
self.h[key] = np.zeros_like(val)
for key in params.keys():
self.h[key] += grads[key] * grads[key]
params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-7)
class RMSprop:
"""RMSprop"""
def __init__(self, lr=0.01, decay_rate=0.99):
self.lr = lr
self.decay_rate = decay_rate
self.h = None
def update(self, params, grads):
if self.h is None:
self.h = {}
for key, val in params.items():
self.h[key] = np.zeros_like(val)
for key in params.keys():
self.h[key] *= self.decay_rate
self.h[key] += (1 - self.decay_rate) * grads[key] * grads[key]
params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-7)
class Adam:
"""Adam (http://arxiv.org/abs/1412.6980v8)"""
def __init__(self, lr=0.001, beta1=0.9, beta2=0.999):
self.lr = lr
self.beta1 = beta1
self.beta2 = beta2
self.iter = 0
self.m = None
self.v = None
def update(self, params, grads):
if self.m is None:
self.m, self.v = {}, {}
for key, val in params.items():
self.m[key] = np.zeros_like(val)
self.v[key] = np.zeros_like(val)
self.iter += 1
lr_t = self.lr * np.sqrt(1.0 - self.beta2 ** self.iter) / (1.0 - self.beta1 ** self.iter)
for key in params.keys():
self.m[key] += (1 - self.beta1) * (grads[key] - self.m[key])
self.v[key] += (1 - self.beta2) * (grads[key] ** 2 - self.v[key])
params[key] -= lr_t * self.m[key] / (np.sqrt(self.v[key]) + 1e-7)
def f(x, y):
return x ** 2 / 20.0 + y ** 2
def df(x, y):
return x / 10.0, 2.0 * y
init_pos = (-7.0, 2.0)
params = {}
params['x'], params['y'] = init_pos[0], init_pos[1]
grads = {}
grads['x'], grads['y'] = 0, 0
optimizers = OrderedDict()
optimizers["SGD"] = SGD(lr=0.95)
optimizers["Momentum"] = Momentum(lr=0.1)
optimizers["AdaGrad"] = AdaGrad(lr=1.5)
optimizers["Adam"] = Adam(lr=0.3)
idx = 1
for key in optimizers:
optimizer = optimizers[key]
x_history = []
y_history = []
params['x'], params['y'] = init_pos[0], init_pos[1]
for i in range(30):
x_history.append(params['x'])
y_history.append(params['y'])
grads['x'], grads['y'] = df(params['x'], params['y'])
optimizer.update(params, grads)
x = np.arange(-10, 10, 0.01)
y = np.arange(-5, 5, 0.01)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)
# for simple contour line
mask = Z > 7
Z[mask] = 0
# plot
plt.subplot(2, 2, idx)
idx += 1
plt.plot(x_history, y_history, 'o-', color="red")
plt.contour(X, Y, Z) # 绘制等高线
plt.ylim(-10, 10)
plt.xlim(-10, 10)
plt.plot(0, 0, '+')
plt.title(key)
plt.xlabel("x")
plt.ylabel("y")
plt.subplots_adjust(wspace=0, hspace=0) # 调整子图间距
plt.show()
Momentum借助了物理中的动量的概念,即前几次的梯度也会参与计算。为了表示动量,引入一个新的变量V,V是之前的梯度的累加,但是在每个回合都会有一定的衰减。它的特点是当前后梯度方向不一致时,能够加速学习,前后梯度方向一致时,能够抑制震荡。其中,v就体现了累加的梯度,ε表示学习率,当前后梯度一致时,v的值就越来越大,因而加速训练,当出现震荡时,v能够起到缓冲震荡的作用。也就是图中更为平滑。
对于梯度大的参数设置小的步长,对于梯度小的参数,设置大的步长。类比于在缓坡上面,我们可以大步长的前进,在陡坡上面,这需要小步长的前进。adagrad则是参考了这个思路。上述的式子中,对梯度的平方进行了累加,所以r值一直都是递增的,故梯度的改变量会越来越小。对于较小的梯度,r的开方若小于1的,故梯度的改变量则较大,对于较大的梯度,r的开放较大,所以梯度改变量则较小。该优化方法的问题是,r的值一直是递增的,导致梯度梯度改变量会一直减小。也就是图中函数值趋向最小值的速度更快。
是。对于AdaGrad,虽然在稀疏场景下表现的非常好,但由于 V t \sqrt{V_t} Vt
是单调递增的,就会使得实际学习率 α / V t α/\sqrt{V_t} α/Vt 递减至0,训练提前结束。
对于Adam避免二阶动量累积,导致训练过程提前结束。
优点:收敛速度很快。
缺点:选择合适的learning rate比较困难;容易收敛到局部最优,并且在某些情况下可能被困在鞍点。
优点:一方面可以加快收敛速度,另一方面可以提高精度(减少震荡,使模型收敛更稳定)。
缺点:需要人工设定学习率,需要有可靠的初始化参数。
优点:前期gt较小的时候,regularizer较大,能够放大梯度;后期gt较大的时候。regularizer较小,能够约束梯度 ,适合处理稀疏梯度 。
缺点:仍依赖于人工设置一个全局学习率,设置过大的话,会使regularizer过于敏感,对梯度的调节太大。中后期,分母上梯度平方的累加将会越来越大,使
,使得训练提前结束 。
优点:结合了Adagrad善于处理稀疏梯度和RMSprop善于处理非平稳目标的优点;对内存需求较小;为不同的参数计算不同的自适应学习率;也适用于大多非凸优化,适用于大数据集和高维空间。
缺点:可能不收敛;可能错过全局最优解。
课上听老师讲结合课下自己动手实操观察了一下,对这几种当下热度高的优化算法有了更深的理解。做选做题对比优缺点,也有了更深的认识。
深度学习中常见的优化方法——SGD,Momentum,Adagrad,RMSprop, Adam
常用的优化算法:SGD、Momentum、AdaGrad、RMSProp、Adam