Day 133 — カスタムアーキテクチャ設計③ — Squeeze-and-Exciteブロックの自作設計

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

🪄 今日の比較の設計（4種類のブロック × reduction 2パターン）

SEMLPBlockはResidualMLPBlockのF(x)部分をそのまま流用し、return x + hをreturn x + s * hに置き換えたものと捉えると理解しやすい。今日はさらにreduction（ボトルネックの圧縮率）を4と16の2パターンで比較し、パラメータ数と精度のトレードオフを見る。

🎯 問題

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

import numpy as np
from sklearn.datasets import make_classification

# --- 合成データ生成（Day131・Day132と同一） ---
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        # ブロック内部の次元（全ブロック共通）
# 今日比較する4種類:
#   (a) PlainMLP  : Day131と同じ（正規化・Skipなし、劣化問題の対照群）
#   (b) ResMLP    : Day131のResidualMLPBlock（H(x) = F(x) + x）
#   (c) GatedMLP  : Day132のGatedMLPBlock（H(x) = T(x)F(x) + (1-T(x))x、gate_bias_init=-3）
#   (d) SEMLP     : 今日新規実装。H(x) = x + S(F(x)) * F(x)（S(F(x))はチャネルごとの重要度スコア）

💡 ヒント

import torch
import torch.nn as nn

class SEMLPBlock(nn.Module):
    def __init__(self, dim, reduction=4):
        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)
        reduced = max(1, dim // reduction)
        self.excitation = nn.Sequential(
            nn.Linear(dim, reduced),
            nn.ReLU(),
            nn.Linear(reduced, dim),
            nn.Sigmoid(),
        )
        self.last_scale = 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)
        s = self.excitation(f)                # チャネルごとの重要度スコア（0〜1）
        self.last_scale = s.mean(dim=0).detach()
        return x + s * f                      # Residual + チャネル別重み付けF(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・Day132と同一） ---
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: SEMLPBlockの自作設計（ボトルネックのreduction可変） ---
class SEMLPBlock(nn.Module):
    def __init__(self, dim, reduction=4):
        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)
        reduced = max(1, dim // reduction)
        self.excitation = nn.Sequential(
            nn.Linear(dim, reduced),
            nn.ReLU(),
            nn.Linear(reduced, dim),
            nn.Sigmoid(),
        )
        self.last_scale = None

    def forward(self, x):
        h = self.norm1(x)
        h = self.act(self.fc1(h))
        h = self.norm2(h)
        f = self.fc2(h)
        s = self.excitation(f)
        self.last_scale = s.mean(dim=0).detach()
        return x + s * f

class GatedMLPBlock(nn.Module):
    """Day132と同じ実装（比較対象）"""
    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)

    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))
        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: 1ブロックあたりの追加パラメータ数（ゲート/SE機構のみ）比較 ---
def count_params(module):
    return sum(p.numel() for p in module.parameters())

dummy_gate = nn.Linear(HIDDEN, HIDDEN)
gate_extra = count_params(dummy_gate)

