HN 日本語サマリー

← 一覧へ戻る
AI・機械学習

PyTorchトレーニングループの解説

The annotated PyTorch training loop (idlemachines.co.uk)

65 pointsby smaddrellmander13 コメント

要約

PyTorchのトレーニングループを構築することは簡単に見えますが、要素の配置や順序を間違えると、収束の失敗、誤った結果、メモリ過剰消費など、見つけにくいバグにつながることがあります。この記事では、トレーニングループの完全な構造と、`model.to(device)`や`optimiser.zero_grad()`などの行を誤って配置した場合の一般的な失敗例とその影響について詳しく解説しています。また、データパイプライン(DatasetとDataLoader)や再現性のためのシード設定といったベストプラクティスについても触れており、堅牢なPyTorchコードを書くための実践的なヒントを提供します。

全文翻訳

注釈付きPyTorchトレーニングループ

[画像: 3クラスのらせんデータセット。陰影領域はモデルのソフトマックス信頼度を示しています。トレーニングが進むにつれて境界線がシャープになります。]

A three-class spiral dataset. Shaded regions show the model's softmax confidence. The boundary sharpens as training progresses.

PyTorchのトレーニングループを構築するのは比較的簡単ですが、すべてを正しい場所、正しい順序で配置することは、驚くほど脆く感じられることがあります。多くの動く部品があり、最も基本的なエラーが修正された後でも、他のほとんどの間違いを見つけるのは非常に困難な場合があります。トレーニングが収束しない、間違った結果を生成する、あるいは行が誤って配置されていると過剰なメモリを消費する可能性があります。

以下のセクションでは、各操作を順に説明し、各セクションを正確に記述する方法と、注意すべき一般的な間違いをすべて解説します。分散トレーニング、FSDP、マルチGPUセットアップはここでは範囲外ですが、将来のエッセイで取り上げます。(上記の画像は、合成データでループを実行し、各エポックでの決定境界をキャプチャして生成されました。)

完全なループ

まず、完全なトレーニングループを見てみましょう。まだ理解したり暗記したりする必要はありません。構造を感じ取ってください。

1import torch
2import torch.nn as nn
3from torch.utils.data import DataLoader, TensorDataset
4
5# --- data ---
6dataset = TensorDataset(X_train, y_train)
7loader  = DataLoader(dataset, batch_size=64, shuffle=True)
8
9# --- model, loss, optimiser ---
10model     = MLP(in_features=2, hidden=128, out_features=3)
11criterion = nn.CrossEntropyLoss()
12optimiser = torch.optim.Adam(model.parameters(), lr=1e-3)
13scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimiser, T_max=100)
14
15# --- loop ---
16for epoch in range(100):
17    model.train()
18    for X_batch, y_batch in loader:
19        optimiser.zero_grad()
20        logits = model(X_batch)
21        loss   = criterion(logits, y_batch)
22        loss.backward()
23        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
24        optimiser.step()
25    scheduler.step()
26
27    model.eval()
28    with torch.no_grad():
29        val_logits = model(X_val)
30        val_loss   = criterion(val_logits, y_val)

それでは、各行を見て、それが何をするのか、そしてそれを壊さない方法を理解しましょう。一般的な間違いから始めます。

TL;DR 順序が本当に重要な場所

最も一般的な失敗のいくつか、そして配置を少し間違えることでトレーニングループを壊す方法を以下に示します。これらを暗記する理由は、これらのどれも例外を発生させないからです。時間をかけて、トレーニング実行でどのような種類のエラーを探すべきか感覚を掴むでしょうが、最初の数回はこのチートシートが役立つでしょう。

行間違った位置何が壊れるか
model.to(device)optimiser = ... の後データ型変換(例: model.half())と組み合わせると、nn.Module.to() は新しい nn.Parameter オブジェクトを割り当てます。オプティマイザは破棄された元のオブジェクトへの参照を保持し、それらに更新を適用します。
optimiser.zero_grad()loss.backward() の後複数のバッチからの勾配が累積します。更新は、現在のバッチのみではなく、それらの合計を使用します。
clip_grad_norm_()loss.backward() の前.grad は空です。呼び出しは no-op です。
clip_grad_norm_()optimiser.step() の後すでに適用された勾配をクリップします。効果はありません。
scheduler.step()バッチループ内LR はエポックごとに1回ではなく len(loader) 回減衰します。
model.train() を model.eval() の後に省略—ドロップアウトが無効になり、BatchNorm が凍結されます。モデルはエラーなしで eval モードでトレーニングされます。
検証中に torch.no_grad() を省略—各検証バッチでオートグラッドグラフが構築されます。メモリは OOM になるまで増加します。
loss を loss.item() の代わりにログに記録—ログ呼び出しの期間、計算グラフをメモリに保持します。

それでは、これらのそれぞれを詳細に見ていきましょう。

データ

PyTorchのデータパイプラインには2つの部分があります: DatasetとDataLoaderです。Datasetは単に__len__(データセット内の要素数)と__getitem__(予想通り、アイテムを取得する)を実装するPythonオブジェクトです。テンソルをラップする単純なものや、オンデマンドでディスクからデータをロードするものもあります。

DataLoaderはデータセットをラップし、バッチを生成します。

データセット全体を1回通過することを1エポックと呼びます。shuffle=Trueの場合、各エポックで例が異なる順序で提示されます。

1dataset = TensorDataset(X_train, y_train)
2loader  = DataLoader(
3    dataset,
4    batch_size=64,
5    shuffle=True,
6    num_workers=2,
7    pin_memory=True,
8    persistent_workers=True,
9)

practice

PyTorch DataLoader

EasyQ342

バッチ処理、シャッフル、反復処理を行うPyTorch DataLoaderを接続します。

TensorDatasetは入力テンソルとラベルテンソルをインデックスでペアにします。dataset[i]でインデックスを付けると(X[i], y[i])が返されます。DataLoaderは__getitem__を繰り返し呼び出し、結果をバッチにまとめ、オプションでバックグラウンドワーカープロセスに作業を渡します。

