pytorch 優化器調參

torch.optim

1. 如何使用optimizer
   • 構建
   • 為每個參數單獨設置選項
   • 進行單次優化
   • optimizer.step（）
   • optimizer.step(closure)
2. 算法
3. 如何調整學習率

---

torch.optim是實現各種優化算法的包。最常用的方法都已經支持，接口很常規，所以以后也可以很容易地集成更復雜的方法。

如何使用optimizer

要使用torch.optim，您必須構造一個optimizer對象。這個對象能保存當前的參數狀態並且基於計算梯度更新參數

構建

要構造一個Optimizer，你必須給它一個包含參數（必須都是Variable對象）進行優化。然后，您可以指定optimizer的參 數選項，比如學習率，權重衰減等。

例子：

optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9) optimizer = optim.Adam([var1, var2], lr = 0.0001)

為每個參數單獨設置選項

Optimizer也支持為每個參數單獨設置選項。若想這么做，不要直接傳入Variable的iterable，而是傳入dict的iterable。每一個dict都分別定 義了一組參數，並且包含一個param鍵，這個鍵對應參數的列表。其他的鍵應該optimizer所接受的其他參數的關鍵字相匹配，並且會被用於對這組參數的 優化。

注意：

您仍然可以將選項作為關鍵字參數傳遞。它們將被用作默認值，在不覆蓋它們的組中。當您只想改變一個選項，同時保持參數組之間的所有其他選項一致時，這很有用。

例如，當我們想指定每一層的學習率時，這是非常有用的：

optim.SGD([
            {'params': model.base.parameters()}, {'params': model.classifier.parameters(), 'lr': 1e-3} ], lr=1e-2, momentum=0.9)

這意味着model.base參數將使用默認的學習速率1e-2，model.classifier參數將使用學習速率1e-3，並且0.9的momentum將會被用於所有的參數。

進行單次優化

所有的optimizer都會實現step()更新參數的方法。它能按兩種方式來使用：

optimizer.step()

這是大多數optimizer所支持的簡化版本。一旦梯度被如backward()之類的函數計算好后，我們就可以調用該函數。

例子

for input, target in dataset: optimizer.zero_grad() output = model(input) loss = loss_fn(output, target) loss.backward() optimizer.step()

optimizer.step(closure)

一些優化算法例如Conjugate Gradient和LBFGS需要重復多次計算函數，因此你需要傳入一個閉包去允許它們重新計算你的模型。這個閉包會清空梯度， 計算損失，然后返回。

例子：

for input, target in dataset: def closure(): optimizer.zero_grad() output = model(input) loss = loss_fn(output, target) loss.backward() return loss optimizer.step(closure)

算法

class torch.optim.Optimizer(params, defaults)

所有優化的基類.

參數：

1. params (iterable) —— 可迭代的Variable 或者 dict。指定應優化哪些變量。
2. defaults-(dict)：包含優化選項的默認值的dict（一個參數組沒有指定的參數選項將會使用默認值）。

load_state_dict(state_dict)

加載optimizer狀態

參數：

1. state_dict (dict) —— optimizer的狀態。應該是state_dict()調用返回的對象。

state_dict()

將優化器的狀態返回為一個dict。

它包含兩個內容：

1. state - 持有當前optimization狀態的dict。它包含了 優化器類之間的不同。
2. param_groups - 一個包含了所有參數組的dict。

step(closure)

執行單個優化步驟（參數更新）。

參數：

1. closure (callable,可選) – 重新評估模型並返回損失的閉包。hon zero_grad()

清除所有優化過的Variable的梯度。

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

實現Adadelta算法。

ADADELTA中提出了一種自適應學習速率法。

參數：

1. params (iterable) – 用於優化的可以迭代參數或定義參數組
2. rho (float, 可選) – 用於計算平方梯度的運行平均值的系數（默認值：0.9）
3. eps (float, 可選) – 增加到分母中以提高數值穩定性的術語（默認值：1e-6）
4. lr (float, 可選) – 將delta應用於參數之前縮放的系數（默認值：1.0）
5. weight_decay (float, 可選) – 權重衰減 (L2范數)（默認值: 0）

