Day 132 — カスタムアーキテクチャ設計② — Gated MLPブロックの自作設計

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

🪄 今日の比較の設計（3種類のブロック × ゲート初期化2パターン）

GatedMLPBlockはResidualMLPBlockのF(x)部分をそのまま流用し、return x + hをreturn t*h + (1-t)*xに置き換えたものと捉えると理解しやすい。今日はさらにgate_bias_init（ゲートの初期開き具合）を0と-3の2パターンで比較する。

🎯 問題

Day131と同系統の合成分類データ・共通骨格（DeepNet）を使い、ResidualMLPBlockに加えて新しくGatedMLPBlockを実装し、比較します。

import numpy as np
from sklearn.datasets import make_classification

# --- 合成データ生成（Day131と同一） ---
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
HIDDEN = 64        # ブロック内部の次元（全ブロック共通）
# 今日比較する3種類:
#   (a) PlainMLP  : Day131と同じ（正規化・Skipなし、劣化問題の対照群）
#   (b) ResMLP    : Day131のResidualMLPBlock（H(x) = F(x) + x、配分は固定）
#   (c) GatedMLP  : 今日新規実装。H(x) = T(x)*F(x) + (1-T(x))*x（配分は学習可能）

💡 ヒント

import torch
import torch.nn as nn

class GatedMLPBlock(nn.Module):
    def __init__(self, dim, gate_bias_init=-3.0):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.fc1 = nn.Linear(dim, dim)
        self.act = nn.ReLU()
        self.norm2 = nn.LayerNorm(dim)
        self.fc2 = nn.Linear(dim, dim)
        self.gate_fc = nn.Linear(dim, dim)          # Transform Gate専用の層
        nn.init.constant_(self.gate_fc.bias, gate_bias_init)  # ← ここが今日のキモ
        self.last_gate_mean = None                   # 可視化用

    def forward(self, x):
        h = self.norm1(x)
        h = self.act(self.fc1(h))
        h = self.norm2(h)
        f = self.fc2(h)                              # F(x)
        t = torch.sigmoid(self.gate_fc(x))            # T(x)  0〜1の要素ごとのゲート
        self.last_gate_mean = t.mean().item()
        return t * f + (1 - t) * x                    # Highway: T(x)F(x) + (1-T(x))x

✅ 模範解答

設計要素↔コード変数の対応表

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

torch.manual_seed(0)

# --- サンプルデータ生成（Day131と同一） ---
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
HIDDEN = 64

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)

# --- ステップ1&2: GatedMLPBlockの自作設計（ゲートのバイアス初期化つき） ---
class GatedMLPBlock(nn.Module):
    def __init__(self, dim, gate_bias_init=-3.0):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.fc1 = nn.Linear(dim, dim)
        self.act = nn.ReLU()
        self.norm2 = nn.LayerNorm(dim)
        self.fc2 = nn.Linear(dim, dim)
        self.gate_fc = nn.Linear(dim, dim)
        nn.init.constant_(self.gate_fc.bias, gate_bias_init)
        self.last_gate_mean = None

    def forward(self, x):
        h = self.norm1(x)
        h = self.act(self.fc1(h))
        h = self.norm2(h)
        f = self.fc2(h)
        t = torch.sigmoid(self.gate_fc(x))
        self.last_gate_mean = t.mean().item()
        return t * f + (1 - t) * x

class ResidualMLPBlock(nn.Module):
    """Day131と同じ実装（比較対象）"""
    def __init__(self, dim):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.fc1 = nn.Linear(dim, dim)
        self.act = nn.ReLU()
        self.norm2 = nn.LayerNorm(dim)
        self.fc2 = nn.Linear(dim, dim)

    def forward(self, x):
        h = self.norm1(x)
        h = self.act(self.fc1(h))
        h = self.norm2(h)
        h = self.fc2(h)
        return x + h

class PlainBlock(nn.Module):
    """Day131と同じ実装（劣化問題の対照群）"""
    def __init__(self, dim):
        super().__init__()
        self.fc1 = nn.Linear(dim, dim)
        self.act1 = nn.ReLU()
        self.fc2 = nn.Linear(dim, dim)
        self.act2 = nn.ReLU()

    def forward(self, x):
        h = self.act1(self.fc1(x))
        h = self.act2(self.fc2(h))
        return h

# --- ステップ3: 共通骨格を持つDeepNet（GatedMLPはgate_bias_initを渡せるようにする） ---
class DeepNet(nn.Module):
    def __init__(self, in_dim=20, hidden=HIDDEN, num_classes=5, n_blocks=20,
                 mode="gated", gate_bias_init=-3.0):
        super().__init__()
        self.input_layer = nn.Linear(in_dim, hidden)
        if mode == "plain":
            self.blocks = nn.ModuleList([PlainBlock(hidden) for _ in range(n_blocks)])
        elif mode == "res":
            self.blocks = nn.ModuleList([ResidualMLPBlock(hidden) for _ in range(n_blocks)])
        elif mode == "gated":
            self.blocks = nn.ModuleList(
                [GatedMLPBlock(hidden, gate_bias_init=gate_bias_init) for _ in range(n_blocks)]
            )
        else:
            raise ValueError(mode)
        self.output_layer = nn.Linear(hidden, num_classes)

    def forward(self, x):
        h = self.input_layer(x)
        for block in self.blocks:
            h = block(h)
        return self.output_layer(h)

    def gate_means(self):
        """gatedモードの場合、各ブロックの直近の平均ゲート値をリストで返す"""
        return [b.last_gate_mean for b in self.blocks if hasattr(b, "last_gate_mean")]

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