num_workers は、GPU計算と並行してバッチをプリフェッチする別のプロセスを起動します。メインプロセスは、バッチがまだ準備できていない場合にのみ.next()でブロックされます。ワーカーがゼロの場合は、メインプロセスがすべてのロードを行い、これはデータ負荷の高いタスクでGPU利用率をボトルネックにすることがよくあります。2〜4人のワーカーは実用的ですが、適切な数はCPU数とI/O速度に依存します。

pin_memory=True は、ピン留めされたホストメモリにバッチテンソルを割り当てます。GPU DMAエンジンは、カーネルバッファを介してコピーする前に、ピン留めされたメモリから直接転送できるため、ホストからデバイスへの転送時間を短縮します。これはnum_workers > 0でCUDAに転送している場合にのみ役立ちます。

persistent_workers=True は、エポック間でワーカープロセスをアクティブに保ちます。これがない場合、ワーカーは各エポックの開始時に再起動され、フォークオーバーヘッドが追加され、多数のワーカーで測定可能になります。

drop_last=True は、最後のバッチがbatch_sizeより小さい場合に破棄します。BatchNormの統計情報は2〜3サンプルのバッチから計算されるためノイズが多く、残りを破棄することでこれを回避します。データを破棄するという小さなコストですが、安定性のためにしばしば価値があります。

より小さいバッチはよりノイズの多い勾配推定値を生成し、これは暗黙的な正則化として機能します。より大きいバッチはより多くのGPUメモリを使用しますが、より多くの並列処理を可能にします。最も重要な効率の1つは、2のべき乗がテンソルコアタイルサイズ(通常は16×16または8×16、データ型による)と整列することを知っていることです。したがって、バッチサイズとレイヤーの次元を8または16の倍数に設定することは良い考えです。

.to(device) はテンソルをターゲットデバイスに移動します。テンソルの場合、これはインプレースではありません。新しいテンソルを返し、元のテンソルは変更しません。たとえば、X_batch.to('cuda')はGPU上の新しいテンソルを返します。X_batch自体はCPU上に残ります。

再現性

モデルとローダーを構築する前にシードを設定すると、実行ごとに同じ結果が得られます。これは実験を再現し、モデルの動作が決定論的であることを確認するために不可欠です。これがモデルに影響を与える主な領域は、データローダーとモデルの重みの初期化です。

1import random
2import numpy as np
3
4def set_seed(seed: int = 42):
5    torch.manual_seed(seed)
6    torch.cuda.manual_seed_all(seed)
7    np.random.seed(seed)
8    random.seed(seed)
9    torch.backends.cudnn.deterministic = True
10    torch.backends.cudnn.benchmark     = False
11
12set_seed(42)

torch.manual_seedはCPUジェネレータにシードを設定します。torch.cuda.manual_seed_allはすべてのGPUにシードを設定します。NumPyとPythonのrandomはPyTorchが触れない独立したRNGです。これには注意してください。それらのために別の乱数シードが必要になる場合があります。

cudnn.deterministic = Trueは、cuDNNに決定論的な畳み込みアルゴリズムを使用することを強制します。一部のcuDNNカーネルは、スループットのためにデフォルトで非決定的です。決定論的な代替手段はわずかに遅いですが、開発中は実質的にそれほど問題にならないはずです。

cudnn.benchmark = Falseはdeterministic = Trueとペアにする必要があります。benchmark = Trueの場合、cuDNNは入力形状ごとにいくつかのアルゴリズムをプロファイリングし、最も速いものを選択します。このプロセス自体は実行ごとに異なります。これをFalseに固定することで、常に同じ結果が得られるようになります。

num_workers > 0の場合、各DataLoaderワーカーは独自のRNG状態を持ち、プロセスのフォーク時にOSによってシードされます。ワーカーのランダム性を再現可能にするには、generatorとworker_init_fnを渡す必要があります。

1g = torch.Generator()
2g.manual_seed(42)
3
4loader = DataLoader(
5    dataset,
6    batch_size=64,
7    shuffle=True,
8    num_workers=2,
9    generator=g,
10    worker_init_fn=lambda worker_id: np.random.seed(42 + worker_id),
11)

モデル

nn.Moduleは、パラメータ追跡、デバイス移動、トレーニング/評価モード切り替え、シリアライゼーションを提供します。各インスタンスには、__init__(すべてのサブモジュールを登録するため)とforward(計算を定義するため)が必要です。

practice

ReLU活性化 + バックワード

EasyQ114

NumPyでReLU活性化とそのバックワードパスを実装し、nn.ReLUが実際に行っていることを見てみましょう。

practice

カスタム線形モジュール

EasyQ328

カスタムnn.Linearをnn.Moduleとして実装し、重みとバイアスをパラメータとして登録します。

1class MLP(nn.Module):
2    def __init__(self, in_features, hidden, out_features):
3        super().__init__()
4        self.net = nn.Sequential(
5            nn.Linear(in_features, hidden),
6            nn.ReLU(),
7            nn.Linear(hidden, hidden),
8            nn.ReLU(),
9            nn.Linear(hidden, out_features),
10        )
11
12    def forward(self, x):
13        return self.net(x)
14
15device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
16model  = MLP(in_features=2, hidden=128, out_features=3).to(device)

super().__init__()が必要です。これはモジュールレジストリを初期化します。__init__でサブモジュールまたはパラメータテンソルを属性として割り当てると、それらは自動的に登録されます。登録されていない通常の属性は、パラメータの反復処理、シリアライゼーション、およびデバイス移動から除外されます。

.to(device) は、登録されているすべてのパラメータとバッファをターゲットデバイスにインプレースで移動します。オプティマイザを構築する前に呼び出してください。デバイスのみの移動の場合、nn.Module.to()は各パラメータの.data属性をインプレースで変更し、オプティマイザの参照は正しく保たれます。データ型変換(例: .half().to(device))が組み合わされると、nn.Module.to()は新しいnn.Parameterオブジェクトを割り当て、モジュールの内部レジストリでそれらを置き換えます。これより前に構築されたオプティマイザは、元のオブジェクトへの参照を保持し、変換されたパラメータではなくそれらに更新を適用します。

