目錄
快捷方式

Adafactor

class torch.optim.Adafactor(params, lr=0.01, beta2_decay=-0.8, eps=(None, 0.001), d=1.0, weight_decay=0.0, *, foreach=None, maximize=False)

實現 Adafactor 演算法。

input:γ(lr), τ(β2 decay), θ0(params), f(θ)(objective), ϵ1,ϵ2 (epsilons), d(clipping threshold), λ(weight decay), maximizeinitialize: R0←0 (second moment row factor), C0←0 (second moment col factor), V^0←0 (second moment for vectors)for t=1 to … doif maximize:Gt←−∇θft(θt−1)elseGt←∇θft(θt−1)β^2t←1−tτρt←min(lr,1t)αt←max(ϵ2,RMS(θt−1))ρtθt←θt−1−γλθt−1if dim(Gt)>1:Rt←β^2tRt−1+(1−β^2t)(Gt⊙Gt)⋅1mCt←β^2tCt−1+(1−β^2t)1n⊤⋅(Gt⊙Gt)V^t←Rt⋅Ctmax(1n⊤⋅Rt,ϵ1)elseV^t←β^2tV^t−1+(1−β^2t)⋅(Gt⊙Gt)Ut←Gtmax(V^t,ϵ1)U^t←Utmax(1,RMS(Ut)d)θt←θt−1−αtU^treturn θt\begin{aligned} &\rule{110mm}{0.4pt} \\ &\textbf{input} : \gamma \text{(lr)}, \: \tau \text{(}\beta_2\text{ decay)}, \: \theta_0 \text{(params)}, \: f(\theta) \text{(objective)}, \\ &\hspace{15mm} \: \epsilon_1, \epsilon_2 \text{ (epsilons)}, \: d \text{(clipping threshold)}, \\ &\hspace{15mm} \: \lambda \text{(weight decay)}, \: \textit{maximize} \\ &\textbf{initialize} : \: R_0 \leftarrow 0 \text{ (second moment row factor)}, \\ &\hspace{23mm} \: C_0 \leftarrow 0 \text{ (second moment col factor)}, \\ &\hspace{23mm} \: \widehat{V}_0 \leftarrow 0 \text{ (second moment for vectors)} \\[-1.ex] &\rule{110mm}{0.4pt} \\ &\textbf{for} \: t=1 \: \textbf{to} \: \ldots \: \textbf{do} \\ &\hspace{5mm}\textbf{if} \: \textit{maximize}: \\ &\hspace{10mm}G_t \leftarrow -\nabla_{\theta} f_t (\theta_{t-1}) \\ &\hspace{5mm}\textbf{else} \\ &\hspace{10mm}G_t \leftarrow \nabla_{\theta} f_t (\theta_{t-1}) \\ &\hspace{5mm}\widehat{\beta}_{2_t} \leftarrow 1 - t^{\tau} \\ &\hspace{5mm}\rho_t \leftarrow min(lr, \frac{1}{\sqrt{t}}) \\ &\hspace{5mm}\alpha_t \leftarrow max(\epsilon_2, \text{RMS}(\theta_{t-1}))\rho_t \\ &\hspace{5mm}\theta_t \leftarrow \theta_{t-1} - \gamma \lambda \theta_{t-1} \\ &\hspace{5mm}\textbf{if} \: \text{dim}(G_t) > 1: \\ &\hspace{10mm}R_t \leftarrow \widehat{\beta}_{2_t}R_{t-1}+ (1-\widehat{\beta}_{2_t})(G_t \odot G_t) \cdot 1_m \\ &\hspace{10mm}C_t \leftarrow \widehat{\beta}_{2_t}C_{t-1}+ (1-\widehat{\beta}_{2_t}) 1^\top_n \cdot (G_t \odot G_t) \\ &\hspace{10mm}\widehat{V}_t \leftarrow \frac{R_t \cdot C_t}{max(1^\top_n \cdot R_t, \epsilon_1)} \\ &\hspace{5mm}\textbf{else} \\ &\hspace{10mm}\widehat{V}_t \leftarrow \widehat{\beta}_{2_t}\widehat{V}_{t-1}+ (1-\widehat{\beta}_{2_t}) \cdot (G_t \odot G_t) \\ &\hspace{5mm}U_t \leftarrow \frac{G_t}{max(\sqrt{\widehat{V}_t}, \epsilon_1)} \\ &\hspace{5mm}\widehat{U}_t \leftarrow \frac{U_t}{max(1, \frac{\text{RMS}(U_t)}{d})} \\ &\hspace{5mm}\theta_t \leftarrow \theta_{t-1} - \alpha_t \widehat{U}_t \\ &\rule{110mm}{0.4pt} \\[-1.ex] &\bf{return} \: \theta_t \\[-1.ex] &\rule{110mm}{0.4pt} \\[-1.ex] \end{aligned}

