《python深度学习》笔记（十二）：动量

最新推荐文章于 2024-06-03 18:37:12 发布

码字神经元

最新推荐文章于 2024-06-03 18:37:12 发布

阅读量2.3k

点赞数 2

分类专栏：《python深度学习》笔记文章标签：深度学习 python pytorch sgd

本文链接：https://blog.csdn.net/qq_59572329/article/details/121584631

版权

《python深度学习》笔记专栏收录该内容

23 篇文章 54 订阅

订阅专栏

1 工作原理

Momentum(动量，冲量)：结合当前梯度与上一次更新信息，用于当前更新。

动量梯度下降法是计算梯度的指数加权平均数，并利用该数值来更新参数值。

指数加权平均：

与原始的梯度下降相比，动量的梯度下降趋势更加平滑，不但能使用较大的学习率，其迭代次数也减少。

在随机梯度的学习算法中，每一步的步幅都是固定的，而在动量学习算法中，每一步走多远不仅依赖于本次的梯度的大小还取决于过去的速度。速度v是累积各轮训练参的梯度，其中 $\公测$ 越大，依赖以前的梯度越大。假如每轮训练的梯度方向都是相同的，和小球从斜坡滚落，由于但衰减因子 $\公测$ 的存在，小球并不会一直加速，而是达到最大速度后开始匀速行驶，这里假设每轮获得的梯度都是相同的，那么速度最大值为：

从上式可以看到当 $\公测$ = 0.9时，最大速度相当于梯度下降的10倍（带进上式去算可得），通常 $\公测$ 可取0.5,0.9,0.99，情况一般 $\公测$ 的调整没有 $\α$ 调整的那么重要适当。取值即可。

不使用动量：

使用动量：

其中表示权重，表示学习率，表示的导数，表示速度，一般初始化为0； momentum 就是引入的动量，一般是设置为0.9。可以理解为，如果上一次的 momentum(v) 与当前的负梯度方向是相同的，那这次下降的幅度就会加大，从而可以加快模型收敛。

def sgd_momentum(parameters, vs, lr, gamma):
    for param, v in zip(parameters, vs):
        v[:] = gamma * v + lr * param.grad.data
        param.data = param.data - v

2 作用

主要是在训练网络时，最开始会对网络进行权值初始化，但是这个初始化不可能是最合适的；因此可能就会出现损失函数在训练的过程中出现局部最小值的情况，而没有达到全局最优的状态。

momentum的出现可以在一定程度上解决这个问题。动量来源于物理学，当momentum越大时，转换为势能的能量就越大，就越有可能摆脱局部凹区域，从而进入全局凹区域。momentum主要是用于权值优化。

3 代码实现

使用公式手动实现动量：

import numpy as np
import torch
from torchvision.datasets import MNIST # 导入 pytorch 内置的 mnist 数据
from torch.utils.data import DataLoader
from torch import nn
from torch.autograd import Variable
import time
import matplotlib.pyplot as plt
# %matplotlib inline

def data_tf(x):
    x = np.array(x, dtype='float32') / 255
    x = (x - 0.5) / 0.5 # 标准化，这个技巧之后会讲到
    x = x.reshape((-1,)) # 拉平
    x = torch.from_numpy(x)
    return x