◎ thinkオプティマイザを構築する前にモデルをデバイスに移動する必要があるのはなぜですか?

register_buffer は、モジュールに従って(.to(device)で移動し、state_dictに表示される)が、トレーニング可能なパラメータではないテンソル用です。BatchNormのrunning_meanとrunning_varはバッファであり、トランスフォーマーの注意マスクも同様です。

model.parameters() は、requires_grad=Trueを持つすべてのリーフテンソルを返します。model.named_parameters() は、名前付きで同じものを返します。これは、重み減衰からバイアスを除外したり、モデルの異なる部分に異なる学習率を割り当てたりする場合に便利です。

model(x)を呼び出すと、forwardではなく__call__が呼び出されます。これは新しいユーザーにとって古典的な誤解です。そのラッパーは、フォワードフック、計算、バックワードフックを実行します。フックをインストルメンテーションまたは勾配変更に使用する場合、この区別は重要です。

torch.compile(model) (PyTorch 2.0以降で利用可能)は、フォワードパスをトレースし、バックエンドを介して最適化されたTriton/CUDAカーネルを生成します。要素ごとの隣接する操作を融合し、メモリトラフィックを削減します。最初のフォワードパスは遅いですが(コンパイル実行が必要)、後続のパスはGPUで10〜30%高速になり、推論負荷の高いワークロードではさらに高速になることがあります。

note

PyTorch Parameter nn.Parameterクラスで気にする2つのことは、.dataに格納されている値と.grad属性です。バックワードパスは勾配を.gradに加算的に累積します。オプティマイザは.gradを読み取って更新を計算し、結果を.dataに書き戻します。

requires_grad=Falseを設定することで、勾配なしでパラメータを使用することもできます。これは、レイヤーを凍結する場合、推論専用モデル、またはトレーニング不可能なパラメータに便利です。

トレーニングモード

1

すべてのサブモジュールをトレーニングモードに設定します。2つの一般的なレイヤーが動作を変更します: Dropoutはランダムなマスキングを適用し、再スケーリングを行い、BatchNormは現在のバッチからの統計情報を保存された実行推定値よりも優先して計算します。

1model.train()                          # [1]
2for X_batch, y_batch in loader:
3    ...

model.train()はモジュールおよびすべてのサブモジュールにフラグを設定します。2つの一般的なレイヤーがフォワードパス中にそれを読み取ります。

Dropout は、各要素をゼロにする確率pを持つベルヌーイマスクをサンプリングし、生存した活性化を期待値の大きさで1/(1−p)1/(1-p)でスケーリングします。評価モードでは、これは恒等関数として機能します。トレーニング時にドロップアウトを反転させる理由は、推論時に再スケーリングする必要がないためです。

BatchNorm は、トレーニング中に現在のバッチの平均と分散を計算し、それらに対して正規化し、指数移動平均を介して保存されたrunning_meanとrunning_varを更新します。評価モードでは、バッチ統計情報ではなく、保存された推定値を使用します。

LayerNorm、GELU、ReLU、およびほとんどの他のレイヤーはトレーニングフラグの影響を受けず、両方のモードで同じように動作します。フラグは通常、アーキテクチャにDropoutまたは任意のBatchNormバリアントが含まれている場合にのみ重要です。

検証後にmodel.train()を省略しても例外は発生しません。モデルはドロップアウトが無効になり、BatchNormが凍結された統計情報を使用するため、どちらも効果的な学習ダイナミクスを変更します。

note

評価モードでは、メモリ削減の大部分はtorch.no_grad()から来ます。これはグラフ構築を完全に無効にします。出力テンソルにはgrad_fnがアタッチされず、バックワードのために中間活性化は保存されません。検証中にこれらを組み合わせると、トレーニングモードのフォワードパスと比較してメモリ使用量が約半分になります。

勾配バッファのクリア

2

次のフォワードパスの前に、すべてのパラメータの.gradをリセットします。PyTorchは勾配を加算的に累積します。この呼び出しがないと、前のバッチからの勾配が現在のバッチに加算されます。

1for X_batch, y_batch in loader:
2    optimiser.zero_grad()              # [2]
3    ...

optimiser.zero_grad()は、次のフォワードパスの前に、すべてのパラメータの.grad属性をリセットします。PyTorchは勾配を加算的に累積します。各.backward()呼び出しは.gradに追加され、置き換えられません。この動作は勾配累積を可能にします。複数のマイクロバッチにわたる勾配を合計してからステップを実行することは、比例して大きいバッチでのトレーニングと同等です。

1# gradient accumulation — effective batch size = batch_size × ACCUM_STEPS
2ACCUM_STEPS = 4
3for i, (X_batch, y_batch) in enumerate(loader):
4    logits = model(X_batch)
5    loss   = criterion(logits, y_batch) / ACCUM_STEPS   # scale to match mean reduction
6    loss.backward()                                       # adds to .grad each time
7    if (i + 1) % ACCUM_STEPS == 0:
8        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
9        optimiser.step()
10        optimiser.zero_grad()

複数の小さなバッチにわたって勾配を累積し、一度ステップを実行することは、損失が平均で削減されていると仮定すると、4倍大きいバッチでのトレーニングと同等です。フルバッチがGPUメモリに収まらない大規模な場合、累積は標準的なアプローチです。

◎ thinkPyTorchは、バックワード呼び出しごとに置き換えるのではなく、なぜ勾配を累積するのですか?

zero_grad(set_to_none=True) は、ゼロで埋める代わりに.gradをNoneに設定します。これはわずかに高速(ゼロ埋めパスをスキップ)で、メモリ使用量が少なくなります(Noneテンソルは解放されます)。これはPyTorch 2.0以降のデフォルトです。カスタムバックワードパスで.gradを直接読み取る場合は注意してください。

フォワードパス

3

forward()を実行し、オートグラッド計算グラフを構築します。requires_grad=Trueを持つテンソルに対するすべての操作が記録されます。入力は何だったか、出力は何だったか、バックワードのためにローカルベクトルヤコビアン積をどのように計算するかです。

1logits = model(X_batch)                # [3]

