pytorch學習之優化器torch.optim

功能：優化更新深度學習模型的參數
介紹：實現了深度學習中絕大多數的優化方法，例如RMSProp,Adam，SGD等，更便於應用，所以通常不需要手動寫上述代碼。
示例代碼：

import torch.optim as optim
#新建一個優化器，指定需要調整的參數和學習率
optimizer = optim.SGD(net.parameters(), lr=0.01)

#在訓練過程中，先梯度清零（與net.zero_grad()效果一樣）
optimizer.zero_grad()

#計算損失
output = net(input)
loss = criterion(output, targer)

#反向傳播
loss.backward()

#更新參數
optimizer.step()

不同優化方法的結果比較：
示例代碼：

import torch
import torch.utils.data as Data
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt
'''
print(torch.__version__)
print(torch.cuda.is_available())
'''
#固定隨機數
torch.manual_seed(1)    # reproducible
#print(torch.rand(1))

LR = 0.01 #learing rate
BATCH_SIZE = 32  #樣本批次個數
EPOCH = 12   #訓練輪次

# fake dataset：torch.unsqueeze：加上一個維度  torch.linspace：線性均勻分割
x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1)
#print(x.size())
#y = x^2+（均值爲0,然後拉伸0.1的正態分佈）
y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))

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

# 使用上節內容提到的 data loader
#創建元組數據
torch_dataset = Data.TensorDataset(x, y)
#print(torch_dataset.tensors)
#torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)
#DataLoader：加載數據，打亂數據，並且加速
#loader = Data.DataLoader(torch_dataset, BATCH_SIZE, shuffle=True, num_workers=2)

loader = Data.DataLoader(torch_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=0,)
#print(loader.dataset)
#創建兩層線性全連接網絡
# 默認的 network 形式
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(1, 20)   # hidden layer
        self.predict = torch.nn.Linear(20, 1)   # output layer

    def forward(self, x):
        x = F.relu(self.hidden(x))      # activation function for hidden layer
        x = self.predict(x)             # linear output
        return x

# 爲每個優化器創建一個 net
net_SGD = Net()
net_Momentum = Net()
net_RMSprop = Net()
net_Adam = Net()
nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]

#創建優化方法和loss
# different optimizers
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()
losses_his = [[], [], [], []]   # 記錄 training 時不同神經網絡的 loss

#訓練和作圖



for epoch in range(EPOCH):
    print('Epoch: ', epoch)
    #print(loader)
    #enumerate:列出索引和元素
    for step, (batch_x, batch_y) in enumerate(loader):
        #print(step)
        #print((batch_x, batch_y))
        b_x = Variable(batch_x)  # 務必要用 Variable 包一下
        b_y = Variable(batch_y)
        #print(b_x)

        # 對每個優化器, 優化屬於他的神經網絡,各個優化器的loss
        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
            #print(loss.data)
            l_his.append(loss.data)     # loss recoder
#一共優化了EPOCH*BATCH_SIZE這麼多次

#作圖

labels = ['net_SGD', 'net_Momentum', 'net_RMSprop', 'net_Adam']
for i, l_hist in enumerate(losses_his):
    print(len(l_hist))
    #len(l_hist) = EPOCH*BATCH_SIZE
    plt.plot(l_hist, label=labels[i])
plt.legend(loc = 'best')
plt.xlabel('steps')
plt.ylabel('loss')
#縱軸座標範圍
plt.ylim((0, 0.2))
plt.show()

測試結果：

SGD 是最普通的優化器, 也可以說沒有加速效果,
而 Momentum 是 SGD 的改良版, 它加入了動量原則. 後面的 RMSprop 又是 Momentum 的升級版. 而 Adam 又是 RMSprop 的升級版. 不過從這個結果中我們看到, Adam 的效果似乎比 RMSprop 要差一點. 所以說並不是越先進的優化器, 結果越佳. 我們在自己的試驗中可以嘗試不同的優化器, 找到那個最適合你數據/網絡的優化器.
注：
（1）優化方法的基本使用方法
（2）如何對模型的不同部分設置不同的學習率
（3）如何調整學習率

參考鏈接：
https://blog.csdn.net/qq_20622615/article/details/83150963
https://www.pytorchtutorial.com/3-6-optimizer/