🔖 キーワード索引

「pytorch」は統計データ分析の文脈で扱う重要概念のひとつ。 本ページでは「pytorch」を取り巻く中核キーワードを以下にチップで一覧化する。 各キーワードは関連する概念・手法・道具立てを含み、 文献検索や学習計画の起点になる。

これらのキーワードは「pytorch の理解 → 適用 → 検証」のプロセスを構成する。 各章で詳しく解説する。

🎨 直感で掴む

📐 定義／数式

PyTorch（PyTorch）：Meta の深層学習フレームワーク

🔬 記号・用語の読み解き

📐 の 3 つの式を、 記号ごとに PyTorch のどの部品に当たるかへ読み替える。

読み方の要点は 2 つある。 1 つは、 連鎖律の式が「経路の和」になっていること。 同じパラメータが 2 か所で使われると経路が 2 本になり、 勾配はその和になる。 PyTorch が .grad に上書きせず足し込むのは、 この和を 1 経路ずつ積み上げるためで、 そのせいで zero_grad() を忘れると前回の勾配まで足されてしまう（このページの 🧭 追補で実測している）。 もう 1 つは、 ミニバッチの勾配が全データの勾配の不偏推定だということ。 平均的には正しい向きを指すが 1 回ごとにはぶれるので、 学習曲線はぎざぎざになる。

🧮 実値で計算してみる

🧮 数式に値を入れて手で計算する: 合成関数の自動微分

合成関数 $f(x) = 3x^2 + 2x + 1$ の自動微分 $df/dx$ を $x=4$ で計算します。

Step 1: 解析解

合成関数を微分:

Step 2: 自動微分 (PyTorch)

計算グラフを構築して backward() で逆伝播:

Step 3: SSDSE-B-2026 でのミニ線形回帰 (Loss = MSE)

SSDSE-B-2026 の総人口 (x) → 出生数 (y) を線形回帰 ŷ = wx + b で予測、 MSE 損失の勾配を autograd で計算します:

Step 4: 自動微分結果との一致

🐍 Python で再現

1
2
3
4
5
6
7

import numpy as np
# numpy で手動微分
def f(x): return 3*x**2 + 2*x + 1
def df(x): return 6*x + 2
x = 4
print(f"f(x) = {f(x)}")
print(f"df/dx = {df(x)}")

📤 実行結果

💬 手計算 (Step 1) 26 と Python 出力が完全一致。

🐍 Python での実装例

SSDSE-B-2026 などの実データを使った最小コード（約 20 行）：

🎯 このコードでやること：PyTorch の nn.Linear + SGD で SSDSE-B-2026（2023 年・47 都道府県）の総人口 → 出生数の単回帰を 200 エポック学習させ、 損失が下がって重み w が最小二乗解（約 6.10）に近づいていくことを確認する。 PyTorch の自動微分・パラメータ更新の最小例。

📥 入力：data/raw/SSDSE-B-2026.csv を英語コードの列名で読み、 2023 年度の 47 行に絞った総人口 A1101（百万人に換算した x、 例: 東京都 14.086）と出生数 A4101（千人に換算した y、 例: 東京都 86.348）。 どちらも (47, 1) の torch.tensor にして渡す。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import pandas as pd, torch, torch.nn as nn
torch.manual_seed(0)

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026']==2023][['A1101','A4101']].dropna()  # 総人口・出生数

x = torch.tensor(df['A1101'].values, dtype=torch.float32).view(-1,1) / 1e6   # 総人口（百万人）
y = torch.tensor(df['A4101'].values, dtype=torch.float32).view(-1,1) / 1e3   # 出生数（千人）

model = nn.Linear(1, 1)
loss_fn = nn.MSELoss()
opt = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(200):
    y_pred = model(x)
    loss = loss_fn(y_pred, y)
    opt.zero_grad()
    loss.backward()
    opt.step()
    if (epoch+1) % 50 == 0:
        w = model.weight.item(); b = model.bias.item()
        print(f'epoch {epoch+1:3d}: loss={loss.item():.3f}, w={w:.3f}, b={b:.3f}')

📤 実行例：

💬 結果の読み方：200 epoch で loss が 3.63 → 2.68 と単調に下がり、 重み w は 6.05 付近に落ち着く。 x を百万人・y を千人単位に揃えているので、 これは「総人口が 100 万人増えるごとに出生数が約 6.0 千人増える」という関係。 PyTorch の backward() が自動微分で勾配を計算し、 opt.step() がパラメータを更新する流れが機能している。 torch.manual_seed(0) を置いてあるので、 この 4 行は手元でもそのまま再現する。

※ data/raw/SSDSE-B-2026.csv は e-Stat SSDSE から取得した実データを想定。

🐍 詳細実装例 (SSDSE-B-2026 適用版)

本ページ冒頭の Python 実装はミニマル版でした。 ここでは PyTorch を SSDSE-B-2026 の実データに適用する完全な実装例を掲載します。 コピペすればそのまま動く形になっています。 ファイルパスは data/raw/SSDSE-B-2026.csv を想定。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# === PyTorch で MLP を SSDSE-B-2026 に適用する完全例 ===
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

torch.manual_seed(0)

# データ読み込み（2023 年度の 47 都道府県に絞る）
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == 2023]
# 出生数（男）・（女）は足すと出生数そのものなので説明変数から外す（リーク防止）
leak = ['SSDSE-B-2026', 'A4101', 'A410101', 'A410102']
X = df.select_dtypes(include='number').drop(columns=leak).dropna(axis=1).values
y = df['A4101'].values.reshape(-1, 1)  # 出生数を予測（総人口・高齢者数などから）

# 前処理（目的変数も標準化し、評価は元の単位＝人に戻す）
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
sx, sy = StandardScaler().fit(X_train), StandardScaler().fit(y_train)

# Tensor 化
X_train_t = torch.tensor(sx.transform(X_train), dtype=torch.float32)
y_train_t = torch.tensor(sy.transform(y_train), dtype=torch.float32)
X_test_t = torch.tensor(sx.transform(X_test), dtype=torch.float32)
y_test_t = torch.tensor(sy.transform(y_test), dtype=torch.float32)
train_loader = DataLoader(TensorDataset(X_train_t, y_train_t), batch_size=8, shuffle=True)

# MLP モデル
class MLP(nn.Module):
    def __init__(self, in_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_dim, 64), nn.ReLU(), nn.Dropout(0.2),
            nn.Linear(64, 32), nn.ReLU(),
            nn.Linear(32, 1)
        )
    def forward(self, x):
        return self.net(x)

device = 'cuda' if torch.cuda.is_available() else 'cpu'
model = MLP(X_train.shape[1]).to(device)
optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
loss_fn = nn.MSELoss()
print(f'学習 {len(X_train)} 県 / テスト {len(X_test)} 県, 特徴量 {X.shape[1]} 列')