フォワードパス中、PyTorchはrequires_grad=Trueを持つテンソルに対するすべての操作を記録する計算グラフを構築します。グラフ内の各ノードは操作を表し、入力テンソル、出力テンソル、およびバックワードパス中に勾配を計算するために必要な関数を格納します。これにより、PyTorchはスカラー損失に対するすべてのパラメータの勾配を自動的に計算できます。

特にこれは動的なグラフであり、フォワードパス中にオンザフライで構築されます。これは、グラフがフォワードパスごとに変更できることを意味し、条件分岐やループ、可変入力サイズを持つモデルアーキテクチャをより柔軟にできます。

これは損失からリーフパラメータまでの有向非巡回グラフ(DAG)です。フォワードパス中、すべてのレイヤーからの活性化は、バックワードパスで使用するためにメモリ内に保持されます。サイズNNのバッチとLLレイヤーのネットワークの場合、単純なケースではメモリコストはO(NL)O(NL)でスケーリングします。

勾配チェックポインティング(torch.utils.checkpoint.checkpoint)はこれを削減します。すべての中間活性化を保存する代わりに、オンデマンドで再計算するためにバックワード中にチェックポイントされたセグメントのフォワードパスを再実行します。ピーク活性化メモリは、チェックポイントされたセグメントの数にスケーリングされ、合計深度ではなく、チェックポイントされたセグメントごとに約1回の追加フォワードパスのコストがかかります。

1from torch.utils.checkpoint import checkpoint
2
3def forward(self, x):
4    x = checkpoint(self.block1, x, use_reentrant=False)
5    x = checkpoint(self.block2, x, use_reentrant=False)
6    return self.head(x)

torch.no_grad()内では、グラフは構築されず、活性化は保存されません。メモリ使用量は、トレーニングモードのフォワードパスと比較して約半分になります。

損失

4

スカラー損失を計算します。CrossEntropyLossの場合、これはログソフトマックスに続いて負の対数尤度であり、バッチ全体で平均化されます。結果はgrad_fnを持つスカラーテンソルであり、まだグラフに接続されています。

1loss = criterion(logits, y_batch)      # [4]

practice

Softmax

EasyQ6

CrossEntropyLossが内部で適用するソフトマックスを実装します。

practice

クロスエントロピー損失

MediumQ18

NumPyでスクラッチからクロスエントロピー損失を実装し、ログ・サム・エクスペ(log-sum-exp)トリックを見てみましょう。

クロスエントロピー損失は、多クラス分類問題の標準的な選択です。これは、モデルのロジットからの予測確率分布と、真の分布(one-hotエンコードされたラベル)との差を測定します。

nn.CrossEntropyLossは2つの操作の組み合わせです: LogSoftmaxとNLLLoss。組み合わせた形式は、ソフトマックス確率を具体化してからその対数を取ることを避けるため、個別に計算するよりも数値的に安定しています。

基になる計算は、オーバーフローを防ぐためにログ・サム・エクスペ(log-sum-exp)トリックを使用します。

log⁡∑jezj=zmax⁡+log⁡∑jezj−zmax⁡\log \sum_j e^{z_j} = z_{\max} + \log \sum_j e^{z_j - z_{\max}}

zmax⁡z_{\max}を指数化する前に減算すると、値が安全な範囲に保たれます。単一の例に対する損失は次のようになります。

Li
=−zyi+log⁡∑jezj\mathcal{L}_i = -z_{y_i} + \log \sum_j e^{z_j}

そして、バッチ損失はNN個の例の平均です。

◎ thinkクロスエントロピーは、ソフトマックスを直接計算するのではなく、なぜログ・サム・エクスペ(log-sum-exp)トリックを必要とするのですか?

一般的な引数:

weightは、各サンプルからの損失寄与に適用される、クラスごとの重みを持つ1Dテンソルを受け入れます。クラスの不均衡、つまりまれなクラスの重みを増やすために使用します。

label_smoothing=0.1は、ターゲットに集中させるのではなく、確率質量の一部をすべてのクラスに均一に分散させます。効果的なターゲット分布は、(1−ϵ)⋅one-hot+ϵ/C(1-\epsilon)\cdot\text{one-hot} + \epsilon / Cになります。過度に確信度の高い疑似確率を防ぎ、最新の画像および言語モデルトレーニングの標準です。

ignore_index=-100は、そのラベルを持つ位置を損失からマスクします。シーケンスモデリングでパディングやマスクされたトークンを除外するために使用されます。

reduction='mean'はバッチサイズで割ります。'sum'は割りません。これらを切り替えると、効果的な損失スケール、したがって効果的な学習率がシフトします。

loss.item()で損失をログに記録すると、Pythonの浮動小数点数が抽出され、グラフからデタッチされます。テンソルを直接ログに記録すると、ログ呼び出しの期間、グラフがメモリに保持されます。注意しないと、トレーニング中にメモリが際限なく増加する可能性があります。

バックワードパス

5

計算グラフをスカラー損失からすべてのリーフパラメータまで逆方向にたどります。連鎖律を介して、各パラメータの.gradをポピュレートします。重みは変更しません。

1loss.backward()                        # [5]

backward()は、逆モード自動微分(バックプロパゲーション)を実装します。スカラー出力の場合、1回のバックワードパスですべてのNNパラメータに対する勾配が計算されます。フォワードモード微分は、パラメータごとに1回、NN回の別々のパスが必要です。最新のネットワークで典型的なパラメータ数では、逆モードが唯一の実用的なオプションです。

バックワードパスは、損失から逆トポロジカル順序で計算グラフをウォークします。各ノードで、バックワード関数(その操作のベクトルヤコビアン積)を適用し、結果を入力に伝播します。リーフパラメータでは、結果が.gradに累積します。

前述のように、.grad属性は加算的に累積します。.backward()が勾配をゼロにする前に呼び出された場合、新しい勾配は.gradに既にあったものに追加されます。勾配累積はこの動作に依存しており、リセットするためにzero_grad()を使用します。

◎ thinkloss.backward()は何を計算し、何を行わないのですか?