step(closure)

執行單個優化步驟。

參數：

1. closure (callable,可選) – 重新評估模型並返回損失的閉包。

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

實現Adagrad算法。

在在線學習和隨機優化的自適應子梯度方法中被提出。

參數：

1. params (iterable) – 用於優化的可以迭代參數或定義參數組
2. lr (float, 可選) – 學習率（默認: 1e-2）
3. lr_decay (float, 可選) – 學習率衰減（默認: 0）
4. weight_decay (float, 可選) – 權重衰減（L2范數）（默認: 0）

step(closure)

執行單個優化步驟。

參數：

1. closure (callable,可選) – 重新評估模型並返回損失的閉包。

class torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)[source]

實現Adam算法。

它在Adam: A Method for Stochastic Optimization中被提出。

參數：

1. params (iterable) – 用於優化的可以迭代參數或定義參數組
2. lr (float, 可選) – 學習率（默認：1e-3）
3. betas (Tuple[float, float], 可選) – 用於計算梯度運行平均值及其平方的系數（默認：0.9，0.999）
4. eps (float, 可選) – 增加分母的數值以提高數值穩定性（默認：1e-8）
5. weight_decay (float, 可選) – 權重衰減（L2范數）（默認: 0）

step(closure) 

執行單個優化步驟。

參數：

1. closure (callable,可選) – 重新評估模型並返回損失的閉包。

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

實現Adamax算法（Adam的一種基於無窮范數的變種）。

它在Adam: A Method for Stochastic Optimization中被提出。

參數：

1. params (iterable) – 用於優化的可以迭代參數或定義參數組
2. lr (float, 可選) – 學習率（默認：2e-3）
3. betas (Tuple[float, float], 可選) – 用於計算梯度以及梯度平方的運行平均值的系數
4. eps (float, 可選) – 增加分母的數值以提高數值穩定性（默認：1e-8）
5. weight_decay (float, 可選) – 權重衰減（L2范數）（默認: 0）

step(closure=None)

執行單個優化步驟。

參數：

1. closure (callable,可選) – 重新評估模型並返回損失的閉包。

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

實現平均隨機梯度下降。

它在Acceleration of stochastic approximation by averaging中被提出。

參數：

1. params (iterable) – 用於優化的可以迭代參數或定義參數組
2. lr (float, 可選) – 學習率（默認：1e-2）
3. lambd (float, 可選) – 衰減期（默認：1e-4）
4. alpha (float, 可選) – eta更新的指數（默認：0.75）
5. t0 (float, 可選) – 指明在哪一次開始平均化（默認：1e6）
6. weight_decay (float, 可選) – 權重衰減（L2范數）（默認: 0）

step(closure)

執行單個優化步驟。

參數：

1. closure (callable,可選) – 重新評估模型並返回損失的閉包。

class 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)

實現L-BFGS算法。

警告: 這個optimizer不支持為每個參數單獨設置選項以及不支持參數組（只能有一個） 現在所有參數必須在單個設備上。將來會有所改善。

注意: 這是一個內存高度密集的optimizer（它要求額外的param_bytes * (history_size + 1) 個字節）。如果它不適應內存，嘗試減小history size，或者使用不同的算法。

參數：

1. lr (float) – 學習率（默認：1）
2. max_iter (int) – 每個優化步驟的最大迭代次數（默認：20）)
3. max_eval (int) – 每個優化步驟的最大函數評估次數（默認：max * 1.25）
4. tolerance_grad (float) – 一階最優的終止容忍度（默認：1e-5）
5. tolerance_change (float) – 功能值/參數更改的終止公差（默認：1e-9）
6. history_size (int) – 更新歷史記錄大小（默認：100）

step(closure)

執行單個優化步驟。

參數：