# 訓練ループ
for epoch in range(101):
    model.train()
    for xb, yb in train_loader:
        xb, yb = xb.to(device), yb.to(device)
        pred = model(xb)
        loss = loss_fn(pred, yb)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    if epoch % 20 == 0:
        model.eval()
        with torch.no_grad():
            p = model(X_test_t.to(device)).cpu().numpy()
        test_loss = loss_fn(torch.tensor(p), y_test_t).item()
        rmse = np.sqrt(np.mean((sy.inverse_transform(p) - y_test) ** 2))
        print(f'epoch {epoch}: train {loss.item():.4f} / test {test_loss:.4f} (RMSE {rmse:,.0f} 人)')

# 保存（保存先のフォルダが無ければ作る）
import os
os.makedirs('output', exist_ok=True)
torch.save(model.state_dict(), 'output/mlp_ssdse.pt')

💬 テストの損失は標準化した単位なので、元の人数に戻した RMSE で読む。epoch 40 で 5,548 人まで下がった後、訓練損失は 0.001 台まで落ちるのにテスト RMSE は 9,231 人に戻っており、37 県で 106 列を覚え込む過学習が起きている。テスト 10 県には出生数 86,348 人の東京都が入っていて学習データの範囲の外にあり、総人口 1 列の単回帰でもテスト RMSE は約 2,473 人なので、この規模のデータでは MLP より単純なモデルが勝つ。12 年度分 564 行を混ぜ、出生数（男）（女）を説明変数に残し、目的変数も標準化しないまま学習すると、損失が 10⁶〜10⁹ の桁になって意味を読み取れない。

⚠️ 実行前に pip install -r requirements.txt で依存パッケージをインストール。 また、 SSDSE-B-2026 の列名は版によって若干異なるので、 df.columns で確認のうえ実コードに合わせて読み替えてください。

🎮 触って理解する

PyTorch の心臓部 autograd（自動微分） を、 最小の計算グラフで体感する。 題材は単一ニューロン + 二乗損失: u = x·w + b, d = u − y, L = d²（目標値 y = 2.0 は定数）。 PyTorch で書けば w = torch.tensor(0.8, requires_grad=True) のように requires_grad=True を付けた葉テンソルだけが .grad に勾配を貯める。 スライダーで x・w・b を動かすと順伝播（forward）の各ノード値がリアルタイムに更新され、 backward() ボタンで連鎖律が計算グラフを逆流する様子をステップごとに追える。

📌 何が起きているか — 連鎖律の逆流

backward() が計算グラフを出力側から辿るとき、 各エッジで連鎖律（chain rule）を 1 回ずつ適用する。 このデモの解析的な勾配は次の通り（d = x·w + b − y）:

• ∂L/∂d = 2d　（L = d² の微分）
• ∂L/∂u = ∂L/∂d × ∂d/∂u = 2d × 1 = 2d
• ∂L/∂b = ∂L/∂u × ∂u/∂b = 2d × 1 = 2d
• ∂L/∂m = ∂L/∂u × ∂u/∂m = 2d × 1 = 2d
• ∂L/∂w = ∂L/∂m × ∂m/∂w = 2d × x = 2dx
• ∂L/∂x = 2d × w — だが x は requires_grad=False なので .grad には保存されない

例えば初期値 x=1.5, w=0.8, b=0.5 では d = −0.3 なので ∂L/∂w = 2×(−0.3)×1.5 = −0.900、 ∂L/∂b = −0.600（本ページ作成時に数値微分と照合し誤差 10⁻¹⁰ 以下で一致確認済み）。 勾配が負 → w を増やすと損失が下がる、 という向きの情報まで含むのが勾配の価値。 optimizer.step() は θ ← θ − η·∂L/∂θ を実行するだけである。 詳しい更新則は 勾配降下法・学習率、 多層への一般化は 誤差逆伝播法 を参照。

💡 直感: define-by-run とテンソルの正体

上のデモで「スライダーを動かすたびに forward が再計算される」ことに注目してほしい。 PyTorch の動的計算グラフ（define-by-run）とはまさにこれで、 グラフは事前に宣言するものではなく、 Python コードが実行された順にその場で記録される。 u = x*w + b と書いた瞬間に mul と add のノードが生え、 各中間テンソルに grad_fn（逆伝播用の局所微分の作り方）がぶら下がる。 だから if 県 == '東京都': のような分岐でグラフの形が毎回変わっても問題ない。 つまり PyTorch のテンソルとは「多次元配列（NumPy ndarray 相当）+ 勾配の置き場 (.grad) + 履歴 (grad_fn)」の三点セットである。 これに対し TensorFlow 1.x の静的グラフ（define-and-run）は先にグラフ全体を組んでから実行する方式だった（TF 2.x は eager 実行で PyTorch に接近）。

⚠️ デモで再現できる落とし穴

• grad 累積（zero_grad 忘れ）: 上のデモで backward() を2 回連続で押してみてほしい。 w.grad が −0.900 → −1.800 と倍になる。 PyTorch の .grad は「代入」ではなく「加算」されるため、 各ステップ冒頭の optimizer.zero_grad() を忘れると、 過去の勾配が混ざった方向に更新されて学習が壊れる。
• detach() と no_grad() の使い分け: y.detach() は「このテンソルから先の履歴を切る」（例: GAN で生成器の勾配を判別器に流さない、 ログ用に値だけ取り出す）。 with torch.no_grad(): は「このブロック内では最初から履歴を記録しない」（例: 評価ループ、 推論）。 前者はできたグラフを切る、 後者はそもそも作らないので、 推論では no_grad の方がメモリ・速度とも有利。
• GPU 転送の非対称性: .to('cuda') はテンソルを GPU メモリへコピーする明示操作で、 CPU テンソルと GPU テンソルの演算は即エラーになる。 さらに tensor.cpu().numpy() のように GPU → CPU 転送は同期を強制するため、 学習ループ内で頻繁に呼ぶと GPU が遊ぶ。 損失の記録は loss.item() を epoch 末にまとめるのが定石。

🚀 発展: 計算グラフ最適化と torch.compile

define-by-run は柔軟だが、 「毎回グラフを作り直す」オーバーヘッドと「演算を 1 個ずつ GPU カーネルとして発行する」非効率がある。 PyTorch 2.x の model = torch.compile(model) は、 実行トレースから計算グラフを捕捉（TorchDynamo）し、 複数の演算を 1 つの GPU カーネルに融合（kernel fusion）してコード生成（TorchInductor）する。 上のデモで言えば「mul → add → sub → square」の 4 ノードを 1 回のメモリ走査で済ませるイメージで、 典型的に 1.3〜2 倍の高速化が得られる。 動的な柔軟さで書き、 静的な最適化で走らせる — フレームワークの進化は両者のいいとこ取りに向かっている。 この構造を踏まえて ニューラルネットワーク や 深層学習 のページへ進むと、 「どんな巨大モデルも結局はこの小さなグラフの積み重ね」であることが腑に落ちるはずである。 損失関数の選び方は 損失関数 を参照。

