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 演算法。

\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) – 要優化的參數的 iterable 或 named_parameters，或者定義參數群組的 dicts 的 iterable。當使用 named_parameters 時，所有群組中的所有參數都應被命名
lr (float, Tensor, optional) – 與其他優化器不同，Adafactor 不需要學習率，並且 Shazeer、Noam 和 Mitchell Stern 完全不使用 lr。與論文不同的是，此實作使用 lr 來應用權重衰減，並作為相對步長大小 rho_t 的最大值。請注意，在論文中，使用 0.01 的常數作為相對步長大小的最大值，因此我們將 0.01 設定為預設值。（預設值：1e-2）
beta2_decay (float, optional) – beta2 的衰減率。beta2 通常指的是用於計算梯度平方的 running average 的係數。（預設值：-0.8）
eps (Tuple[float, float], optional) – epsilon1 是添加到更新計算分母中的項，以提高數值穩定性。 epsilon1 的這種使用方式與論文中寫的演算法不同！請參閱下面的注釋以了解更多詳細資訊。 epsilon2 是用於避免在應用參數縮放時權重更新太小的項。（預設值：(None, 1e-3)）
d (float, optional) – 剪裁閾值，用於避免大於預期的更新。
weight_decay (float, optional) – 權重衰減係數（預設值：1e-2）
foreach (bool, optional) – 是否使用優化器的 foreach 實作。請注意，由於中間值是 tensorlist 而不是僅一個 tensor，因此 foreach 實作使用的峰值記憶體比 for 迴圈版本多約 sizeof(params)。由於 Adafactor 通常在記憶體受到限制時使用，因此除非明確將此標誌設定為 True，否則 Adafactor 將預設為較慢的單個 tensor for 迴圈實作。這種行為與其他優化器相反，其他優化器會嘗試預設為 CUDA 上的 foreach 以獲得更快的執行時間。（預設值：None）
maximize (bool, optional) – 相對於參數最大化目標，而不是最小化（預設值：False）

注意

Adafactor 的實作與 Shazeer、Noam 和 Mitchell Stern 以及某些其他框架的實作略有不同，因為它使用了學習率和 $\epsilon_1$ 。

關於學習率超參數：Shazeer、Noam 和 Mitchell Stern 完全不使用 lr，因為所述演算法使用 $\rho_t$ 並更新剪裁以影響步長。

此實作允許 lr 影響 $\rho_t$ 的最大值

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

這與 Shazeer、Noam 和 Mitchell Stern 的方法不同，他們使用 0.01 作為 $\rho_t$ 的最大值。

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

Shazeer、Noam 和 Mitchell Stern 並未強制規定權重衰減應如何計算，因此我們使用學習率作為解耦權重衰減的係數，類似於 Decoupled Weight Decay Regularization 中提出的建議。

關於使用 $\epsilon_1$ ：此實作試圖重現 Shazeer、Noam 和 Mitchell Stern 使用 $\epsilon_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}

其中平方梯度的行和列因子 $R_t$ 和 $C_t$ 被單獨保留，並且我們將 $\epsilon_1$ 應用於變異數估計值 $\widehat{V}_t$ 的最終計算以及更新 $U_t$ 。

這與 Shazeer、Noam 和 Mitchell Stern 以及其他框架形成對比，後者將 $\epsilon_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 + \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 group 的 "param_names" 鍵下）不會影響載入過程。要使用參數的名稱進行自定義操作（例如，當載入的 state dict 中的參數與優化器中初始化的參數不同時），應該實作一個自定義的 register_load_state_dict_pre_hook 以相應地調整載入的 dict。如果載入的 state dict param_groups 中存在 param_names，它們將被保存並覆蓋優化器狀態中目前的名稱（如果存在）。如果它們在載入的 state dict 中不存在，優化器的 param_names 將保持不變。

register_load_state_dict_post_hook(hook, prepend=False)[source]¶

註冊一個 load_state_dict 後置 hook，它將在呼叫 load_state_dict() 之後被呼叫。它應該具有以下簽章：

hook(optimizer) -> None

optimizer 參數是正在使用的優化器實例。

在 self 上呼叫 load_state_dict 之後，將使用參數 self 呼叫該 hook。註冊的 hook 可用於在 load_state_dict 載入 state_dict 後執行後處理。

參數

hook (Callable) – 要註冊的使用者定義的 hook。
prepend (bool) – 如果為 True，則提供的後置 hook 將在 load_state_dict 上所有已註冊的後置 hook 之前觸發。否則，提供的 hook 將在所有已註冊的後置 hook 之後觸發。（預設：False）

傳回

一個可以用於通過呼叫 handle.remove() 來移除添加的 hook 的 handle

傳回類型

torch.utils.hooks.RemoveableHandle

register_load_state_dict_pre_hook(hook, prepend=False)[source]¶

註冊一個 load_state_dict 前置 hook，它將在呼叫 load_state_dict() 之前被呼叫。它應該具有以下簽章：

hook(optimizer, state_dict) -> state_dict or None

optimizer 參數是正在使用的優化器實例，state_dict 參數是使用者傳遞給 load_state_dict 的 state_dict 的淺複製。 hook 可以就地修改 state_dict，或者選擇性地傳回一個新的。如果傳回一個 state_dict，它將被用於載入到優化器中。

