深度學習優化器

深度學習演算法在許多情況下都涉及優化，我們經常使用解析優化去證明或設計演算法。在深度學習的諸多優化問題中，最難的是神經網路的設計，這其中的優化問題非常重要，代價也很高，因此研究者們開發了一組專門為此設計的優化技術，也就是我們本文中要介紹的——神經網路優化器。

這些優化器主要關注一類特定的優化問題：尋找神經網路上的一組引數θ

\theta

θ，它能顯著地降低代價函式j(θ

)j(\theta)

j(θ)

，該代價函式通常包括整個訓練集上的效能評估和額外的正則化項。

torch.optim.sgd(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=false)

torch.optim.asgd(params, lr=0.01, lambd=0.0001, alpha=0.75, t0=1000000.0, weight_decay=0)

torch.optim.adagrad(params, lr=0.01, lr_decay=0, weight_decay=0)

torch.optim.adadelta(params, lr=1.0, rho=0.9, eps=1e-06, weight_decay=0)

torch.optim.rmsprop(params, lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=false)

torch.optim.adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)

torch.optim.adamax(params, lr=0.002, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)

torch.optim.sparseadam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08)

torch.optim.lbfgs(params, lr=1, max_iter=20, max_eval=none, tolerance_grad=1e-05, tolerance_change=1e-09, history_size=100, line_search_fn=none)

torch.optim.rprop(params, lr=0.01, etas=(0.5, 1.2), step_sizes=(1e-06, 50))

如果資料是稀疏的，就用自適用方法，即 adagrad, adadelta, rmsprop, adam。

rmsprop, adadelta, adam 在很多情況下的效果是相似的。

adam 就是在 rmsprop 的基礎上加了 bias-correction 和 momentum，

隨著梯度變的稀疏，adam 比 rmsprop 效果會好。

整體來講，adam 是最好的選擇。

很多**裡都會用 sgd，沒有 momentum 等。sgd 雖然能達到極小值，但是比其它演算法用的時間長，而且可能會被困在鞍點。

如果需要更快的收斂，或者是訓練更深更複雜的神經網路，需要用一種自適應的演算法。

import torch

import torch.utils.data as data
import torch.nn.functional as f
from torch.autograd import variable
import matplotlib.pyplot as plt
# 超引數
lr = 0.01
batch_size = 32
epoch = 12
# 生成假資料
# torch.unsqueeze() 的作用是將一維變二維，torch只能處理二維的資料
x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1) # x data (tensor), shape(100, 1)
# 0.2 * torch.rand(x.size())增加噪點
y = x.pow(2) + 0.1 * torch.normal(torch.zeros(*x.size()))
# 定義資料庫
dataset = data.tensordataset(data_tensor = x, target_tensor = y)
# 定義資料載入器
loader = data.dataloader(dataset = dataset, batch_size = batch_size, shuffle = true, num_workers = 2)
# 定義pytorch網路
class net(torch.nn.module):
def __init__(self, n_features, n_hidden, n_output):
super(net, self).__init__()
self.hidden = torch.nn.linear(n_features, n_hidden)
self.predict = torch.nn.linear(n_hidden, n_output)
def forward(self, x):
x = f.relu(self.hidden(x))
y = self.predict(x)
return y
# 定義不同的優化器網路
net_sgd = net(1, 10, 1)
net_momentum = net(1, 10, 1)
net_rmsprop = net(1, 10, 1)
net_adam = net(1, 10, 1)
# 選擇不同的優化方法
opt_sgd = torch.optim.sgd(net_sgd.parameters(), lr = lr)
opt_momentum = torch.optim.sgd(net_momentum.parameters(), lr = lr, momentum = 0.9)
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))
nets = [net_sgd, net_momentum, net_rmsprop, net_adam]
optimizers = [opt_sgd, opt_momentum, opt_rmsprop, opt_adam]
# 選擇損失函式
loss_func = torch.nn.mseloss()
# 不同方法的loss
loss_sgd = 
loss_momentum = 
loss_rmsprop =
loss_adam = 
# 儲存所有loss
losses = [loss_sgd, loss_momentum, loss_rmsprop, loss_adam]
# 執行訓練
for epoch in xrange(epoch):
for step, (batch_x, batch_y) in enumerate(loader):
var_x = variable(batch_x)
var_y = variable(batch_y)
for net, optimizer, loss_history in zip(nets, optimizers, losses):
# 對x進行**
prediction = net(var_x)
# 計算損失
loss = loss_func(prediction, var_y)
# 每次迭代清空上一次的梯度
optimizer.zero_grad()
# 反向傳播
loss.backward()
# 更新梯度
optimizer.step()
# 儲存loss記錄
# 畫圖
labels = ['sgd', 'momentum', 'rmsprop', 'adam']
for i, loss_history in enumerate(losses):
plt.plot(loss_history, label = labels[i])
plt.legend(loc = 'best')
plt.xlabel('steps')
plt.ylabel('loss')
plt.ylim((0, 0.2))
plt.show()

pytorch學習之十種優化函式

如何選擇優化器 optimizer

pytorch基本用法(九)——優化器

「花書」《深度學習》

深度學習 優化器

神經網路的訓練過程是通過迭代更新超引數來最小化損失函式的過程，最終目標是找到使損失函式最小，最能準確 的超引數組合。而在更新迭代超引數時就需要用到不同的優化器，本文簡要介紹幾種常用的優化器。計算t時刻損失函式關於當前引數的梯度 計算t時刻的一階動量mt 與梯度相關的函式 和二階動量vt 與梯度平方相...

深度學習常用優化器介紹

深度學習的優化演算法從sgd sgdm nag adagrad adadelta adam nadam這樣的發展歷程，理論知識參考這裡，下面我們依次介紹tensorflow中這些優化器的實現類，官方文件。優化器 optimizers 類的基類。這個類定義了在訓練模型的時候新增乙個操作的api。你基本...

深度學習之optimizer優化器

優化演算法通常只考慮最小化目標函式。其實，任何最大化問題都可以很容易地轉化為最小化問題。很多優化問題並不存在解析解，而需要使用基於數值方法的優化演算法找到近似解，即數值解。為了求得最小化目標函式的數值解，我們將通過優化演算法有限次迭代模型引數來盡可能降低損失函式的值。深度學習模型的目標函式可能有若干...