Day 128 — SOTA手法の追跡・論文実装③ — 学習を安定させるExponential Moving Average（EMA）

📚 背景知識（読んでから問題へ）

🪄 EMAの適用ステップ（今日の学習ループの流れ）

SAM（Day127）が「1ステップの中で完結する処理」だったのに対し、EMAは「学習の全ステップをまたいで状態を蓄積し続けるオブジェクト」である点が対照的。

🎯 問題

Day126・Day127と同様の合成分類データに対し、学習率を大きめに固定して意図的に「後半のエポックで重みが揺れ続ける」状況を作り、raw weight（学習ループの最終ステップの生の重み）とEMA weight（学習全体を通したEMA重み）それぞれでテスト精度がどう振る舞うかを比較します。

import numpy as np
from sklearn.datasets import make_classification

# --- 合成データ生成（5クラス分類。Day126/127と同系統） ---
X, y = make_classification(
    n_samples=2400, n_features=20, n_informative=12,
    n_classes=5, n_clusters_per_class=1, random_state=42,
    flip_y=0.03,
)

TRAIN_LEN = 1800   # 先頭1800件をtrain、残り600件をtest
# 学習率は減衰させず lr=0.02 程度で固定し、後半エポックでも重みが揺れ続けるようにする

💡 ヒント

import copy
import torch

class EMA:
    def __init__(self, model, decay=0.99):
        self.decay = decay
        self.shadow = copy.deepcopy(model.state_dict())

    def update(self, model):
        with torch.no_grad():
            for name, param in model.state_dict().items():
                self.shadow[name] = (
                    self.decay * self.shadow[name] + (1 - self.decay) * param
                )

    def apply_to(self, model):
        """モデルの現在の重みを退避しつつ、EMA重みを注入する。戻り値は退避した元の重み"""
        backup = copy.deepcopy(model.state_dict())
        model.load_state_dict(self.shadow)
        return backup

# 学習ループ内: optimizer.step() の直後に ema.update(model) を呼ぶ

✅ 模範解答

記号↔変数の対応表

import copy
import numpy as np
import torch
import torch.nn as nn
from sklearn.datasets import make_classification
from torch.utils.data import TensorDataset, DataLoader

torch.manual_seed(0)

# --- サンプルデータ生成（問題文と同じ） ---
X, y = make_classification(
    n_samples=2400, n_features=20, n_informative=12,
    n_classes=5, n_clusters_per_class=1, random_state=42, flip_y=0.03,
)
TRAIN_LEN = 1800

X_mean, X_std = X[:TRAIN_LEN].mean(axis=0), X[:TRAIN_LEN].std(axis=0)
X_scaled = (X - X_mean) / X_std

X_train = torch.tensor(X_scaled[:TRAIN_LEN], dtype=torch.float32)
y_train = torch.tensor(y[:TRAIN_LEN], dtype=torch.long)
X_test = torch.tensor(X_scaled[TRAIN_LEN:], dtype=torch.float32)
y_test = torch.tensor(y[TRAIN_LEN:], dtype=torch.long)

train_loader = DataLoader(TensorDataset(X_train, y_train), batch_size=32, shuffle=True)

class MLP(nn.Module):
    def __init__(self, in_dim=20, hidden=32, num_classes=5):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_dim, hidden), nn.ReLU(),
            nn.Linear(hidden, hidden), nn.ReLU(),
            nn.Linear(hidden, num_classes),
        )
    def forward(self, x):
        return self.net(x)

loss_fn = nn.CrossEntropyLoss()

# --- ステップ1: EMAの数式をそのままコードに翻訳 ---
class EMA:
    """theta_EMA_t = decay * theta_EMA_{t-1} + (1 - decay) * theta_t"""
    def __init__(self, model, decay=0.99):
        self.decay = decay
        self.shadow = copy.deepcopy(model.state_dict())

    def update(self, model):
        with torch.no_grad():
            for name, param in model.state_dict().items():
                self.shadow[name] = (
                    self.decay * self.shadow[name] + (1 - self.decay) * param
                )

    def apply_to(self, model):
        backup = copy.deepcopy(model.state_dict())
        model.load_state_dict(self.shadow)
        return backup

def evaluate(model):
    model.eval()
    with torch.no_grad():
        preds = model(X_test).argmax(dim=1)
    return (preds == y_test).float().mean().item()