⚠️ よくある落とし穴

🌐 関連手法・派生・バリエーション

• TensorFlow／Keras／JAX／Lightning（PyTorch ラッパ）／Hugging Face Transformers／ONNX

🌐 エコシステム: PyTorch の周辺ツール群

どんなに優れた手法でも、 周辺ツール・ライブラリ・コミュニティの厚みが実用性を決めます。 ここでは PyTorch をめぐる現代的エコシステムを俯瞰し、 自分の用途に合うツールを選べるようにします。

PyTorch エコシステムは巨大で、 主要コンポーネントは: コア (torch, torchvision, torchaudio, torchtext)、 訓練フレームワーク (PyTorch Lightning, HuggingFace Accelerate, Fabric)、 NLP (HuggingFace Transformers, spaCy, AllenNLP)、 CV (Detectron2, MMDetection, Kornia)、 グラフ (PyG (PyTorch Geometric), DGL)、 強化学習 (stable-baselines3, RLlib)、 ハイパラ最適化 (Optuna, Ray Tune)、 実験管理 (Weights & Biases, MLflow, TensorBoard, ClearML)、 デプロイ (TorchServe, ONNX Runtime, NVIDIA Triton, TorchScript)、 量子化・最適化 (bitsandbytes, torch.ao, torch.compile)、 分散訓練 (DDP, FSDP, DeepSpeed, Megatron-LM)。 学習リソースは: 公式チュートリアル (pytorch.org/tutorials)、 dive into deep learning (d2l.ai)、 fast.ai コース、 Stanford CS231n・CS224n、 Andrej Karpathy の YouTube シリーズ。 SSDSE-B-2026 のような小規模表データであれば、 PyTorch + PyTorch Lightning + Optuna の組み合わせで、 100 行程度のスクリプトで完結します。

🔧 補講 R280: PyTorch の「自動微分」が初学者を躓かせる場所

PyTorch を学び始めた人がほぼ全員ぶつかる壁は「requires_grad」「loss.backward()」「optimizer.zero_grad()」の三点セットの正しい順序である。 これらは数式上は単純な勾配降下のステップでも、 計算グラフを動的に構築する PyTorch の仕様上、 順番を誤ると勾配が累積したり、 計算グラフが分断されたりする。 本補講では SSDSE-B-2026 の都道府県人口を題材に、 1 変数の単回帰 (総人口 → 出生数) を最小限のテンソル操作で実装し、 各 API がどのタイミングで何をしているかを 1 行ずつ解説する。

▶ PyTorch 学習ループの 5 ステップ責務分担

▶ SSDSE-B-2026 都道府県人口で単回帰を PyTorch で実装

このコードでやること: 47 都道府県の総人口を入力 x、 出生数を目標 y とし、 y ≈ wx + b の単回帰を 200 エポックで学習する。 自動微分が学習ループのどこに効いてくるかを最小コードで確認する。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import pandas as pd, torch, torch.nn as nn
torch.manual_seed(0)

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026']==2023][['A1101','A4101']].dropna()  # 総人口・出生数

x = torch.tensor(df['A1101'].values, dtype=torch.float32).view(-1,1) / 1e6   # 総人口（百万人）
y = torch.tensor(df['A4101'].values, dtype=torch.float32).view(-1,1) / 1e3   # 出生数（千人）

model = nn.Linear(1, 1)
loss_fn = nn.MSELoss()
opt = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(200):
    y_pred = model(x)
    loss = loss_fn(y_pred, y)
    opt.zero_grad()
    loss.backward()
    opt.step()
    if (epoch+1) % 50 == 0:
        w = model.weight.item(); b = model.bias.item()
        print(f'epoch {epoch+1:3d}: loss={loss.item():.3f}, w={w:.3f}, b={b:.3f}')

📤 実行例:

💬 結果の読み方: 学習が進むにつれ loss が 3.63 → 2.68 と単調減少。 重み w が 6.05 付近に収束しており「総人口が 100 万人増えるごとに出生数が約 6.1 千人（約 6 千人）増える」という関係を、 PyTorch の自動微分が逆伝播経由で発見した（sklearn の解析解 w=6.10, b=-0.68, R²=0.99 とほぼ一致）。 同じ計算を numpy で書くと勾配を手計算で導出する必要がある。 PyTorch では backward() 一行で済むのが大きな価値。

▶ nn.Module サブクラス化の典型パターン

このコードでやること: 上の nn.Linear(1,1) は最小だが、 中間層が増えると nn.Module を継承する書き方が必須。 2 層 MLP で同じデータを予測し、 サブクラス化の構造を確認する。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import torch.nn as nn, torch
torch.manual_seed(0)   # 実行のたびに同じ結果が出るようにする

class TinyMLP(nn.Module):
    def __init__(self, hidden=16):
        super().__init__()
        self.fc1 = nn.Linear(1, hidden)
        self.fc2 = nn.Linear(hidden, 1)
        self.act = nn.ReLU()
    def forward(self, x):
        h = self.act(self.fc1(x))
        return self.fc2(h)

model = TinyMLP(hidden=16)
print(model)
print('total params:', sum(p.numel() for p in model.parameters()))

📤 実行例:

💬 結果の読み方: パラメータ数は 49 個 (fc1 が 1×16+16=32 個、 fc2 が 16×1+1=17 個、 合計 49)。 サブクラス化により forward 内で複雑な分岐や複数入力に対応できる。 後続の CNN/RNN/Transformer もすべてこの nn.Module パターンで実装される。 ニューラルネットワーク、 バックプロパゲーション、 勾配降下法 と組み合わせて理解する。

▶ TensorFlow / Keras との API 対応表

補講のまとめ: PyTorch は「動的計算グラフ」を採用しており、 Python の制御フロー (if/for) をそのまま使える柔軟さが TensorFlow との最大の差異。 自動微分の責務分担を 5 ステップで把握し、 機械学習ライブラリ としての 深層学習 実装の入口にする。 後続の CNN、 RNN、 転移学習 も同じ nn.Module パターンで構築される。

📝 補講 R280-6: PyTorch の理解度チェック (練習問題)

以下の練習問題を自分で解いてみることで、 補講内容の定着度を確認できる。 解答例は各問の下に折りたたみ式で示すが、 まず自分で考えてから開くこと。 練習問題は実務で頻出する PyTorch のトラブルシューティングを抽出している。