retain_graph=True は、バックワード後にグラフが解放されないようにします。通常、グラフは一度だけ使用されると想定されるため、すぐに解放されます。同じグラフに対して複数回バックワードを呼び出す場合(たとえば、ディスクリミネータとジェネレータの両方の損失に対して共有エンコーダをバックプロパゲートするGANの場合)は、retain_graph=Trueが必要です。

create_graph=True は、バックワードパス自体を通じた微分を可能にします。バックワード計算は微分可能になり、高階導関数(ヘッセ行列ベクトル積、MAMLスタイルのメタ勾配、または2次オプティマイザ)を有効にします。

勾配クリッピング

6

すべてのパラメータ勾配のグローバルL2ノルムを計算します。それがmax_normを超えた場合、すべての勾配を比例して再スケーリングします。backward()の後、step()の前に呼び出されます。

1torch.nn.utils.clip_grad_norm_(
2    model.parameters(), max_norm=1.0
3)

clip_grad_norm_は、すべてのパラメータにわたるグローバルノルムを計算します。

∥g∥2
=∑i∥gi∥2|g|_2 = \sqrt{\sum_i |g_i|^2}

∥g∥2

max
_norm|g|_2 > \text{max_norm} の場合、すべての勾配テンソルはmax
_norm/∥g∥2\text{max_norm} / |g|_2 で乗算されます。相対的な方向は保持されます。大きさのみが制限されます。

◎ thinkグローバルノルムクリッピングはなぜ勾配方向を保持するのですか?要素ごとのクリッピングはそうしないのですか?

トランスフォーマーのトレーニングでは、勾配スパイクが一般的です。アテンションソフトマックスは飽和し、ほぼワンホットの分布を生成する可能性があり、連鎖律を介して前のパラメータに大きな勾配ノルムを伝播させます。

グローバルノルムクリッピングは標準的なプラクティスです。max_norm=1.0は、元のGPT-2論文、その後のほとんどの言語モデルの作業、および多くのビジョントランスフォーマー論文で使用されています。よく条件付けされたデータ上の小さなMLPでは、それほど必要とされないことはまれです。

practice

勾配クリッピング

MediumQ338

グローバルノルムによる勾配クリッピングを実装します。ノルムを計算し、閾値を超えた場合にスケーリングします。

clip_grad_value_は、グローバルノルムではなく、個々の勾配成分を[−clip
_value,clip
_value][-\text{clip_value}, \text{clip_value}]にクリップします。勾配方向を保持せず、あまり一般的に使用されません。

クリッピングをbackward()の前に行うと効果がありません(.gradは空です)。step()の後に行うと、すでに重みに適用された勾配をクリップします。

重み更新

7

すべてのパラメータの.gradを読み取り、更新ルールを適用します。モーメント推定値が更新されます。重みはここで、そしてここでしか変更されません。

1optimiser.step()                       # [7]

パラメータ値はstep()で変更され、それ以外では変更されません。モーメンタム付きのプレーンSGDの場合:

vt
=μvt−1+gtv_t = \mu v_{t-1} + g_t

θt
=θt−1−ηvt\theta_t = \theta_{t-1} - \eta v_t

Adamは、1次モーメント(勾配平均)と2次モーメント(勾配分散)のパラメータごとの推定値を維持します。

mt
=β1mt−1+(1−β1)gtm_t = \beta_1 m_{t-1} + (1-\beta_1) g_t

vt
=β2vt−1+(1−β2)gt2v_t = \beta_2 v_{t-1} + (1-\beta_2) g_t^2

両方の推定値は初期化時にゼロに偏っています(ゼロから始まり、初期のmtm_tとvtv_tの値は真のモーメントを過小評価します)。バイアス補正はこれを考慮します。

m^t
=mt(1−β1t)\hat{m}_t = \frac{m_t}{(1-\beta_1^t)}

v^t
=vt(1−β2t)\hat{v}_t = \frac{v_t}{(1-\beta_2^t)}

重み更新は次のようになります。

θt
=θt−1−η m^tv^t+ϵ\theta_t = \theta_{t-1} - \frac{\eta, \hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}

practice

Adamオプティマイザステップ

MediumQ118

NumPyでAdamオプティマイザステップを実装します。バイアス補正とパラメータごとの適応レート。

practice

Adamステップ(PyTorch)

MediumQ335

PyTorchを使用してAdamステップを実装します。内部はtorch.optim.Adamです。

practice

AdamWステップ

MediumQ36

AdamWステップを実装します。デカップルされた重み減衰は、勾配ではなく重みに直接適用されます。

デフォルトのハイパーパラメータ: β1
=0.9\beta_1 = 0.9, β2
=0.999\beta_2 = 0.999, ϵ
=10−8\epsilon = 10^{-8}。パラメータごとの適応学習率により、Adamはパラメータ間の勾配スケールの変動に対してロバストになります。これは、初期レイヤーと後期レイヤーがしばしば非常に異なる大きさの勾配を持つディープネットワークで重要です。

AdamWは、重み減衰を勾配更新からデカップルします。L2正則化を持つ標準Adamは、更新の前に勾配項λθ\lambda\thetaを追加し、それが適応ステップサイズによってスケーリングされます。AdamWは、重み減衰を直接重みに適用します: θt
=(1−ηλ)θt−1−Adam
更新\theta_t = (1 - \eta\lambda)\theta_{t-1} - \text{Adam update}。これら2つは同等ではありません。AdamWはより予測可能な効果的な正則化を提供し、トランスフォーマーのトレーニングでは標準となっています。

◎ thinkL2正則化を持つAdamとAdamWの実際の違いは何ですか?

fused=True (CUDAのみ): パラメータグループごとに完全なパラメータ更新を単一のCUDAカーネルに融合し、Pythonループと複数のカーネル起動を回避します。パラメータ数が多い場合、デフォルトよりも約30〜50%高速に実行されます。

foreach=True: すべてのパラメータをベクトル化されたPythonループでまとめて処理する、バッチ処理されたtorch._foreach_*操作を使用します。速度はデフォルトと融合の中間にあり、CPUでも利用可能です。

