はじめに
インストールとテンソル
コアデータ構造であるのが、PyTorch のテンソルです。テンソルを GPU へ動かすには、to(device) を使いましょう。正規分布からの乱数を返すのが、torch.randn です。あなたの CUDA バージョンに合う wheel URL を選び、開発には CPU 専用ビルドが小さくて良いです。
# install PyTorch (CUDA 11.8)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
import torch
# create a tensor
x = torch.tensor([[1, 2], [3, 4]])
y = torch.zeros(3, 3)
z = torch.randn(2, 3) # standard normal
# tensor on GPU
device = "cuda" if torch.cuda.is_available() else "cpu"
x = x.to(device)テンソルの属性
shape、dtype、device の属性を持つのが、すべてのテンソルです。よくある dtype:float32(デフォルト)、float16、int64、bool です。要素の合計数を返すのが、numel() です。メモリを半減させ GPU の計算を速くするため、混合精度には float16 を選びましょう。
x = torch.randn(3, 4, 5)
print(x.shape) # torch.Size([3, 4, 5])
print(x.dtype) # torch.float32
print(x.device) # cpu or cuda:0
print(x.requires_grad) # False
# specify dtype at creation
x = torch.zeros(3, dtype=torch.int64)
x = torch.tensor([1.0, 2.0], dtype=torch.float16)
# check number of elements
print(x.numel()) # 3テンソルの作成
定数テンソルを作るのが、torch.zeros/ones/full です。range テンソルを作るのが、arange と linspace です。一様なのが rand で、正規が randn です。上限を除外するのが、randint です。再現性のため、ランダム操作の前に torch.manual_seed(42) を使いましょう。
# from Python lists
a = torch.tensor([1, 2, 3])
# special tensors
zeros = torch.zeros(2, 3)
ones = torch.ones(2, 3)
eye = torch.eye(3) # identity matrix
full = torch.full((2, 3), 7.0)
# ranges
arange = torch.arange(0, 10, 2) # [0, 2, 4, 6, 8]
linspace = torch.linspace(0, 1, 5) # [0, 0.25, 0.5, 0.75, 1.0]
# random
rand = torch.rand(2, 3) # uniform [0, 1)
randn = torch.randn(2, 3) # normal N(0, 1)
randint = torch.randint(0, 10, (3, 3))型の変換
テンソルの型を変えるのが、to(dtype) です。ショートカット:.float()、.long()、.int()、.bool() です。テンソルとメモリを共有するのが(CPU 上ではゼロコピー)、numpy() です。0 次元テンソルから単一の Python スカラーを取り出すのが、item() です。numpy() の前に、GPU テンソルは CPU へ動かされなければなりません。
x = torch.tensor([1.5, 2.5, 3.5])
# change dtype
y = x.to(torch.int32) # tensor([1, 2, 3])
y = x.int() # shortcut
y = x.float()
y = x.bool()
y = x.long() # int64
# to numpy and back
arr = x.numpy() # shares memory (CPU)
t = torch.from_numpy(arr)
# 0-d tensor to Python scalar
val = x[0].item() # 1.5インデックスとスライス
NumPy を映し返すのが、PyTorch のインデックスです。0 次元テンソルを返すのが、整数インデックスです(Python スカラーには .item() を)。結果を平坦化するのが、真偽マスクです。最初の次元に沿って選択するのが、LongTensor によるインデックスです。コピーを作るのが、応用インデックスで、ビューを作るのが、基本のスライスです。
x = torch.arange(12).reshape(3, 4)
# tensor([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11]])
x[0] # first row
x[1, 2] # element at (1, 2) -> 6
x[:, 1] # second column
x[0:2] # first two rows
x[:, ::2] # every other column
# boolean mask
mask = x > 5
x[mask] # tensor([6, 7, 8, 9, 10, 11])
# index with LongTensor
idx = torch.tensor([0, 2])
x[idx] # rows 0 and 2リシェイプとビュー
連続メモリを要求するのが、view で、(必要ならコピーし)常に機能するのが、reshape です。サイズ 1 の次元の追加・除去が、unsqueeze/squeeze です。すべての次元を並べ替えるのが、permute で、2 つを交 換するのが、transpose です。平坦化するのが、reshape(-1) です。permute のような操作が、テンソルを非連続にし、view() の前に .contiguous() を必要とさせ得ます。
x = torch.arange(12)
# reshape (returns view when possible)
y = x.reshape(3, 4)
y = x.view(3, 4) # only for contiguous tensors
# add/remove dimensions
y = x.unsqueeze(0) # shape (1, 12)
y = x.squeeze() # remove size-1 dims
# transpose / permute
a = torch.randn(3, 4, 5)
b = a.permute(2, 0, 1) # shape (5, 3, 4)
b = a.transpose(0, 1) # swap dims 0 and 1
# flatten
flat = a.flatten() # shape (60,)
flat = a.reshape(-1) # equivalentテンソルの操作
算術の操作
要素ごとであるのが、算術演算子(+、-、*、/)です。_ で終わるのが、インプレースの操作です。メモリを節約しますが autograd の履歴を無効化するため、grad を必要とするテンソル上では避けましょう。NumPy のルールに従うのが、broadcasting です:末尾の次元が一致するか、1 へ引き伸ばされます。
a = torch.tensor([1.0, 2.0, 3.0])
b = torch.tensor([4.0, 5.0, 6.0])
# element-wise ops
a + b # tensor([5., 7., 9.])
a * b # tensor([ 4., 10., 18.])
a / b # element-wise division
a ** 2 # tensor([1., 4., 9.])
# in-place (suffix _)
a.add_(1) # a = a + 1, modifies in place
a.mul_(2) # a = a * 2
# scalar ops
a + 10
b * 0.5要素ごとの数学
torch.* と tensor.* のメソッドを映し返すのが、要素ごとの数学です。クリッピングの PyTorch 名が、clamp です。数値的に安全な log のために、ハードコードされた 1e-8 の代わりに、torch.finfo(x.dtype).eps を使いましょう。モデルのために、nn モジュールとしても利用可能なのが(nn.ReLU())、活性化関数です。
x = torch.tensor([-1.0, 0.0, 1.0, 2.0])
torch.abs(x) # absolute value
torch.sqrt(torch.abs(x))
torch.exp(x) # e^x
torch.log(x.abs() + 1e-8)
torch.sin(x)
torch.clamp(x, -0.5, 1.5) # clip values
# activation functions
torch.sigmoid(x) # 1 / (1 + e^-x)
torch.tanh(x)
torch.relu(x) # max(0, x)
# rounding
y = torch.tensor([1.4, 1.5, 2.6])
torch.round(y) # tensor([1., 2., 3.])
torch.floor(y)
torch.ceil(y)削減の操作
1 つ以上の次元を 折りたたむのが、削減です。軸を選ぶには dim を渡し、削減された軸をサイズ 1 で保つのが(broadcasting には決定的に重要)、keepdim=True です。名前付きタプル(values、indices)を返すのが、dim 付きの max/min です。0 次元テンソルを Python スカラーへ引き出すのが、item() です。
x = torch.arange(12).reshape(3, 4).float()
x.sum() # 66.0 (scalar tensor)
x.sum(dim=0) # sum over rows -> shape (4,)
x.sum(dim=1) # sum over columns -> shape (3,)
x.mean(dim=1)
x.max() # returns value tensor
x.max(dim=1) # returns (values, indices)
x.argmin(dim=1) # indices of min along dim
# keep dimensions
x.sum(dim=1, keepdim=True) # shape (3, 1)
# norm
x.norm() # Frobenius norm
x.norm(dim=1) # per-row norm比較の操作
bool テンソルを返すのが、比較演算子です。正確な等価性を確認し Python の bool を返すのが、torch.equal です。ベクトル化された三項が、torch.where(cond, x, y) です — マスキングや選択に完璧です。値とインデックスの両方を返すのが、topk で、top-1 / top-5 の精度に有用です。
a = torch.tensor([1, 2, 3, 4])
b = torch.tensor([3, 2, 1, 4])
a == b # tensor([False, True, False, True])
a > b # tensor([False, False, True, False])
a != b
torch.equal(a, b) # False (single bool)
# where: pick from two tensors
torch.where(a > b, a, b) # element-wise max
# boolean helpers
(a > 2).any() # True
(a > 2).all() # False
(a == b).sum() # 2 (count of True)
# top-k
torch.topk(a, 2) # returns top 2 values + indices行列の操作
行列の乗算を行い、バッチ次元上で broadcast するのが、@ と torch.matmul です。厳密な 3D のバッチ化された matmul(broadcasting なし)には、torch.bmm を。マルチテンソルの縮約に表現力豊かなのが、einsum ですが、一部のハードウェアでは matmul より遅くなり得ます。torch.solve / linalg.solve で解けるなら、行列の逆行列を避けましょう。
a = torch.randn(2, 3)
b = torch.randn(3, 4)
# matrix multiplication
c = a @ b # shape (2, 4)
c = torch.matmul(a, b) # equivalent
# batched matmul
A = torch.randn(10, 2, 3)
B = torch.randn(10, 3, 4)
C = A @ B # shape (10, 2, 4)
# element-wise product
e = a * a # shape (2, 3)
# other ops
torch.inverse(a[:, :3]) # inverse of square slice
torch.det(a[:, :3])
torch.svd(a) # singular value decomposition
torch.einsum('bi,i->b', torch.randn(5,3), torch.randn(3)) # batched dot連 結とスタッキング
既存の軸に沿ってテンソルを結合するのが、cat で、新しい軸を加えるのが、stack です。チャンクサイズで分割するのが、split で、断片の数で分割するのが、chunk です。broadcast されたデータを持つビューを作るのが(メモリコピーなし)、expand です。可能な限り、repeat の代わりにこれを使いましょう。データを物理的に複製するのが、repeat です。
a = torch.randn(2, 3)
b = torch.randn(2, 3)
# concat along existing dim
c = torch.cat([a, b], dim=0) # shape (4, 3)
c = torch.cat([a, b], dim=1) # shape (2, 6)
# stack along new dim
s = torch.stack([a, b], dim=0) # shape (2, 2, 3)
# split / chunk
x = torch.arange(6).reshape(2, 3)
parts = torch.split(x, 2, dim=0) # split into chunks of size 2
chunks = torch.chunk(x, 3, dim=1) # split into 3 chunks
# repeat / expand
r = a.repeat(2, 3) # repeat whole tensor
e = a.unsqueeze(0).expand(4, 2, 3) # broadcast without copyAutograd
基本の Autograd
autograd のために操作を追跡させるには、requires_grad=True を設定しましょう。スカラーテンソル上の .backward() 呼び出しが、requires_grad=True を持つすべてのリーフテンソルに対する、そのテンソルの勾配を計算します。.grad へ蓄積されるのが、勾配です。反復の間に、optimizer.zero_grad() か x.grad=None を呼びましょう。
import torch
# tensors that require gradient tracking
x = torch.tensor([2.0], requires_grad=True)
y = torch.tensor([3.0], requires_grad=True)
# build a computation graph
z = x * y + x ** 2 # z = xy + x^2
print(z.grad_fn) # <AddBackward0 object>
# backprop
z.backward()
# dz/dx = y + 2x = 3 + 4 = 7
print(x.grad) # tensor([7.])
# dz/dy = x = 2
print(y.grad) # tensor([2.])勾配の計算
スカラー出力上でしか機能しないのが、backward() です。テンソルのためには、まず sum か mean しましょう。.grad に保存せず、タプルとして勾配を返すのが、torch.autograd.grad です。ライブラリの内側や、非リーフテンソルの勾配が必要なときに、こちらが推奨です。
import torch
x = torch.linspace(-3, 3, steps=10, requires_grad=True)
y = torch.sin(x)
# sum needed for backward on non-scalar
y.sum().backward()
print(x.grad) # cos(x)
# gradient w.r.t. intermediate tensor
a = torch.tensor(1.0, requires_grad=True)
b = a * 2
c = b ** 2
grads = torch.autograd.grad(c, a)
print(grads) # (tensor(8.),) dc/da = 4b * 2 = 8勾配追跡の無効化
推論のための torch.no_grad() で、グラフの構築がスキップされます — メモリと時間が節約されます。データを共有するがグラフから切断されるテンソルを返すのが、.detach() です。ロギングや、非 PyTorch のコードへのテンソル供給に最適です。レイヤー(dropout、BN)を推論モードへ切り替えるのが、model.eval() ですが、autograd を無効化し「ません」 — torch.no_grad() と組み合わせましょう。
x = torch.tensor([1.0], requires_grad=True)
# option 1: context manager (preferred)
with torch.no_grad():
y = x * 2 # y.requires_grad == False
# option 2: decorator
@torch.no_grad()
def inference(x):
return model(x)
# option 3: detach from graph
y = (x * 2).detach() # y is a new tensor, no grad
# enable grad inside no_grad
with torch.no_grad():
with torch.enable_grad():
z = x * 3 # z requires grad高次の勾配
勾配自体のグラフを保つのが、create_graph=True です。そのため、再度微分できます。勾配のペナルティ(WGAN-GP)、メタ学習、物理情報付きの損失に有用です。余分なメモリを消費するため、終わったら retain_graph=False で中間のグラフを解放しましょう。
x = torch.tensor(0.5, requires_grad=True)
# first derivative
y = torch.sin(x)
y.backward(create_graph=True)
print(x.grad) # cos(0.5)
# second derivative (gradient of gradient)
x.grad.zero_()
g = torch.autograd.grad(torch.sin(x), x, create_graph=True)[0]
g2 = torch.autograd.grad(g, x)[0]
print(g2) # -sin(0.5)
# practical use: penalize gradient (e.g. gradient penalty)
loss = g.norm()勾配のフック
テンソル上の register_hook により、backward 中に勾配を検査・修正できます。NaN のデバッグや、特定のテンソル上の勾配クリッピングの実装に手軽です。入力と出力の両方の勾配を見るのが、モジュール上の register_full_backward_hook です。変化を伝播させたいなら、修正された勾配を必ず返しましょう。
x = torch.tensor([1.0, 2.0], requires_grad=True)
y = (x ** 2).sum()
# full backward hook on a tensor
def print_grad(grad):
print("grad:", grad)
return grad * 2 # can modify gradient
y.register_hook(print_grad)
y.backward()
print(x.grad) # 2x but doubled by hook
# module hook
def hook_fn(module, grad_input, grad_output):
print(module.__class__.__name__, grad_output)
model.layer.register_full_backward_hook(hook_fn)計算グラフの詳細
ユーザーが作る(requires_grad=True、grad_fn なし)のが、リーフテンソルです。非リーフであるのが、中間の結果です。デフォルトで、backward() 後にグラフが解放されるため、backward を複数回呼ぶには、retain_graph=True を渡しましょう。高次の微分のための、勾配のグラフを保持するのが、create_graph=True です。メモリが急速に成長するため、反復の間に x.grad=None で消去しましょう。
x = torch.tensor(2.0, requires_grad=True)
w = torch.tensor(3.0, requires_grad=True)
b = torch.tensor(1.0, requires_grad=True)
y = w * x + b
print(y.is_leaf) # False
print(x.is_leaf) # True
# retain graph for multiple backward passes
loss = (y - 5) ** 2
loss.backward(retain_graph=True)
# can call backward again
loss.backward()
# double backward
loss.backward(create_graph=True)
print(x.grad)データのローディング
Dataset と DataLoader
Dataset をバッチ化し、シャッフルし、並列ロードするのが、DataLoader です。サブプロセスを使うのが、num_workers>0 で、GPU ごとに 2〜8 を設定しましょう。CPU→GPU の転送を速くするのが、pin_memory=True です。RAM に収まる小さい dataset には、オーバーヘッドを避けるため num_workers=0 を設定しましょう。
from torch.utils.data import Dataset, DataLoader
# built-in datasets
from torchvision import datasets
mnist = datasets.MNIST("./data", train=True, download=True)
# wrap in DataLoader
loader = DataLoader(
mnist,
batch_size=64,
shuffle=True,
num_workers=4,
pin_memory=True,
)
for x, y in loader:
print(x.shape, y.shape) # (64, 1, 28, 28), (64,)
breakバッチのサンプリング
どのインデックスが各バッチを形成するか正確に制御するには、batch_sampler を渡しましょう。まれなクラスのオーバ ーサンプリングにより、不均衡なクラスを再バランスさせるのが、WeightedRandomSampler です。最後の短いバッチを落とすのが、drop_last=True で — BatchNorm の安定には重要です。インデックス上で反復するのが、サンプラーで、本物のデータを取得するのが、DataLoader です。
from torch.utils.data import DataLoader, BatchSampler, RandomSampler
dataset = list(range(100))
sampler = RandomSampler(dataset)
batch_sampler = BatchSampler(sampler, batch_size=10, drop_last=True)
loader = DataLoader(dataset, batch_sampler=batch_sampler)
# custom sampler
class EvenSampler:
def __init__(self, data): self.data = data
def __iter__(self): return iter(range(0, len(self.data), 2))
def __len__(self): return len(self.data) // 2
# weighted sampling for imbalanced classes
from torch.utils.data import WeightedRandomSampler
weights = [0.1] * 50 + [1.0] * 50
sampler = WeightedRandomSampler(weights, num_samples=100)シャッフルとサンプリング
各エポックで順序をランダム化するのが(学習に良い)、shuffle=True です。再現可能な指標のためには、検証は shuffle=False のままにしましょう。便利だが RNG が直接シード設定できないのが、random_split です。フルの制御のためには、torch.randperm と Generator を使った Subset を使いましょう。薄いインデックスのビューにすぎず、データのコピーはないのが、Subset です。
from torch.utils.data import DataLoader, random_split
# train/val split
train, val = random_split(dataset, [80, 20])
train_loader = DataLoader(train, batch_size=16, shuffle=True)
val_loader = DataLoader(val, batch_size=32, shuffle=False)
# reproducible split
from torch.utils.data import Subset
import numpy as np
gen = torch.Generator().manual_seed(42)
idx = torch.randperm(len(dataset), generator=gen).tolist()
train_idx, val_idx = idx[:80], idx[80:]
train, val = Subset(dataset, train_idx), Subset(dataset, val_idx)カスタム Collate
サンプルのリストをバッチへ変えるのが、collate_fn です。新しい dim 0 に沿ってテンソルをスタックするのが、デフォルトです。可変長のシーケンス(pack_padded_sequence のためにパディングし長さでソートする)、dict ベースのサンプル、またはテンソル/非テンソルの混合データのために、上書きしましょう。関数は安価に保つこと — データローディングの worker 上で動くためです。
from torch.utils.data import default_collate
# variable-length sequences: pad in collate
def pad_collate(batch):
# batch is list of (tensor, label)
seqs, labels = zip(*batch)
lens = torch.tensor([len(s) for s in seqs])
max_len = lens.max()
padded = torch.zeros(len(seqs), max_len)
for i, s in enumerate(seqs):
padded[i, :len(s)] = s
return padded, lens, torch.tensor(labels)
loader = DataLoader(dataset, batch_size=4, collate_fn=pad_collate)
# stack batch as dict
def dict_collate(batch):
return default_collate(batch)並列ローディング
データのローディングを並列化し、GPU が決して待たないのが、num_workers です。エポックごとの worker 起動のコストを避けるのが、persistent_workers=True です。各 worker がどれだけ先にバッチを準備するかの制御が、prefetch_factor(デフォルト 2)です。Windows と Jupyter では、マルチプロセッシングが不調和になり得るため、デバッグには num_workers=0 へフォールバックしましょう。注意:完全なプロセスの状態を各 worker が継承します。開いたファイルハンドルと CUDA のコンテキストを含めて。
loader = DataLoader(
dataset,
batch_size=128,
num_workers=8, # one process per worker
pin_memory=True, # page-locked memory for fast H2D copy
persistent_workers=True, # keep workers alive across epochs
prefetch_factor=4, # batches prefetched per worker
)
# avoid CPU bottleneck
import os
os.cpu_count() # check available cores
# in Jupyter / Windows: set start method
import torch.multiprocessing as mp
# mp.set_start_method('spawn') # uncomment if needednn.Module
モジュールの定義
nn.Module を継承し forward() を実装しましょう。属性としてサブモジュールとパラメータを宣言すれば、自動的に登録されます(.to(device)、.parameters()、state_dict を可能にするものです)。必ず super().__init__() を呼 びましょう。forward での任意の Python ロジックは避け、微分可能でテンソルだけに保ちましょう。
import torch.nn as nn
class MLP(nn.Module):
def __init__(self, in_dim, hidden, out_dim):
super().__init__()
self.fc1 = nn.Linear(in_dim, hidden)
self.fc2 = nn.Linear(hidden, hidden)
self.fc3 = nn.Linear(hidden, out_dim)
self.act = nn.ReLU()
def forward(self, x):
x = self.act(self.fc1(x))
x = self.act(self.fc2(x))
return self.fc3(x) # logits
model = MLP(784, 128, 10)
print(model) # prints structureLinear と活性化のレイヤー
y = xW^T + b を適用するのが、nn.Linear です。(out, in) であるのが、weight の形状です。登録(state_dict、hooks)させたいときには、活性化モジュールを推奨し、1 回限りの操作には、関数型の F.* を使いましょう。transformer アーキテクチャを支配するのが、GELU と SwiGLU 風の活性化です。通常、モデルから Softmax を省略し、CrossEntropyLoss に処理させるべきです。
import torch.nn as nn
linear = nn.Linear(in_features=20, out_features=10, bias=True)
print(linear.weight.shape) # (10, 20)
print(linear.bias.shape) # (10,)
# common activations
nn.ReLU() # max(0, x)
nn.LeakyReLU(0.01)
nn.GELU() # smooth, used in transformers
nn.Sigmoid() # (0, 1)
nn.Tanh() # (-1, 1)
nn.Softmax(dim=1)
nn.ELU()
# functional API (no parameters)
import torch.nn.functional as F
out = F.relu(linear(x)) # same as nn.ReLU()(linear(x))パラメータとサブモジュール
ツリー全体のための (name, tensor) を出すのが、named_parameters() です — 凍結、weight decay、デバッグに最適です。子へ再帰するのが、.modules() で、1 レベルだけなのが、.children() です。state_dict には現れるが parameters() には現れないのが、buffer です(BatchNorm の running 統計など)。それを見るには、named_buffers() を。
model = MLP(784, 128, 10)
# iterate parameters
for name, p in model.named_parameters():
print(name, p.shape, p.requires_grad)
# only trainable params
trainable = filter(lambda p: p.requires_grad, model.parameters())
# count parameters
n_params = sum(p.numel() for p in model.parameters())
print(f"{n_params:,} parameters")
# access submodules by name
model.fc1 # the Linear layer
model['fc1'] # equivalent if using nn.ModuleDict
# children vs modules
list(model.children()) # direct children
list(model.modules()) # recursively all sub-modulesSequential モデル
各出力が次の入力を供給する、モジュールのチェーンが、nn.Sequential です — 線形のパイプラインに完璧です。属性(model.fc1)によりインデックスできるよう、ステージに名前を付けるには、OrderedDict を使いましょう。分岐、skip 接続、複数の入出力を持つモデルのためには、nn.Module を継承し forward() を明示的に書きましょう。
import torch.nn as nn
# simple stack
model = nn.Sequential(
nn.Linear(784, 256),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(256, 10),
)
# named layers via OrderedDict
from collections import OrderedDict
model = nn.Sequential(OrderedDict([
('fc1', nn.Linear(784, 256)),
('relu', nn.ReLU()),
('dropout', nn.Dropout(0.5)),
('fc2', nn.Linear(256, 10)),
]))
print(model.fc1) # access by name
# append at runtime
model.append(nn.Softmax(dim=1))モジュールのメソッド
パラメータと buffer を動かすのが、to(device) で、dtype をキャストするのが、.double()/.half()/.float() です。self.training フラグをトグルするのが、train()/eval() です。それ上で分岐するのが、Dropout と BatchNorm です。すべてのパラメータと buffer の OrderedDict を返すのが、state_dict() で、復元するのが、load_state_dict です。すべてのサブモジュールへ再帰するのが、.apply(fn) で、カスタム初期化に有用です。
model = MLP(784, 128, 10)
# move to device / dtype
model = model.to('cuda')
model = model.to(torch.float16)
# train vs eval mode
model.train() # enable dropout, update BN stats
model.eval() # disable dropout, freeze BN stats
# state dict
sd = model.state_dict()
model.load_state_dict(sd)
# apply a function to all submodules
model.apply(lambda m: print(type(m).__name__))
# set requires_grad on all parameters
for p in model.parameters():
p.requires_grad_(False)初期化
ほとんどのケースで機能する、Linear/Conv のためのデフォルトが、PyTorch による Kaiming He init です。torch.nn.init の関数で上書きしましょう(接尾辞 _ がインプレースを意味します)。ReLU ファミリーに適したのが、Kaiming で、tanh/sigmoid に適したのが、Xavier/Glorot です。ゼロへのバイアスの初期化が標準です。すべてのサブモジュール上で fn を実行するのが、.apply(fn) で — 一括初期化や重みのリセットに完璧です。
import torch.nn as nn
import torch.nn.init as init
class Net(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(100, 50)
self.fc2 = nn.Linear(50, 10)
self._init_weights()
def _init_weights(self):
init.kaiming_normal_(self.fc1.weight, nonlinearity='relu')
init.zeros_(self.fc1.bias)
init.xavier_uniform_(self.fc2.weight)
init.zeros_(self.fc2.bias)
# apply to existing model
def init_all(m):
if isinstance(m, nn.Linear):
init.kaiming_normal_(m.weight)
if m.bias is not None:
init.zeros_(m.bias)
model.apply(init_all)損失関数
CrossEntropyLoss
内部的に log-softmax + NLLLoss を適用するのが、CrossEntropyLoss です — softmax 出力でなく、生の logits を渡しましょう。整数のクラスインデックスであるのが(one-hot ではない)、ターゲットです。不均衡なクラスには weight を使い、パディングトークンのマスクには、ignore_index=-100 を。分類と NLP の人気のある正則化器が、label_smoothing=0.1 です。
import torch
import torch.nn as nn
# logits shape (N, C), targets shape (N,) with class indices
logits = torch.randn(4, 3) # 4 samples, 3 classes
targets = torch.tensor([0, 2, 1, 0])
criterion = nn.CrossEntropyLoss()
loss = criterion(logits, targets)
# equivalently, combine LogSoftmax + NLLLoss
log_softmax = nn.LogSoftmax(dim=1)
nll = nn.NLLLoss()
loss2 = nll(log_softmax(logits), targets)
# weight classes (handle imbalance)
weights = torch.tensor([1.0, 2.0, 1.0])
criterion = nn.CrossEntropyLoss(weight=weights)
# ignore padding index (NLP)
criterion = nn.CrossEntropyLoss(ignore_index=-100)MSELoss と L1Loss
大きな誤差を二乗で罰するのが(はずれ値に敏感)、MSELoss で、線形でより頑健なのが、L1 です。ゼロ近くでは L2 のように、遠くでは L1 のように振る舞うのが、SmoothL1Loss です — オブジェクト検出で使われます(Fast R-CNN)。要素ご とのテンソルを返すのが、reduction='none' で、.mean() を呼ぶ前に、自分でマスクや重み付けできます。
import torch.nn as nn
pred = torch.randn(4, 1)
target = torch.randn(4, 1)
# mean squared error (L2)
mse = nn.MSELoss()
loss = mse(pred, target) # mean over all elements
# L1 (mean absolute error)
l1 = nn.L1Loss()
loss = l1(pred, target)
# smooth L1 (Huber) — robust to outliers
smooth = nn.SmoothL1Loss(beta=0.1)
# reduction options
mse_sum = nn.MSELoss(reduction='sum')
mse_none = nn.MSELoss(reduction='none') # per-elementBCELoss と BCEWithLogitsLoss
BCELoss+sigmoid より、BCEWithLogitsLoss を必ず推奨しましょう — 数値的安定のために log-sum-exp のトリックを使うからです。クラスの不均衡を対抗するため、陽性項を掛けるのが、pos_weight です(focal loss lite のような)。マルチラベル分類(各クラスが独立)のためには、形状 (N, C) と sigmoid 出力付きの BCEWithLogitsLoss を使いましょう。
import torch.nn as nn
# binary classification, multi-label, or sigmoid outputs
logits = torch.randn(4, 1)
target = torch.tensor([[1.0], [0.0], [1.0], [0.0]])
# preferred: combines sigmoid + BCE, numerically stable
criterion = nn.BCEWithLogitsLoss()
loss = criterion(logits, target)
# BCELoss expects probabilities (apply sigmoid first)
criterion = nn.BCELoss()
probs = torch.sigmoid(logits)
loss = criterion(probs, target)
# positive weight for imbalanced binary tasks
pos_weight = torch.tensor([5.0])
criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weight)カスタム損失関数
スカラーテンソルを返す(関数か nn.Module であるのが)、カスタム損失です。残りは autograd が扱います。すべての操作を微分可能にしましょう(微分可能な分岐付きの torch.where は問題ありません)。ハイパーパラメータ、シリアライゼーション、設定への登録が必要なときには、モジュールの形式が推奨です。挙動が予測可能になるよう、reduction を(mean/sum/none)明示的に保ちましょう。
import torch
import torch.nn as nn
import torch.nn.functional as F
# as a function
def huber_loss(pred, target, delta=1.0):
error = pred - target
abs_err = error.abs()
quad = torch.where(abs_err <= delta,
0.5 * error ** 2,
delta * (abs_err - 0.5 * delta))
return quad.mean()
# as a module (so it can have parameters / state)
class FocalLoss(nn.Module):
def __init__(self, alpha=0.25, gamma=2.0):
super().__init__()
self.alpha = alpha
self.gamma = gamma
def forward(self, logits, targets):
bce = F.binary_cross_entropy_with_logits(logits, targets, reduction='none')
p = torch.sigmoid(logits)
pt = p * targets + (1 - p) * (1 - targets)
loss = self.alpha * (1 - pt) ** self.gamma * bce
return loss.mean()
criterion = FocalLoss()損失の削減と組み合わせ
サンプルごとの損失を与えるのが、reduction='none' です。そのため、マスク、重み付け、手動集約ができます。加重和により、マルチタスクの損失を組み合わせましょう — 重みがバランスさせるのは、大きさだけでなく勾配です(調整しましょう)。各サブ損失が、微分可能かつ同じ device/dtype 上に留まらなければなりません。backprop せずログしたい損失項は、.detach() で分離しましょう。
import torch.nn as nn
import torch
criterion = nn.CrossEntropyLoss(reduction='none')
loss_per = criterion(logits, targets) # shape (N,)
loss = loss_per.mean()
# class-wise mask
mask = targets != -100
loss = criterion(logits[mask], targets[mask])
# multi-task loss
loss_cls = nn.CrossEntropyLoss()(logits, labels)
loss_box = nn.L1Loss()(boxes_pred, boxes_gt)
total = 1.0 * loss_cls + 0.5 * loss_box
# gradient-weighted
total = loss_cls + 0.5 * loss_box
total.backward()NLLLoss とその他の損失
数学的に CrossEntropyLoss と同一だが、log-probs を再利用できるのが、NLLLoss + LogSoftmax です。metric-learning の埋め込みを学習するのが、TripletMarginLoss です。log-probs を入力として、probs をターゲットとして期待するのが、KLDivLoss です。未分割のシーケンスをターゲットへ整列させるのが、CTCLoss です — ランタイムエラーを避けるため、input_lengths と target_lengths を渡しましょう。
import torch.nn as nn
# NLLLoss expects log-probabilities (use LogSoftmax first)
log_probs = torch.log_softmax(logits, dim=1)
loss = nn.NLLLoss()(log_probs, targets)
# triplet loss for embeddings
anchor = torch.randn(4, 128)
positive = torch.randn(4, 128)
negative = torch.randn(4, 128)
loss = nn.TripletMarginLoss(margin=1.0)(anchor, positive, negative)
# KL divergence (distributions)
loss = nn.KLDivLoss(reduction='batchmean')(log_probs, target_dist)
# cosine embedding loss
loss = nn.CosineEmbeddingLoss()(x1, x2, torch.tensor([1, -1, 1, -1]))
# CTCLoss for sequence alignment (ASR/OCR)
loss = nn.CTCLoss(blank=0, zero_infinity=True)(log_probs, targets, in_lens, out_lens)オプティマイザー
SGD
大バッチの CNN 学習のトップの選択であり続け、一部のタスクで Adam より良く汎化するのが、SGD + momentum です。標準が momentum 0.9 で、小さな余分な利得を与えるのが、Nesterov です。L2 正則化を加えるのが、weight_decay です。慎重な LR のスケジューリングとウォームアップを必要とするのが、SGD です。Adam のように自動チューニングではありません。