關於該演算法的更多細節，請參考 Adafactor: Adaptive Learning Rates with Sublinear Memory Cost。

引數

  • params (iterable) – 待最佳化的引數迭代器或 named_parameters 迭代器，或定義引數組的字典迭代器。使用 named_parameters 時，所有組中的所有引數都應被命名

  • lr (float, Tensor, optional) – 與其他最佳化器不同，Adafactor 不需要學習率，並且 Shazeer, Noam, 和 Mitchell Stern 完全不使用 lr。與論文有所不同，此實現使用 lr 來應用權重衰減，並作為相對步長 rho_t 的最大值。請注意，在論文中，使用常數 0.01 作為相對步長的最大值，因此我們將 0.01 設定為預設值。(default: 1e-2)

  • beta2_decay (float, optional) – beta2 的衰減率。beta2 通常指用於計算梯度平方移動平均的係數。(default: -0.8)

  • eps (Tuple[float, float], optional) – epsilon1 是新增到更新計算分母中的項，用於提高數值穩定性。此對 epsilon1 的使用與論文中描述的演算法有所不同！更多詳情請參閱下面的注意事項。epsilon2 是用於避免在應用引數縮放時權重更新過小的項。(default: (None, 1e-3))

  • d (float, optional) – 裁剪閾值，用於避免更新值大於期望值。

  • weight_decay (float, optional) – 權重衰減係數 (default: 1e-2)

  • foreach (bool, optional) – 是否使用 foreach 實現的最佳化器。請注意，foreach 實現比 for-loop 版本佔用更多的峰值記憶體，大約是 sizeof(params) 的大小，因為中間變數是一個 tensorlist 而不是單個 tensor。由於 Adafactor 通常在記憶體受限的情況下使用，因此除非明確將此標誌設定為 True，否則 Adafactor 將預設使用較慢的單 tensor for-loop 實現。此行為與其他最佳化器相反，其他最佳化器在 CUDA 上會嘗試預設使用 foreach 以獲得更快的執行時效能。(default: None)

  • maximize (bool, optional) – 相對於引數最大化目標，而不是最小化 (default: False)

注意

Adafactor 的實現與 Shazeer, Noam, 和 Mitchell Stern 以及其他一些框架中的實現在使用學習率和 ϵ1\epsilon_1 方面略有不同。

關於學習率超引數：Shazeer, Noam, 和 Mitchell Stern 完全不使用 lr，因為其提出的演算法使用 ρt\rho_t 和更新裁剪來影響步長。

此實現允許 lr 影響 ρt\rho_t 的最大值

ρt←min(lr,1t)\begin{aligned} &\hspace{5mm}\rho_t \leftarrow min(lr, \frac{1}{\sqrt{t}}) \end{aligned}

這與 Shazeer, Noam, 和 Mitchell Stern 不同，他們使用常數 0.01 作為 ρt\rho_t 的最大值

ρt←min(0.01,1t)\begin{aligned} &\hspace{5mm}\rho_t \leftarrow min(0.01, \frac{1}{\sqrt{t}}) \end{aligned}

Shazeer, Noam, 和 Mitchell Stern 沒有對如何計算權重衰減給出明確意見，因此我們使用學習率作為解耦權重衰減的係數，這類似於 Decoupled Weight Decay Regularization 中建議的做法。

關於使用 ϵ1\epsilon_1：此實現試圖複製 Shazeer, Noam, 和 Mitchell Stern 在梯度平方變小時使用 ϵ1\epsilon_1 作為穩定項的預期意圖。

此穩定化可以寫為

