Celery's Blog

0%

加速神经网络训练

发表于 Valine：

Speed Up Training

主要包括以下几种模式：

  • Stochastic Gradient Descent (SGD)
  • Momentum
  • AdaGrad
  • RMP Prop
  • Adam

Stochastic Gradient Descent (SGD)

SGD

想象红色方块使我们要训练的data，如果用普通的训练方法，就需要重复不断的把整套数据放入神经网络NN训练，这样消耗的计算资源会很大

SGD的正确打开方式：将这些数据拆分成小批小批的，然后再分批不断放入NN中计算。每次使用批数据，虽然不能反映整体数据情况，不过却很大程度上加速了NN的训练过程，而且也不会丢失太多准确率

SGD

Momentum

大多数途径是在更新神经网络参数那一步上东东手脚。传统的参数W的更新是把原始的W累加上一个负的学习效率（Learning Rate）乘以校正值（dx）。这种方法可能会让学习的过程曲折无比，看起来像喝醉的人回家时，摇摇晃晃走了很多弯路

Momentum

所以我们把这个人从平地上放到了一个斜坡上, 只要他往下坡的方向走一点点, 由于向下的惯性, 他不自觉地就一直往下走, 走的弯路也变少了. 这就是 Momentum 参数更新

Momentum

AdaGrad

加速神经网络训练 (Speed Up Training)

这种方法是在学习率上面动手脚, 使得每一个参数更新都会有自己与众不同的学习率, 他的作用和 momentum 类似, 不过不是给喝醉酒的人安排另一个下坡, 而是给他一双不好走路的鞋子, 使得他一摇晃着走路就脚疼, 鞋子成为了走弯路的阻力, 逼着他往前直着走. 他的数学形式是这样的.

RMSProp

加速神经网络训练 (Speed Up Training)

有了 momentum 的惯性原则 , 加上 adagrad 的对错误方向的阻力, 我们就能合并成这样. 让 RMSProp同时具备他们两种方法的优势. 不过还没把 Momentum合并完全, RMSProp 还缺少了 momentum 中的 这一部分. 所以, 我们在 Adam 方法中补上了这种想法.

Adam

加速神经网络训练 (Speed Up Training)

计算m 时有 momentum 下坡的属性, 计算 v 时有 adagrad 阻力的属性, 然后再更新参数时 把 m 和 V 都考虑进去. 实验证明, 大多数时候, 使用 adam 都能又快又好的达到目标, 迅速收敛. 所以说, 在加速神经网络训练的时候, 一个下坡, 一双破鞋子, 功不可没.

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
import torch 
import torch.utils.data as Data
import torch.nn.functional as F 
from torch.autograd import Variable
import matplotlib.pyplot as plt 

# hyper parameters
LR = 0.01
BATCH_SIZE = 32
EPOCH = 12

x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1)
y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))

# plt.scatter(x.numpy(), y.numpy())
# plt.show()

torch_dataset = Data.TensorDataset(x, y)
loader = Data.DataLoader(
    dataset=torch_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,
    num_workers=2,
)

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(1, 20)
        self.predict = torch.nn.Linear(20, 1)

    def forward(self, x):
        x = F.relu(self.hidden(x))
        x = self.predict(x)
        return x

if __name__ == '__main__':
    # different nets
    net_SGD =       Net()
    net_Momentum =  Net()
    net_RMSprop =   Net()
    net_Adam =      Net()
    nets =[net_SGD, net_Momentum, net_RMSprop, net_Adam]

    # different optimizers
    # 为每一个优化器创建一个net
    opt_SGD = torch.optim.SGD(net_SGD.parameters(), lr=LR)
    opt_Momentum = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
    opt_RMSprop = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)
    opt_Adam = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))
    optimizers = [opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]

    loss_func = torch.nn.MSELoss()
    # 记录training时不同神经网络的loss
    losses_his = [[], [], [], []]   # record loss

    # training
    for epoch in range(EPOCH):
        print('Epoch: ', epoch)
        for step, (b_x, b_y) in enumerate(loader):
            # 对每个优化器，优化属于他的神经网络
            for net, opt, l_his in zip(nets, optimizers, losses_his):
                output = net(b_x)               # get output for every net
                loss = loss_func(output, b_y)   # compute loss for every net
                opt.zero_grad()                 # clear gradients for next train
                loss.backward()                 # backpropagation, compute gradients
                opt.step()                      # apply gradients
                l_his.append(loss.data.numpy()) # loss recorder

    labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
    for i, l_his in enumerate(losses_his):
        plt.plot(l_his, label=labels[i])
    plt.legend(loc='best')
    plt.xlabel('Steps')
    plt.ylabel('Loss')
    plt.ylim((0, 0.2))
    plt.show()

最后的图表：

optimizer