▶ 練習問題 1: 形状エラーの原因特定

SSDSE 都道府県データ 47 件を入力 (B=1, C=1, L=47) として、 nn.Conv1d(1, 8, kernel_size=5, padding=0, stride=2) を通したときの出力形状は? 自分で計算してから検算してみよう。

ヒント: 出力長 L' = floor((L + 2*padding - kernel) / stride) + 1。 ここでは L=47, padding=0, kernel=5, stride=2。

解答: L' = floor((47 + 0 - 5) / 2) + 1 = floor(42/2) + 1 = 21 + 1 = 22。 出力形状は (1, 8, 22)。

▶ 練習問題 2: optimizer.zero_grad() を忘れたらどうなるか

補講の学習ループから opt.zero_grad() 行を削除した場合、 各エポックで勾配はどうなるか? loss の収束は速くなるか遅くなるか? 自分で実験してみよう。

解答: 勾配が毎ステップ累積され、 実効学習率が線形に増加。 結果として loss が振動・発散する傾向。 まれに最初の数ステップだけ速く収束するが、 長期的には不安定。

▶ 練習問題 3: モデルを GPU に乗せ忘れたエラー

model = TinyMLP().cuda() としたが、 x = torch.tensor([1.0]) のまま渡したらどんなエラーが出るか? 自分で再現してみよう。

解答: RuntimeError: Expected all tensors to be on the same device, but found at least two devices, cuda:0 and cpu!。 入力テンソルも x.cuda() または x.to(device) で同じデバイスに移す必要がある。

理解度チェックのまとめ: 形状計算、 勾配リセット、 デバイス整合の 3 つは PyTorch トラブルの 80% を占める。 これらを「自分で再現できる」「自分で説明できる」状態になれば、 PyTorch 入門は卒業と言ってよい。

🔗 関連用語（前提・並列・発展）

PyTorch を読むのに先に要る概念、 同じ役割を持つ別の道具、 PyTorch の上で学ぶ手法を分けて示す。

• 前提：NumPy（Tensor は NumPy 配列に自動微分と GPU を足したもの）、 勾配降下法（optimizer.step() がしていること）、 誤差逆伝播（loss.backward() がしていること）、 損失関数（backward() の起点になるスカラー）。
• 並列：TensorFlow / Keras（同じ役割の深層学習フレームワーク）、 scikit-learn（47 行の表データのように小さな問題では、 こちらで足りることが多い）。
• 発展：ニューラルネットワーク・多層パーセプトロン・深層ニューラルネットワーク（nn.Module で組むモデル）、 転移学習（学習済みの重みを読み込んで一部だけ学習し直す）。

📖 数式を言葉で読み解く

記号 1 つ 1 つではなく、 PyTorch の数式が表現している物語を文章で読み解きます。 SSDSE-B-2026 (47 都道府県 × 各種指標) を題材に、 「もしこの式を使ったら何が分かるのか」を可能な限り具体的に説明します。

PyTorch は Meta (旧 Facebook) AI Research が開発した深層学習フレームワークで、現在の研究コミュニティではほぼ事実上の標準となっています。その設計思想の核心は「define-by-run (動的計算グラフ)」で、TensorFlow 1.x のように静的グラフを事前にコンパイルする必要がなく、Python の通常の制御フロー (if 文・for 文) をそのまま使ってネットワークを記述できます。中心となる数式的概念は自動微分 (autograd) で、テンソル $\mathbf{x}$ に対して `requires_grad=True` を設定すると、計算グラフ上の全演算が記録され、`loss.backward()` を呼ぶだけで連鎖律 $\frac{\partial L}{\partial \theta} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial \theta}$ が自動計算されます。テンソルは NumPy 配列と同じ N 次元データ構造ですが、GPU 上での計算 (`.to('cuda')`) と自動微分の両方をサポートする点が決定的に異なります。`torch.nn.Module` を継承してネットワークを定義し、`torch.optim` で最適化器 (SGD・Adam・AdamW 等) を選び、`torch.utils.data.DataLoader` でミニバッチ化するという 3 点セットが基本パターンです。SSDSE-B-2026 のような 47 行 × 数十列の小規模表データでは MLP や TabNet を、より大きなデータでは Transformer 系を PyTorch 上で構築するのが定番。エコシステムも豊富で、PyTorch Lightning (訓練ループの簡略化)・HuggingFace Transformers (事前学習モデル)・PyTorch Geometric (グラフニューラルネット)・TorchVision (画像処理) など、目的別の高レベル API が揃っています。

📚 関連グループ教材

PyTorch は「深層学習」の教材群で使う道具にあたる。 ニューラルネットワーク・誤差逆伝播・勾配降下法の教材で数式として出てくる処理が、 このページの nn.Module・loss.backward()・optimizer.step() にそのまま対応する。 表データの回帰や分類から入るなら scikit-learn の教材を先に読み、 このページの単回帰（総人口 → 出生数）が sklearn の解析解と一致することを確かめてから深層学習に進むと、 どこからが PyTorch でないとできない部分かが分かる。

🔭 上級トピック: PyTorch の autograd と動的計算グラフの仕組み

PyTorch の最大の強みは 動的計算グラフ (define-by-run) による柔軟性で、 これを実現しているのが autograd モジュールです。 テンソル $\mathbf{x}$ に requires_grad=True を設定すると、 そのテンソルを起点とする全演算が「Function オブジェクト」として記録され、 計算結果のテンソルにグラフへの参照が保持されます。 loss.backward() を呼ぶと、 このグラフを逆順に辿りながら連鎖律 $\frac{\partial L}{\partial x_i} = \sum_j \frac{\partial L}{\partial y_j}\frac{\partial y_j}{\partial x_i}$ を再帰的に計算し、 葉ノード (リーフテンソル) の .grad 属性に勾配が累積されます。 ここで重要なのが「累積される」点で、 イテレーションの先頭で optimizer.zero_grad() または model.zero_grad() を呼ばないと、 前回の勾配が残ったまま新しい勾配が足し込まれ、 学習が崩壊します。 また no_grad() コンテキストや requires_grad=False で勾配計算を無効化することで、 推論時のメモリ削減・推論高速化が可能。 中級者向けには torch.autograd.grad() で任意のスカラーから任意のテンソルへのヤコビアン要素を取り出す機能、 torch.autograd.Function をサブクラス化してカスタム逆伝搬を定義する機能があり、 物理シミュレーションや微分方程式系の微分も実装可能。 さらに torch.compile (PyTorch 2.x) では動的グラフを実行時に部分的に静的化することで、 30–50% の高速化を達成しつつ柔軟性を維持する仕組みも導入されています。

🎓 理論深掘り: PyTorch の数学的構造