オプティマイザは、すべてのパラメータのモーメント状態を格納します。7BパラメータモデルのAdamの場合、それはmm用の7B float32テンソルとvv用の7B float32テンソル、フル精度で約56GBのオプティマイザ状態です。その規模では、トレーニングは通常8ビットオプティマイザ(bitsandbytes)を使用するか、デバイス間で状態をシャードします(ZeRO)。

学習率スケジューラ

8

スケジュールに従って学習率を更新します。エポックごとに1回、optimiser.step()の後、バッチループの外側で呼び出されます。

1    scheduler.step()                   # [8]

スケジューラは、オプティマイザ内の各パラメータグループのlrフィールドを変更します。最も一般的な間違いは、バッチループ内で呼び出すことです。

1# wrong — lr decays len(loader) times per epoch instead of once
2for X_batch, y_batch in loader:
3    optimiser.step()
4    scheduler.step()
5
6# correct
7for X_batch, y_batch in loader:
8    optimiser.step()
9scheduler.step()

コサインアニーリングは、T_maxエポックにわたって学習率をeta_maxからeta_minに減衰させます。

ηt
=ηmin⁡+12(ηmax⁡−ηmin⁡)(1+cos⁡tπTmax⁡)\eta_t = \eta_{\min} + \frac{1}{2}(\eta_{\max} - \eta_{\min})\left(1 + \cos\frac{t\pi}{T_{\max}}\right)

practice

LRスケジューラ

EasyQ339

線形ウォームアップ付きのコサインアニーリングで学習率スケジューラを接続します。

最新の大規模モデルトレーニングでは、標準的なスケジューラは線形ウォームアップとコサイン減衰を組み合わせます。ウォームアップフェーズ(通常は全ステップの1〜5%)は、パラメータがトレーニング済み値から離れている間の更新の大きさを制限します。コサイン減衰は、残りのステップのレートを低下させます。

1# linear warmup + cosine decay
2# (using HuggingFace's implementation as reference)
3from transformers import get_cosine_schedule_with_warmup
4
5scheduler = get_cosine_schedule_with_warmup(
6    optimiser,
7    num_warmup_steps=100,
8    num_training_steps=10_000,
9)
10scheduler.step()   # called per step, not per epoch, with this scheduler

ReduceLROnPlateauは、引数なしのルール例外です。メトリック値を受け取り、メトリックがpatienceエポック改善しなくなった場合にのみ学習率を低下させます。検証損失で呼び出す必要があります: scheduler.step(val_loss)。

検証

9

model.eval()はレイヤーの動作を変更します。torch.no_grad()はグラフ構築を停止します。これらは独立した操作です。検証には両方が必要です。

1model.eval()                           # [9]
2with torch.no_grad():                  # [10]
3    val_logits = model(X_val)
4    val_loss   = criterion(val_logits, y_val)

model.eval()とtorch.no_grad()は独立した操作です。

model.eval()は、すべてのモジュールでself.training = Falseを設定します。BatchNormは、バッチ統計情報の計算から保存されたrunning_meanとrunning_varの使用に切り替わります。Dropoutは、ベルヌーイマスクのサンプリングから恒等関数に切り替わります。他の標準レイヤーは影響を受けません。

torch.no_grad()は、オートグラッドグラフの構築を完全に無効にします。コンテキスト内で生成されたテンソルにはgrad_fnがアタッチされず、中間活性化は保存されません。これにより、メモリ使用量がトレーニングモードのフォワードパスと比較して約半分になり、計算がわずかに高速になります(各操作あたりのブックキーピング操作が少ない)。

これら2つは独立した選択です。

  • 評価モード、グラフ有効: 入力勾配(サリエンスマップ、敵対的例)の計算に有効。
  • トレーニングモード、no_grad: 勾配を必要としないフォワードパスチェック用。
  • 両方同時: 標準的な検証パス。

◎ thinkmodel.eval()はtorch.no_grad()と同じですか?

torch.inference_mode() は、no_grad()のより厳密な形式です。コンテキスト内で作成されたテンソルはis_inference() == Trueを持ち、コンテキストマネージャをエスケープしてもバックワードパスに参加できなくなります。オートグラッドエンジンの追加チェックをいくつか削除し、no_grad()よりも約10%高速に実行されます。

ログ記録

lossではなくloss.item()を使用して、トレーニングおよび検証メトリックを追跡します。.item()を呼び出すと、Pythonの浮動小数点数が抽出され、グラフからデタッチされます。テンソルへの参照を保持すると、次の呼び出しまで完全なバックワードグラフがアクティブになります。

1for epoch in range(NUM_EPOCHS):
2    model.train()
3    running_loss = 0.0
4    for X_batch, y_batch in loader:
5        optimiser.zero_grad()
6        loss = criterion(model(X_batch), y_batch)
7        loss.backward()
8        optimiser.step()
9        running_loss += loss.item()
10    train_loss = running_loss / len(loader)
11
12    model.eval()
13    with torch.no_grad():
14        val_logits = model(X_val)
15        val_loss   = criterion(val_logits, y_val).item()
16        val_acc    = (val_logits.argmax(1) == y_val).float().mean().item()
17
18    print(f'epoch {epoch:3d}  train {train_loss:.4f}  val {val_loss:.4f}  acc {val_acc:.3f}')

チェックポインティング

torch.saveはチェックポイントファイルを書き込み、torch.loadはそれを読み込みます。チェックポイントにより、トレーニング実行はクラッシュやプリエンプションを乗り越えることができます。

1# save
2torch.save({
3    'epoch':                epoch,
4    'model_state_dict':     model.state_dict(),
5    'optimiser_state_dict': optimiser.state_dict(),
6    'scheduler_state_dict': scheduler.state_dict(),
7    'val_loss':             val_loss,
8}, 'checkpoint.pt')
9
10# resume
11checkpoint = torch.load('checkpoint.pt', map_location=device)
12model.load_state_dict(checkpoint['model_state_dict'])
13optimiser.load_state_dict(checkpoint['optimiser_state_dict'])
14scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
15start_epoch = checkpoint['epoch'] + 1

state_dict()は、パラメータとバッファテンソルの順序付き辞書を返します。クラス定義は含まれていないため、load_state_dictを呼び出す前にモデルクラスがスコープ内で定義されている必要があります。