Rt←β^2tRt−1+(1−β^2t)(Gt⊙Gt+1n⋅1m⊤)⋅1mCt←β^2tCt−1+(1−β^2t)1n⊤⋅(Gt⊙Gt+1n⋅1m⊤)V^t←Rt⋅Ctmax(1n⊤⋅Rt,ϵ1)Ut←Gtmax(V^t,ϵ1)\begin{aligned} &\hspace{5mm}R_t \leftarrow \widehat{\beta}_{2_t}R_{t-1}+ (1-\widehat{\beta}_{2_t})(G_t \odot G_t + 1_n \cdot 1^\top_m) \cdot 1_m \\ &\hspace{5mm}C_t \leftarrow \widehat{\beta}_{2_t}C_{t-1}+ (1-\widehat{\beta}_{2_t}) 1^\top_n \cdot (G_t \odot G_t + 1_n \cdot 1^\top_m) \\ &\hspace{5mm}\widehat{V}_t \leftarrow \frac{R_t \cdot C_t}{max(1^\top_n \cdot R_t, \epsilon_1)} \\ &\hspace{5mm}U_t \leftarrow \frac{G_t}{max(\sqrt{\widehat{V}_t}, \epsilon_1)} \\ \end{aligned}

其中，梯度平方的行因子 RtR_t 和列因子 CtC_t 被單獨處理，並且我們在方差估計值 V^t\widehat{V}_t 的最終計算和更新 UtU_t 中應用了 ϵ1\epsilon_1。

這與 Shazeer、Noam 和 Mitchell Stern 等將 ϵ1\epsilon_1 應用於梯度平方的行因子和列因子，但不應用於之後的計算中的其他框架不同。

Rt←β^2tRt−1+(1−β^2t)(Gt⊙Gt+ϵ11n⋅1m⊤)⋅1mCt←β^2tCt−1+(1−β^2t)1n⊤⋅(Gt⊙Gt+ϵ11n⋅1m⊤)V^t←Rt⋅Ct1n⊤⋅RtUt←GtV^t\begin{aligned} &\hspace{5mm}R_t \leftarrow \widehat{\beta}_{2_t}R_{t-1}+ (1-\widehat{\beta}_{2_t})(G_t \odot G_t + \epsilon_1 1_n \cdot 1^\top_m) \cdot 1_m \\ &\hspace{5mm}C_t \leftarrow \widehat{\beta}_{2_t}C_{t-1}+ (1-\widehat{\beta}_{2_t}) 1^\top_n \cdot (G_t \odot G_t + \epsilon_1 1_n \cdot 1^\top_m) \\ &\hspace{5mm}\widehat{V}_t \leftarrow \frac{R_t \cdot C_t}{1^\top_n \cdot R_t} \\ &\hspace{5mm}U_t \leftarrow \frac{G_t}{\sqrt{\widehat{V}_t}} \\ \end{aligned}
add_param_group(param_group)[source]

新增一個引數組到 Optimizer 的 param_groups 中。

這在微調預訓練網路時很有用，因為隨著訓練的進行，被凍結的層可以變得可訓練並被新增到 Optimizer 中。

引數

param_group (dict) – 指定應該與組特定的最佳化選項一起最佳化的張量。

load_state_dict(state_dict)[source]

載入最佳化器狀態。

引數

state_dict (dict) – 最佳化器狀態。它應該是一個呼叫 state_dict() 返回的物件。

注意

引數的名稱（如果它們存在於 state_dict() 中每個引數組的“param_names”鍵下）不會影響載入過程。對於自定義情況（例如，載入的狀態字典中的引數與最佳化器中初始化的引數不同時），應該實現一個自定義的 register_load_state_dict_pre_hook 來相應地調整載入的字典。如果載入的狀態字典的 param_groups 中存在 param_names，它們將被儲存並覆蓋最佳化器狀態中當前的名稱（如果存在的話）。如果載入的狀態字典中不存在 param_names，最佳化器的 param_names 將保持不變。

register_load_state_dict_post_hook(hook, prepend=False)[source]

註冊一個 `load_state_dict` 後置鉤子，它將在呼叫 load_state_dict() 之後被呼叫。它應該具有以下簽名

hook(optimizer) -> None

