原文： PyTorch torch.optim

torch.optim 是實現(xiàn)各種優(yōu)化算法的軟件包。 已經(jīng)支持最常用的方法，并且接口足夠通用，因此將來也可以輕松集成更復雜的方法。

如何使用優(yōu)化器

要使用 torch.optim ，您必須構造一個優(yōu)化器對象，該對象將保持當前狀態(tài)并根據(jù)計算出的梯度更新參數(shù)。

構造它

要構建 Optimizer ，您必須為其提供一個包含參數(shù)的可迭代項(所有參數(shù)應為Variable）以進行優(yōu)化。 然后，您可以指定優(yōu)化器特定的選項，例如學習率，權重衰減等。

注意

如果您需要通過.cuda()將模型移至 GPU，請在為其構建優(yōu)化器之前執(zhí)行此操作。 .cuda()之后的模型參數(shù)將與調(diào)用之前的參數(shù)不同。

通常，在構造和使用優(yōu)化器時，應確保優(yōu)化的參數(shù)位于一致的位置。

例：

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

每個參數(shù)選項

Optimizer 也支持指定每個參數(shù)選項。 為此，不要傳遞Variable的迭代器，而是傳遞dict的迭代器。 它們每個都將定義一個單獨的參數(shù)組，并且應包含一個params鍵，其中包含屬于它的參數(shù)列表。 其他鍵應與優(yōu)化器接受的關鍵字參數(shù)匹配，并將用作該組的優(yōu)化選項。

Note

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

例如，當要指定每層學習率時，這非常有用：

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

這意味著model.base的參數(shù)將使用默認的學習率1e-2，model.classifier的參數(shù)將使用1e-3的學習率，并且動量0.9會用于所有參數(shù)。

采取優(yōu)化步驟

所有優(yōu)化器均實現(xiàn) step() 方法，該方法可更新參數(shù)。 它可以以兩種方式使用：

optimizer.step()

這是大多數(shù)優(yōu)化程序支持的簡化版本。 一旦使用例如計算出梯度，就可以調(diào)用該函數(shù)。 backward()。

Example:

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

optimizer.step(closure)

某些優(yōu)化算法(例如共軛梯度和 LBFGS）需要多次重新評估函數(shù)，因此您必須傳遞閉包以允許它們重新計算模型。 閉合應清除梯度，計算損耗，然后將其返回。

Example:

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

所有優(yōu)化程序的基類。

警告

需要將參數(shù)指定為具有確定性順序的集合，這些順序在兩次運行之間是一致的。 不滿足這些屬性的對象的示例是字典值的集合和迭代器。

參數(shù)

• 參數(shù)(迭代）– torch.Tensor 或dict s 的迭代。 指定應優(yōu)化哪些張量。
• 默認值為 –(dict）：包含優(yōu)化選項默認值的 dict(在參數(shù)組未指定優(yōu)化選項時使用）。

add_param_group(param_group)?

將參數(shù)組添加到 Optimizer 的 <cite>param_groups</cite> 中。

當對預訓練的網(wǎng)絡進行微調(diào)時，這很有用，因為可以使凍結層成為可訓練的，并隨著訓練的進行而添加到 Optimizer 中。

Parameters

• param_group (dict )–指定應與組一起優(yōu)化哪些張量
• 優(yōu)化選項。 (特定于）–

load_state_dict(state_dict)?

加載優(yōu)化器狀態(tài)。

Parameters

state_dict (dict )–優(yōu)化器狀態(tài)。 應該是從對 state_dict() 的調(diào)用返回的對象。

state_dict()?

以dict的形式返回優(yōu)化器的狀態(tài)。

它包含兩個條目：

• state - a dict holding current optimization state. Its content
  
  
  
  

優(yōu)化器類之間有所不同。

• param_groups-包含所有參數(shù)組的字典

step(closure)?

執(zhí)行單個優(yōu)化步驟(參數(shù)更新）。

Parameters

閉合(可調(diào)用的）–重新評估模型并返回損失的閉合。 對于大多數(shù)優(yōu)化程序是可選的。

zero_grad()?

清除所有優(yōu)化的 torch.Tensor 的梯度。

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

實現(xiàn) Adadelta 算法。

在 ADADELTA 中提出了一種：自適應學習率方法。

Parameters

• 參數(shù)(可迭代）–參數(shù)可迭代以優(yōu)化或命令定義參數(shù)組
• rho (python：float ， 可選）–用于計算平方梯度的移動平均值的系數(shù)(默認值：0.9）
• eps (python：float ， 可選）–分母添加到分母以提高數(shù)值穩(wěn)定性(默認值：1e-6）
• lr (python：float ， 可選）–在將增量應用于參數(shù)之前對其進行縮放的系數(shù)(默認值：1.0）
• weight_decay (python：float ， 可選）–權重衰減(L2 懲罰）(默認值：0）

step(closure=None)?

執(zhí)行一個優(yōu)化步驟。

Parameters

閉合(可調(diào)用的， 可選）–重新評估模型并返回損失的閉合。

class torch.optim.Adagrad(params, lr=0.01, lr_decay=0, weight_decay=0, initial_accumulator_value=0, eps=1e-10)?

實現(xiàn) Adagrad 算法。

它已在在線學習和隨機優(yōu)化的自適應次梯度方法中提出。

Parameters

• params (iterable) – iterable of parameters to optimize or dicts defining parameter groups
• lr (python：float ， 可選）–學習率(默認值：1e-2）
• lr_decay (python：float ， 可選）–學習速率衰減(默認值：0）
• weight_decay (python:float__, optional) – weight decay (L2 penalty) (default: 0)
• eps (python：float ， 可選）–分母添加到分母以提高數(shù)值穩(wěn)定性(默認值：1e-10）

step(closure=None)?

Performs a single optimization step.

Parameters

closure (callable__, optional) – A closure that reevaluates the model and returns the loss.

class torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)?

實現(xiàn)亞當算法。

在 Adam 中提出了一種隨機優(yōu)化方法。

Parameters

• params (iterable) – iterable of parameters to optimize or dicts defining parameter groups
• lr (python：float ， 可選）–學習率(默認值：1e-3）
• Betas (Tuple [ python：float ， python：float ] ， 可選）–用于計算梯度及其平方的移動平均值的系數(shù)(默認值：(0.9，0.999））
• eps (python：float ， 可選）–分母添加到分母以提高數(shù)值穩(wěn)定性(默認值：1e-8）
• weight_decay (python:float__, optional) – weight decay (L2 penalty) (default: 0)
• amsgrad (布爾值 ， 可選）–是否使用論文上該算法的 AMSGrad 變體 Adam and Beyond (默認值：False）

step(closure=None)?

Performs a single optimization step.

Parameters

closure (callable__, optional) – A closure that reevaluates the model and returns the loss.

class torch.optim.AdamW(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.01, amsgrad=False)?

實現(xiàn) AdamW 算法。

最初的 Adam 算法是在 Adam：隨機優(yōu)化方法中提出的。 AdamW 變體在去耦權重衰減正則化中提出。

Parameters

• params (iterable) – iterable of parameters to optimize or dicts defining parameter groups
• lr (python:float__, optional) – learning rate (default: 1e-3)
• betas (Tuple[python:float__, python:float], optional) – coefficients used for computing running averages of gradient and its square (default: (0.9, 0.999))
• eps (python:float__, optional) – term added to the denominator to improve numerical stability (default: 1e-8)
• weight_decay (python：float ， 可選）–權重衰減系數(shù)(默認值：1e-2）
• amsgrad (boolean__, optional) – whether to use the AMSGrad variant of this algorithm from the paper On the Convergence of Adam and Beyond (default: False)

step(closure=None)?

Performs a single optimization step.

Parameters

closure (callable__, optional) – A closure that reevaluates the model and returns the loss.

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

實現(xiàn)適用于稀疏張量的 Adam 算法的惰性版本。

在此變體中，僅顯示出現(xiàn)在漸變中的力矩，并且僅將漸變的那些部分應用于參數(shù)。

Parameters

• params (iterable) – iterable of parameters to optimize or dicts defining parameter groups
• lr (python:float__, optional) – learning rate (default: 1e-3)
• betas (Tuple[python:float__, python:float], optional) – coefficients used for computing running averages of gradient and its square (default: (0.9, 0.999))
• eps (python:float__, optional) – term added to the denominator to improve numerical stability (default: 1e-8)

step(closure=None)?

Performs a single optimization step.

Parameters

closure (callable__, optional) – A closure that reevaluates the model and returns the loss.

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

實現(xiàn) Adamax 算法(基于無窮范數(shù)的 Adam 的變體）。

It has been proposed in Adam: A Method for Stochastic Optimization.

Parameters

• params (iterable) – iterable of parameters to optimize or dicts defining parameter groups
• lr (python：float ， 可選）–學習率(默認值：2e-3）
• Betas (Tuple [ python：float ， python：float ] ， 可選）–用于計算梯度及其平方的移動平均值的系數(shù)
• eps (python:float__, optional) – term added to the denominator to improve numerical stability (default: 1e-8)
• weight_decay (python:float__, optional) – weight decay (L2 penalty) (default: 0)

step(closure=None)?

Performs a single optimization step.

Parameters

closure (callable__, optional) – A closure that reevaluates the model and returns the loss.

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

實施平均隨機梯度下降。

在通過平均對隨機逼近的加速中提出。

Parameters

• params (iterable) – iterable of parameters to optimize or dicts defining parameter groups
• lr (python:float__, optional) – learning rate (default: 1e-2)
• lambd (python：float ， 可選）–衰減項(默認值：1e-4）
• alpha (python：float ， 可選）– eta 更新的電源(默認值：0.75）
• t0 (python：float ， 可選）–開始平均的點(默認值：1e6）
• weight_decay (python:float__, optional) – weight decay (L2 penalty) (default: 0)

step(closure=None)?

Performs a single optimization step.

Parameters

closure (callable__, optional) – A closure that reevaluates the model and returns the loss.

class torch.optim.LBFGS(params, lr=1, max_iter=20, max_eval=None, tolerance_grad=1e-07, tolerance_change=1e-09, history_size=100, line_search_fn=None)?

實現(xiàn) L-BFGS 算法，該算法受到 <cite>minFunc < https://www.cs.ubc.ca/~schmidtm/Software/minFunc.html ></cite> 的啟發(fā)。

Warning

此優(yōu)化器不支持每個參數(shù)的選項和參數(shù)組(只能有一個）。

Warning

現(xiàn)在，所有參數(shù)都必須在單個設備上。 將來會有所改善。

Note

這是一個非常占用內(nèi)存的優(yōu)化器(它需要額外的param_bytes * (history_size + 1)字節(jié)）。 如果內(nèi)存不足，請嘗試減小歷史記錄的大小，或使用其他算法。

Parameters

• lr (python：float )–學習率(默認值：1）
• max_iter (python：int )–每個優(yōu)化步驟的最大迭代次數(shù)(默認值：20）
• max_eval (python：int )–每個優(yōu)化步驟的最大函數(shù)求值數(shù)(默認值：max_iter * 1.25）。
• tolerance_grad (python：float )–一階最優(yōu)的終止公差(默認值：1e-5）。
• tolerance_change (python：float )–函數(shù)值/參數(shù)更改的終止公差(默認值：1e-9）。
• history_size (python：int )–更新歷史記錄大小(默認值：100）。
• line_search_fn (str )–“ strong_wolfe”或“無”(默認值：無）。

step(closure)?

Performs a single optimization step.

Parameters

閉合(可調(diào)用的）–重新評估模型并返回損失的閉合。

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

實現(xiàn) RMSprop 算法。

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

居中版本首先出現(xiàn)在中，并使用遞歸神經(jīng)網(wǎng)絡生成序列。

這里的實現(xiàn)在添加 epsilon 之前取梯度平均值的平方根(請注意，TensorFlow 會互換這兩個操作）。 因此，有效學習率是，其中是計劃的學習率，是平方梯度的加權移動平均值。

Parameters

• params (iterable) – iterable of parameters to optimize or dicts defining parameter groups
• lr (python:float__, optional) – learning rate (default: 1e-2)
• 動量 (python：float ， 可選）–動量因子(默認值：0）
• alpha (python：float ， 可選）–平滑常數(shù)(默認值：0.99）
• eps (python:float__, optional) – term added to the denominator to improve numerical stability (default: 1e-8)
• 以為中心的 (bool ， 可選）–如果True來計算居中的 RMSProp，則通過對其斜率的估計對其進行歸一化 方差
• weight_decay (python:float__, optional) – weight decay (L2 penalty) (default: 0)

step(closure=None)?

Performs a single optimization step.

Parameters

closure (callable__, optional) – A closure that reevaluates the model and returns the loss.

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

實現(xiàn)彈性反向傳播算法。

Parameters

• params (iterable) – iterable of parameters to optimize or dicts defining parameter groups
• lr (python:float__, optional) – learning rate (default: 1e-2)
• etas (元組 [ python：float ， python：float ] ， 可選）–對(增加，減少）(增加，減少）(默認值：(0.5，1.2））
• step_sizes (元組 [ python：float ， python：float ] ， 可選）–一對最小和最大允許步長(默認值：(1e-6，50））

step(closure=None)?

Performs a single optimization step.

Parameters

closure (callable__, optional) – A closure that reevaluates the model and returns the loss.

class torch.optim.SGD(params, lr=<required parameter>, momentum=0, dampening=0, weight_decay=0, nesterov=False)?

實現(xiàn)隨機梯度下降(可選帶動量）。

Nesterov 動量基于中關于初始化和動量在深度學習中的重要性的公式。

Parameters

• params (iterable) – iterable of parameters to optimize or dicts defining parameter groups
• lr (python：float )–學習率
• momentum (python:float__, optional) – momentum factor (default: 0)
• weight_decay (python:float__, optional) – weight decay (L2 penalty) (default: 0)
• 衰減 (python：float ， 可選）–衰減動量(默認值：0）
• 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()

Note

用 Momentum / Nesterov 實施 SGD 與 Sutskever 等人的方法有所不同。 等 以及其他一些框架中的實現(xiàn)。

考慮到動量的具體情況，可以將更新寫為

其中，p，g，v 和分別表示參數(shù)，梯度，速度和動量。

這與 Sutskever 等人相反。 等 和其他使用表格更新的框架

Nesterov 版本進行了類似的修改。

step(closure=None)?

Performs a single optimization step.

Parameters

closure (callable__, optional) – A closure that reevaluates the model and returns the loss.

如何調(diào)整學習率

torch.optim.lr_scheduler提供了幾種根據(jù)時期數(shù)來調(diào)整學習率的方法。 torch.optim.lr_scheduler.ReduceLROnPlateau 允許基于某些驗證度量來降低動態(tài)學習率。

優(yōu)化器更新后應應用學習率安排； 例如，您應該以這種方式編寫代碼：

>>> scheduler = ...
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

Warning

在 PyTorch 1.1.0 之前，學習率調(diào)度程序應在優(yōu)化程序更新之前調(diào)用； 1.1.0 改變了這種行為，打破了 BC。 如果您在優(yōu)化程序更新之前(調(diào)用optimizer.step()）使用學習率計劃程序(調(diào)用scheduler.step()），則會跳過學習率計劃的第一個值。 如果升級到 PyTorch 1.1.0 后無法重現(xiàn)結果，請檢查是否在錯誤的時間調(diào)用了scheduler.step()。

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

將每個參數(shù)組的學習率設置為給定函數(shù)的初始 lr 倍。 當 last_epoch = -1 時，將初始 lr 設置為 lr。

Parameters

• 優(yōu)化器 (優(yōu)化器)–包裝的優(yōu)化器。
• lr_lambda (函數(shù) 或 列表）–一個給定整數(shù)參數(shù)紀元的乘法因子或此類函數(shù)列表的函數(shù) ，對于 optimizer.param_groups 中的每個組一個。
• last_epoch (python：int )–最后一個紀元的索引。 默認值：-1。

Example

>>> # 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):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

load_state_dict(state_dict)?

加載調(diào)度程序狀態(tài)。

Parameters

state_dict (dict )–調(diào)度程序狀態(tài)。 應該是從對 state_dict() 的調(diào)用返回的對象。

state_dict()?

返回調(diào)度程序的狀態(tài)為dict。

它包含 self . dict 中不是優(yōu)化程序的每個變量的條目。 學習率 lambda 函數(shù)僅在它們是可調(diào)用對象時才被保存，而在它們是函數(shù)或 lambda 時才被保存。

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

將每個參數(shù)組的學習率乘以指定函數(shù)中給定的因子。 當 last_epoch = -1 時，將初始 lr 設置為 lr。

Parameters

• optimizer (Optimizer) – Wrapped optimizer.
• lr_lambda (function or list) – A function which computes a multiplicative factor given an integer parameter epoch, or a list of such functions, one for each group in optimizer.param_groups.
• last_epoch (python:int) – The index of last epoch. Default: -1.

Example

>>> # Assuming optimizer has two groups.
>>> lmbda = lambda epoch: 0.95
>>> scheduler = LambdaLR(optimizer, lr_lambda=lmbda)
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

load_state_dict(state_dict)?

Loads the schedulers state.

Parameters

state_dict (dict )–調(diào)度程序狀態(tài)。 應該是從對 state_dict() 的調(diào)用返回的對象。

state_dict()?

Returns the state of the scheduler as a dict.

It contains an entry for every variable in self.dict which is not the optimizer. The learning rate lambda functions will only be saved if they are callable objects and not if they are functions or lambdas.

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

在每個 step_size 時期，通過 gamma 降低每個參數(shù)組的學習率。 注意，這種衰減可能與此調(diào)度程序外部的學習速率的其他更改同時發(fā)生。 當 last_epoch = -1 時，將初始 lr 設置為 lr。

Parameters

• optimizer (Optimizer) – Wrapped optimizer.
• step_size (python：int )–學習率衰減的周期。
• 伽瑪 (python：float )–學習率衰減的乘法因子。 默認值：0.1
• last_epoch (python:int) – The index of last epoch. Default: -1.

Example

>>> # Assuming optimizer uses lr = 0.05 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):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

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

一旦歷元數(shù)達到其中一個里程碑，則通過伽馬衰減每個參數(shù)組的學習率。 注意，這種衰減可能與此調(diào)度程序外部的學習速率的其他更改同時發(fā)生。 當 last_epoch = -1 時，將初始 lr 設置為 lr。

Parameters

• optimizer (Optimizer) – Wrapped optimizer.
• 里程碑(列表）–時期索引列表。 必須增加。
• gamma (python:float) – Multiplicative factor of learning rate decay. Default: 0.1.
• last_epoch (python:int) – The index of last epoch. Default: -1.

Example

>>> # Assuming optimizer uses lr = 0.05 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):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

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

在每個時期以伽馬衰減每個參數(shù)組的學習率。 當 last_epoch = -1 時，將初始 lr 設置為 lr。

Parameters

• optimizer (Optimizer) – Wrapped optimizer.
• 伽瑪 (python：float )–學習率衰減的乘法因子。
• last_epoch (python:int) – The index of last epoch. Default: -1.

class torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)?

使用余弦退火進度表設置每個參數(shù)組的學習率，其中設置為初始 lr，是自 SGDR 上次重新啟動以來的時期數(shù)：

當 last_epoch = -1 時，將初始 lr 設置為 lr。 注意，由于調(diào)度是遞歸定義的，因此其他操作員可以在此調(diào)度器外部同時修改學習率。 如果學習率僅由此調(diào)度程序設置，則每個步驟的學習率變?yōu)椋?/p>

它已在 SGDR：具有暖重啟的隨機梯度下降中提出。 請注意，這僅實現(xiàn) SGDR 的余弦退火部分，而不實現(xiàn)重新啟動。

Parameters

• optimizer (Optimizer) – Wrapped optimizer.
• T_max (python：int )–最大迭代次數(shù)。
• eta_min (python：float )–最低學習率。 默認值：0
• last_epoch (python:int) – The index of last epoch. Default: -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 倍。 該調(diào)度程序讀取一個指標數(shù)量，如果在“耐心”時期沒有看到改善，則學習速度會降低。

Parameters

• optimizer (Optimizer) – Wrapped optimizer.
• 模式 (str )– <cite>min</cite> ， <cite>max</cite> 中的一種。 在 <cite>min</cite> 模式下，當監(jiān)視的數(shù)量停止減少時，lr 將減??； 在 <cite>max</cite> 模式下，當監(jiān)視的數(shù)量停止增加時，它將減少。 默認值：“分鐘”。
• 因子 (python：float )–將降低學習率的因子。 new_lr = lr *因子。 默認值：0.1
• 耐心 (python：int )–沒有改善的時期數(shù)，之后學習率將降低。 例如，如果<cite>耐心= 2</cite> ，那么我們將忽略前兩個時期，而沒有改善，并且如果損失仍然沒有改善，則只會在第三個時期之后降低 LR。 默認值：10
• 詳細 (bool )–如果True，則為每次更新向 stdout 打印一條消息。 默認值：False。
• 閾值 (python：float )–用于測量新最優(yōu)值的閾值，僅關注重大變化。 默認值：1e-4。
• threshold_mode?(str?)– <cite>相對</cite>， <cite>abs</cite> 之一。 在<cite>相對于</cite>模式下，dynamic_threshold =最佳(1 +閾值）在“最大”模式下，最佳(1-閾值）在 <cite>min</cite> 模式下。 在<cite>絕對</cite>模式下，dynamic_threshold =最佳+ <cite>max</cite> 模式下的閾值，或 best-閾值 <cite>min</cite> 模式下的閾值。 默認值：“ rel”。
• 冷卻時間 (python：int )–減少 lr 后恢復正常運行之前要等待的時期數(shù)。 默認值：0
• min_lr (python：float 或 列表）–標量或標量列表。 所有參數(shù)組或每個組的學習率的下限。 默認值：0
• eps (python：float )–應用于 lr 的最小衰減。 如果新舊 lr 之間的差異小于 eps，則忽略該更新。 默認值：1e-8。

Example

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

class torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr, max_lr, step_size_up=2000, step_size_down=None, mode='triangular', gamma=1.0, scale_fn=None, scale_mode='cycle', cycle_momentum=True, base_momentum=0.8, max_momentum=0.9, last_epoch=-1)?

根據(jù)周期學習率策略(CLR）設置每個參數(shù)組的學習率。 該策略以恒定的頻率在兩個邊界之間循環(huán)學習率，如論文訓練神經(jīng)網(wǎng)絡的循環(huán)學習率中所述。 兩個邊界之間的距離可以在每個迭代或每個周期的基礎上縮放。

周期性學習率策略會在每批之后更改學習率。 在將一批用于訓練之后，應調(diào)用<cite>步驟</cite>。

如本文所述，該類具有三個內(nèi)置策略：

• “三角形”：沒有幅度縮放的基本三角形周期。
• “ triangular2”：一個基本的三角形周期，它將每個周期的初始幅度縮放一半。
• “ exp_range”：一個在每次循環(huán)迭代中按縮放初始幅度的循環(huán)。

此實現(xiàn)改編自 github 存儲庫： bckenstler / CLR

Parameters

• optimizer (Optimizer) – Wrapped optimizer.
• base_lr (python：float 或 列表）–初始學習速率，它是每個參數(shù)組循環(huán)的下限。
• max_lr (python：float 或 列表）–每個參數(shù)組在循環(huán)中的較高學習率邊界。 從功能上講，它定義了循環(huán)幅度(max_lr-base_lr）。 任何周期的 lr 是 base_lr 與振幅的一定比例之和； 因此，取決于縮放函數(shù)，可能實際上無法達到 max_lr。
• step_size_up (python：int )–周期遞增的一半中的訓練迭代次數(shù)。 默認值：2000
• step_size_down (python：int )–減少周期的一半內(nèi)的訓練迭代次數(shù)。 如果 step_size_down 為 None，則將其設置為 step_size_up。 默認值：無
• 模式 (str )– {triangle，trial2，exp_range}中的一種。 值與上面詳述的策略相對應。 如果 scale_fn 不為 None，則忽略此參數(shù)。 默認值：“三角形”
• 伽瑪 (python：float )–'exp_range'縮放函數(shù)中的常量：gamma **(循環(huán)迭代）默認值：1.0
• scale_fn (函數(shù)）–由單個參數(shù) lambda 函數(shù)定義的自定義縮放策略，其中對于所有 x > = 0 < = scale_fn(x）< = 1 0。如果指定，則忽略“模式”。 默認值：無
• scale_mode (str )– {“周期”，“迭代次數(shù)”}。 定義是否在循環(huán)數(shù)或循環(huán)迭代(自循環(huán)開始后的訓練迭代）中評估 scale_fn。 默認值：“循環(huán)”
• cycle_momentum (bool )–如果True，則動量與學習速率成反比地在“ base_momentum”和“ max_momentum”之間循環(huán)。 默認值：True
• base_momentum (python：float 或 列表）–每個參數(shù)組的循環(huán)動量邊界較低。 注意，動量與學習速度成反比。 在一個周期的最高峰，動量為“ base_momentum”，學習速率為“ max_lr”。 默認值：0.8
• max_momentum (python：float 或 列表）–每個參數(shù)組在循環(huán)中的較高動量邊界。 從功能上講，它定義了循環(huán)幅度(max_momentum-base_momentum）。 任何周期的動量都是 max_momentum 與振幅的一定比例之差； 因此，取決于縮放功能，實際上可能無法達到 base_momentum。 注意，動量與學習速度成反比。 在周期開始時，動量為“ max_momentum”，學習率為“ base_lr”默認值：0.9
• last_epoch (python：int )–最后一批的索引。 恢復訓練作業(yè)時使用此參數(shù)。 由于 <cite>step(）</cite>應該在每個批處理之后而不是在每個時期之后調(diào)用，因此該數(shù)字表示所計算的批次的總數(shù)，而不是所計算的時期總數(shù)。 當 last_epoch = -1 時，調(diào)度將從頭開始。 默認值：-1

Example

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> scheduler = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=0.01, max_lr=0.1)
>>> data_loader = torch.utils.data.DataLoader(...)
>>> for epoch in range(10):
>>>     for batch in data_loader:
>>>         train_batch(...)
>>>         scheduler.step()

get_lr()?

計算批次索引的學習率。 此函數(shù)將 <cite>self.last_epoch</cite> 視為最后一批索引。

如果 <cite>self.cycle_momentum</cite> 為True，則此功能具有更新優(yōu)化器動量的副作用。

class torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr, total_steps=None, epochs=None, steps_per_epoch=None, pct_start=0.3, anneal_strategy='cos', cycle_momentum=True, base_momentum=0.85, max_momentum=0.95, div_factor=25.0, final_div_factor=10000.0, last_epoch=-1)?

根據(jù) 1cycle 學習率策略設置每個參數(shù)組的學習率。 1 周期策略將學習速率從初始學習速率退火到某個最大學習速率，然后從該最大學習速率退火到某個遠低于初始學習速率的最小學習速率。 最初在論文超融合：使用大學習率的超快速神經(jīng)網(wǎng)絡訓練中描述了此策略。

1 周期學習率策略每批更改一次學習率。 在將一批用于訓練之后，應調(diào)用<cite>步驟</cite>。

此調(diào)度程序不可鏈接。

還請注意，可以用以下兩種方法之一確定循環(huán)中的步驟總數(shù)(按優(yōu)先順序列出）：

1. 明確提供了 total_steps 的值。
2. 提供了多個時期(epoch）和每個時期的步驟數(shù)(steps_per_epoch）。 在這種情況下，總步數(shù)由 total_steps = epochs * steps_per_epoch 推斷

您必須為 total_steps 提供一個值，或者為紀元和 steps_per_epoch 提供一個值。

Parameters

• optimizer (Optimizer) – Wrapped optimizer.
• max_lr (python：float 或 列表）–每個參數(shù)組在循環(huán)中的較高學習率邊界。
• total_steps (python：int )–循環(huán)中的總步數(shù)。 請注意，如果此處提供了一個值，則必須通過為 epochs 和 steps_per_epoch 提供一個值來進行推斷。 默認值：無
• 紀元 (python：int )–要訓練的紀元數(shù)。 如果未提供 total_steps 的值，則將其與 steps_per_epoch 一起使用以推斷循環(huán)中的步驟總數(shù)。 默認值：無
• steps_per_epoch (python：int )–每個紀元要訓練的步數(shù)。 如果未提供 total_steps 的值，則將其與歷元一起使用以推斷循環(huán)中的總步數(shù)。 默認值：無
• pct_start (python：float )–花費的周期百分比(步數(shù)）提高了學習率。 默認值：0.3
• anneal_strategy (str )– {'cos'，'linear'}指定退火策略：余弦退火為“ cos”，線性退火為“ linear”。 默認值：“ cos”
• cycle_momentum (bool) – If True, momentum is cycled inversely to learning rate between 'base_momentum' and 'max_momentum'. Default: True
• base_momentum (python：float 或 列表）–每個參數(shù)組的循環(huán)動量邊界較低。 注意，動量與學習速度成反比。 在一個周期的最高峰，動量為“ base_momentum”，學習速率為“ max_lr”。 默認值：0.85
• max_momentum (python：float 或 列表）–每個參數(shù)組在循環(huán)中的較高動量邊界。 從功能上講，它定義了循環(huán)幅度(max_momentum-base_momentum）。 注意，動量與學習速度成反比。 在周期開始時，動量為“ max_momentum”，學習率為“ base_lr”默認值：0.95
• div_factor (python：float )–通過 initial_lr = max_lr / div_factor 確定初始學習率默認值：25
• final_div_factor (python：float )–通過 min_lr = initial_lr / final_div_factor 確定最小學習率默認值：1e4
• last_epoch (python:int) – The index of the last batch. This parameter is used when resuming a training job. Since <cite>step()</cite> should be invoked after each batch instead of after each epoch, this number represents the total number of batches computed, not the total number of epochs computed. When last_epoch=-1, the schedule is started from the beginning. Default: -1

Example

>>> data_loader = torch.utils.data.DataLoader(...)
>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.01, steps_per_epoch=len(data_loader), epochs=10)
>>> for epoch in range(10):
>>>     for batch in data_loader:
>>>         train_batch(...)
>>>         scheduler.step()

class torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0, T_mult=1, eta_min=0, last_epoch=-1)?

使用余弦退火進度表設置每個參數(shù)組的學習率，其中設置為初始 lr，是自上次重啟以來的時期數(shù)，是兩次暖啟動之間的時期數(shù) 在 SGDR 中：

當時，設置。 重新啟動后時，設置。

它已在 SGDR：具有暖重啟的隨機梯度下降中提出。

Parameters

• optimizer (Optimizer) – Wrapped optimizer.
• T_0 (python：int )–首次重啟的迭代次數(shù)。
• T_mult (python：int ， 可選）–重新啟動后，因素會增加。 默認值：1。
• eta_min (python：float ， 可選）–最低學習率。 默認值：0
• last_epoch (python：int ， 可選）–最后一個紀元的索引。 默認值：-1。

step(epoch=None)?

每次批量更新后都可以調(diào)用該步驟

Example

>>> scheduler = CosineAnnealingWarmRestarts(optimizer, T_0, T_mult)
>>> iters = len(dataloader)
>>> for epoch in range(20):
>>>     for i, sample in enumerate(dataloader):
>>>         inputs, labels = sample['inputs'], sample['labels']
>>>         scheduler.step(epoch + i / iters)
>>>         optimizer.zero_grad()
>>>         outputs = net(inputs)
>>>         loss = criterion(outputs, labels)
>>>         loss.backward()
>>>         optimizer.step()

可以交錯方式調(diào)用此函數(shù)。

Example

>>> scheduler = CosineAnnealingWarmRestarts(optimizer, T_0, T_mult)
>>> for epoch in range(20):
>>>     scheduler.step()
>>> scheduler.step(26)
>>> scheduler.step() # scheduler.step(27), instead of scheduler(20)