オプティマイザの状態は、モデルと並行して保存してトレーニングを正しく再開する必要があります。Adamの場合、状態にはパラメータごとのモーメント推定値mtm_tとvtv_tが含まれます。これらはゼロからウォームアップするのに数百ステップかかります。これらなしで再開することは、オプティマイザをコールドスタートすることと同等であり、通常は再開ポイントで損失スパイクを生成します。

map_location=deviceは、チェックポイントがロードするGPUとは異なるGPUで保存された一般的なケースを処理します。

標準的なパターンは、検証損失が改善した場合にのみ保存するため、保存された重みは最終エポックではなく、最もよく汎化するエポックに対応します。

1best_val_loss = float('inf')
2
3for epoch in range(NUM_EPOCHS):
4    # ... training loop ...
5
6    model.eval()
7    with torch.no_grad():
8        val_loss = criterion(model(X_val), y_val).item()
9
10    if val_loss < best_val_loss:
11        best_val_loss = val_loss
12        torch.save(model.state_dict(), 'best_model.pt')

トレーニング後に最適なモデルを復元するには: model.load_state_dict(torch.load('best_model.pt', map_location=device))。

GPU効率

トレーニングループの細かい部分を調べている間、基本的なGPU最適化手法について少し時間をかけて考える価値があります。これらのどれも正確には「ハードウェアを溶かす」というわけではありませんが、ほぼすべて完全に無料のスピードアップです。

デバイス配置

モデルとデータを同じGPUに配置すると、データ転送のオーバーヘッドが最小限に抑えられます。

1device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
2
3model = MLP(in_features=2, hidden=128, out_features=3).to(device)
4# construct optimiser AFTER moving model — it captures parameter references
5optimiser = torch.optim.Adam(model.parameters(), lr=1e-3)
6
7# per-batch: move data to device
8for X_batch, y_batch in loader:
9    X_batch = X_batch.to(device, non_blocking=True)
10    y_batch = y_batch.to(device, non_blocking=True)

non_blocking=Trueは、ホストからデバイスへの転送を非同期に開始し、すぐに返します。GPUは、新しいバッチが転送されている間に、前のバッチからの作業を開始できます。オーバーラップは、DataLoaderでpin_memory=Trueの場合にのみ役立ちます。ピン留めされていないメモリは非同期に転送できません。

混合精度

最新のGPUには、同じハードウェアでfloat32よりも4〜8倍高速にfloat16(およびbfloat16)行列乗算を実行する専用のテンソルコアがあります。混合精度トレーニングでは、重みをfloat32で保持しますが、フォワードパスとバックワードパスはfloat16で実行します。

これにより計算が効率的になりますが、float16はfloat32よりもダイナミックレンジがはるかに小さいため、小さな勾配値がゼロにアンダーフローし、不正確な更新を生成します。妥協案は、累積丸め誤差がfloat32ダイナミックレンジ内に収まるfloat32で重みを維持することです。

1scaler = torch.amp.GradScaler('cuda')
2
3for X_batch, y_batch in loader:
4    optimiser.zero_grad()
5
6    with torch.amp.autocast('cuda', dtype=torch.float16):
7        logits = model(X_batch)
8        loss   = criterion(logits, y_batch)
9
10    scaler.scale(loss).backward()           # backward in float16
11    scaler.unscale_(optimiser)              # unscale before clipping
12    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
13    scaler.step(optimiser)                  # step only if no inf/nan
14    scaler.update()                         # adjust scale factor

torch.amp.autocastとtorch.amp.GradScalerは現在のAPI(PyTorch 2.0+)です。古いfrom torch.cuda.amp import autocast, GradScalerはまだ機能しますが、非推奨です。

GradScalerの理由: float16はfloat32よりもダイナミックレンジがはるかに小さいです。小さな勾配値はゼロにアンダーフローし、不正確な更新を生成します。GradScalerは、バックワードの前に損失に大きなスケールファクター(通常は2162^{16})を乗算し、勾配の大きさをfloat16範囲内に保ちます。オプティマイザステップの前に、勾配は実際のスケールに戻されます。オーバーフローが検出された場合(任意の勾配にinfまたはnan)、ステップはスキップされ、スケールファクターが減少します。

bfloat16 (dtype=torch.bfloat16)は、float32と同じ指数範囲を持ちますが、マントッサビットが少ないため、アンダーフローせず、GradScalerを必要としません。最新のハードウェア(A100、H100、TPU)では推奨されるデータ型です。

◎ thinkbfloat16はなぜGradScalerを必要としないのですか?float16は必要ですか?

1with torch.amp.autocast('cuda', dtype=torch.bfloat16):
2    logits = model(X_batch)
3    loss   = criterion(logits, y_batch)
4
5loss.backward()                # no scaler needed
6optimiser.step()
DataLoaderパイプライン

GPUトレーニングの場合、ボトルネックはGPUではなく、それを供給するデータパイプラインであることがよくあります。num_workers=4, pin_memory=True, persistent_workers=True, prefetch_factor=2を持つDataLoaderは、GPUを停止させずに供給し続けます。prefetch_factor=2(デフォルト)は、各ワーカーが消費されたバッチよりも2つ先のバッチをプリフェッチすることを意味します。

torch.backends.cudnn.benchmark = Trueは、最初のバッチで短いプロファイリングパスを実行し、特定の入力形状に最適な畳み込みアルゴリズムを決定します。後続のバッチはそのキャッシュされた選択を使用します。入力形状がバッチ間で異なる場合は、このオプションを使用しないでください。新しい形状ごとにプロファイリングオーバーヘッドが再度発生します。

コンパイル
1model = torch.compile(model)

PyTorch 2.0以降で利用可能なcompileは、フォワードパスをトレースし、Inductorバックエンドを介して最適化されたTritonカーネルを生成します。主な利点は、操作の融合です。隣接する要素ごとの操作(例: 活性化+ドロップアウト+残差加算)は単一のカーネルにマージされ、メモリの読み書きが削減されます。GPUトレーニングでの典型的な速度向上は10〜30%で、推論ワークロードや多数の小さな操作を持つアーキテクチャではさらに高くなります。