def train_and_measure(mode, n_blocks=20, epochs=60, lr=1e-3, gate_bias_init=-3.0):
    torch.manual_seed(0)
    model = DeepNet(n_blocks=n_blocks, mode=mode, gate_bias_init=gate_bias_init)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)

    first_batch_grad_norm = None
    for epoch in range(epochs):
        model.train()
        for xb, yb in train_loader:
            optimizer.zero_grad()
            loss = F.cross_entropy(model(xb), yb)
            loss.backward()
            if first_batch_grad_norm is None:
                first_batch_grad_norm = model.input_layer.weight.grad.norm().item()
            optimizer.step()

    acc = evaluate(model)
    return model, acc, first_batch_grad_norm

# --- ステップ4: PlainMLP・ResMLP・GatedMLP(bias=-3)の3者比較（N_BLOCKS=20） ---
for mode, kwargs in [("plain", {}), ("res", {}), ("gated", {"gate_bias_init": -3.0})]:
    model, acc, grad_norm = train_and_measure(mode, n_blocks=20, **kwargs)
    print(f"{mode:6s}: acc={acc:.4f}  input_layer勾配ノルム(1バッチ目)={grad_norm:.6f}")
# 出力例（乱数・実行環境により変動）:
# plain : acc=0.2117  input_layer勾配ノルム(1バッチ目)=0.000031
# res   : acc=0.7217  input_layer勾配ノルム(1バッチ目)=0.183760
# gated : acc=0.7350  input_layer勾配ノルム(1バッチ目)=0.241300
# → gatedはresよりわずかに精度が高く、勾配ノルムも大きい（ゲートが「ほぼ恒等写像」から
#   ゆるやかに開いていくため、深い場合でも勾配が伝わりやすい経路が保たれる）

# --- ステップ5: ゲートのバイアス初期化(0 vs -3)の比較 ---
for bias_init in [0.0, -3.0]:
    _, acc, grad_norm = train_and_measure("gated", n_blocks=20, gate_bias_init=bias_init)
    print(f"gate_bias_init={bias_init:5.1f}: acc={acc:.4f}  勾配ノルム(1バッチ目)={grad_norm:.6f}")
# 出力例の傾向:
# gate_bias_init=  0.0: acc=0.6650  勾配ノルム(1バッチ目)=0.052300
# gate_bias_init= -3.0: acc=0.7350  勾配ノルム(1バッチ目)=0.241300
# → bias=0（五分五分スタート）はresより悪化することがある。bias=-3（ほぼ恒等写像
#   スタート）の方が安定して高精度・高勾配ノルムを維持する

# --- ステップ6: 深さ方向のゲートの開き具合を可視化 ---
gated_model, _, _ = train_and_measure("gated", n_blocks=20, gate_bias_init=-3.0)
gated_model.eval()
with torch.no_grad():
    _ = gated_model(X_test)   # forwardを1回走らせてlast_gate_meanを更新
gate_profile = gated_model.gate_means()
for i, g in enumerate(gate_profile, start=1):
    print(f"block {i:2d}: gate_mean={g:.4f}")
# 出力例の傾向:
# block  1: gate_mean=0.61   浅い層は比較的ゲートが開く
# block 10: gate_mean=0.34
# block 20: gate_mean=0.09   深い層はゲートがほぼ閉じたまま=ほぼ恒等写像として機能

📊 結果の可視化（ゲート初期化の効果・ブロック別ゲート開度）

🪜 Step-by-Step 解説

1T(x)はスカラーではなく「次元ごとのゲート」であることの意味

t = torch.sigmoid(self.gate_fc(x))   # shape: (batch, dim)
return t * f + (1 - t) * x           # 要素ごとの積（アダマール積）

2gate_fcをfc1・fc2と共有してはいけない理由

3なぜgate_bias_init=-3が0より優れた結果になったのか

# sigmoid(-3) ≈ 0.047 → 学習開始時は「95%くらいxをそのまま通す」
# sigmoid(0)  = 0.5   → 学習開始時は「五分五分で混ぜる」

4深さ方向のゲートの開き具合のパターンが示すもの

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

🏆 Kaggleでの実践的な使い方

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

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: 今日はT(x)をブロック内部のLinear層1つから計算しましたが、Highway Networks以降の研究では「複数のゲート（更新ゲート・出力ゲートなど役割の異なる複数のゲート）を組み合わせる」設計（LSTM/GRUなど）も広く使われています。GatedMLPBlockを拡張し、T(x)とは別に「出力に直接掛けるゲート」をもう1つ追加した2ゲート版を実装し、精度やゲートの振る舞いがどう変わるか試してみましょう
• 次回予告: Phase6テーマ2「カスタムアーキテクチャ設計」3日目。今日のResidual/Gated系ブロックとは異なるアプローチとして、Squeeze-and-Excitation（SE）ブロックを自作します。「各特徴量チャネルの重要度を、そのチャネル自身の統計量（平均値など）から動的に再重み付けする」という、Attentionの前身にあたる軽量な機構を表形式データに応用します

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

Day131でResidual Connectionを実装し、今日はその配分比率を学習可能にするGated MLPブロックを実装。次回はチャネル単位の再重み付けを行うSqueeze-and-Exciteブロックへと進む。

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