train_set = MNIST('./data', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换
test_set = MNIST('./data', train=False, transform=data_tf, download=True)

# 定义 loss 函数
criterion = nn.CrossEntropyLoss()

# 现在手动实现一下动量法
def sgd_momentum(parameters, vs, lr, gamma):
    for param, v in zip(parameters, vs):
        v[:] = gamma * v + lr * param.grad.data
        param.data = param.data - v


train_data = DataLoader(train_set, batch_size=64, shuffle=True)
# 使用 Sequential 定义 3 层神经网络
net = nn.Sequential(
    nn.Linear(784, 200),
    nn.ReLU(),
    nn.Linear(200, 10),
)

# 将速度初始化为和参数形状相同的零张量
vs = []
for param in net.parameters():
    vs.append(torch.zeros_like(param.data))

# 开始训练
losses = []
idx = 0
start = time.time()  # 记时开始
for e in range(5):
    train_loss = 0
    for im, label in train_data:
        im = Variable(im)
        label = Variable(label)
        # 前向传播
        out = net(im)
        loss = criterion(out, label)
        # 反向传播
        net.zero_grad()
        loss.backward()
        sgd_momentum(net.parameters(), vs, 1e-2, 0.9)  # 使用的动量参数为 0.9，学习率 0.01

        train_loss += loss.data
        # 记录误差
        if idx % 30 == 0:  # 30 步记录一次
            losses.append(loss.data)
        idx += 1
    print('epoch: {}, Train Loss: {:.6f}'
          .format(e, train_loss / len(train_data)))
end = time.time()  # 计时结束
print('使用时间: {:.5f} s'.format(end - start))

pytorch 内置了动量法的实现，直接用 torch.optim.SGD(momentum=0.9) 实现：

import numpy as np
import torch
from torchvision.datasets import MNIST # 导入 pytorch 内置的 mnist 数据
from torch.utils.data import DataLoader
from torch import nn
from torch.autograd import Variable
import time
import matplotlib.pyplot as plt
# %matplotlib inline

def data_tf(x):
    x = np.array(x, dtype='float32') / 255
    x = (x - 0.5) / 0.5 # 标准化，这个技巧之后会讲到
    x = x.reshape((-1,)) # 拉平
    x = torch.from_numpy(x)
    return x

train_set = MNIST('./data', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换
test_set = MNIST('./data', train=False, transform=data_tf, download=True)

# 定义 loss 函数
criterion = nn.CrossEntropyLoss()




train_data = DataLoader(train_set, batch_size=64, shuffle=True)
# 使用 Sequential 定义 3 层神经网络
net = nn.Sequential(
    nn.Linear(784, 200),
    nn.ReLU(),
    nn.Linear(200, 10),
)
optimizer = torch.optim.SGD(net.parameters(), lr=1e-2, momentum=0.9) # 加动量

# 开始训练
losses = []
idx = 0
start = time.time()  # 记时开始
for e in range(5):
    train_loss = 0
    for im, label in train_data:
        im = Variable(im)
        label = Variable(label)
        # 前向传播
        out = net(im)
        loss = criterion(out, label)
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        train_loss += loss.data
        # 记录误差
        if idx % 30 == 0:  # 30 步记录一次
            losses.append(loss.data)
        idx += 1
    print('epoch: {}, Train Loss: {:.6f}'
          .format(e, train_loss / len(train_data)))
end = time.time()  # 计时结束
print('使用时间: {:.5f} s'.format(end - start))

x_axis = np.linspace(0, 5, len(losses), endpoint=True)
plt.semilogy(x_axis, losses, label='momentum: 0.9')
plt.legend(loc='best')
plt.show()

对比动量和不加动量的SGD：

net = nn.Sequential(
    nn.Linear(784, 200),
    nn.ReLU(),
    nn.Linear(200, 10),
)
optimizer = torch.optim.SGD(net.parameters(), lr=1e-2) # 加动量
losses1 = []
idx = 0
start = time.time()  # 记时开始
for e in range(5):
    train_loss = 0
    for im, label in train_data:
        im = Variable(im)
        label = Variable(label)
        # 前向传播
        out = net(im)
        loss = criterion(out, label)
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        train_loss += loss.data
        # 记录误差
        if idx % 30 == 0:  # 30 步记录一次
            losses1.append(loss.data)
        idx += 1
    print('epoch: {}, Train Loss: {:.6f}'
          .format(e, train_loss / len(train_data)))
end = time.time()  # 计时结束
print('使用时间: {:.5f} s'.format(end - start))

x_axis = np.linspace(0, 5, len(losses), endpoint=True)
plt.semilogy(x_axis, losses, label='momentum: 0.9')
plt.semilogy(x_axis, losses1, label='no momentum')
plt.legend(loc='best')
plt.show()

码字神经元

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
2
评论
《python深度学习》笔记（十二）：动量

在随机梯度的学习算法中，每一步的步幅都是固定的，而在动量学习算法中，每一步走多远不仅依赖于本次的梯度的大小还取决于过去的速度。速度v是累积各轮训练参的梯度，其中越大，依赖以前的梯度越大。假如每轮训练的梯度方向都是相同的，和小球从斜坡滚落，由于但衰减因子的存在，小球并不会一直加速，而是达到最大速度后开始匀速行驶，这里假设每轮获得的梯度都是相同的，那么速度最大值为：
复制链接

扫一扫