mode='max-autotune'は、追加のプロファイリングを実行して、各操作に最適なカーネルを選択します。コンパイルには時間がかかりますが、生成されたモデルは高速になり、コストは長いトレーニング実行で償却されます。

最初のフォワードパスはコンパイルをトリガーし、遅いです。torch._dynamo.reset()は、再コンパイルする必要がある場合(例: モデル構造を変更した後)にキャッシュをクリアします。

効率的なループ
1device = torch.device('cuda')
2model  = torch.compile(MLP(...).to(device))
3
4torch.backends.cudnn.benchmark = True
5
6for epoch in range(NUM_EPOCHS):
7    model.train()
8    for X_batch, y_batch in loader:
9        X_batch = X_batch.to(device, non_blocking=True)
10        y_batch = y_batch.to(device, non_blocking=True)
11
12        optimiser.zero_grad(set_to_none=True)
13
14        with torch.amp.autocast('cuda', dtype=torch.bfloat16):
15            logits = model(X_batch)
16            loss   = criterion(logits, y_batch)
17
18        loss.backward()                                        # no scaler: bf16 doesn't underflow
19        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
20        optimiser.step()
21
22    scheduler.step()
23
24    model.eval()
25    with torch.inference_mode():
26        val_logits = model(X_val.to(device))
27        val_loss   = criterion(val_logits, y_val.to(device))

practice

分類器のトレーニング

HardQ343

すべてをまとめて、合成データセットで分類器をトレーニングし、目標精度を達成します。

完全な注釈付きスクリプト

同じループ、すべての行を参照しています。

1

生の入力テンソル、形状 (N, features)。らせんデータセットの場合、N=2000、features=2。

2

整数クラスインデックス、形状 (N,)。ワンホットではありません: CrossEntropyLossはインデックスを直接期待します。

3

TensorDatasetは入力とラベルをインデックスでペアにします。__getitem__は(X[i], y[i])を返します。

4

DataLoaderは、バッチ処理、各エポックでのシャッフル、およびnum_workersを介したオプションの並列プリフェッチを処理します。

5

nn.Moduleサブクラス。__init__でサブモジュールを登録し、forwardで計算を定義します。

6

.to(device)は、すべてのパラメータとバッファを移動します。オプティマイザを構築する前にこれを行います。

7

CrossEntropyLoss = LogSoftmax + NLLLoss。生のロジットを渡します。ソフトマックス出力ではありません。

8

Adamはパラメータごとのモーメント推定値を維持します。model.parameters()は最適化するテンソルを提供します。

9

コサインアニーリングスケジューラ。scheduler.step()はオプティマイザのパラメータグループのlrを調整します。

10

model.train(): ドロップアウトマスクがアクティブ、バッチノーマライゼーションはバッチ統計情報を使用します。

11

zero_grad(): .gradをクリアします。PyTorchはデフォルトで累積します。これがないと、勾配はバッチ間で累積します。

12

フォワードパス: オートグラッドグラフを構築します。すべての操作は、入力とそのバックワード関数を記録します。

13

損失: スカラーテンソル、まだグラフ内にあります。grad_fnはバックワードのエントリポイントです。

14

backward(): 逆モードAD。すべてのリーフパラメータの.gradをポピュレートします。重みは変更されません。

15

勾配クリッピング: グローバルノルム再スケーリング。スパイクがトレーニングを不安定にするのを防ぎます。

16

optimiser.step(): .gradを読み取り、Adam更新を適用し、モーメント推定値を更新します。重みが変更されます。

17

scheduler.step(): lrを調整します。エポックごとに1回、optimiser.step()の後、バッチループの外側で。

18

model.eval(): ドロップアウトはパススルー、バッチノーマライゼーションは実行統計情報を使用します。

19

torch.no_grad()(またはinference_mode()): グラフ構築なし。高速、低メモリ。

1import torch
2import torch.nn as nn
3from torch.utils.data import DataLoader, TensorDataset
4
5# ── data ──────────────────────────────────────────────────────────────────────
6X_train = torch.randn(2000, 2)                                     # [1]
7y_train = make_labels(X_train)                                     # [2]
8
9dataset = TensorDataset(X_train, y_train)                          # [3]
10loader  = DataLoader(dataset, batch_size=64, shuffle=True,         # [4]
11                     num_workers=2, pin_memory=True)
12
13# ── model ──────────────────────────────────────────────────────────────────────
14class MLP(nn.Module):                                              # [5]
15    def __init__(self, in_features, hidden, out_features):
16        super().__init__()
17        self.net = nn.Sequential(
18            nn.Linear(in_features, hidden), nn.ReLU(),
19            nn.Linear(hidden, hidden),      nn.ReLU(),
20            nn.Linear(hidden, out_features),
21        )
22    def forward(self, x):
23        return self.net(x)
24
25model = MLP(in_features=2, hidden=128, out_features=3).to(device)  # [6]
26
27# ── loss, optimiser, scheduler ────────────────────────────────────────────────
28criterion = nn.CrossEntropyLoss()                                  # [7]
29optimiser = torch.optim.Adam(model.parameters(), lr=1e-3)          # [8]
30scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(            # [9]
31    optimiser, T_max=100
32)
33
34# ── training loop ─────────────────────────────────────────────────────────────
35for epoch in range(100):
36
37    model.train()                                                   # [10]
38
39    for X_batch, y_batch in loader:
40
41        optimiser.zero_grad()                                       # [11]
42
43        logits = model(X_batch)                                     # [12]
44
45        loss = criterion(logits, y_batch)                           # [13]
46
47        loss.backward()                                             # [14]
48
49        torch.nn.utils.clip_grad_norm_(
50            model.parameters(), max_norm=1.0
51        )
52
53        optimiser.step()                                            # [16]
54
55    scheduler.step()                                                # [17]
56
57    # ── validation ────────────────────────────────────────────────────────────
58    model.eval()                                                    # [18]
59    with torch.no_grad():                                           # [19]
60        val_logits = model(X_val)
61        val_loss   = criterion(val_logits, y_val)
62        val_acc    = (val_logits.argmax(1) == y_val).float().mean()