1. closure (callable,可選) – 重新評估模型並返回損失的閉包。

class torch.optim.RMSprop(params, lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)[source]

實現RMSprop算法。

由G. Hinton在他的課程中提出.

中心版本首次出現在Generating Sequences With Recurrent Neural Networks.

參數：

1. params (iterable) – 用於優化的可以迭代參數或定義參數組
2. lr (float, 可選) – 學習率（默認：1e-2）
3. momentum (float, 可選) – 動量因子（默認：0）
4. alpha (float, 可選) – 平滑常數（默認：0.99）
5. eps (float, 可選) – 增加分母的數值以提高數值穩定性（默認：1e-8）
6. centered (bool, 可選) – 如果為True，計算中心化的RMSProp，通過其方差的估計來對梯度進行歸一化
7. weight_decay (float, 可選) – 權重衰減（L2范數）（默認: 0）

step(closure)

執行單個優化步驟。

參數：

1. closure (callable,可選) – 重新評估模型並返回損失的閉包。

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

實現彈性反向傳播算法。

參數：

1. params (iterable) – 用於優化的可以迭代參數或定義參數組
2. lr (float, 可選) – 學習率（默認：1e-2）
3. etas (Tuple[float, float], 可選) – 一對（etaminus，etaplis）, 它們是乘數增加和減少因子（默認：0.5，1.2）
4. step_sizes (Tuple[float, float], 可選) – 允許的一對最小和最大的步長（默認：1e-6，50）

step(closure) 

執行單個優化步驟。

參數：

1. closure (callable,可選) – 重新評估模型並返回損失的閉包。

class torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)

實現隨機梯度下降算法（momentum可選）。

Nesterov動量基於On the importance of initialization and momentum in deep learning中的公式.

參數：

1. params (iterable) – 用於優化的可以迭代參數或定義參數組
2. lr (float) – 學習率
3. momentum (float, 可選) – 動量因子（默認：0）
4. weight_decay (float, 可選) – 權重衰減（L2范數）（默認：0）
5. dampening (float, 可選) – 動量的抑制因子（默認：0）
6. nesterov (bool, 可選) – 使用Nesterov動量（默認：False）

例子：

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9) >>> optimizer.zero_grad() >>> loss_fn(model(input), target).backward() >>> optimizer.step()

提示：

帶有動量/Nesterov的SGD的實現稍微不同於Sutskever等人以及其他框架中的實現。 考慮到Momentum的具體情況，更新可以寫成 v=ρ∗v+g p=p−lr∗v 其中，p、g、v和ρ分別是參數、梯度、速度和動量。 這是在對比Sutskever et. al。和其他框架采用該形式的更新 v=ρ∗v+lr∗g p=p−v Nesterov版本被類似地修改。

step(closure) 

執行單個優化步驟。

參數：

1. closure (callable,可選) – 重新評估模型並返回損失的閉包。

如何調整學習率

torch.optim.lr_scheduler 提供了幾種方法來根據epoches的數量調整學習率。torch.optim.lr_scheduler.ReduceLROnPlateau允許基於一些驗證測量來降低動態學習速率。

class torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1)

將每個參數組的學習速率設置為初始的lr乘以一個給定的函數。當last_epoch=-1時，將初始lr設置為lr。

參數：

1. optimizer (Optimizer) – 包裝的優化器。
2. lr_lambda (function or list) – 一個函數來計算一個乘法因子給定一個整數參數的epoch，或列表等功能，為每個組optimizer.param_groups。
3. last_epoch (int) – 最后一個時期的索引。默認: -1.

例子：

>>> # Assuming optimizer has two groups. >>> lambda1 = lambda epoch: epoch // 30 >>> lambda2 = lambda epoch: 0.95 ** epoch >>> scheduler = LambdaLR(optimizer, lr_lambda=[lambda1, lambda2]) >>> for epoch in range(100): >>> scheduler.step() >>> train(...) >>> validate(...)

class torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1)

將每個參數組的學習速率設置為每個step_size時間段由gamma衰減的初始lr。當last_epoch = -1時，將初始lr設置為lr。

1. optimizer (Optimizer) – 包裝的優化器。
2. step_size (int) – 學習率衰減期。
3. gamma (float) – 學習率衰減的乘積因子。默認值:-0.1。
4. last_epoch (int) – 最后一個時代的指數。默認值:1。

例子：

>>> # Assuming optimizer uses lr = 0.5 for all groups >>> # lr = 0.05 if epoch < 30 >>> # lr = 0.005 if 30 <= epoch < 60 >>> # lr = 0.0005 if 60 <= epoch < 90 >>> # ... >>> scheduler = StepLR(optimizer, step_size=30, gamma=0.1) >>> for epoch in range(100): >>> scheduler.step() >>> train(...) >>> validate(...)

class torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1)

一旦時間的數量達到一個里程碑,則將每個參數組的學習率設置為伽瑪衰減的初始值。當last_epoch=-1時，將初始lr設置為lr。

參數：

1. optimizer (Optimizer) – 包裝的優化器。
2. milestones (list) – 時期指標的列表。必須增加。
3. gamma (float) – 學習率衰減的乘積因子。 默認: -0.1.
4. last_epoch (int) – 最后一個時代的指數。 默認: -1.

例子：

>>> # Assuming optimizer uses lr = 0.5 for all groups >>> # lr = 0.05 if epoch < 30 >>> # lr = 0.005 if 30 <= epoch < 80 >>> # lr = 0.0005 if epoch >= 80 >>> scheduler = MultiStepLR(optimizer, milestones=[30,80], gamma=0.1) >>> for epoch in range(100): >>> scheduler.step() >>> train(...) >>> validate(...)

class torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-1)

將每個參數組的學習速率設置為每一個時代的初始lr衰減。當last_epoch=-1時，將初始lr設置為lr。

1. optimizer (Optimizer) – 包裝的優化器。
2. gamma (float) – 學習率衰減的乘積因子。
3. last_epoch (int) – 最后一個指數。默認: -1.

class torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)

當指標停止改善時，降低學習率。當學習停滯不前時，模型往往會使學習速度降低2-10倍。這個調度程序讀取一個指標量，如果沒有提高epochs的數量，學習率就會降低。

1. optimizer (Optimizer) – 包裝的優化器。
2. mode (str) – min, max中的一個. 在最小模式下，當監測量停止下降時，lr將減少; 在最大模式下，當監控量停止增加時，會減少。默認值：'min'。
3. factor (float) – 使學習率降低的因素。 new_lr = lr * factor. 默認: 0.1.
4. patience (int) –epochs沒有改善后，學習率將降低。 默認: 10.
5. verbose (bool) – 如果為True，則會向每個更新的stdout打印一條消息。 默認: False.
6. threshold (float) – 測量新的最優值的閾值，只關注顯着變化。 默認: 1e-4.
7. threshold_mode (str) – rel, abs中的一個. 在rel模型, dynamic_threshold = best ( 1 + threshold ) in ‘max’ mode or best ( 1 - threshold ) 在最小模型. 在絕對值模型中, dynamic_threshold = best + threshold 在最大模式或最佳閾值最小模式. 默認: ‘rel’.
8. cooldown (int) – 在lr減少后恢復正常運行之前等待的時期數。默認的: 0.
9. min_lr (float or list) – 標量或標量的列表。對所有的組群或每組的學習速率的一個較低的限制。 默認: 0.
10. eps (float) – 適用於lr的最小衰減。如果新舊lr之間的差異小於eps，則更新將被忽略。默認: 1e-8.

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9) >>> scheduler = torch.optim.ReduceLROnPlateau(optimizer, 'min') >>> for epoch in range(10): >>> train(...) >>> val_loss = validate(...) >>> # Note that step should be called after validate() >>> scheduler.step(val_loss)