reduced4 = max(1, HIDDEN // 4)
reduced16 = max(1, HIDDEN // 16)
se4_extra = count_params(nn.Linear(HIDDEN, reduced4)) + count_params(nn.Linear(reduced4, HIDDEN))
se16_extra = count_params(nn.Linear(HIDDEN, reduced16)) + count_params(nn.Linear(reduced16, HIDDEN))
# 出力例:
# ResidualMLPBlock:        +0 個
# GatedMLPBlock:           +4160 個（64*64+64）
# SEMLPBlock(reduction=4): +2128 個（64*16+16 + 16*64+64）
# SEMLPBlock(reduction=16):+580 個（64*4+4 + 4*64+64）
# → SEブロックはボトルネックのおかげでGatedMLPより少ないパラメータで
#   チャネル別の重み付けを実現している

# --- ステップ4: 共通骨格を持つDeepNet ---
class DeepNet(nn.Module):
    def __init__(self, in_dim=20, hidden=HIDDEN, num_classes=5, n_blocks=20,
                 mode="se", gate_bias_init=-3.0, reduction=4):
        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)]
            )
        elif mode == "se":
            self.blocks = nn.ModuleList(
                [SEMLPBlock(hidden, reduction=reduction) 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 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, reduction=4):
    torch.manual_seed(0)
    model = DeepNet(n_blocks=n_blocks, mode=mode, gate_bias_init=gate_bias_init, reduction=reduction)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    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()
            optimizer.step()
    acc = evaluate(model)
    return model, acc

# --- ステップ4: PlainMLP・ResMLP・GatedMLP・SEMLP(r=4)の4者比較（N_BLOCKS=20） ---
for mode, kwargs in [("plain", {}), ("res", {}), ("gated", {"gate_bias_init": -3.0}), ("se", {"reduction": 4})]:
    model, acc = train_and_measure(mode, n_blocks=20, **kwargs)
    print(f"{mode:6s}: acc={acc:.4f}")
# 出力例（乱数・実行環境により変動）:
# plain : acc=0.2117
# res   : acc=0.7217
# gated : acc=0.7350
# se    : acc=0.7417
# → SEMLPはGatedMLPよりわずかに精度が高く、しかもパラメータ数はGatedMLPの約半分(2128 vs 4160)

# --- ステップ5: reduction比率(4 vs 16)の比較 ---
for r in [4, 16]:
    _, acc = train_and_measure("se", n_blocks=20, reduction=r)
    extra = se4_extra if r == 4 else se16_extra
    print(f"reduction={r:2d}: acc={acc:.4f}  追加パラメータ数(1ブロック)={extra}")
# 出力例の傾向:
# reduction= 4: acc=0.7417  追加パラメータ数(1ブロック)=2128
# reduction=16: acc=0.7183  追加パラメータ数(1ブロック)=580
# → reduction=16はパラメータ数を4分の1近くまで削っても、resより高い精度を維持する

# --- ステップ6: チャネル重要度の可視化 ---
se_model, _ = train_and_measure("se", n_blocks=20, reduction=4)
se_model.eval()
with torch.no_grad():
    _ = se_model(X_test)
last_block_scale = se_model.blocks[-1].last_scale
sorted_idx = torch.argsort(last_block_scale, descending=True)
for rank, idx in enumerate(sorted_idx[:5], start=1):
    print(f"重要度上位{rank}: channel={idx.item():2d}  scale={last_block_scale[idx]:.4f}")
for rank, idx in enumerate(sorted_idx[-5:], start=1):
    print(f"重要度下位{rank}: channel={idx.item():2d}  scale={last_block_scale[idx]:.4f}")
# 出力例の傾向:
# 重要度上位1: channel=12  scale=0.8320
# 重要度下位1: channel= 3  scale=0.3512
# → 全チャネルが一様に0.5前後に収束するのではなく、明確な高低差(0.35〜0.83程度)が生じる

📊 結果の可視化（パラメータ効率とチャネル重要度）

🪜 Step-by-Step 解説

1なぜ表形式データでは「Squeeze」のステップを省略できるのか

f = self.fc2(h)              # F(x)。shape: (batch, dim)
s = self.excitation(f)       # そのままExcitationへ。GAPなどの追加集約は不要

2S(F(x)) * F(x)が「配分」ではなく「フィルタ」である理由

3ボトルネック構造がパラメータを削減しながら機能する理由

# GatedMLPBlockのgate_fc: dim -> dim（フル結合）           → dim*dim + dim 個
# SEMLPBlockのexcitation: dim -> dim/r -> dim（ボトルネック）→ 2*(dim*dim/r) + dim/r + dim 個

4チャネル重要度の可視化が示す「学習された選択的注意」

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

🏆 Kaggleでの実践的な使い方

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

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: 今日はSEMLPBlockのExcitationをF(x)自体から計算しましたが、元論文のように「バッチ内の複数サンプルにまたがる統計量（例: バッチ平均・分散）」を追加の入力として使うバリエーションも考えられます。SEMLPBlockを拡張し、fだけでなくfのバッチ内平均を連結した情報からExcitationを計算する版を実装し、精度がどう変わるか試してみましょう
• 次回予告: Phase6テーマ2「カスタムアーキテクチャ設計」4日目。SEブロックは「重要度をチャネル自身から計算する」機構でしたが、次回はいよいよMulti-Head Self-Attentionブロックを表形式データに応用します。SEが「各チャネルをどれだけ信じるか」を計算したのに対し、Attentionは「他のサンプル（あるいは他の特徴量グループ）とどれだけ関連しているか」を動的に計算する、より一般化された注意機構です

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

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

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