PyTorch の autograd は逆モード自動微分 (reverse-mode AD) を計算グラフ上で実装したものです。 関数 $f: \mathbb{R}^n \to \mathbb{R}$ (損失関数) の勾配 $\nabla f$ を計算するとき、 順方向に値を計算しつつ各演算ノードに「逆伝搬関数」を記録し、 出力から入力に向かって連鎖律を適用します。 数学的には、 計算グラフ $G$ の各ノード $v$ について随伴変数 $\bar{v} = \partial L / \partial v$ を計算する逆方向走査で、 1 回のフォワード + 1 回のバックワードで全ての入力変数についての勾配が同時に得られます (順モード AD なら入力ごとに 1 回ずつ必要)。 PyTorch ではこれを torch.Tensor の grad_fn 属性として実装し、 各テンソルがどの演算から生成されたかを保持。 backward() 呼び出し時に Function オブジェクトの逆伝搬メソッドが再帰的に呼ばれ、 リーフテンソルの .grad に勾配を集約します。 動的グラフのため、 制御フロー (if/while) を含むモデルでも自然に微分でき、 RNN や条件分岐ネットワークが書きやすい。 torch.compile (PyTorch 2.0 で導入) は、 動的グラフを部分的にトレースして TorchInductor 経由で OpenAI Triton カーネルにコンパイルし、 訓練・推論ともに 30–80% の高速化を達成します。 さらに torch.func モジュールでは JAX 風の関数型 API (vmap, grad, jacrev) も提供され、 ヤコビアン・ヘシアン・高階微分が容易に。

📜 PyTorch の歴史を辿る

PyTorch の歴史は、 Lua 言語で書かれた Torch (2002 年、 NYU の Yann LeCun らが開発) に遡ります。 2016 年 9 月、 Facebook AI Research (FAIR) の Adam Paszke・Sam Gross・Soumith Chintala らが Python ベースの Torch として PyTorch を公開。 当時の競合は Google の TensorFlow (2015 年公開) で、 TF の静的グラフ・複雑な API に対し PyTorch の動的グラフ・Pythonic な API が研究者に圧倒的支持を得ました。 2017-2018 年に研究コミュニティへ急速に浸透し、 2019 年には NeurIPS・ICML・CVPR 等の主要会議の論文の 70% 以上が PyTorch を採用するように。 2019 年 5 月、 PyTorch 1.0 リリースで本番運用向けの機能が整備、 同年 ONNX 経由で TensorFlow Serving 等への変換も可能に。 2022 年 12 月、 PyTorch 2.0 で torch.compile による JIT コンパイル機能が追加、 訓練・推論ともに大幅高速化。 2023 年に Linux Foundation 配下の PyTorch Foundation が設立され、 ベンダーニュートラルなオープンソース運営に移行。 2024-2025 年現在は深層学習フレームワークのほぼデファクトスタンダードとなり、 学術論文の 90%+ 以上が PyTorch ベース。 エコシステムも巨大で、 HuggingFace Transformers (NLP)・PyTorch Geometric (グラフ)・TorchVision (画像)・TorchAudio (音声)・PyTorch Lightning (訓練ループ)・Lightning AI (クラウド)・Detectron2 (物体検出)・Fairseq (seq2seq)・stable-baselines3 (RL) など、 各分野で標準ツールが PyTorch ベース。 LLM 訓練 (GPT・Llama・Mistral) も PyTorch + DeepSpeed/FSDP が主流で、 産業界でも Tesla の Autopilot・Meta の Reels アルゴリズム・OpenAI の GPT 訓練など、 大規模本番システムで採用されています。

🗺 概念マップ — PyTorch の周辺地図

図の中心が PyTorch。 前提は自動微分と Tensor（NumPy 配列に勾配と GPU を足したもの）、 並列は同じ役割の TensorFlow・JAX、 発展は本番向けの書き出し（TorchScript）と大規模モデルの分散学習（FSDP）、 応用は画像分類や自然言語処理、 基盤は GPU で計算を動かす CUDA・cuDNN、 対比は深層学習を使わない scikit-learn。 SSDSE-B-2026 の 47 行のような小さな表データでは「対比」の scikit-learn で足りることが多く、 PyTorch が必要になるのは画像・文章のような大きなデータや、 自分でモデルの形を組みたいときである。

🗺 補講 R280-5: PyTorch エコシステムの「全体地図」

PyTorch を本格的に使い始めると、 単体ライブラリだけでは足りないことに気付く。 画像、 自然言語、 グラフ、 強化学習、 各領域に PyTorch 系の特化ライブラリがあり、 それらを「いつ使うか」を地図化しておくと、 新しい課題に対しても流用がきく。 本補講では PyTorch エコシステムを 5 領域に整理し、 各領域の代表ライブラリと「素の PyTorch から切り替えるべき判断基準」を示す。

▶ PyTorch エコシステム 5 領域

補講のまとめ: PyTorch は「ピュアな計算ライブラリ」と「領域特化ライブラリのエコシステム」の二層構造。 まず素の PyTorch で計算グラフと自動微分を理解し、 次に領域特化ライブラリで生産性を上げ、 最後に Lightning / DeepSpeed で運用品質を上げる、 という 3 段階で学習を進めるのが効率的。 TensorFlow との比較、 機械学習ライブラリ としての位置づけ、 深層学習 全体の中の役割を意識して学ぶこと。

📒 補講 R280-4: PyTorch 学習ループの「再現性」と「乱数シード」の正しい固定

機械学習の論文や実験ノートで「再現できない」「同じコードを動かしたのに結果が違う」と詰まる原因の 95% は乱数シードの固定が不完全だからである。 PyTorch は CPU / CUDA / cuDNN / Python 標準 random / NumPy / DataLoader の 6 経路で乱数を使い、 そのどれかを固定漏れすると非決定的になる。 本補講では、 完全に再現可能な PyTorch 学習を実現する 6 行のテンプレを示し、 SSDSE-B-2026 の単回帰で「同じ結果が必ず出る」ことを確認する。

▶ 再現性のための 6 シード固定テンプレ

補講のまとめ: 上記 6 経路をすべて固定して初めて「完全な再現性」が確保される。 ただし cuDNN の deterministic モードは速度が 1.2-1.5 倍遅くなるので、 開発時は固定、 本番学習では性能優先で外す、 の使い分けが現実解。 論文やコンペ提出時は再現性を最優先し、 commit hash と乱数シードを README に明記する習慣を持つこと。 機械学習ライブラリ としての品質保証の入口。

🚀 補講 R280-3: 学習時のメモリ・速度最適化テクニック

PyTorch でモデルが大きくなると、 GPU メモリ不足や学習時間の長期化が深刻になる。 ここでは「メモリ削減」「速度向上」の代表 5 手法を整理し、 SSDSE-B-2026 の単回帰例で使い分けの目安を示す。 小さなデータでも「常に最適化を意識する」癖が、 大規模化したときの安全網になる。