`optimizer` 引數是正在使用的最佳化器例項。

在對 `self` 呼叫 `load_state_dict` 之後，將使用引數 `self` 呼叫該鉤子。註冊的鉤子可用於在 `load_state_dict` 載入完 `state_dict` 後執行後處理。

引數

  • hook (Callable) – 要註冊的使用者定義的鉤子。

  • prepend (bool) – 如果為 True，提供的後置 `hook` 將在所有已註冊的 `load_state_dict` 後置鉤子之前觸發。否則，提供的 `hook` 將在所有已註冊的後置鉤子之後觸發。（預設值：False）

返回值

一個控制代碼，可以透過呼叫 handle.remove() 來移除新增的鉤子。

返回型別

torch.utils.hooks.RemoveableHandle

register_load_state_dict_pre_hook(hook, prepend=False)[source]

註冊一個 `load_state_dict` 前置鉤子，它將在呼叫 load_state_dict() 之前被呼叫。它應該具有以下簽名

hook(optimizer, state_dict) -> state_dict or None

`optimizer` 引數是正在使用的最佳化器例項，而 `state_dict` 引數是使用者傳遞給 `load_state_dict` 的 `state_dict` 的淺複製。鉤子可以就地修改 state_dict，或者選擇性地返回一個新的 state_dict。如果返回一個 state_dict，它將被用來載入到最佳化器中。

在對 `self` 呼叫 `load_state_dict` 之前，將使用引數 `self` 和 `state_dict` 呼叫該鉤子。註冊的鉤子可用於在呼叫 `load_state_dict` 之前執行預處理。

引數

  • hook (Callable) – 要註冊的使用者定義的鉤子。

  • prepend (bool) – 如果為 True，提供的前置 `hook` 將在所有已註冊的 `load_state_dict` 前置鉤子之前觸發。否則，提供的前置 `hook` 將在所有已註冊的前置鉤子之後觸發。（預設值：False）

返回值

一個控制代碼，可以透過呼叫 handle.remove() 來移除新增的鉤子。

返回型別

torch.utils.hooks.RemoveableHandle

register_state_dict_post_hook(hook, prepend=False)[source]

註冊一個狀態字典後置鉤子，它將在呼叫 state_dict() 之後被呼叫。

它應該具有以下簽名

hook(optimizer, state_dict) -> state_dict or None

在 `self` 上生成 `state_dict` 之後，將使用引數 `self` 和 `state_dict` 呼叫該鉤子。鉤子可以就地修改 state_dict，或者選擇性地返回一個新的 state_dict。註冊的鉤子可用於在返回 `state_dict` 之前對其執行後處理。

引數

  • hook (Callable) – 要註冊的使用者定義的鉤子。

  • prepend (bool) – 如果為 True，提供的後置 `hook` 將在所有已註冊的 `state_dict` 後置鉤子之前觸發。否則，提供的後置 `hook` 將在所有已註冊的後置鉤子之後觸發。（預設值：False）

返回值

一個控制代碼，可以透過呼叫 handle.remove() 來移除新增的鉤子。

返回型別

torch.utils.hooks.RemoveableHandle

register_state_dict_pre_hook(hook, prepend=False)[source]

註冊一個狀態字典前置鉤子，它將在呼叫 state_dict() 之前被呼叫。

它應該具有以下簽名

hook(optimizer) -> None

`optimizer` 引數是正在使用的最佳化器例項。在對 `self` 呼叫 `state_dict` 之前，將使用引數 `self` 呼叫該鉤子。註冊的鉤子可用於在呼叫 `state_dict` 之前執行預處理。

引數

  • hook (Callable) – 要註冊的使用者定義的鉤子。

  • prepend (bool) – 如果為 True，提供的前置 `hook` 將在所有已註冊的 `state_dict` 前置鉤子之前觸發。否則，提供的前置 `hook` 將在所有已註冊的前置鉤子之後觸發。（預設值：False）

返回值

一個控制代碼，可以透過呼叫 handle.remove() 來移除新增的鉤子。

返回型別

torch.utils.hooks.RemoveableHandle

register_step_post_hook(hook)[source]

註冊一個最佳化器步後鉤子，它將在最佳化器步執行後被呼叫。

它應該具有以下簽名