在 self 上呼叫 load_state_dict 之前，將使用參數 self 和 state_dict 呼叫該 hook。註冊的 hook 可用於在呼叫 load_state_dict 之前執行預處理。

參數

hook (Callable) – 要註冊的使用者定義的 hook。
prepend (bool) – 如果為 True，則提供的前置 hook 將在 load_state_dict 上所有已註冊的前置 hook 之前觸發。否則，提供的 hook 將在所有已註冊的前置 hook 之後觸發。（預設：False）

傳回

一個可以用於通過呼叫 handle.remove() 來移除添加的 hook 的 handle

傳回類型

torch.utils.hooks.RemoveableHandle

register_state_dict_post_hook(hook, prepend=False)[source]¶

註冊一個 state dict 後置 hook，它將在呼叫 state_dict() 之後被呼叫。

它應該具有以下簽章：

hook(optimizer, state_dict) -> state_dict or None

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

參數

hook (Callable) – 要註冊的使用者定義的 hook。
prepend (bool) – 如果為 True，則提供的前置 hook 將在 state_dict 上所有已註冊的後置 hook 之前觸發。否則，提供的 hook 將在所有已註冊的後置 hook 之後觸發。（預設：False）

傳回

一個可以用於通過呼叫 handle.remove() 來移除添加的 hook 的 handle

傳回類型

torch.utils.hooks.RemoveableHandle

register_state_dict_pre_hook(hook, prepend=False)[原始碼]¶

註冊一個 state dict pre-hook，它將在呼叫 state_dict() 之前被呼叫。

它應該具有以下簽章：

hook(optimizer) -> None

optimizer 參數是正在使用的優化器實例。在 self 上呼叫 state_dict 之前，將使用參數 self 呼叫該 hook。註冊的 hook 可用於在進行 state_dict 呼叫之前執行預處理。

參數

hook (Callable) – 要註冊的使用者定義的 hook。
prepend (bool) – 如果為 True，則提供的 pre hook 將在 state_dict 上所有已註冊的 pre-hooks 之前觸發。否則，提供的 hook 將在所有已註冊的 pre-hooks 之後觸發。（預設值：False）

傳回

一個可以用於通過呼叫 handle.remove() 來移除添加的 hook 的 handle

傳回類型

torch.utils.hooks.RemoveableHandle

register_step_post_hook(hook)[原始碼]¶

註冊一個優化器 step post hook，它將在優化器 step 之後被呼叫。

它應該具有以下簽章：

hook(optimizer, args, kwargs) -> None

optimizer 參數是正在使用的優化器實例。

參數: hook (Callable) – 要註冊的使用者定義的 hook。
傳回: 一個可以用於通過呼叫 handle.remove() 來移除添加的 hook 的 handle
傳回類型: torch.utils.hooks.RemovableHandle

register_step_pre_hook(hook)[原始碼]¶

註冊一個優化器 step pre hook，它將在優化器 step 之前被呼叫。

它應該具有以下簽章：

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

optimizer 參數是正在使用的優化器實例。如果 args 和 kwargs 被 pre-hook 修改，則轉換後的值將作為包含 new_args 和 new_kwargs 的元組傳回。

參數: hook (Callable) – 要註冊的使用者定義的 hook。
傳回: 一個可以用於通過呼叫 handle.remove() 來移除添加的 hook 的 handle
傳回類型: torch.utils.hooks.RemovableHandle

state_dict()[原始碼]¶

傳回優化器的狀態，作為一個 dict。

它包含兩個條目

state：一個 Dict，用於保存當前的優化狀態。它的內容
在不同的優化器類別之間有所不同，但一些常見的特徵是成立的。例如，狀態是按參數保存的，並且參數本身不會被保存。state 是一個字典，它將參數 ID 映射到一個字典，其中包含與每個參數對應的狀態。
param_groups：一個列表，其中包含所有參數組，其中每個
參數組是一個 Dict。每個參數組都包含特定於優化器的元數據，例如學習率和權重衰減，以及該組中參數 ID 的列表。如果一個參數組是用 named_parameters() 初始化的，則名稱內容也將保存在 state dict 中。

注意：參數 ID 可能看起來像索引，但它們只是將狀態與 param_group 關聯的 ID。從 state_dict 加載時，優化器將壓縮 param_group params (int IDs) 和優化器 param_groups (實際的 nn.Parameter s) 以匹配狀態，而無需額外的驗證。

傳回的 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)[原始碼][原始碼]¶

執行單個優化步驟。

參數: closure (Callable, optional) – 一個重新評估模型並傳回損失的 closure。

zero_grad(set_to_none=True)[原始碼]¶

重置所有已優化的 torch.Tensor 的梯度。

參數: set_to_none (bool) – 將梯度設為 None 而非設為零。一般而言，這樣做可以減少記憶體佔用，並稍微提高效能。然而，這會改變某些行為。例如：1. 當使用者嘗試存取梯度並對其執行手動操作時，None 屬性或包含一堆 0 的 Tensor 行為會有所不同。2. 如果使用者請求 zero_grad(set_to_none=True)，然後執行反向傳播，則保證未接收到梯度的參數的 .grad 為 None。3. 如果梯度為 0 或 None，torch.optim 優化器的行為會有所不同（一種情況下，它會以梯度 0 執行步進，另一種情況下，它會完全跳過步進）。

Adafactor¶

文件

教學課程

資源