▶ 5 つの最適化手法と適用判断

補講のまとめ: PyTorch は「動的かつ柔軟」な反面、 メモリ・速度の管理は開発者の責任。 まず Mixed Precision と DataLoader の num_workers 設定を試し、 それでも足りなければ Gradient Accumulation / Checkpointing を投入する順序が定石。 大規模学習では torch.compile や DistributedDataParallel を組み合わせ、 GPU クラスタ環境での効率を引き上げる。 各最適化は単独でも効くが、 組み合わせて初めて生産性が劇的に上がる。

⚙️ 補講 R280-2: PyTorch の「テンソル形状」を間違えない読み方

PyTorch を実装していて最も時間を奪うエラーは「shape mismatch」である。 入力テンソルの形状 (batch_size, channels, height, width) を、 各層がどう変形して次の層に渡すのか、 を頭の中で正確にトレースできるかが鍵。 本補講では SSDSE-B-2026 の都道府県データを CNN に入力する仮想シナリオを通じて、 テンソル形状の変化を 1 ステップずつ追う技術を解説する。 同じ思考プロセスは CNN や RNN でも共通して使える。

▶ テンソル形状読みのチェックポイント

▶ 形状ロガーで CNN の各層を追跡

このコードでやること: SSDSE 都道府県データの 1 列 (人口) を擬似 1D 画像と見なし、 Conv1d で特徴抽出。 各層の入出力形状を print で確認し、 形状が想定通りに変化することを目視。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import pandas as pd, torch, torch.nn as nn
torch.manual_seed(0)   # 実行のたびに同じ結果が出るようにする

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
pop = df[df['SSDSE-B-2026']==2023]['A1101'].values  # 総人口 47 値

# Tensor (batch=1, channels=1, length=47) として配置
x = torch.tensor(pop, dtype=torch.float32).view(1, 1, 47) / 1e6