hook(optimizer, args, kwargs) -> None

`optimizer` 引數是正在使用的最佳化器例項。

引數

hook (Callable) – 要註冊的使用者定義的鉤子。

返回值

一個控制代碼，可以透過呼叫 handle.remove() 來移除新增的鉤子。

返回型別

torch.utils.hooks.RemovableHandle

register_step_pre_hook(hook)[source]

註冊一個最佳化器步前鉤子，它將在最佳化器步執行前被呼叫。

它應該具有以下簽名

hook(optimizer, args, kwargs) -> None or modified args and kwargs

`optimizer` 引數是正在使用的最佳化器例項。如果引數 `args` 和 `kwargs` 被步前鉤子修改，則轉換後的值將以包含 `new_args` 和 `new_kwargs` 的元組形式返回。

引數

hook (Callable) – 要註冊的使用者定義的鉤子。

返回值

一個控制代碼，可以透過呼叫 handle.remove() 來移除新增的鉤子。

返回型別

torch.utils.hooks.RemovableHandle

state_dict()[source]

將最佳化器的狀態作為 dict 返回。

它包含兩個條目

  • state: 一個 holding 當前最佳化狀態的 Dict。其內容

    在不同的最佳化器類之間有所不同，但保留了一些共同的特性。例如，狀態按引數儲存，而引數本身不儲存。`state` 是一個將引數 ID 對映到包含對應每個引數狀態的 Dict 的字典。

  • param_groups: 一個包含所有引數組的 List，其中每個

    引數組都是一個 Dict。每個引數組包含特定於最佳化器的元資料，例如學習率和權重衰減，以及該組中引數的引數 ID 列表。如果引數組是使用 `named_parameters()` 初始化的，則名稱內容也將儲存到 state dict 中。

注意：引數 ID 可能看起來像索引，但它們只是將狀態與 param_group 相關聯的 ID。從 state_dict 載入時，最佳化器將打包 param_group 的 `params`（int ID）和最佳化器的 `param_groups`（實際的 `nn.Parameter`），以便匹配狀態而無需額外驗證。

返回的 state dict 可能看起來像這樣

{
    'state': {
        0: {'momentum_buffer': tensor(...), ...},
        1: {'momentum_buffer': tensor(...), ...},
        2: {'momentum_buffer': tensor(...), ...},
        3: {'momentum_buffer': tensor(...), ...}
    },
    'param_groups': [
        {
            'lr': 0.01,
            'weight_decay': 0,
            ...
            'params': [0]
            'param_names' ['param0']  (optional)
        },
        {
            'lr': 0.001,
            'weight_decay': 0.5,
            ...
            'params': [1, 2, 3]
            'param_names': ['param1', 'layer.weight', 'layer.bias'] (optional)
        }
    ]
}
返回型別

dict[str, Any]

step(closure=None)[source][source]

執行一次最佳化步。

引數

closure (可呼叫物件, 可選) – 一個重新評估模型並返回損失的閉包。

zero_grad(set_to_none=True)[source]

重置所有最佳化過的 torch.Tensor 的梯度。

引數

set_to_none (bool) – 不是將梯度設定為零，而是將梯度設定為 None。這通常會降低記憶體佔用，並可以適度提高效能。但是，它會改變某些行為。例如：1. 當用戶嘗試訪問梯度並對其執行手動操作時，None 屬性或全為 0 的 Tensor 的行為會不同。2. 如果使用者請求 `zero_grad(set_to_none=True)` 後執行反向傳播，則未接收到梯度的引數的 `.grad` 保證為 None。3. `torch.optim` 最佳化器在梯度為 0 或 None 時的行為不同（在前一種情況下，它會以 0 梯度執行步進，而在後一種情況下則完全跳過步進）。

文件

訪問 PyTorch 的完整開發者文件

檢視文件

教程

獲取面向初學者和高階開發者的深入教程

檢視教程

資源

查詢開發資源並獲得問題解答

檢視資源

為了分析流量並最佳化您的體驗，我們在本網站上提供 cookie。透過點選或導航，您同意我們使用 cookie。作為本網站的當前維護者，適用 Facebook 的 Cookie 政策。瞭解更多資訊，包括可用的控制選項：Cookie 政策。