# --- ステップ2/3: 学習率固定(減衰なし)で学習しつつ、EMAを並行更新 ---
def train_with_ema(epochs=80, lr=0.02, decay=0.99, tail=20):
    torch.manual_seed(0)
    model = MLP()
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)  # schedulerなし=学習率固定
    ema = EMA(model, decay=decay)

    raw_acc_history = []
    ema_acc_history = []

    for epoch in range(epochs):
        model.train()
        for xb, yb in train_loader:
            optimizer.zero_grad()
            loss = loss_fn(model(xb), yb)
            loss.backward()
            optimizer.step()
            ema.update(model)  # 生の重みを更新した直後にEMAも更新

        raw_acc = evaluate(model)
        backup = ema.apply_to(model)   # モデルの重みを一時的にEMA重みへ差し替え
        ema_acc = evaluate(model)
        model.load_state_dict(backup)  # raw weightへ復元

        raw_acc_history.append(raw_acc)
        ema_acc_history.append(ema_acc)

    raw_tail = raw_acc_history[-tail:]
    ema_tail = ema_acc_history[-tail:]
    return raw_tail, ema_tail

# --- ステップ4: decay=0.99での比較 ---
raw_tail, ema_tail = train_with_ema(decay=0.99)
print(f"raw  weight: mean={np.mean(raw_tail):.4f}  std={np.std(raw_tail):.4f}")
print(f"EMA  weight: mean={np.mean(ema_tail):.4f}  std={np.std(ema_tail):.4f}")
# 出力例（乱数・実行環境により変動）:
# raw  weight: mean=0.7220  std=0.0186
# EMA  weight: mean=0.7365  std=0.0071
# → EMA weightの方が平均は同等以上、標準偏差(ばらつき)は明確に小さい

# --- ステップ5: decayの感度確認 ---
for decay in [0.9, 0.99, 0.999]:
    raw_tail, ema_tail = train_with_ema(decay=decay)
    print(f"decay={decay:<6} raw: mean={np.mean(raw_tail):.4f} std={np.std(raw_tail):.4f}  |  EMA: mean={np.mean(ema_tail):.4f} std={np.std(ema_tail):.4f}")
# decay=0.9    raw: mean=0.720 std=0.019  |  EMA: mean=0.726 std=0.015  (追従は速いがまだ揺れが残る)
# decay=0.99   raw: mean=0.722 std=0.019  |  EMA: mean=0.737 std=0.007  (揺れがよく抑えられ、平均も良い)
# decay=0.999  raw: mean=0.721 std=0.018  |  EMA: mean=0.705 std=0.004  (揺れは最小だが追従が遅く平均が伸び悩む)

📊 安定性の可視化（最後20エポックの test精度: raw vs EMA）

🪜 Step-by-Step 解説

1EMAの数式を、状態を持つクラスのupdateメソッドに対応づける

def update(self, model):
    for name, param in model.state_dict().items():
        self.shadow[name] = self.decay * self.shadow[name] + (1 - self.decay) * param

2なぜ「evaluateの前後でload_state_dictを2回呼ぶ」手順が必要か

backup = ema.apply_to(model)   # EMA重みを注入
ema_acc = evaluate(model)
model.load_state_dict(backup)  # raw weightへ復元

3decayによって「安定性」と「追従の速さ」がどう変わるかを実験で確認する

4tail（最後20エポックだけを見る）という比較設計の意図

🧮 数学・統計の補足（文系向け）

🏆 Kaggleでの実践的な使い方

よく使われるコンペカテゴリ: ☐ 表形式データ（Tabular） / ☐ 自然言語処理（NLP） / ☑ 画像認識（CV） / ☐ 時系列（Time Series）

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: 今日実装したtrain_with_emaのtail区間について、raw weightとEMA weightのtest精度をエポックごとに折れ線グラフでプロットしてみましょう。「raw weightはギザギザ、EMA weightはなだらか」という直感が、数値だけでなく視覚的にも確認できます
• 次回予告: Day 129 — SOTA手法の追跡・論文実装④。引き続きPhase6テーマ1の枠内で、今日と同じ「論文の数式→実装」ワークフローを別の題材（Mixup: 2つの訓練サンプルを線形補間して合成するデータ拡張手法、x' = λx_i + (1−λ)x_j）に適用し、論文を読んで実装に落とし込む力をもう一段鍛えます

Phase 6 の学習マップ（全20テーマ）

Day126でLabel Smoothing（損失関数の改造）、Day127でSAM（Optimizerの改造）、Day128でEMA（学習ループ外での重みの後処理）と、「論文→実装」ワークフローを異なる切り口で3回反復。次はさらに別のSOTA手法へ。

📝 自己評価（解いた後に記入）