class ShapeLogger(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv1d(1, 8, kernel_size=3, padding=1)
        self.pool = nn.MaxPool1d(2)
        self.conv2 = nn.Conv1d(8, 16, kernel_size=3, padding=1)
        self.fc = nn.Linear(16*11, 1)
    def forward(self, x):
        print(f'input: {tuple(x.shape)}')
        x = self.conv1(x); print(f'after conv1: {tuple(x.shape)}')
        x = self.pool(x);  print(f'after pool1: {tuple(x.shape)}')
        x = self.conv2(x); print(f'after conv2: {tuple(x.shape)}')
        x = self.pool(x);  print(f'after pool2: {tuple(x.shape)}')
        x = x.view(x.size(0), -1); print(f'after flatten: {tuple(x.shape)}')
        x = self.fc(x);    print(f'output: {tuple(x.shape)}')
        return x

model = ShapeLogger()
_ = model(x)

📤 実行例:

💬 結果の読み方: Conv1d は (B, C, L) の形状で動作する。 conv1 では padding=1, kernel=3 なので長さは保たれ 47 のまま、 チャネル数だけ 1→8 に増加。 pool で長さが半分 (47/2=23、 23/2=11) に縮小。 最後の Linear 入力は 16*11=176 で合っている必要がある。 ここを間違えると RuntimeError: mat1 and mat2 shapes cannot be multiplied。 デバッグ時はこの形状ロガーを nn.Module の forward に貼り付けるのが定石。

▶ 学習済モデル保存と復元の標準パターン

このコードでやること: 学習したパラメータを state_dict 経由で保存・復元する。 モデル本体は別途定義してから load_state_dict する「分離保存」が PyTorch の推奨。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import torch, torch.nn as nn
torch.manual_seed(0)   # 実行のたびに同じ結果が出るようにする

# 1) 学習したモデル (例: 総人口 → 出生数 の単回帰)
model = nn.Linear(1, 1)
with torch.no_grad():
    model.weight.fill_(6.048)
    model.bias.fill_(-0.379)

# 2) 保存 (state_dict のみ、 推奨)
torch.save(model.state_dict(), 'pytorch_linear.pt')

# 3) 復元 (同じ構造のモデルを作ってから load)
model2 = nn.Linear(1, 1)
model2.load_state_dict(torch.load('pytorch_linear.pt'))
model2.eval()  # 推論モードに切替 (dropout/batchnorm の挙動が変わる)

print('w:', model2.weight.item(), 'b:', model2.bias.item())
print('出生数予測 (総人口 1000 万):', model2(torch.tensor([[10.0]])).item())

📤 実行例:

💬 結果の読み方: 保存した重み (w=6.048, b=-0.379＝前節の 200 epoch 後の値) が復元後も完全一致。 item() は float32 をそのまま出すので 6.047999… と表示されるが、 これは丸め表示の差であって値は一致している。 推論結果 60.10（千人）は w*10 + b（総人口 1000 万人 → x=10）の計算と一致。 「state_dict のみ保存」がベストプラクティスで、 モデル構造は別途コードで管理する分離設計。 これにより PyTorch のバージョン互換性も保たれる。 詳細は公式 機械学習ライブラリ ガイドラインも参照。

📊 PyTorch のDataLoader でミニバッチ学習

このコードでやること: Dataset と DataLoader を組み合わせ、 47 都道府県データを「ミニバッチ単位」で学習する。 大規模データではメモリに全部載らないので、 ミニバッチ取り出しは必須。 SSDSE-B-2026 のような数十行のデータでも、 同じ仕組みを「縮小版」で確認しておくと、 後で大規模化したときにスムーズに移行できる。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import pandas as pd, torch
from torch.utils.data import Dataset, DataLoader

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026']==2023][['A1101','A4101']].dropna()  # 総人口・出生数

class PrefDataset(Dataset):
    def __init__(self, df):
        self.x = torch.tensor(df['A1101'].values, dtype=torch.float32).view(-1,1) / 1e6
        self.y = torch.tensor(df['A4101'].values, dtype=torch.float32).view(-1,1) / 1e3
    def __len__(self): return len(self.x)
    def __getitem__(self, i): return self.x[i], self.y[i]

ds = PrefDataset(df)
dl = DataLoader(ds, batch_size=8, shuffle=True)

for batch_x, batch_y in dl:
    print(f'バッチ形状: x={tuple(batch_x.shape)}, y={tuple(batch_y.shape)}')
    break
print(f'\n全 {len(ds)} 件 / バッチサイズ 8 → {len(dl)} バッチ')

📤 実行例:

💬 結果の読み方: 47 件を 8 件ずつ取り出すと 6 バッチ (47÷8=5.875→6 バッチ目は 7 件)。 shuffle=True で毎エポックの並び順が変わり、 確率的勾配降下 (SGD) の効果が発揮される。 画像や音声の大規模データセットでも同じ DataLoader パターンを使う。 並列読み込みは num_workers で制御し、 GPU では pin_memory=True で転送高速化。 バッチ、 勾配降下法 のページと併読推奨。

🔗 隣接手法への橋渡し

「PyTorch」は単独で完結する手法ではなく、 隣接領域と 接続 / 統合 / 比較 の 3 視点で連携して初めて真価を発揮する。 章 10 が派生カタログ、 章 15 が初期分岐、 本セクションは 実務で隣接技術と組み合わせる切替判断 に集中する。

🔌 接続: 上流 → PyTorch → 下流

PyTorch を中心に、 データ取得から本番デプロイまでの一気通貫パイプラインの隣接ノードを整理:

• 上流 (データ準備): NumPy 配列 や pandas DataFrame を torch.from_numpy(arr) / torch.tensor(df.values) で tensor 化。 画像なら PIL / torchvision.transforms、 テキストなら tokenizer でテンソル化。
• 並走 (実験管理): 実験管理 = MLflow / Weights & Biases で学習ハイパラ・損失曲線を記録、 クロスバリデーション = scikit-learn の KFold と組み合わせて再現性確保。
• 下流 (本番デプロイ): torch.jit.script / torch.onnx.export で書き出し → TorchServe / Triton Inference Server / ONNX Runtime で本番推論。 軽量化なら torch.quantization で 8-bit 量子化、 蒸留なら Knowledge Distillation。
• 横展開 (周辺ライブラリ): HuggingFace Transformers (LLM)、 torchvision (画像)、 torchaudio (音声)、 torch_geometric (グラフ) — 全てが PyTorch tensor 上で動く。

🧬 統合: PyTorch ×「他手法」の合わせ技 (3 セット)

PyTorch 単独では効果が限定的、 以下 3 つの隣接手法と組み合わせると爆発的に価値が出る:

• PyTorch + 転移学習: 表形式 SSDSE-B-2026 のような小規模データ (47 県) では fully-trained DL は過学習する。 ImageNet / BERT で事前学習された巨大モデルの最終層だけ自前データで fine-tune するのが定石。 SSDSE-B-2026 の自由記述列を BERT に流し → 最終層を MLP で人口予測に再構成、 と組み合わせれば 47 サンプルでも実用精度に到達。
• PyTorch + 分散訓練 (FSDP / DeepSpeed): LLM や CV モデルが GPU メモリに収まらない場合、 モデルを複数 GPU/ノードに分割。 FSDP (Fully Sharded Data Parallel) はパラメータ・勾配・optimizer state を分散保持、 DeepSpeed ZeRO は同等の最適化を提供。 単一 GPU では訓練不可能な 70B 級モデルも可能に。
• PyTorch + 実験管理 (W&B / MLflow): ハイパラ探索 (学習率・batch size・layer 数) を wandb.init() + wandb.config で記録、 全 run の比較を web UI で可視化。 「どのハイパラが効いたか」「再現できる構成」を明文化するのは 1 人開発でも必須。

⚖️ 比較: 類似 DL/ML フレームワークとの切替判断

「PyTorch vs 他フレームワーク」の選定で迷ったらこの表 (相補的 = 用途で使い分け、 競合的 = 1 つを選ぶ):

PyTorch を選ぶべき場面の要約: (i) 研究・実験プロトタイピング、 (ii) 動的計算グラフ (RNN・条件分岐)、 (iii) HuggingFace の事前学習モデル活用、 (iv) 巨大モデルの分散訓練 — のいずれかが該当するなら PyTorch 一択。 SSDSE-B-2026 のような小規模表形式データのみなら scikit-learn / XGBoost で十分。

🌳 手法選択フロー — PyTorch を選ぶか

「PyTorch を使うべきか」を判断するためのフローチャート。 上から順番に Yes/No で答えていけば、 自分の問題に最適な手法選定にたどり着きます。

1. 1. 研究・実験用途か？ Yes → PyTorch 一択 / プロトタイピングが多いなら必須。
2. 2. 本番デプロイ用途か？ Yes → TorchScript or ONNX で書き出し、 TorchServe / Triton / ONNX Runtime で推論。
3. 3. モバイル展開？ Yes → PyTorch Mobile or Core ML 変換 (iOS) / TFLite 変換 (Android)。
4. 4. 巨大モデル (LLM) の訓練？ PyTorch + FSDP or DeepSpeed for マルチノード分散訓練。
5. 5. GPU は必要か？ ローカル開発なら CPU で十分。 学習が遅いと感じたら Google Colab・Kaggle Notebook (無料 GPU)・AWS EC2 / GCP / Azure へ。
6. 6. 初学者なら何から？ 公式チュートリアル「60 分で学ぶ PyTorch」→ PyTorch Lightning で訓練ループ抽象化 → HuggingFace で事前学習モデル活用。

🧭 深掘り追記 ── 直感・落とし穴・発展（追補）

本節は既存の解説を壊さずに補う追記です。 PyTorch の核心である autograd（自動微分）と define-by-run（動的計算グラフ）に絞り、 SSDSE-B-2026 の実測値と再現コードで確かめます。 姉妹ページ TensorFlow が「テンソルを流す（Flow）＋小データで MLP が過学習する」という角度だったのに対し、 本節は「勾配が正しく計算されているか」「その勾配がなぜ累積するのか」という PyTorch 固有の挙動を数値で追います。 数値はすべて手元で計算した実測であり、 合成した箇所は「架空」と明記します。

🎨 直感の追補 ── autograd は「テープ」に演算を録画する

PyTorch の define-by-run（実行しながら定義）とは、 Python が 1 行ずつ順伝播を実行するその瞬間に計算グラフを組み立てる方式です。 requires_grad=True のテンソルが関わる演算は、 まるでテープ（tape）に録画されるように順番に記録され、 loss.backward() を呼ぶとテープを逆再生して連鎖律で各葉（leaf）テンソルの勾配 $\partial L/\partial w$ を .grad に書き込みます。 グラフは毎回の順伝播で作り直されるので、 if や for でモデルの形をイテレーションごとに変えられる ── これが静的グラフ時代の TF1 に対する PyTorch の決定的な武器で、 可変長系列や再帰的モデルを自然に書けます。 仕組みの根っこは バックプロパゲーション、 更新則は 勾配降下法 を参照。 なお autograd と tensor の単独ページは本サイト未整備のため、 ここではテキストで補います。

本当に正しい勾配が出ているのか？ を SSDSE-B-2026 の実測で確認します。 最新年 2023 年・47 都道府県、 総人口（A1101） を $x$、 65歳以上人口（A1303） を $y$ とし、 両者を標準化して単回帰 $\hat y = w x + b$、 損失は MSE とします。 標準化データでは損失の勾配は解析的に $\partial L/\partial w = -2\,\overline{x z\, y z}$ と書け、 重み初期値 $w=0,\,b=0$ での理論値と PyTorch の autograd を突き合わせると次の通り完全一致します。

注意：この 0.991 は「総人口が多い県は高齢人口も多い」というほぼ自明な強相関で、 統計的発見ではありません。 ここでの目的はautograd が手計算の微分と一致することを確かめる数値デモです。

⚠️ 落とし穴の追補（重要） ── zero_grad を忘れると勾配は「足し算」される

PyTorch 最大の初学者トラップは .grad が上書きではなく加算されることです。 backward() を呼ぶたびに、 新しい勾配が既存の .grad に足し込まれます。 上と同じデータで、 zero_grad() を挟まずに backward() を 2 回呼ぶと ──

この「加算」はバグではなく仕様です。 勾配累積（gradient accumulation）で擬似的に大きなバッチを作る、 RNN で複数の損失を合算する、 といった高度な使い方をこの性質が支えています。 だからこそ通常の学習ループでは毎ステップ optimizer.zero_grad()（または model.zero_grad()）で明示的にリセットする必要があります。 忘れると勾配がイテレーションごとに膨らみ、 実効学習率が暴走して損失が発散します。 なお本ページ上部の「🎮 触って理解する」ウィジェットでも、 この zero_grad の効果を手で確かめられます。

その他、 PyTorch で踏みやすい固有の落とし穴（既存「⚠️ よくある落とし穴」章と重複しない補足）：

• 損失をそのまま貯めるとメモリリーク：total += loss のように loss（グラフに繋がったテンソル）を蓄積すると、 計算グラフ全体が解放されず VRAM が膨張します。 ログ用途なら必ず total += loss.item()（Python の float に落とす）か .detach() を使う。
• model.train() / model.eval() の切替忘れ：Dropout と BatchNorm は学習時と推論時で挙動が変わります。 評価前に model.eval()、 かつ with torch.no_grad(): で勾配計算とグラフ保持を止めないと、 精度がぶれ、 メモリも無駄に食う。
• in-place 演算が autograd を壊す：x += 1 や relu_() など末尾 _ の破壊的演算は、 逆伝播に必要な中間値を上書きして RuntimeError: a leaf Variable that requires grad is being used in an in-place operation を招くことがある。 迷ったら非破壊版（x = x + 1）に。
• NumPy との dtype 齟齬：NumPy の既定は float64、 PyTorch の既定は float32。 torch.from_numpy(np_arr) は dtype を引き継ぐため、 モデル（float32）に float64 を渡すと型不一致で落ちる。 .float() で明示変換する。
• torch.from_numpy / .numpy() はメモリ共有：変換後のテンソルと元配列は同じメモリを指す。 片方を書き換えると他方も変わる。 独立させたいなら .clone() / .copy()。
• デバイスの取り違え：モデルを .to("cuda") したのに入力を CPU のまま渡すと Expected all tensors to be on the same device。 入力・ラベル・モデルを同じ device に揃える。

🐍 実測を再現するコード

上の 2 つの表を再現します（autograd と解析勾配の一致・勾配累積）。 PyTorch が無くても NumPy 部分だけで解析値は確認できます。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import numpy as np, pandas as pd, torch

df = pd.read_csv("data/raw/SSDSE-B-2026.csv", encoding="cp932", skiprows=[1])
d  = df[df["SSDSE-B-2026"] == 2023]                 # 最新年・47都道府県
x  = d["A1101"].astype(float).values               # 総人口
y  = d["A1303"].astype(float).values               # 65歳以上人口
xz = (x - x.mean()) / x.std()
yz = (y - y.mean()) / y.std()

# 解析的勾配（w=0,b=0）: dL/dw = -2*mean(xz*yz)
print("analytic dL/dw =", round(-2*np.mean(xz*yz), 6))   # -1.981958

# PyTorch autograd
xt = torch.tensor(xz); yt = torch.tensor(yz)
w  = torch.zeros(1, requires_grad=True)
b  = torch.zeros(1, requires_grad=True)
L  = ((w*xt + b - yt)**2).mean()
L.backward()
print("autograd  w.grad =", round(w.grad.item(), 6))     # -1.981958（一致）

# zero_grad を挟まず 2 回目 → 勾配は加算されて 2 倍
L2 = ((w*xt + b - yt)**2).mean(); L2.backward()
print("2nd backward (no zero_grad) =", round(w.grad.item(), 6))  # -3.963915

💬 両方を標準化しているので mean(xz·yz) は総人口と 65 歳以上人口の相関係数そのもので、−1.981958 は −2 × 0.990979 にあたる。autograd の w.grad が小数 6 桁まで手計算と一致し、backward() が式どおりの微分をしていると確かめられた。zero_grad() を挟まずにもう一度 backward() すると −3.963915 とちょうど 2 倍になり、勾配は上書きではなく足し込まれる。訓練ループで optimizer.zero_grad() を忘れると、この加算がバッチごとに積み重なって学習率を勝手に大きくしたのと同じことになる。

🚀 発展の追補

• 勾配累積で大バッチを模す：VRAM が足りず大きな バッチを積めないとき、 zero_grad を数ステップに 1 回だけ呼び、 その間 backward で勾配を貯めてから optimizer.step()。 上で見た「加算される仕様」の正しい活用法。
• torch.no_grad() と detach()：推論やメトリクス計算ではテープ録画を止めてメモリと速度を稼ぐ。 学習ループの評価パートは with torch.no_grad(): で囲むのが定石。
• nn.Module と optimizer：層を ニューラルネットワークとして組み、 torch.optim.SGD/Adam に model.parameters() を渡す。 活性化は ReLU ほか（活性化関数）。
• 小データでは深層化しない：47 件規模では NN は 過学習しやすく、 正則化や古典手法（Ridge / 勾配ブースティング）が頑健 ── 姉妹ページ TensorFlow の追補で MLP の交差検証 R² が負に落ちる実測を示した通り。
• 本番への跳躍：学習後は モデルデプロイ（TorchScript / ONNX / torch.compile）と MLOps へ。 応用モデルは CNN・Transformer、 配列演算の土台は NumPy、 全体像は 深層学習 を参照。

🔗 関連ページ

• 前提 ── バックプロパゲーション / 勾配降下法 / NumPy
• 並列・比較 ── TensorFlow / ニューラルネットワーク / 深層学習
• 発展 ── CNN / Transformer / MLOps / モデルデプロイ
• 周辺概念 ── バッチ / エポック / ReLU / 活性化関数 / 過学習 / 正則化（autograd・tensor・dropout は本サイト単独ページ未整備）