チューリングテスト — 知能を測る最初の物差し

Arc 1 Scene 1「ダートマスの夏」— 「知能とは何か」をゲームで体感する

📐 判定の論理

概要: チューリングテスト = 「機械は考えるか？」という答えようのない問いを、「審査員は機械と人間を見分けられるか？」という観測できる問いに置き換えた操作的定義（A. Turing, 1950）。

模倣ゲーム: 審査員が文字だけの会話で、見えない相手 A（人間）と B（機械）を判定する。

合格条件: $\Pr[\,\text{審査員が機械を正しく見抜く}\,] \approx \underbrace{0.5}_{\text{コイン投げと同じ}}$
→ 当てずっぽうと区別がつかない ＝ 機械は「知能あり」とみなしてよい

Turing の予測(1950): 5 分間の会話では審査員の $70\%$ 程度しか機械を見抜けない機械が、2000 年までに現れる
→「考えているか（内面・意識）」ではなく「考えているように振る舞えるか（外から見える行動）」を問う = 行動主義的アプローチ

📊 インタラクティブ: あなたが審査員（模倣ゲーム）

手がかりは文字の会話だけ。相手が 人間 か 機械 かを当ててください。時代を切り替えると、機械の「化け方」が変わります。

正解 0 / 0
👀 試してみよう: 時代を 1966年 にすると機械はすぐ見抜ける。2024年 に上げるとほぼ不可能になる ―― この変化こそ、機械が人間に追いついた 70 年間の縮図です。

🔧 ELIZA を覗く — オウム返しの正体

1966 年の ELIZA は実は 数本のパターン応答ルールでできていた。「理解」していない ―― それでも多くの人が「話を聞いてくれた」と感じた。これが ELIZA 効果です。試しに自分の言葉を入力して、どのルールに引っかかるか覗いてみよう。

DOCTOR. TELL ME MORE ABOUT YOUR_ ELIZA-1966
DOCTOR (1966)
MIT, J. Weizenbaum
あなた:
ELIZA のルール表（上から順にマッチをチェック / マッチしたルールがハイライトされる）:
🧠 ELIZA 効果: Weizenbaum 自身が驚いたのは、人々が「ELIZA は本当に話を聞いてくれている」と信じたこと ―― 秘書ですら「席を外してください、これは個人的な話なんです」と頼んだといいます。知能の判定は、相手の側ではなく観察者の側で起きる ―― これがチューリングテストの底にある真実です。

💡 解説

1950年、Turing は「機械は考えるか」という曖昧な問いを、外から観測できる振る舞いの問いに変換した ―― AI に初めて測定可能な目標を与えた
ダートマス会議（1956）の 6 年前。この「知能とは何か」の操作的定義が、その後すべての AI 研究の出発点になった
中国語の部屋（サール, 1980）: ルール表に従って中国語を返す人は、中国語を「理解」しているのか？ → 正しく振る舞えても「理解」とは限らない、という反論
現代の大規模言語モデルは事実上テストを通過した。だが「賢く見える」ことは「賢い」ことと同じなのか？ 議論は今も続いている
💡 直感的に: カーテン越しに誰かと話して、相手がロボットだと気づけなければ「十分に賢い」。中身（意識があるか）は問わず、外から見える振る舞いだけで判定する ―― これがチューリングの大胆な割り切りでした。

📖 詳細解説

① 模倣ゲームの原型
Turing の原論文は、まず「男・女・審査員」の 3 人ゲームを示す。審査員は文字の質問だけで男女を当てる。次に「男」を機械に置き換える ―― これが模倣ゲーム。狙いは 相手の正体を直接見せないこと。声や外見という先入観を排し、純粋に「知的な振る舞い」だけを評価する。
② 時代で変わる「化け方」
機械年代仕組み見抜きどころ
ELIZA1966言葉を質問で返す型自分を語れない
PARRY / A.L.I.C.E.1972–2000年代パターン応答の辞書矛盾・深掘りに弱い
大規模言語モデル2020年代巨大データで次の語を予測整いすぎ・即答すぎ
★ ポイント: 70 年かけて「見抜きどころ」は、機械の弱点から人間の癖へと逆転した。
③ では、機械はどうやって賢くなる？
チューリングテストは「知能のゴール」を定めた。だが どうやってそこに到達するか は別問題。ダートマス会議では道が 2 つに分かれる ―― ルールを人間が書く 記号主義 と、脳のニューロンを真似る 結合主義。次の図解では、その結合主義の出発点 ―― 1943年に生まれた「最初の人工ニューロン」に触れる。

マカロック-ピッツ ニューロン — 史上初の「考える部品」

Arc 1 Scene 1「ダートマスの夏」— 脳を真似た最初の人工ニューロン（1943）

📐 数式 — ニューロンは「多数決スイッチ」

概要: マカロック-ピッツ ニューロン（1943）= 脳の神経細胞を初めて数式にした史上初の人工ニューロン。発想はシンプルで、「入力たちの多数決で発火を決める」。

多数決の比喩: 入力 $x_i$ = 委員のスタンス（賛成 1 / 棄権 0）／ 重み $w_i$ = その委員の発言力 ／ 閾値 $\theta$ = 議案を通すのに必要な票数。合計が閾値を超えれば 発火（=可決）。

発火するか、しないか:
$y = \begin{cases} 1 & (\,\underbrace{\sum_i w_i x_i}_{\text{重み付きの総得票}} \ge \underbrace{\theta}_{\text{可決ライン}}\,) \\ 0 & (\text{それ以外}) \end{cases}$

$x_i \in \{0, 1\}$ → 入力（前のニューロンが発火したか ＝ 委員が賛成票を入れたか）
$w_i$ → 結合の重み（その入力の発言力。負なら反対票として効く ＝ 抑制性）
$\theta$ → 閾値（可決ライン） ／ $y$ → 出力（発火 ＝ 議決成立）

ポイント: 重み $w$ も閾値 $\theta$ も 人間が手で設計する。ニューロン自身は学習しない ―― ここが次の「パーセプトロン」との決定的な違い。

📊 インタラクティブ: 1 個のニューロンで AND / OR を組む

本編では AND（全員賛成で可決） と OR（誰か 1 人賛成で可決） の 2 例で「多数決スイッチ」の仕組みを体感します。NOT / NAND / XOR は下の「📖 詳細解説」で深掘り。

プリセット:
👀 試してみよう: ① プリセット「AND」（可決ライン 2 票）から閾値 $\theta$ を 2 → 1 に下げると、たった 1 票で可決される「OR」に化ける。② 重みを負（抑制票）にすると NOT / NAND が組める。③ どう頑張っても XOR は作れない ―― その「作れなさ」が次の Scene の伏線です。詳細解説 ③ で理由を見ます。

💡 解説

1943年、マカロック と ピッツ は脳の神経細胞を初めて数式にした。「脳は論理計算をする機械」というこの見方が、AI と計算機科学の共通の土台になった
ニューロン 1 個で AND・OR・NOT が作れる。組み合わせれば、原理上どんな論理回路 ―― つまりどんな計算 ―― も表現できる
重み $w$ と閾値 $\theta$ は人間が手で設計する。ニューロン自身は学べない → 「自分で重みを決める」のが パーセプトロン（1957、Scene 2）
1 個のニューロン（＝ 1 本の直線）では XOR が解けない。この限界が、のちの「AI の冬」の引き金になる（Scene 3）
💡 直感的に: ニューロンは 多数決スイッチ。委員（入力 $x_i$）が一票ずつ持ち、それぞれの発言力（重み $w_i$）で重み付けされる。総得票が可決ライン（閾値 $\theta$）を超えれば発火（=可決）。脳の神秘だった「思考」が、初めて ON / OFF の計算として書けることを示した ―― それが 1943 年の革新でした。

📖 詳細解説

① 数値例 ―― AND ゲートを 1 個のニューロンで
設定: $w_1 = 1,\ w_2 = 1,\ \theta = 2$。
・両方 OFF $(0,0)$: 合計 $= 0$。$0 \ge 2$ ? いいえ → $y = 0$
・片方だけ ON $(1,0)$: 合計 $= 1$。$1 \ge 2$ ? いいえ → $y = 0$
・両方 ON $(1,1)$: 合計 $= 2$。$2 \ge 2$ ? はい → y = 1
「両方そろったときだけ発火」＝ まさに AND。閾値 $\theta$ が「2 票そろえ」という可決ラインになっている。
② OR ゲート ―― 可決ラインを 1 票に下げる
設定: $w_1 = 1,\ w_2 = 1,\ \theta = 1$（AND と重みは同じ、閾値だけ 1 に）。
・両方 OFF $(0,0)$: 合計 $= 0$。$0 \ge 1$ ? いいえ → $y = 0$
・片方だけ ON $(1,0)$: 合計 $= 1$。$1 \ge 1$ ? はい → y = 1
・両方 ON $(1,1)$: 合計 $= 2$。$2 \ge 1$ ? はい → y = 1
「誰か 1 人でも賛成すれば発火」＝ まさに OR。AND との違いは 可決ラインの厳しさだけ。同じ重みでも閾値 1 つで論理が変わる。
③ NOT ゲート ―― 抑制票（負の重み）で否決する
設定: $w_1 = -1,\ w_2 = 0,\ \theta = 0$。
・$x_1 = 0$: 合計 $= 0$。$0 \ge 0$ ? はい → y = 1（入力が来ないので、デフォルトで発火）
・$x_1 = 1$: 合計 $= -1$。$-1 \ge 0$ ? いいえ → $y = 0$（反対票が入って否決）
重みの符号が 興奮性（＋）／ 抑制性（−）を表す。脳のニューロンも興奮性／抑制性のシナプスを持つ ―― この対応が「脳の数式化」の核心。
④ NAND ゲート ―― AND の反転は全員に反対票
設定: $w_1 = -1,\ w_2 = -1,\ \theta = -1$。
・$(0,0)$: 合計 $= 0$。$0 \ge -1$ ? はい → y = 1
・$(1,0)$ または $(0,1)$: 合計 $= -1$。$-1 \ge -1$ ? はい → y = 1
・$(1,1)$: 合計 $= -2$。$-2 \ge -1$ ? いいえ → $y = 0$
「両方が立ったときだけ発火しない」＝ AND の反転。NAND が重要なのは NAND だけですべての論理回路が作れること（万能ゲート）―― 原理的に、NAND を組み合わせるだけでコンピュータが組める。
⑤ 設計レシピのまとめ
ゲートw₁w₂θ多数決として読む
AND+1+122 票そろえば可決（全会一致）
OR+1+111 票で可決（誰でも提案可）
NOT x₁−100x₁ の反対票で否決
NAND−1−1−1全員反対のときのみ否決
★ 重みの符号が「興奮票（＋）／ 反対票（−）」、閾値が「可決ライン」。この 3 つの数字だけで論理が決まる。
⑥ なぜ XOR は作れないのか
XOR は「入力が違うときだけ発火」＝ $(0,1)$ と $(1,0)$ で $y = 1$、$(0,0)$ と $(1,1)$ で $y = 0$。
1 個のニューロンが引けるのは 1 本の直線だけ。だが XOR の「発火する点」と「しない点」は、どんな直線を引いても 2 グループに分けられない（線形分離不可能）。
多数決の言葉で言えば、「全員一致でもダメ、誰か一人でもダメ、ちょうど 1 人だけ賛成のときだけ可決」というルールは 単一の可決ラインでは決められない。
この限界をミンスキーらが 1969 年に指摘し、ニューラルネット研究は「冬」に入る。打開策は ―― 多数決スイッチを 多層に重ねること。その物語が Scene 2・3、そして Scene 5 へと続く。
⑦ Scene 1 → Scene 2 への橋
1943 マカロック-ピッツ ニューロン（学習しない）→ 1957 パーセプトロン（自分で重みを学習する）→ 多層パーセプトロン（XOR を解く）。
このニューロンは「考える部品」の最初の 1 個。次の Scene 2「パーセプトロンの興奮と絶望」で、ニューロンはついに 自分で学び始めます。

1. 活性化関数と勾配消失

Arc 1 Scene 5「脳を模倣せよ」関連

📐 数式

Sigmoid (シグモイド: S字曲線): $\sigma(z) = \dfrac{1}{1 + e^{\overbrace{-z}^{\text{入力を反転}}}}$ → 出力 $\in (0, 1)$
$z \gg 0$ → 出力≈1 / $z \ll 0$ → 出力≈0 / $z=0$ → 出力=0.5。確率として解釈可能
微分: $\sigma'(z) = \underbrace{\sigma(z)(1 - \sigma(z))}_{\text{最大0.25 → 層を重ねると消失}}$

tanh (Hyperbolic Tangent: 双曲線正接): $\tanh(z) = \dfrac{e^z - e^{-z}}{e^z + e^{-z}}$
→ 出力を−1〜1に。Sigmoidより中心が0で学習しやすい
→ 微分: $\tanh'(z) = 1 - \tanh^2(z)$　←最大1だが両端で消失

ReLU (Rectified Linear Unit: 整流線形ユニット): $f(z) = \max(0, z)$
→ z>0 なら勾配が常に1、z≤0 なら0（Dead ReLU問題）
→ 微分: $f'(z) = \begin{cases} 1 & (z>0) \\ 0 & (z \leq 0) \end{cases}$　←勾配消失しない！

改良版: Leaky ReLU (z≤0でも微小勾配=0.01z) / GELU (Gaussian Error Linear Unit: ガウス誤差線形ユニット, Transformer標準) / Swish (x·σ(x), Google 2017)

📊 グラフ

💡 解説

Sigmoid/tanhで連続的な微分が可能になり、誤差逆伝播が実現した（1986年〜）
Sigmoid/tanhは両端で勾配≈0 → 深い層で勾配が消失し学習不能に（勾配消失問題）
ReLU (2010年代) が勾配消失を解決。z>0で勾配=1のため、何層重ねても勾配が伝わる
ReLUはz≤0で完全に0（Dead ReLU）。Leaky ReLU, GELU等の改良版が登場

試験ポイント: 「なぜSigmoidからReLUに移行したか」→ 勾配消失問題の解決。微分の最大値を比較すると一目瞭然。

💡 直感的に: 活性化関数は「閾値スイッチ」。Sigmoidは滑らかなスイッチ、ReLUは「0以下は切り捨て」のシンプルなスイッチ。深い層で勾配が消えない（ReLU）ことがDL成功の鍵。

多層パーセプトロン (MLP) — 順伝播の全体像

Arc 1 Scene 5「脳を模倣せよ」— NN の核心を数値で理解する

📐 数式: 順伝播（Forward Pass）

1層目（隠れ層）: 各ニューロンで「重み付き合計 → 活性化」
$z_1 = w_{11} x_1 + w_{12} x_2 + b_1$ ← 重み付き合計
$a_1 = \sigma(z_1)$ ← 活性化関数を通す（ここでは $\sigma$ = Sigmoid。実務では ReLU が標準）
$z_2 = w_{21} x_1 + w_{22} x_2 + b_2$
$a_2 = \sigma(z_2)$

2層目（出力層）:
$z_3 = w_{31} a_1 + w_{32} a_2 + b_3$
$\hat{y} = \sigma(z_3)$ ← 最終出力（予測値）

ポイント: 活性化関数 $\sigma$ がなければ、どんなに層を重ねても全体は1つの線形変換 $y = W'x + b'$ にしかならない（XOR解けない！）。$\sigma$ が非線形性を入れることで、多層NNは「任意の関数を近似」できるようになる。

📊 インタラクティブ: 数値が流れる様子

重みを変えて、各ニューロンの値がリアルタイムに変化するのを確認。

💡 解説

各層で「重み付き合計 $z$ → 活性化 $a = \sigma(z)$」を繰り返すのがNNの全て
活性化関数 $\sigma$ が非線形性を導入。これがなければ多層にする意味がない
重み $w$ とバイアス $b$ をどう調整するか → 次のページ「誤差逆伝播」で解決
試してみよう: $w_{11}$ を 3→-3 に変えて、$a_1$ がどう変わるか確認。$\sigma$ が値を 0〜1 に押し込めている
💡 直感的に: 多層NNの核心は「重み付き合計 → 活性化」の繰り返し。活性化関数がなければどんなに層を重ねても1つの線形変換。非線形性を入れることで「任意の関数を近似」できるようになる。

誤差逆伝播 — 連鎖律で勾配を計算する

Arc 1 Scene 5「脳を模倣せよ」— DLの全てを支える微分の仕組み

📐 数式: 連鎖律（Chain Rule）の導出

目標: 損失 $L$ を各重み $w$ で微分し、「$w$ をどう変えれば $L$ が減るか」を知る

損失: $L = \frac{1}{2}(y - \hat{y})^2$

Step 1: 出力層の勾配
$\dfrac{\partial L}{\partial \hat{y}} = -(y - \hat{y})$ ← 予測と正解のズレ

$\dfrac{\partial \hat{y}}{\partial z_3} = \sigma'(z_3) = \hat{y}(1 - \hat{y})$ ← シグモイドの微分

$\dfrac{\partial L}{\partial z_3} = \dfrac{\partial L}{\partial \hat{y}} \cdot \dfrac{\partial \hat{y}}{\partial z_3}$ ← ← これが連鎖律

Step 2: 出力層の重み $w_{31}$ への勾配
$\dfrac{\partial z_3}{\partial w_{31}} = a_1$ ← $z_3 = w_{31} a_1 + w_{32} a_2 + b_3$ を $w_{31}$ で微分

$\dfrac{\partial L}{\partial w_{31}} = \dfrac{\partial L}{\partial z_3} \cdot a_1$ ← ← 連鎖律でチェーンを繋ぐ

Step 3: 隠れ層への逆伝播
$\dfrac{\partial L}{\partial a_1} = \dfrac{\partial L}{\partial z_3} \cdot w_{31}$ ← 勾配が $w_{31}$ を通じて逆流

$\dfrac{\partial L}{\partial z_1} = \dfrac{\partial L}{\partial a_1} \cdot \sigma'(z_1)$ ← 活性化の微分を掛ける

$\dfrac{\partial L}{\partial w_{11}} = \dfrac{\partial L}{\partial z_1} \cdot x_1$ ← 最初の重みへの勾配が求まった！

要するに: $\frac{\partial L}{\partial w_{11}} = \underbrace{\frac{\partial L}{\partial \hat{y}}}_{-\text{誤差}} \cdot \underbrace{\frac{\partial \hat{y}}{\partial z_3}}_{\sigma'(z_3)} \cdot \underbrace{\frac{\partial z_3}{\partial a_1}}_{w_{31}} \cdot \underbrace{\frac{\partial a_1}{\partial z_1}}_{\sigma'(z_1)} \cdot \underbrace{\frac{\partial z_1}{\partial w_{11}}}_{x_1}$

📊 インタラクティブ: 勾配が逆流する様子

正解 $y$ を変えると勾配が変わり、各重みの更新量が変化する。

💡 解説

連鎖律の核心: 複合関数の微分を「鎖のように繋いで掛け算する」。$\frac{\partial L}{\partial w} = \frac{\partial L}{\partial z} \cdot \frac{\partial z}{\partial w}$
なぜ「逆」伝播か: 出力側 (∂L/∂ŷ) から計算を始め、入力側 (∂L/∂w₁₁) へ向かって勾配を伝える
勾配消失: $\sigma'(z)$ の最大値は 0.25。5層なら $0.25^5 = 0.001$。勾配がほぼ消える → ReLU で解決
試してみよう: y=1（正解は1）に設定。ŷ が 1 に近いほど損失↓、勾配↓（もう調整不要）。y=0 に変えると勾配の符号が反転する
💡 直感的に: 「出力の誤差を、鎖のように逆方向にたどって各重みの責任を計算する」。微分の連鎖律で「この重みを変えたら損失がどう変わるか」を効率よく求める。DL全体を支える基礎技術。

2. パーセプトロンの決定境界

Arc 1 Scene 2「パーセプトロンの興奮と絶望」関連

📐 数式

出力: $y = f(w_1 x_1 + w_2 x_2 + b)$
$w_1, w_2$ = 各入力の重み（重要度）
$b$ = バイアス（閾値の負値）
$f$ = ステップ関数: $f(z) = \begin{cases} 1 & (z \geq 0) \\ 0 & (z < 0) \end{cases}$

決定境界: $w_1 x_1 + w_2 x_2 + b = 0$
→ 2次元では直線。この直線で空間を2クラスに分割する。

📊 グラフ

💡 解説

AND/ORは直線1本で分離可能 → パーセプトロンで学習できる（線形分離可能）
XORは直線1本では分離不可能 → パーセプトロンの致命的限界（ミンスキー 1969）
人類初の「学習する機械」。重みを自動調整するアルゴリズムを持つ
単層では非線形問題を解けない → 多層化（MLP）が必要 → 誤差逆伝播の発明へ

試してみよう: XORを選び、直線をどう動かしても●と×を分離できないことを確認。これがAI冬の直接原因。

💡 直感的に: データを直線1本で2グループに分ける装置。AND/ORは分けられるがXOR（斜め対角）は直線1本では無理。この限界がAI冬の引き金に。層を重ねれば解決 → 多層NN。

MYCIN 推論チェーン — IF-THEN ルールと確信度 (CF)

Arc 1 Scene 3 Tech Nugget #1 — page 03、ファイゲンバウムとショートリフが書いた感染症診断システム を、あなたの手で動かす

数式と仕組み

エキスパートシステム = 「ルール (IF-THEN) + 推論エンジン + 知識ベース」。MYCIN (Stanford, 1976) は感染症診断に 600 個のルールを書き、医師と同等以上の正診率を示した最初のシステム。

各ルールには 確信度 (Certainty Factor, CF) = 0.0〜1.0 が付き、ルールが連鎖発火すると確信度が掛け算で伝播する:

$\text{cf}(\text{結論}) = \min(\text{cf}(\text{条件}_1), \text{cf}(\text{条件}_2), \ldots) \times \text{cf}(\text{ルール})$

これは MYCIN が古典確率論ではなく独自設計した経験則 (heuristic)。実際は症状の組み合わせから「どれくらい確からしい」を機械が扱える数値に翻訳する仕組みで、現代のベイジアン推論やニューラルネットの確率出力の祖先と言える。

インタラクティブ: 症状を選んでルール連鎖を観察

細菌の特徴 (Gram 染色 / 形態) と感染部位を選択すると、3 つの IF-THEN ルールが順に発火し、最終的に治療薬と確信度が導出される。

入力事実 (1.0) gram-neg, rod, blood R1 (cf=0.8) IF gram-neg AND rod THEN enterobacteriaceae enterobacteriaceae cf = 0.80 R2 (cf=0.7) IF enterobacteriaceae AND blood THEN e.coli e.coli cf = 0.56 R3 (cf=0.9) IF e.coli THEN therapy = gentamicin gentamicin cf = 0.50
確信度の伝播: 入力 (cf=1.0) から R1 適用で 0.80 → R2 適用で 0.56 → R3 適用で 0.504
最終診断: e.coli 感染 → gentamicin (確信度 0.50)

試してみよう

3 つの症状を全部チェック (デフォルト) すると、ルールが全て連鎖発火し、確信度 = 1.0 × 0.8 × 0.7 × 0.9 = 0.504 で「e.coli → gentamicin」が導出される。これが forward chaining (前向き推論) の基本形。
「血液感染」をオフにすると R2 が発火せず、推論は途中で止まる ―― 「腸内細菌科の疑い」までしか言えない。実際の医療診断では、複数の症状が組み合わさって初めて確信度が積み上がる。
考えてみよう: 確信度 0.50 という数字、現実の医師の「6 割くらいかな」とは違う何かを表している。MYCIN の CF は独自設計の経験則であり、古典確率論ではない。だから実際に FDA は認可せず、研究用に留まった ―― だが、その発想は現代のベイジアン推論やニューラルネットの確率出力にまで生きている。

次のステップ

暗黙知の壁 →
MYCIN は感染症で成功した。だが「自転車に乗る方法」のような暗黙知 (Tacit Knowledge, Polanyi 1966) は、どんなに頑張っても IF-THEN では書き下せなかった。次は Cyc が常識を全部書き下そうとした究極の試み、そして Symbolic AI の遺産が現代のロボットエージェントへ繋がる STRIPS へ。

Cyc 常識推論 — 知識グラフから新事実を導く

Arc 1 Scene 3 Tech Nugget #2 — page 10、レナトが 40 年かけて書き続けた「常識を全部 IF-THEN で書く」プロジェクト

数式と仕組み

Cyc (Stanford → Cycorp, 1984~) は、人間が「当たり前」と思っている事実 ―― 木は葉を持つ、水は飲める、火は熱い ―― を機械が扱える形に書き下す、レナトが 40 年かけたプロジェクト。

基本構造は 三つ組 (triple): 主語 — 述語 — 目的語。これは現代の Knowledge Graph (Google KG, Wikidata) や RDF/SPARQL の祖先。

$(\text{Tree}, \text{HAS-PART}, \text{leaves}) \quad \land \quad (\text{leaves}, \text{CAN-DO}, \text{photosynthesis}) \Rightarrow (\text{Tree}, \text{CAN-DO}, \text{photosynthesis})$

これは transitive inference (推移的推論)。「木は葉を持つ」+「葉は光合成できる」→「木は光合成できる」が導出される。同様の論理で、現代の検索エンジンは「○○ の創設者は誰?」のような質問に答えている。

インタラクティブ: KB を拡張して INFER を観察

初期 KB に 4 つの事実が入っている。「INFER (推論)」ボタンを押すと、Cyc が transitive 推論を実行し、新事実を導出。グラフが拡張される。

Tree leaves photo-synthesis sun sunlight HAS-PART CAN-DO REQUIRES COMES-FROM CAN-DO ✨ (INFER) REQUIRES ✨
推論ログ
初期 KB: 4 facts
(Tree HAS-PART leaves)
(leaves CAN-DO photosynthesis)
(photosynthesis REQUIRES sunlight)
(sunlight COMES-FROM sun)
→ INFER ボタンを押してください

試してみよう

INFER を押すと、KB の事実 2 つを組み合わせて 新事実「Tree CAN-DO photosynthesis」が導出される。これは Tree という単語と photosynthesis という単語の 直接の関係を、機械が KB に書いていない にもかかわらず、推論で繋げた瞬間。これが transitive inference。
もう一度 INFER を押すと、「Tree REQUIRES sunlight」が導出される。Cyc は何百万もの事実を組み合わせて、人間が直接書いていない事実を 100 万通りも生成できる ―― これがレナトの「常識を機械に与える」夢。
考えてみよう: Cyc の発想は今も生きている。Google 検索が「日本の総理大臣は誰?」と聞くと正しく答えられるのは、内部に Knowledge Graph という Cyc 的な知識ベースを持っているから (ただし学習で自動構築されている)。Wikidata、Wolfram Alpha、SPARQL ―― 全部 Cyc の延長線上にある。

次のステップ

知識から行動計画へ →
KB を持つ機械は推論できる。だが ロボットが実世界で動く には、推論だけでは足りない ―― 状態を変える「行動の計画」が必要。次は STRIPS プランナー (1971, Shakey ロボット制御) ―― 現代の LLM エージェント (ReAct, Plan-and-Execute) の祖先へ。

STRIPS プランナー — ブロックワールドで「行動の計画」を作る

Arc 1 Scene 3 おまけ — 1971 SRI Fikes & Nilsson、Shakey ロボットを動かした「状態空間探索」が、現代の LLM エージェントへ

数式と仕組み

STRIPS (Stanford Research Institute Problem Solver, 1971) は、初期状態 → 目標状態 に到達するための「行動の列 (plan)」を自動で探索するシステム。Shakey ロボット (1966-1972、世界初の自律移動ロボット) の制御に使われた。

各アクションは 3 つの集合で定義される:
$\text{Action} = \langle \text{precondition},\ \text{add-list},\ \text{delete-list} \rangle$

例: pickup(A) = 「A を掴む」
- precondition: A が table 上、A の上に何もない、手が空いている
- add-list: 手が A を持っている
- delete-list: A は table 上ではなくなる、手は空いていない

STRIPS は state-space search (状態空間探索) を行う。現代の LLM エージェント (ReAct, Plan-and-Execute, AutoGPT) は、LLM が plan を「生成」する点で違うが、根本構造は同じ ―― 状態 → アクション → 状態の繰り返しで目標に到達する。

インタラクティブ: ブロックワールドで plan を観察

初期状態: A が B の上、C が table の上。目標状態: C が B の上、A が table の上。STRIPS が plan を 4 ステップで導出し、アニメーション再生する。

初期状態
A B C (on A B) (on-table C)
目標状態
A C B (on-table A) (on C B)
現在状態 (ステップ 0 / 4)
table A B C hand: 空
Plan ログ
初期: (on A B) (on-table C) (clear A) (clear C) (hand-empty)
目標: (on-table A) (on C B)
→ Plan 実行ボタンを押してください

試してみよう

「Plan 実行」を押すと、STRIPS が 4 ステップの plan を順次実行: ①A を B から取る → ②A を table に置く → ③C を table から取る → ④C を B の上に積む。各アクションには precondition / add / delete が定義されている。
「1 ステップ」ボタンで 1 アクションずつ進めると、各ステップで「なぜそれをしたか」が分かる。「A を直接 table に動かす」というショートカットはなく、必ず 持つ→置く の 2 ステップに分解される ―― これが symbolic AI の「世界を象徴で記述する」発想。
考えてみよう: もし初期状態が (on A B), (on B C), (on-table C) (A は B の上、B は C の上) だったら、STRIPS は何ステップで (on-table A) (on-table B) (on-table C) に到達する? 答え: 4 ステップ (unstack A, putdown A, unstack B, putdown B)。状態空間探索は組合せ爆発しやすいが、precondition を使って枝刈りすることで現実的な時間で解ける。

現代への橋

STRIPS が今も生きている →
2022 年以降の LLM エージェント (ReAct, Plan-and-Execute, AutoGPT) は、LLM が plan を「生成」する点で違うが、根本構造は同じ。「現在の状態 → アクション → 新しい状態」の繰り返しで目標達成する設計図は、Shakey ロボットの 1971 年から変わっていない ―― これが Bitter Lesson が「単純な敗北ではない」と言う理由。Symbolic AI の遺産は形を変えて、今も AI の中で生きている。

→ 巻末解説で Bitter Lesson の完全な意味を読む

3. 勾配降下法 — 学習率の影響

Arc 1 Scene 6「学びすぎる機械」関連

📐 数式

SGD (Stochastic Gradient Descent: 確率的勾配降下法):
$\underbrace{w}_{\text{重み}} \leftarrow w - \underbrace{\eta}_{\substack{\text{学習率}\\\text{(ステップ幅)}}} \cdot \underbrace{\dfrac{\partial L}{\partial w}}_{\substack{\text{勾配}\\\text{(方向と量)}}}$
最もシンプル。勾配方向にそのまま進む。振動しやすく、谷の形に弱い

Momentum (モメンタム: 慣性):
$v \leftarrow \underbrace{\beta}_{\substack{\text{慣性係数}\\\text{(通常0.9)}}} v + \dfrac{\partial L}{\partial w}, \quad w \leftarrow w - \eta \cdot v$
過去の勾配を「慣性」として蓄積。坂道を転がるボールのように加速 → 振動を抑え収束を高速化

AdaGrad (Adaptive Gradient: 適応的勾配):
$w \leftarrow w - \dfrac{\eta}{\sqrt{\underbrace{G}_{\substack{\text{過去の勾配の}\\\text{二乗和の蓄積}}}} + \varepsilon} \cdot \dfrac{\partial L}{\partial w}$
勾配が大きかったパラメータは学習率を下げる（自動調整）。問題: 学習が進むと学習率が0に → 学習停止

RMSProp (Root Mean Square Propagation):
AdaGrad の「学習率が0になる問題」を修正。過去の勾配を指数移動平均で管理 → 古い勾配の影響が減衰

Adam (Adaptive Moment Estimation: 適応的モーメント推定) ← 現在の標準:
$m \leftarrow \underbrace{\beta_1}_{\text{0.9}} m + (1-\beta_1) \dfrac{\partial L}{\partial w}$ ← 1次モーメント (= Momentum)
$v \leftarrow \underbrace{\beta_2}_{\text{0.999}} v + (1-\beta_2) \left(\dfrac{\partial L}{\partial w}\right)^2$ ← 2次モーメント (= RMSProp)
$w \leftarrow w - \eta \cdot \dfrac{\hat{m}}{\sqrt{\hat{v}} + \varepsilon}$
= Momentum (慣性で加速) + RMSProp (パラメータ別に学習率調整) の組合せ。ほぼ全ての場合でうまく動く

📊 グラフ — SGD vs Momentum vs Adam

💡 解説

SGD: 最もシンプル。勾配方向にそのまま進む
Momentum: 慣性で振動を抑え高速収束。SGD の弱点を改善
Adam: Momentum + RMSProp。ほぼ全ての場合で安定動作 ← 現在の標準
非凸関数では局所解・鞍点に捕まるリスクが残る（Adam でも完全解決ではない）
📌 進化の系譜: SGD (基本) → Momentum (慣性で加速) → AdaGrad (パラメータ別調整) → RMSProp (AdaGrad改良) → Adam (Momentum + RMSProp = 最強)

試してみよう: η=0.5: SGD は振動するが Adam は安定収束。η=1.0: SGD は発散するが Momentum/Adam は耐える。

💡 直感的に: SGD は「目隠しで坂道を一歩ずつ下る」。Momentum は「ボールを転がす（慣性で加速、谷を通り過ぎにくい）」。Adam は「賢いボール（パラメータごとに最適な速度で転がる）」。迷ったら Adam を使えばほぼ OK。

4. 過学習 vs 未学習

Arc 1 Scene 6「学びすぎる機械」関連

📐 数式

バイアス-バリアンストレードオフ:
$\text{誤差} = \underbrace{\text{Bias}^2}_{\substack{\text{偏り: モデルが}\\\text{単純すぎ→未学習}}} + \underbrace{\text{Variance}}_{\substack{\text{分散: データに}\\\text{過敏→過学習}}} + \underbrace{\sigma^2_{\text{noise}}}_{\substack{\text{ノイズ}\\\text{(削減不可)}}}$
次数を上げる → Bias↓ Variance↑ / 次数を下げる → Bias↑ Variance↓

📊 グラフ

💡 解説

次数1-3: 適切な複雑さ。真の関数に近い曲線（汎化）
次数10+: 学習データを全て通るが激しく振動（過学習）
対策: Early Stopping, Dropout, L1/L2正則化, Data Augmentation
次数1: 直線しか引けず真の関数を捉えられない（未学習/underfitting）

試してみよう: 次数1→3→10→15と上げて「ちょうどいい複雑さ」を見つけてみよう。

💡 直感的に: 「模試で100点だが本番で30点」= 過学習。モデルが学習データを丸暗記して未知データに通用しない。次数1=未学習（単純すぎ）、次数15=過学習（複雑すぎ）。ちょうどいい複雑さがある。

5. L1 vs L2 正則化

Arc 1 Scene 6「学びすぎる機械」関連
📌 L2正則化 = Ridge回帰 / L1正則化 = Lasso回帰 です。このページは両者の比較に焦点を当てています。 → 個別の詳細: Ridge (L2) の解析解・多重共線性 | Lasso (L1) の座標降下法・スパース化 | Elastic Net (L1+L2)

📐 数式

通常の損失: $L = \sum_i (y_i - \hat{y}_i)^2$

L1 正則化（Lasso）: $L' = L + \lambda \sum_i |w_i|$
→ 重みの絶対値にペナルティ → 不要な重みを完全に0にする（スパース化、特徴選択）

L2 正則化（Ridge）: $L' = L + \lambda \sum_i w_i^2$
→ 重みの二乗にペナルティ → 全重みを小さく保つ（滑らかな解）

$\lambda$ = 正則化強度。大きい → 過学習を防ぐが、大きすぎると未学習に

📊 グラフ

💡 解説

L1: 不要な特徴の重みを0に → 自動的な特徴選択。解釈しやすいモデルに
L2: 全重みを均等に小さく → 過学習防止の標準手法。NNではWeight Decay
L1: 最適解付近で不安定になりやすい（微分が不連続）
λの選択: Cross Validation で最適値を探す必要がある

注目: L1はw=0付近で尖っている（最小値がw=0寄り）、L2はなめらか（最小値がw=0にならない）。この形の違いがスパース性の差を生む。

💡 直感的に: L1 は「不要な特徴量を完全カット（V字の先端に引っかかる）」、L2 は「全体を均等に小さく（放物線で0にはならない）」。λが大きいほどペナルティが強い。

6. 混同行列 & Precision / Recall / F1

Arc 1 Scene 6「学びすぎる機械」関連

📐 数式

Precision（適合率）: $\text{Precision} = \dfrac{TP}{TP + FP}$
→ 「陽性と予測したもの」のうち本当に陽性の割合。誤検出を減らしたい時

Recall（再現率）: $\text{Recall} = \dfrac{TP}{TP + FN}$
→ 「実際に陽性のもの」のうち正しく検出できた割合。見逃しを減らしたい時

F1: $F_1 = \dfrac{2 \cdot \text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}}$
→ PとRの調和平均。バランスの良い指標

Accuracy: $\text{Accuracy} = \dfrac{TP + TN}{TP + FP + FN + TN}$
→ 不均衡データでは高くても無意味な場合あり（例: 99%が正常なら「全部正常」で99%）

📊 グラフ

💡 解説

医療: Recall重視（見逃し=命に関わる）。FN最小化
スパムフィルタ: Precision重視（正常メールを誤ってスパム判定=困る）。FP最小化
不均衡データ（定義: クラスごとのサンプル数に大きな偏りがあるデータ。例: 不正検知 0.1%/正常 99.9%、病気 1%/健常 99%）でAccuracy=99%でも、Recall=0%ということがある
F1は P と R が両方高い時だけ高くなる。どちらかが低いと大幅に下がる（調和平均の性質）

試してみよう: TP=0, TN=990 → Acc=99% だが Precision/Recall/F1 は全て 0%。「全部陰性」と予測するだけで 99% になる = Accuracy の罠。だから不均衡データでは F1 や AUC で評価する。→ ROC曲線/AUC

💡 直感的に: Accuracy 99% でも見逃し100% はありうる（不均衡データ）。医療なら Recall重視（見逃し厳禁）、スパム判定なら Precision重視（誤判定厳禁）。F1は両方のバランス。

7. CNN畳み込みフィルタ

Arc 2 Scene 1「機械が見た」関連

📐 数式

畳み込み演算:
$y(i,j) = \displaystyle\sum_m \sum_n \underbrace{x(i+m, j+n)}_{\substack{\text{入力画像の}\\\text{局所領域}}} \cdot \underbrace{K(m, n)}_{\substack{\text{フィルタ}\\\text{(学習対象)}}} + \underbrace{b}_{\text{バイアス}}$

$K$ = 3×3ならわずか9パラメータ。画像全体で同じ $K$ を共有 → パラメータ数が劇的に削減
→ 全結合の数億パラメータ vs CNNの数万パラメータ
→ フィルタを変えると検出するパターンが変わる（エッジ、ぼかし等）

📊 グラフ

💡 解説

パラメータ数を劇的に削減（重み共有）。画像のどこに特徴があっても検出可能（位置不変性）
浅い層→エッジ、中間→テクスチャ、深い層→物体全体と階層的に特徴を抽出
プーリングで位置情報が失われる。回転や拡大には弱い場合がある
フィルタサイズや層数の設計は試行錯誤が必要（ハイパーパラメータ）
💡 直感的に: 画像全体を見る代わりに「小さなフィルタを滑らせてパターンを探す」。フィルタは9個のパラメータだけで画像全体をスキャン（重み共有）。浅い層→エッジ、深い層→物体全体を階層的に認識。

📖 詳細解説

① 畳み込みの具体的な計算

5×5 の入力画像に 3×3 のフィルタ（水平エッジ）を適用 → 3×3 の出力:

入力 (5×5)フィルタ (3×3)出力 (3×3)
12013-1-1-10-24
01321×000=22-2
20102111-240
13210黄枠 = 現在の窓
01031↑ 出力の黄枠 = この計算結果
対応する位置を掛けて全部足す（出力の左上 = 0 の計算）:
1×(-1) + 2×(-1) + 0×(-1) + 0×0 + 1×0 + 3×0 + 2×1 + 0×1 + 1×1 = 0

次に窓を1マス右にずらして同じ計算 → さらに右 → 次の行... と全9位置をスキャンして出力 3×3 が完成。
② 各フィルタの効果（適用前 → 適用後）

水平エッジ [-1,-1,-1 / 0,0,0 / 1,1,1]:
上の行 = -1（暗くする）、下の行 = +1（明るくする）→ 上下の明るさが急変する場所だけが反応
均一な領域 → 0。上が明るく下が暗い → 正の値。逆 → 負の値

ぼかし [1/9 が9個]:
3×3 の全ピクセルの平均を取る → 細かいノイズが消えて滑らかに

シャープ [0,-1,0 / -1,5,-1 / 0,-1,0]:
中心を5倍に強調し周囲を引く → 周囲との差（=エッジ）が際立つ

★ 最も重要な点:
実際のCNNではフィルタの値は人間が設計するのではない。
誤差逆伝播で自動的に「画像を分類するのに最適なフィルタ」が学習される。
結果として、浅い層ではエッジ検出フィルタが、深い層では「猫の耳」「車のタイヤ」のような
高次パターンが勝手に獲得される。人間が設計するよりはるかに高性能。
③ プーリング (Max Pooling)

2×2 の領域で最大値だけを残す:

132146
4265→85
7813
2145
同じ色の2×2から最大値を取る → 4×4 が 2×2 に縮小

なぜ情報を捨てても大丈夫なのか？
CNNの目的は「画像を元に戻す（復元）」ではなく「何が写っているか（分類）」。
分類には「ここに猫の耳の特徴がある」ことが重要で、「耳が正確にピクセル(127,84)にある」ことは不要。
Max Pooling は「特徴の有無」を残し、「正確な位置」を捨てることで:
• 計算量とパラメータを削減（4倍速）
• 猫の耳が1-2ピクセルずれても同じ最大値 → 位置のズレに強くなる
• 過学習を防ぐ（細かい位置情報を覚えすぎない）
④ CNN は最終的に何を出力するか

CNN のゴールは「この画像が何であるか」を当てること（分類）。
層を重ねるごとに、低レベルな特徴（エッジ）から高レベルな特徴（物体全体）へと段階的に抽象化し、最後に各クラスの確率を出力する。

処理出力何をしている？
Conv + ReLU (浅い層)特徴マップエッジ（縦線、横線）を検出
Pooling縮小マップ位置を粗くして特徴の有無に集中
Conv + ReLU (中間層)特徴マップテクスチャ（毛並み、模様）を検出
Pooling縮小マップさらに粗く
Conv + ReLU (深い層)特徴マップ物体全体（猫の顔、車のシルエット）を認識
全結合層 (FC)スコア全特徴を統合して各クラスのスコアを計算
Softmax確率猫 0.92 / 犬 0.05 / 鳥 0.03

最もスコアが高いクラスが予測結果（この例では「猫」）。
⑤ Softmax とは

各クラスの「生スコア」(任意の実数) を確率 (0〜1、合計=1) に変換する関数:
$\text{softmax}(z_k) = \dfrac{e^{z_k}}{\sum_{j} e^{z_j}}$

ステップ猫犬鳥
生スコア $z$2.01.00.1
$e^z$7.392.721.11合計 = 11.22
確率0.660.240.10合計 = 1.00 ✓
• $e^z$ で正の値に変換 → 合計で割って正規化 → 確率に
• スコアの差が指数的に強調される（少しの差でも確率に大差がつく）
• 2クラス版 = Sigmoid（ロジスティック回帰） → ロジスティック回帰

8. ImageNet精度の進化

Arc 2 Scene 2「ImageNetの衝撃」関連

📐 数式

通常の層: $y = H(x)$
→ 層は「望ましい出力 $H(x)$ を直接学習」する。深くなるほど $H$ は複雑になり、勾配が伝わらず学習困難に

ResNet（残差学習）: $y = \underbrace{F(x)}_{\text{残差}} + \underbrace{x}_{\substack{\text{スキップ}\\\text{接続}}}$
ここで $F(x) = H(x) - x$（= 望ましい出力と入力の差 = 残差）

→ 層は「$H(x)$ そのもの」ではなく「$x$ にどれだけ 足せばよいか」を学ぶ
→ もし $F(x)=0$（何も学ばない）でも $y = x$ となり、恒等写像になる = 「最悪でも入力をそのまま通す」が保証される
→ 層を深くしても「浅い層と同等以上」が原理的に保証される → 152層が学習可能に

📊 グラフ（深さ vs 勾配・学習誤差）

👀 試してみよう: γ を 0.9 にすると Plain は L=100 で勾配が $10^{-5}$ オーダーまで消滅。一方 ResNet は 1 に近いまま 保たれる。
γ を 1.1 にすると Plain は 勾配爆発（指数的に発散）。ResNet はほとんど影響を受けない。
下のグラフは「劣化問題」のシミュレーション: Plain では深層化で訓練誤差が 逆に悪化 するが、ResNet は深くするほど良くなる。

💡 解説

2012 AlexNet: ReLU + GPU + Dropout で一夜にして10%改善。DL時代の幕開け
2015 ResNet: スキップ接続で152層を実現、人間(5.1%)を超えた(3.6%)
VGG: 3×3フィルタのみ → パラメータ削減 + 非線形性UP
通常層の深層化は「勾配消失」と「劣化問題」で頭打ち（〜20層が限界）
モデルが巨大化 → 計算資源の需要が急増（GPU依存）
💡 直感的に: 2012年のAlexNetが10%以上の精度改善で世界を変えた。ReLU+GPU+Dropoutの3点セット。ResNetは「層に全部覚えさせる」のではなく「入力からの差分だけ学ばせる」発想で、勾配消失と劣化を同時に解決 → 152層でも学習可能 → 人間超え。

📖 詳細解説

① 残差ブロックの実数値計算 — 入力ベクトルがどう流れるか

3次元の特徴ベクトルで考えよう。残差関数 $F(x) = W_2 \cdot \text{ReLU}(W_1 x)$（バイアスは省略）。
学習初期は重みが小さく初期化される（Xavier/He 初期化）ことを反映して:

入力: $x = \begin{bmatrix} 1.0 \\ 0.5 \\ -0.3 \end{bmatrix}$ $W_1$ = $\begin{bmatrix} 0.2 & 0.1 & 0.0 \\ -0.1 & 0.2 & 0.1 \\ 0.0 & -0.1 & 0.2 \end{bmatrix}$ $W_2$ = $\begin{bmatrix} 0.3 & 0.0 & 0.1 \\ 0.0 & 0.3 & 0.0 \\ 0.1 & 0.0 & 0.3 \end{bmatrix}$

Step 1: $W_1 x = \begin{bmatrix} 0.2(1.0)+0.1(0.5)+0.0(-0.3) \\ -0.1(1.0)+0.2(0.5)+0.1(-0.3) \\ 0.0(1.0)-0.1(0.5)+0.2(-0.3) \end{bmatrix} = \begin{bmatrix} 0.25 \\ -0.03 \\ -0.11 \end{bmatrix}$

Step 2: $\text{ReLU}(W_1 x) = \begin{bmatrix} 0.25 \\ 0 \\ 0 \end{bmatrix}$　← 負の要素は 0 に潰される

Step 3: $F(x) = W_2 \cdot \text{ReLU}(W_1 x) = \begin{bmatrix} 0.3(0.25) \\ 0 \\ 0.1(0.25) \end{bmatrix} = \begin{bmatrix} 0.075 \\ 0 \\ 0.025 \end{bmatrix}$

Step 4: 出力を比較

通常層 (Plain)残差ブロック (ResNet)
$y_{\text{plain}} = F(x) = \begin{bmatrix} 0.075 \\ 0 \\ 0.025 \end{bmatrix}$

入力 $x$ の情報が ほぼ消失
（特に第2,3要素） 		$y_{\text{res}} = F(x) + x = \begin{bmatrix} 1.075 \\ 0.5 \\ -0.275 \end{bmatrix}$

入力 $x$ がほぼ保持されつつ
小さな修正 $F(x)$ が加算される

★ 観察: 学習初期、ResNet はほぼ 恒等写像（$y \approx x$）として始動 → 「最悪でも何もしない層」が保証される。学習が進むにつれて $F(x)$ が意味のある修正を学ぶ。
② 勾配の伝播 — ヤコビアン行列で見る

逆伝播では「ヤコビアン行列 $\partial y / \partial x$」が次の層から渡された勾配に掛けられる。

残差ブロックのヤコビアン:
$\dfrac{\partial y_{\text{res}}}{\partial x} = \dfrac{\partial F(x)}{\partial x} + I$（単位行列）

ReLU の微分は活性化された要素のみ 1（先ほど第1要素のみ正だった）:
$\dfrac{\partial F}{\partial x} = W_2 \cdot \text{diag}(1, 0, 0) \cdot W_1 = \begin{bmatrix} 0.06 & 0.03 & 0 \\ 0 & 0 & 0 \\ 0.02 & 0.01 & 0 \end{bmatrix}$

通常層のヤコビアン残差ブロックのヤコビアン
$\dfrac{\partial y_{\text{plain}}}{\partial x} = \begin{bmatrix} 0.06 & 0.03 & 0 \\ \mathbf{0} & \mathbf{0} & \mathbf{0} \\ 0.02 & 0.01 & 0 \end{bmatrix}$

第2行が 完全にゼロ → 第2要素方向の勾配が 消滅 		$\dfrac{\partial y_{\text{res}}}{\partial x} = \begin{bmatrix} 1.06 & 0.03 & 0 \\ 0 & \mathbf{1} & 0 \\ 0.02 & 0.01 & \mathbf{1} \end{bmatrix}$

対角に +1 が乗る → 全方向の勾配が 必ず保持

L 層を重ねたときの全体勾配:
$\dfrac{\partial y_L}{\partial x_0} = \prod_{l=1}^{L} \left( \dfrac{\partial F_l}{\partial x_l} + I \right)$

→ 各因子が「単位行列 + 小さな摂動」なので、積を取っても $I$ から大きく外れない
通常層なら $0.9^{152} \approx 10^{-7}$ で勾配が完全に消えるが、ResNet では概ね $1.0$ オーダーを保つ

★ これが上のグラフで γ<1 でも ResNet 線が水平に近い理由: 残差項の貢献は小さくても、$+I$ がスキップ接続として勾配を「ハイウェイ」のように運ぶ。

9. YOLO — 物体検出（信頼度フィルタ + NMS）

Arc 2 Scene 3「どこに何がある？」関連

📐 数式

YOLO の予測: 画像を $S \times S$ グリッドに分割し、各セルが $B$ 個のバウンディングボックス と $C$ 個のクラス確率 を一度の順伝播で出力。

各ボックスの予測値: $(\underbrace{x, y}_{\substack{\text{中心}\\\text{座標}}}, \underbrace{w, h}_{\substack{\text{幅・}\\\text{高さ}}}, \underbrace{\text{conf}}_{\substack{\text{物体らしさ}\\\times \text{IoU}}})$

IoU (Intersection over Union):
$\text{IoU}(A, B) = \dfrac{|A \cap B|}{|A \cup B|} = \dfrac{\text{重なり面積}}{\text{和集合面積}}$
→ 2つのボックスがどれだけ重なっているかの指標（0=完全分離、1=完全一致）

NMS (Non-Maximum Suppression):
1. 同じクラスの予測ボックスを信頼度の降順にソート
2. 最も信頼度の高いボックスを「採用」リストに追加
3. 残りのボックスのうち、採用ボックスとの IoU が 閾値以上 のものを削除
4. 残りがある限り 2 を繰り返す
→ 同じ物体に対する重複検出を排除する

📊 グラフ（信頼度 + NMS の効果）

👀 試してみよう: 信頼度閾値を 0.05 にすると誤検出（False Positive）が増え、0.7 以上にすると見逃し（False Negative）が起きる。
NMS 閾値を 0.9 近くに上げると、重複検出が抑えられず同じ物体に複数のボックスが残る。0.1 まで下げると正常な検出も統合されすぎる。

💡 解説

2016 YOLO: 1回の順伝播で「位置 + サイズ + クラス」を同時予測 → リアルタイム検出（30+ FPS）
画像全体の文脈を見るため背景誤検出が少ない
エンドツーエンド学習。前処理・後処理が単純
グリッドサイズより小さい物体・密集した物体の検出が苦手
2段階手法（Faster R-CNN）に比べて精度はやや劣る場合がある
💡 直感的に: 写真を「マス目」に区切り、各マスが「ここに何がいる？どんな大きさ？」を 同時に 答える。重複ボックスは NMS で「最も自信のあるもの一つ」だけ残す。

📖 詳細解説

① IoU の具体計算 — 2つのボックスがどれだけ重なるか

ボックス A = (x=100, y=100, w=200, h=100) → 範囲 [100,300] × [100,200]
ボックス B = (x=200, y=130, w=200, h=100) → 範囲 [200,400] × [130,230]

重なり領域: $x \in [\max(100,200), \min(300,400)] = [200, 300]$、$y \in [\max(100,130), \min(200,230)] = [130, 200]$
$|A \cap B| = (300-200) \times (200-130) = 100 \times 70 = 7000$

各面積: $|A| = 200 \times 100 = 20000$, $|B| = 200 \times 100 = 20000$
和集合: $|A \cup B| = |A| + |B| - |A \cap B| = 20000 + 20000 - 7000 = 33000$

IoU = $7000 / 33000 \approx \mathbf{0.212}$ → 重なり弱め（NMS閾値 0.4 ならどちらも残る）
完全一致なら IoU=1、全く重ならないなら 0、半分重なれば約 0.33。物体検出の評価指標 mAP でも IoU≥0.5 を「正解」とする慣習がある（COCO は 0.5〜0.95 の平均）。
② NMS の具体例 — 5個の重複予測から1個に絞る

ある猫の周りに 5 個のボックスが予測された（信頼度: 0.92, 0.78, 0.55, 0.42, 0.31）。NMS 閾値 = 0.4。

ステップ処理残りの候補採用済み
初期信頼度降順ソート[0.92, 0.78, 0.55, 0.42, 0.31][]
1最高信頼度 0.92 を採用[0.78, 0.55, 0.42, 0.31][0.92]
20.92 との IoU が 0.4 以上のボックスを削除（全部該当）[][0.92]
終了候補なし → 終了—最終: 1個 (0.92)

→ クラスごとに独立して NMS を実行（猫と犬の重なりは無視）。NMS 閾値が高いほど多くのボックスが残り、低いほど厳しく統合される。
③ R-CNN 系との比較 — なぜ YOLO は速い？

手法アプローチ速度（推論）特徴
R-CNN (2014)2段階: ① Selective Search で領域提案 約2000個 → ② 各領域に CNN を独立適用約 47秒/画像最初の深層物体検出。CNN を 2000 回実行
Fast R-CNN (2015)2段階: 画像全体に CNN 1 回 → 領域に対応する特徴を抽出（RoI Pooling）約 2秒/画像CNN は 1 回だけ。だが領域提案 (Selective Search) が CPU 処理
Faster R-CNN (2015)2段階: 領域提案も NN化（RPN: Region Proposal Network）約 0.2秒/画像 (5 FPS)領域提案も学習可能に。精度が高く現在も使われる
YOLO (2016)1段階: 画像全体を 1 回の CNN で「位置 + クラス」を同時予測約 0.02秒/画像 (45+ FPS)領域提案が不要。リアルタイム検出が可能に
SSD (2016)1段階 + 複数スケール特徴マップを使用約 0.02秒/画像大小さまざまな物体に強い

★ 速度の本質的な違い: R-CNN系は「領域を提案 → 分類」の 2段階。YOLO は「位置・サイズ・クラスを 1回の順伝播で同時に 予測」。これにより冗長な計算が排除され、約100倍高速化。
→ G検定では「YOLO の高速性の理由」「R-CNN系の進化（提案手法のNN化）」がよく問われる

10. U-Net — セマンティックセグメンテーション

Arc 2 Scene 3「どこに何がある？」関連

📐 数式

U-Net の構造: エンコーダ（縮小）+ デコーダ（拡大）+ スキップ接続（同解像度の特徴を連結）

エンコーダブロック: $x_{l+1} = \text{MaxPool}(\text{Conv}_{3\times 3}(\text{ReLU}(\text{Conv}_{3\times 3}(x_l))))$
→ 解像度を半分に、チャンネル数を倍に

デコーダブロック: $y_{l-1} = \text{Conv}(\text{ReLU}(\text{Conv}(\underbrace{[\text{UpConv}(y_l) \mathbin{;} x_l]}_{\substack{\text{デコーダ出力と}\\\text{エンコーダ特徴を連結}}})))$
→ 解像度を倍に、チャンネル数を半分に。スキップ接続でエンコーダの $x_l$ を 連結（concat） する

最終出力: $\text{out} = \text{Conv}_{1 \times 1}(y_0)$ → 各ピクセルに $C$ クラスのロジット
$\hat{p}(c | i, j) = \text{softmax}(\text{out}(i,j))_c$
→ ピクセル $(i,j)$ がクラス $c$ である確率

📊 グラフ（スキップ接続の効果 — 1D信号でデモ）

👀 試してみよう: スキップ接続を OFF にすると、ボトルネック（深さ 4 なら 16 要素）からの逆推定だけになり、境界がなだらかなスロープになる。
深さを 5 に上げる と、ボトルネックが 8 要素まで縮むため、スキップなしでは情報がほぼ消失する。スキップありなら復元できる。

💡 解説

2015 U-Net: 医療画像セグメンテーション（細胞・腫瘍）の標準アーキテクチャ
スキップ接続でエンコーダの「どこ」情報をデコーダに直接届ける → 境界がシャープ
少ないデータで学習可能（オリジナル論文は 30 枚程度の訓練画像）
スキップ接続のメモリ消費が大きい（高解像度の特徴マップを保持）
クラス数が多いと出力チャンネルが膨らむ。3D 拡張版（3D U-Net）はさらに重い
💡 直感的に: 縮小（エンコーダ）で「何があるか」を抽象化、拡大（デコーダ）で「どこにあるか」を復元。スキップ接続は「縮小段階で失った位置情報を、拡大段階に直接渡すバイパス」 — ResNet のスキップ接続と同じ発想で 位置情報を救う。

📖 詳細解説

① 各層の解像度・チャンネル数（オリジナル U-Net、入力 572×572）

レベルエンコーダ出力デコーダ入力スキップ接続
0 (入力)572×572×64388×388×64→ concat
1284×284×128200×200×128→ concat
2140×140×256104×104×256→ concat
368×68×51256×56×512→ concat
4 (ボトルネック)32×32×1024 ← 最も抽象的な「何があるか」表現—

圧縮率の凄さ: 入力 572×572=327,184 ピクセル → ボトルネック 32×32=1,024 → 約 320 倍に圧縮
★ ここでスキップ接続がなければ: 1,024 個の数字から元の 327,184 ピクセル位置を復元するのは 原理的に不可能（情報量が足りない）。スキップ接続が「失われた情報を取り戻す」ハイウェイとして機能する。
② デコーダブロック内部 — concat と up-conv の数値例

レベル 3 のデコーダブロックで起きていること（チャンネル数を簡略化して 4ch で説明）:

Step 1: ボトルネック出力 $y_4$（解像度 1×1×8ch、簡略のため極小化）を Up-Conv 2×2 で 2×2×4ch に拡大:
$y_4 = \begin{bmatrix} 0.8 & 0.2 & 0.5 & 0.1 & 0.3 & 0.6 & 0.4 & 0.7 \end{bmatrix}$ → Up-Conv（学習可能）→ $\text{up}(y_4) = \begin{bmatrix} 0.7 & 0.4 \\ 0.5 & 0.6 \end{bmatrix}$ × 4ch

Step 2: スキップ接続で同解像度 (2×2×4ch) のエンコーダ特徴 $x_3$ を取得:
$x_3 = \begin{bmatrix} 0.9 & 0.1 \\ 0.2 & 0.8 \end{bmatrix}$ × 4ch（ シャープな境界情報 を保持）

Step 3: チャンネル方向に 連結 (concat) → 2×2×8ch:
$[\text{up}(y_4) \mathbin{;} x_3] = \begin{bmatrix} (0.7, 0.9) & (0.4, 0.1) \\ (0.5, 0.2) & (0.6, 0.8) \end{bmatrix}$（各セル 8ch、前半=デコーダ、後半=スキップ）

Step 4: Conv 3×3 で 8ch → 4ch に圧縮しながら、両者の情報を 融合学習:
出力 $y_3$ は「デコーダの抽象情報 + スキップの精細位置情報」の最適混合
→ Conv が「いつスキップ情報を信じるか / いつデコーダを信じるか」を学習する。これが U-Net の柔軟性の源
③ FCN との比較 — なぜ U-Net が標準になった？

手法構造境界精度特徴
FCN (2015)エンコーダのみ + 単純 Upsampling（Conv の deconv 1〜3段）中（FCN-8s で粗いスキップあり）「全結合層を Conv に置き換えた」初のセグメンテーション NN。任意サイズの入力 OK
U-Net (2015)対称な U字 エンコーダ・デコーダ + 全レベルでスキップ接続高（境界がシャープ）医療画像で標準。少ないデータでも高精度
SegNet (2017)エンコーダ・デコーダ + Pooling Indices で位置を記憶中〜高メモリ効率が良い（特徴マップでなく Index のみ保持）
DeepLab 系Atrous（拡張）Conv で受容野を広げる高エンコーダ・デコーダなし。CRF で後処理

★ U-Net の核心: FCN は粗いスキップ（最終層付近のみ）だったが、U-Net は 全エンコーダ層からデコーダへスキップ。これにより「浅い層のエッジ情報」「中間層のテクスチャ」「深い層の意味」が 各解像度で適切に融合 される。
→ G検定では「U-Net がスキップ接続でなぜ境界をシャープにできるか」「FCN と U-Net の違い」が問われる

11. RNN vs LSTM — 勾配伝達

Arc 2 Scene 4-5「RNN/LSTM」関連

📐 数式

RNN (Recurrent Neural Network — 再帰型ニューラルネットワーク):
$h_t = \tanh(\underbrace{W_h \cdot h_{t-1}}_{\substack{\text{前の時刻の}\\\text{メモリ}}} + \underbrace{W_x \cdot x_t}_{\substack{\text{今の}\\\text{入力}}} + b)$

逆伝播での勾配: $\dfrac{\partial h_t}{\partial h_{t-1}} = \underbrace{\text{diag}(1 - h_t^2)}_{\substack{\text{tanhの微分}\\\text{(0〜1)}}} \cdot \underbrace{W_h}_{\substack{\text{隠れ層の}\\\text{重み行列}}}$
$T$ ステップ先の勾配: $\dfrac{\partial h_T}{\partial h_0} = \prod_{t=1}^{T} (1 - h_t^2) \cdot W_h$　← $\gamma = |(1-h^2) \cdot w_h|$ が毎ステップ掛けられる
→ $\gamma < 1$（典型値 0.2〜0.6）なので、$\gamma^{20} \approx 10^{-3}\!\sim\!10^{-14}$ → 勾配消失

LSTM (Long Short-Term Memory — 長・短期記憶)　※ 4 つのゲート + セル状態:

Step 1: $f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$　←「忘却ゲート」前の記憶をどれだけ残すか（0〜1）
Step 2: $i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i)$　←「入力ゲート」新情報をどれだけ書き込むか（0〜1）
Step 3: $\tilde{C}_t = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C)$　←「候補」新しい記憶の中身（-1〜+1）
Step 4: $\boxed{C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t}$　←「セル状態」= 長期記憶の本体
Step 5: $o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$　←「出力ゲート」セル状態のうち何を出力するか
Step 6: $h_t = o_t \odot \tanh(C_t)$　←「隠れ状態」= 次の時刻 + 出力層への入力

セル状態の勾配: $\dfrac{\partial C_t}{\partial C_{t-1}} = f_t$　← 忘却ゲートの値がそのまま勾配になる
→ $f_t \approx 1$ なら勾配 $\approx 1$。$T$ ステップでも $\prod f_t \approx 0.95^{20} = 0.36$（RNN の $10^{-14}$ と雲泥の差）

📊 グラフ

👀 試してみよう: RNN の γ を 0.5 にすると 20 ステップで勾配 $10^{-6}$（完全消失）。LSTM の $f_t$ を 0.95 にしても 20 ステップで 0.36 — 36% の勾配が残る。

💡 解説

RNN: tanh微分(0〜1) × W_h の積が毎ステップ掛けられ、20ステップで勾配が事実上ゼロに
LSTM: セル状態 $C$ が「勾配のハイウェイ」。忘却ゲート $f_t \approx 1$ で勾配を直通バイパス
GRU (Gated Recurrent Unit): LSTMの簡略版（2ゲート: リセット+更新）。同等性能で軽量
2017年以降、Transformerが並列処理可能な代替として台頭
💡 直感的に: RNNは「メモを取りながら読む」機械だが、長い文だとメモが薄れる（勾配消失）。LSTMは「忘却/入力/出力」の3つのゲートで「何を覚え何を忘れるか」を自動学習する。セル状態 $C$ はResNet のスキップ接続と同じ発想 — 情報を「ハイウェイ」で次の時刻に直通させる。

📖 詳細解説

① RNN の数値追跡 — 「猫が走る」の3ステップ

スカラー（1次元）の隠れ状態で簡略化。重み: $w_h = 0.8$, $w_x = 1.0$, $b = 0$
入力: $x_1 = 0.5$（猫）, $x_2 = 0.2$（が）, $x_3 = 0.9$（走る）, $h_0 = 0$

t入力 $x_t$$w_h \cdot h_{t-1} + w_x \cdot x_t$$h_t = \tanh(\cdot)$$1-h_t^2$（tanh微分）
1 (猫)0.50.8·0 + 1.0·0.5 = 0.5000.4620.787
2 (が)0.20.8·0.462 + 1.0·0.2 = 0.5700.5150.735
3 (走る)0.90.8·0.515 + 1.0·0.9 = 1.3120.8630.255

勾配の計算（$h_3$ の誤差を $h_1$ まで逆伝播）:
$\dfrac{\partial h_t}{\partial h_{t-1}} = (1-h_t^2) \cdot w_h$ ← これが各ステップの「勾配の掛け率」

$\dfrac{\partial h_3}{\partial h_2} = 0.255 \times 0.8 = 0.204$
$\dfrac{\partial h_2}{\partial h_1} = 0.735 \times 0.8 = 0.588$

$\dfrac{\partial h_3}{\partial h_1} = 0.204 \times 0.588 = \mathbf{0.120}$ ← たった2ステップで勾配が 12% に

→ 20ステップなら？ 平均 γ ≈ 0.4 として $0.4^{20} \approx 10^{-8}$。「猫」の情報は「走る」の学習に全く貢献できない。
② LSTM の数値追跡 — 同じ「猫が走る」でゲートの動きを見る

スカラー（1次元）セル状態で簡略化。$C_0 = 0, h_0 = 0$。
ゲートの値は「LSTMが学習した結果として出力する値」として仮定:

t入力$f_t$
(忘却)		$i_t$
(入力)		$\tilde{C}_t$
(候補)		$C_t = f_t C_{t-1} + i_t \tilde{C}_t$
(セル状態)		$o_t$
(出力)		$h_t = o_t \cdot \tanh(C_t)$
1 (猫)0.50.10
前の記憶なし
→忘却不要		0.90
重要語!
→ゲート開		0.80
「猫」の
特徴量		0.72
0.1·0+0.9·0.8
= 0.72		0.700.433
0.7·tanh(0.72)
2 (が)0.20.95
助詞→
記憶保持!		0.10
機能語
→ゲート閉		0.300.714
0.95·0.72+0.1·0.3
= 0.714		0.300.184
0.3·tanh(0.714)
3 (走る)0.90.90
猫の記憶
→保持		0.85
重要語!
→ゲート開		0.70
「走る」の
特徴量		1.238
0.9·0.714+0.85·0.7
= 1.238		0.800.677
0.8·tanh(1.238)

★ セル状態 C の動き: 0 → 0.72 → 0.714 → 1.238
「猫」の情報（0.72）が「が」を通過しても 0.714 にほぼ保持され（$f_2 = 0.95$）、
「走る」でさらに追加情報が上乗せされている。

★ ゲートの役割をまとめると:
🔴 忘却ゲート $f_t$: 「この単語が来たら、前の記憶をどれだけ残す？」
🟢 入力ゲート $i_t$: 「この単語の情報をどれだけ書き込む？」
🔵 出力ゲート $o_t$: 「セル状態のうち、今どれだけ外に出す？」
→ 4つとも sigmoid（0〜1）で、「開閉の度合い」を学習する。ゲートの重み $W_f, W_i, W_o$ が学習パラメータ。
③ 勾配の比較 — なぜ LSTM は消失しないのか

セル状態 $C_t = f_t \cdot C_{t-1} + \ldots$ の勾配は:
$\dfrac{\partial C_t}{\partial C_{t-1}} = f_t$ ← 忘却ゲートの値がそのまま勾配になる（単純！）

$T$ ステップ先: $\dfrac{\partial C_T}{\partial C_0} = \prod_{t=1}^{T} f_t$

ステップRNN 勾配 ($\gamma \approx 0.4$)LSTM 勾配 ($f \approx 0.95$)
2ステップ前$0.4^2 = 0.160$$0.95^2 = 0.903$
5ステップ前$0.4^5 = 0.010$$0.95^5 = 0.774$
10ステップ前$0.4^{10} = 1.0 \times 10^{-4}$$0.95^{10} = 0.599$
20ステップ前$0.4^{20} = 1.1 \times 10^{-8}$$0.95^{20} = 0.358$
100ステップ前$\approx 10^{-40}$（完全消滅）$0.95^{100} = 0.006$（まだ残る）

★ なぜこの差が生まれるか:
• RNN: 勾配が「tanh微分（0〜1）× $W_h$」を毎ステップ通る → 2つの縮小要因が 掛け算 で蓄積
• LSTM: セル状態の勾配は「忘却ゲート $f_t$」一つだけを通る → 残りの経路は バイパス

→ これは ResNet のスキップ接続（$\partial y/\partial x = \partial F/\partial x + I$ の $+I$）と本質的に同じ構造。セル状態 $C$ が「勾配のハイウェイ」として機能する。

12. Self-Attention ヒートマップ

Arc 2 Scene 6-7「Attention/Transformer」関連

📐 数式

$\text{Attention}(Q, K, V) = \underbrace{\text{softmax}\!\left(\dfrac{Q K^\top}{\sqrt{d_k}}\right)}_{\substack{\text{注意の重み } \alpha\\\text{(どこを見るか)}}} \cdot \underbrace{V}_{\substack{\text{参照先の情報}\\\text{(何を取り出すか)}}}$

翻訳（Encoder-Decoder Attention）での役割:
$Q$ (Query): デコーダ側 — 「今 "猫が" を出力中。原文のどこを見ればいい？」
$K$ (Key): エンコーダ側 — 各入力単語の「見出し」。Q との相性で注意の重みが決まる
$V$ (Value): エンコーダ側 — 各入力単語の「中身（意味ベクトル）」。重み付き平均で取り出される

$\alpha = \text{softmax}(Q \cdot K^\top / \sqrt{d_k})$ ← 「どこを見るか」の重み（合計=1）
$\text{context} = \alpha \cdot V = \sum_i \alpha_i \cdot v_i$ ← 「重み付きで情報を取り出す」= コンテキストベクトル
→ Q が変わるたびに $\alpha$ が変わり、$V$ から取り出す情報が動的に変化。これが Attention の核心

📊 グラフ（翻訳 "I love cats very much" → "私は猫が大好きです"）

👀 試してみよう: Query を切り替えると、左のグラフ（Attention）の注意の重みが 劇的に変化 する — 「猫が」なら "cats" に集中、「好き」なら "love"+"much" に分散。
右のグラフ（固定長 C）は どの出力でも同じ — RNN の最終状態に偏った固定ベクトルしか使えない。

💡 解説

固定長ボトルネックを解消。出力の各ステップで入力全体を動的に参照
RNNの逐次処理→並列行列演算。GPUの性能をフル活用
Multi-Head: 複数の「視点」で同時に注目（文法/意味/位置関係）
計算量はO(n²)（系列長の二乗）。長い系列では効率が課題
💡 直感的に: 翻訳で「猫が」を出力するとき、原文の "cats" に目を戻す。「好き」を出力するときは "love" と "much" に目を移す。毎回「今必要な情報」を動的に取りに行く。固定長 C では文全体を1つのベクトルに詰め込むため、長い文ほど情報が失われる。

📖 詳細解説

① Q·K·V の具体計算 — 「猫が」を出力する瞬間

デコーダが「猫が」を出力しようとしている。エンコーダは "I love cats very much" を処理済み。

Step 1: Q·K^T で相性スコアを計算
$Q_{\text{猫が}}$ = デコーダの現在の隠れ状態（「猫が」に対応するベクトル）
$K_i$ = 各入力単語のキーベクトル

入力単語$Q \cdot K_i$
(相性スコア)		$\alpha_i = \text{softmax}$
(注意の重み)		$V_i$
(意味ベクトル)		$\alpha_i \times V_i$
(重みづけ)
I1.20.05[0.8, 0.1][0.04, 0.01]
love1.50.05[0.2, 0.9][0.01, 0.05]
cats5.80.80[0.7, 0.3][0.56, 0.24]
very1.30.05[0.1, 0.6][0.01, 0.03]
much1.40.05[0.3, 0.7][0.02, 0.04]

Step 2: コンテキストベクトル = $\sum \alpha_i V_i$ = [0.64, 0.37] ← 「cats」の情報 [0.7, 0.3] に非常に近い

★ V（Value）の役割: $\alpha$ が「どこを見るか（重み）」を決め、$V$ が「実際に取り出す情報」。最終的にデコーダに渡されるのは $\alpha$ で重みづけした $V$ の加重平均。
② 固定長 C（LSTM Encoder-Decoder）との比較

固定長 C（LSTM Seq2Seq）Attention
コンテキストエンコーダの最終隠れ状態 $h_T$ 1つだけ出力ごとに $\alpha$ を再計算 → 動的なコンテキスト
「猫が」出力時"much" 付近の情報が支配的。
"I" は 5 ステップ前 → 薄れている		"cats" に α=0.80 で集中。
「猫が」にぴったりの情報を取得
「好き」出力時同じ $h_T$ を使うしかない。
"love" の情報は薄い		"love" に α=0.50, "much" に α=0.30。
感情に関連する情報を集中取得
長文（50語）50語を1ベクトルに詰め込む → 情報が失われる
（RNN の勾配消失と同じ問題）		全 50 語に直接アクセス可能
（文長に関係なく必要な箇所を参照）

★ 要するに: 固定長 C は「5語の文を1つの数字に要約して、そこから全てを翻訳」。Attention は「毎回原文を見返して、今必要な箇所を読み直す」。長い文ほど差が歴然。
③ Self-Attention vs Cross-Attention（Encoder-Decoder Attention）

Cross-Attention（上の翻訳の例）:
Q = デコーダ（出力側）, K = V = エンコーダ（入力側）
→ 「出力するとき、入力のどこを参照するか」

Self-Attention（エンコーダ内部 / デコーダ内部）:
Q = K = V = 同じ系列の各単語
→ 「文中の単語どうしが、互いにどう関係しているか」を学ぶ

例: "The cat sat on the mat" の Self-Attention で "mat" の $Q$ を見ると:
"sat"（座った場所として関連）と "the"（冠詞として関連）に高い $\alpha$
→ 文の構造理解に使われる

→ Transformer では 両方 を使う: エンコーダ内で Self-Attention → デコーダ内で Self-Attention → Cross-Attention でエンコーダの情報を参照

13. Transformer — 全体構造（Encoder-Decoder）

Arc 2 Scene 7「Attention Is All You Need」関連

📐 数式

Transformer ブロック = 以下の 4 つの部品を積み重ねたもの:

① Multi-Head Self-Attention:
$\text{MultiHead}(Q,K,V) = \text{Concat}(\text{head}_1, \ldots, \text{head}_h) W^O$
各ヘッド: $\text{head}_i = \text{Attention}(Q W_i^Q, K W_i^K, V W_i^V)$
→ 複数の「視点」で同時に注目（文法/意味/位置関係 etc.）

② Add & Norm（残差接続 + Layer Normalization）:
$\text{output} = \text{LayerNorm}(x + \text{SubLayer}(x))$
→ ResNet と同じスキップ接続。勾配消失を防ぎ、深層化を可能に

③ Feed-Forward Network（位置ごとの全結合層）:
$\text{FFN}(x) = \text{ReLU}(x W_1 + b_1) W_2 + b_2$
→ 各トークンに独立に適用。非線形変換で表現力を追加

④ Positional Encoding（位置情報の付与）:
$PE_{(pos, 2i)} = \sin(pos / 10000^{2i/d})$, $PE_{(pos, 2i+1)} = \cos(pos / 10000^{2i/d})$
→ Transformer は順序を知らない（RNN と違い）。sin/cos で「何番目の単語か」を教える

📊 グラフ（データの流れを追跡）

👀 試してみよう: 3 つのモードを切り替えて、Encoder（BERT型）、Decoder（GPT型）、Encoder-Decoder（翻訳型）の構造の違いを比較。Decoder の Causal Mask と Cross-Attention がポイント。

💡 解説

2017年 "Attention Is All You Need" — RNN を完全に置き換え。並列処理で GPU 効率が劇的に向上
1つのアーキテクチャから BERT（理解）、GPT（生成）、ViT（画像）が派生 → AI の統一基盤
残差接続 + Layer Norm で深層化が容易（BERT-large: 24層、GPT-3: 96層）
Self-Attention は O(n²)。長い系列では計算量が爆発（→ Sparse Attention 等で対処）
💡 直感的に: Transformer = 「Self-Attention（全単語を同時に見る目）+ FFN（各単語を深く考える脳）+ 残差接続（情報のハイウェイ）+ Positional Encoding（順序の記憶）」の4点セット。この組み合わせが、2017年以降の AI 革命の共通基盤になった。

📖 詳細解説

① Transformer の 4 つの部品

部品役割直感既出ページ
Multi-Head
Self-Attention		全単語ペア間の関係を計算
$\text{softmax}(QK^T/\sqrt{d_k})V$		「全員が全員を見る会議室」
各ヘッドが別の議題を担当		12. Self-Attention
Add & Norm
(残差接続)		入力 $x$ をスキップ接続で加算
+ Layer Normalization		ResNet と同じ発想
「最低でも入力を保持」		8. ResNet
Feed-Forward
Network		各トークンに独立に 2 層 MLP
$\text{ReLU}(xW_1+b_1)W_2+b_2$		Attention が「関係」を見て、
FFN が「意味」を深く処理		MLP 順伝播
Positional
Encoding		sin/cos で位置情報を付与
（RNN のような順序感覚がないため）		「座席番号」を配る
なければ全員同じ席		—（本ページ）

★ 「Attention Is All You Need」の意味: RNN・CNN を使わず、Attention（+ FFN + 残差）だけ で最高精度を達成した。「Attention が全て」＝他の部品は汎用的な MLP と正規化だけ。
② Encoder vs Decoder vs Encoder-Decoder の使い分け

構成代表モデルSelf-Attention用途
Encoder onlyBERT, RoBERTa双方向（全単語を同時参照）分類・固有表現認識・感情分析・質問応答
Decoder onlyGPT, Claude, LLaMA単方向（Causal Mask で右を隠す）文章生成・対話・コード生成
Encoder-Decoder原論文, T5, BARTEnc=双方向, Dec=単方向
+ Cross-Attention		翻訳・要約・テキスト変換

Masked Self-Attention（Causal Mask）とは？
通常の Self-Attention は全単語を参照するが、Decoder では「未来の単語」が見えてはならない（生成時には存在しないから）。
→ Attention スコア行列の右上三角を $-\infty$ にマスクし、softmax 後に 0 にする:

私は猫が好き
私は0.8−∞→0−∞→0
猫が0.30.7−∞→0
好き0.20.50.3

→ 緑 = 参照可能、赤 = マスクされ参照不可。「好き」は「私は」と「猫が」を見られるが、「私は」は自分だけしか見られない。
③ なぜ Positional Encoding が必要か？

RNN: $h_t = f(h_{t-1}, x_t)$ → 順番に処理するので、「$x_t$ は $t$ 番目」が構造的に保証される
Transformer: 全単語を 同時に 行列演算 → 入力の順番を知る手段がない

実験: "猫が好き" と "好きが猫" を Positional Encoding なしで入れると:
→ Self-Attention は 全く同じ出力 を返す（入力の順序に関する情報がゼロ）

sin/cos エンコーディングの利点:
• 任意の長さの系列に対応（学習不要）
• 相対位置の情報を内積で取り出せる（$PE_{pos+k}$ と $PE_{pos}$ の関係が $k$ だけで決まる）
→ G検定では「Transformer に位置情報を与える方法」「RNN と違い順序を知らない」がよく問われる

14. BERT vs GPT — Transformer の2つの使い方

Arc 2 Scene 8「言葉の地図」/ Arc 3 Scene 3「GPTの誕生」関連

📐 数式

BERT (Bidirectional Encoder Representations from Transformers):
事前学習: MLM (Masked Language Model) — ランダムに 15% の単語を [MASK] にして予測
$P(w_i | w_1, \ldots, w_{i-1}, \text{[MASK]}, w_{i+1}, \ldots, w_n)$ ← 双方向（前後の文脈を両方使う）
構造: Transformer Encoder のみ（Self-Attention で全単語を同時に参照）

GPT (Generative Pre-trained Transformer):
事前学習: 次の単語予測 — 左から右へ順に次の単語を予測
$P(w_t | w_1, \ldots, w_{t-1})$ ← 単方向（右のコンテキストは見えない = Causal Mask）
構造: Transformer Decoder のみ（Masked Self-Attention で未来の単語をマスク）

→ BERT = 理解 に特化（分類・固有表現認識・質問応答）。文全体を見て判断
→ GPT = 生成 に特化（文章生成・対話・コード生成）。左→右に逐次出力
→ 同じ Transformer だが「Encoder だけ使う」か「Decoder だけ使う」かの違い

📊 グラフ（MLM vs 自己回帰の体験）

👀 試してみよう: BERT モードで位置を変えると、前後の文脈が使えるため高精度で正解を予測する。GPT モードに切り替えると、同じ位置でも 右のコンテキストが見えないため不確実性が上がる。

💡 解説

BERT (2018): 事前学習+ファインチューニングで NLP の大半のタスクで SOTA を達成
GPT-3 (2020): 1750億パラメータ。Few-shot / In-Context Learning でファインチューニング不要に
転移学習: 大量テキストで事前学習 → 少量データでファインチューニング → 新タスクに適応
巨大化: GPT-4 は 1兆超パラメータ。訓練に数千万ドル規模のコスト
💡 直感的に: BERT は「穴埋めテスト（前後を見て答える）」の天才 → 理解向き。GPT は「続きを書く」の天才 → 生成向き。同じ Transformer の Encoder/Decoder を別々に使うだけで、能力の方向性がまるで変わる。

📖 詳細解説

① BERT vs GPT 構造比較

BERTGPT
正式名称Bidirectional Encoder Representations from TransformersGenerative Pre-trained Transformer
構造Transformer Encoder のみTransformer Decoder のみ
文脈の方向双方向（前後を同時に参照）単方向（左→右のみ）
事前学習MLM (15%マスク予測) + NSP (次文予測)次の単語予測（自己回帰）
適応方法ファインチューニング（重み更新）In-Context Learning（プロンプトだけ）
得意タスク分類、固有表現認識、感情分析、質問応答文章生成、対話、コード生成、翻訳
規模BERT-base: 1.1億 / BERT-large: 3.4億GPT-3: 1750億 / GPT-4: 1兆超

★ 同じ Transformer でも: Encoder は「全体を見渡して理解」、Decoder は「左から順に生成」。目的が違うから構造が違う。
② スケーリング法則 — 大きくすれば賢くなる

$L(N) \propto N^{-\alpha}$　（$N$ = パラメータ数、$L$ = 損失、$\alpha \approx 0.076$）

モデルパラメータ数年特筆能力
GPT-11.17億2018転移学習が有効であることを実証
GPT-215億2019Zero-shot で文章生成（「危険すぎる」と公開制限）
GPT-31750億2020Few-shot / In-Context Learning が創発
GPT-41兆超（推定）2023マルチモーダル（画像+テキスト）

RLHF (Reinforcement Learning from Human Feedback):
① GPT を事前学習 → ② 人間が「良い回答」を評価 → ③ 報酬モデルを学習 → ④ PPO で GPT を最適化
→ ChatGPT (2022) = GPT-3.5 + RLHF
→ G検定では「スケーリング法則」「創発的能力」「RLHF」がよく問われる

15. Vision Transformer (ViT) — 画像をトークン化する

Arc 3 Scene 5「見て聞いて考える」関連

📐 数式

ViT のアイデア: 画像を $P \times P$ のパッチに分割し、各パッチを「トークン」として Transformer に入力

Step 1: 画像 ($H \times W$) を $P \times P$ パッチに分割 → $N = \dfrac{H \times W}{P^2}$ 個のパッチ
Step 2: 各パッチを線形射影でベクトル化 → トークン埋め込み
Step 3: [CLS] トークンを先頭に追加 + Positional Encoding
Step 4: Transformer Encoder で Self-Attention
Step 5: [CLS] トークンの出力で分類

→ NLP の Transformer が「単語をトークンとして処理」するように、ViT は「画像パッチをトークンとして処理」
→ CNN のような局所的な帰納バイアスを持たない → 大量データが必要だが、データがあれば CNN を超える

📊 グラフ（パッチ分割の可視化）

👀 試してみよう: パッチサイズを 2×2 にすると 64 トークン → Self-Attention の計算量が増えるが精度は上がる。8×8 にすると 4 トークン → 軽いが粗い。ViT-Base は 16×16 パッチ（224×224 画像で 196 トークン）。

💡 解説

2020 ViT: ImageNet で CNN (EfficientNet) を超える精度 → 画像も Transformer の時代へ
統一アーキテクチャ: テキストも画像も同じ Transformer → マルチモーダル (CLIP/GPT-4V) の基盤
局所的な帰納バイアスがないため、小規模データでは CNN に劣る
Self-Attention は O(n²) → パッチ数が増えると計算量が急増
💡 直感的に: 画像を「パズルのピース」に切り分けて、各ピースが他の全ピースとの関係を Transformer で学ぶ。CNN が「近くから徐々に遠くへ」見るのに対し、ViT は「最初から全体を見渡す」。

📖 詳細解説

① CNN vs ViT 構造比較

CNN (ResNet等)ViT
入力処理ピクセル単位で畳み込み（3×3 フィルタ）パッチ(16×16)に分割 → 線形射影でベクトル化
特徴抽出局所→大域（浅い層=エッジ、深い層=物体）最初から全パッチ間で Self-Attention（大域的）
帰納バイアス局所性 + 平行移動不変性（少データでも動く）ほぼなし（大量データが必要）
データ量ImageNet (100万枚) で十分JFT-300M (3億枚) 等で事前学習が必要
スケーラビリティ深くしても性能向上に限界データ・モデル規模に比例して精度向上

★ なぜ ViT が重要か: テキスト(GPT/BERT)も画像(ViT)も同じ Transformer で扱えるようになった → CLIP（テキスト+画像）や GPT-4V（マルチモーダル）の基盤技術。「1つのアーキテクチャで全モダリティ」という統一が実現。

16. GAN — Generator vs Discriminator

Arc 3 Scene 1「偽物を見抜け」関連

📐 数式

$\underbrace{\min_G \max_D}_{\substack{\text{Gは最小化}\\\text{Dは最大化}}} V = \underbrace{\mathbb{E}_{x}[\log D(x)]}_{\substack{\text{本物を「本物」と}\\\text{判定する確率 (D↑)}}} + \underbrace{\mathbb{E}_{z}[\log(1 - D(G(z)))]}_{\substack{\text{偽物を「偽物」と}\\\text{判定する確率 (D↑, G↓)}}}$

$D(x)$: Discriminator が入力 $x$ を「本物」と判定する確率（0〜1）
$G(z)$: Generator がノイズ $z$ から生成した偽画像
ナッシュ均衡: $D(G(z)) = 0.5$（本物と偽物を区別できない = G の勝利）

📊 グラフ（学習ダイナミクスのシミュレーション）

👀 試してみよう: 4 つのシナリオを切り替えて、GAN 学習の「成功」と「失敗パターン」を比較。モード崩壊では品質は上がるのに多様性（紫線）が崩壊する様子が見える。

💡 解説

教師信号なしで高品質画像生成を実現（2014年〜）
モード崩壊: Gが1パターンだけ生成してDを騙す → 多様性喪失
応用: 超解像、スタイル変換、データ拡張、StyleGAN（実在しない顔）
学習不安定。G/Dのバランス調整が難しい → 2020年代に拡散モデルが台頭
💡 直感的に: 贋作師（Generator）と鑑定士（Discriminator）が切磋琢磨。均衡状態では鑑定士がコイン投げ（D=0.5）= 本物と偽物を区別できない品質に到達。
💡 GAN の革新: GAN 以前は「分類・予測」だけで「新しい画像を作る」ことは不可能だった。G は D のフィードバックを通じて「作り方」を重みに一般化して蓄積する。学習後はデータ不要 — ノイズ $z$ を変えるだけで学習データにない新画像を生成できる。「生成できる NN = G」の誕生が、全ての生成 AI の出発点。

📖 詳細解説

① G と D の正体 — 中身は CNN

Generator（G）= CNN の逆（アップサンプリング）
入力: ランダムなノイズ $z$（例: 100 次元の乱数ベクトル）
出力: 画像（例: 64×64×3 の RGB）

層処理サイズ変化直感
入力ノイズ $z$100ランダムな「種」
全結合FC + Reshape100 → 4×4×512「種」を立体に展開
転置Conv 1TransposeConv + BN + ReLU4×4×512 → 8×8×256解像度 2 倍に拡大
転置Conv 2TransposeConv + BN + ReLU8×8×256 → 16×16×128さらに 2 倍
転置Conv 3TransposeConv + BN + ReLU16×16×128 → 32×32×64さらに 2 倍
転置Conv 4TransposeConv + tanh32×32×64 → 64×64×3RGB 画像が完成!

Discriminator（D）= 普通の CNN 分類器
入力: 画像（64×64×3）— 本物 or G の生成物
出力: sigmoid → 0〜1（本物である確率）

層処理サイズ変化直感
入力画像64×64×3本物 or 偽物
Conv 1Conv + LeakyReLU64×64×3 → 32×32×64エッジ検出（CNN と同じ）
Conv 2Conv + BN + LeakyReLU32×32×64 → 16×16×128テクスチャ認識
Conv 3Conv + BN + LeakyReLU16×16×128 → 8×8×256構造認識
Conv 4Conv + BN + LeakyReLU8×8×256 → 4×4×512全体像の把握
全結合+sigmoidFC → sigmoid4×4×512 → 10〜1（本物確率）

★ 要するに:
• G = CNN の逆: 通常 CNN は「画像 → 特徴」に圧縮。G は「特徴 → 画像」に拡大（転置畳み込み）
• D = 普通の CNN: 7. CNN 畳み込みフィルタと同じ構造。出力が「猫/犬」ではなく「本物/偽物」の 2 値分類
② 転置畳み込み — G はどうやって画像を「拡大」するのか

通常の畳み込みが「5×5 → 3×3」に縮小するのに対し、転置畳み込みは「3×3 → 5×5」に拡大する。

具体例（3×3 入力 → 5×5 出力、フィルタ 3×3、stride=1、padding=0）:

入力 (3×3)フィルタ (3×3)
2 0 1 1 0 1
1 3 0 × 0 1 0
0 2 1 1 0 1

Step: 入力の各値をフィルタ全体に掛けて、出力上に「貼り付ける」（重なる部分は足し算）:

入力 (0,0) = 2 → フィルタ全体を ×2 して出力の (0,0)〜(2,2) に貼る:
出力 (0,0) += 2×1=2, (0,1) += 2×0=0, (0,2) += 2×1=2
出力 (1,0) += 2×0=0, (1,1) += 2×1=2, (1,2) += 2×0=0
出力 (2,0) += 2×1=2, (2,1) += 2×0=0, (2,2) += 2×1=2

入力 (0,1) = 0 → 何も足されない。入力 (0,2) = 1 → フィルタ ×1 を (0,2)〜(2,4) に貼る...
→ 全 9 要素を順番に貼って重ねると 5×5 の出力 が完成。

★ 直感: 通常畳み込みが「3×3 の窓で見て 1 つの数字にまとめる」（縮小）なのに対し、転置畳み込みは「1 つの数字を 3×3 に 散らす」（拡大）。G はこれを 4 回繰り返して 4×4 → 64×64 に拡大する。
→ フィルタの値は学習パラメータ。G は「どう散らせば本物っぽい画像になるか」を D のフィードバックから学ぶ。
③ GAN の学習ループ — 1 ステップの全体像

Step 1: 本物をバッチ取得
学習データから本物画像 $x$ を 64 枚取得

Step 2: G で偽画像生成
ノイズ $z$ ∼ N(0,1) を 64 個サンプリング → $G(z)$ で偽画像 64 枚を生成

Step 3: D を更新（本物を「本物」、偽物を「偽物」と判定するよう学習）
$L_D = -[\log D(x) + \log(1 - D(G(z)))]$ ← 最小化
• $D(x) \nearrow$（本物を「本物」と判定）
• $D(G(z)) \searrow$（偽物を「偽物」と判定）

Step 4: G を更新（D を騙す画像を作るよう学習）
$L_G = -\log D(G(z))$ ← 最小化
• $D(G(z)) \nearrow$（偽物を D に「本物」と判定させたい）
• G の重みだけ更新（D は固定）。D からの勾配が G の転置 Conv の重みまで逆伝播

→ Step 1-4 を何万回も繰り返す

★ G が学べる理由: G 自体は「良い画像とは何か」を知らない。D の判定を通して間接的に学ぶ。D が「この画像はここが不自然」と勾配で伝える → G がその部分を改善 → D がさらに細かい違いを見つける → 繰り返し。
④ GAN の1ステップを数値で追跡

初期状態（エポック 0）: G はノイズしか生成できない、D はランダム判定

ステップ処理計算結果
1本物 $x$ を D に入力$D(x) = 0.6$（本物と判定）$\log(0.6) = -0.51$
2G がノイズ $z$ から偽画像生成$G(z) = $ ぼやけた画像—
3偽画像を D に入力$D(G(z)) = 0.3$（偽物と判定）$\log(1-0.3) = -0.36$
4aD を更新（V を最大化）$V_D = \log(0.6) + \log(0.7) = -0.87$
→ D の重みを更新して V↑		D が賢くなる
$D(x) \nearrow$, $D(G(z)) \searrow$
4bG を更新（V を最小化）$V_G = \log(1-0.3) = -0.36$
→ G の重みを更新して $D(G(z)) \nearrow$		G が上手くなる
次回 $D(G(z)) \nearrow$

10 エポック後: $D(x) = 0.8$, $D(G(z)) = 0.4$ → D がまだ優勢
50 エポック後: $D(x) = 0.6$, $D(G(z)) = 0.5$ → ほぼ均衡
100 エポック後: $D(x) = 0.52$, $D(G(z)) = 0.49$ → 均衡達成! D はコイン投げ状態

★ 核心: D は「本物を見抜く」能力を高め、G は「D を騙す」能力を高める。この敵対的な圧力が両者を同時に改善させる。
⑤ モード崩壊 — なぜ起きるのか（数値例）

顔画像を生成する GAN を学習中。本物データには「男性/女性/子供」の 3 パターンがあるとする。

エポックG が生成D の判定G の学習
10ぼやけた顔（多様）全部偽物と判定全般的に改善
30それなりの顔（多様）大体見抜ける全般的に改善
50「女性の顔」だけ生成女性の偽物を見抜けない!「女性だけ出せば D を騙せる」
→ 男性/子供を生成しなくなる
80ほぼ同じ女性の顔のみD は女性に適応 → 見抜けるが
G は別パターンに切り替えない		品質高いが多様性ゼロ

★ なぜ起きる: G にとって「多様な画像を生成する」義務はない。$D(G(z))$ を上げれば良いだけ → 1 パターンで D を騙す「ショートカット」を発見してしまう。
→ 対策: Mini-batch Discrimination（生成物の多様性を D に教える）/ Unrolled GAN / Spectral Normalization
⑥ GAN の進化 — 問題をどう解決したか

手法年解決した問題アイデア
GAN2014—（原論文）G vs D の敵対的学習
DCGAN2015画像品質G/D に CNN（転置畳み込み + BatchNorm）を使用
WGAN2017学習不安定JS ダイバージェンス → Wasserstein 距離に変更。
勾配消失を防ぎ、学習を安定化
Progressive GAN2018高解像度低解像度から段階的に高解像度へ成長
StyleGAN2019品質 + 制御性スタイルベクトルで髪型・表情・年齢を独立制御。
「実在しない人の顔」で話題に
Conditional GAN—条件付き生成クラスラベルを条件に追加（「猫を生成」と指定可能）

→ G検定では「GAN の基本構造（G vs D）」「モード崩壊」「WGAN の改善点」「StyleGAN の特徴」がよく問われる

17. 拡散モデル — ノイズから画像を生成

Arc 3 Scene 4「ノイズから傑作を」関連

📐 数式

📌 起源は「物理学」: 2015年 Sohl-Dickstein らが 非平衡熱力学（インクが水に拡散する不可逆過程）の発想を機械学習に応用。「壊し方を学べば作り方がわかる」。

Forward Process（拡散過程: 既知、学習不要）:
$x_t = \underbrace{\sqrt{1 - \beta_t}}_{\substack{\text{元画像の}\\\text{残り具合}}} \cdot x_{t-1} + \underbrace{\sqrt{\beta_t}}_{\substack{\text{ノイズの}\\\text{追加量}}} \cdot \underbrace{\varepsilon}_{\substack{\text{ガウス}\\\text{ノイズ}}}, \quad \varepsilon \sim \mathcal{N}(0, I)$

任意の時刻 $t$ への直接ジャンプ（累積ノイズ）:
$x_t = \sqrt{\bar{\alpha}_t} \cdot x_0 + \sqrt{1 - \bar{\alpha}_t} \cdot \varepsilon$ ただし $\bar{\alpha}_t = \prod_{s=1}^t (1-\beta_s)$
→ $\bar{\alpha}_t$ = 「元画像の残存率」、$1-\bar{\alpha}_t$ = 「累積ノイズ比率」

Reverse Process（逆拡散: 学習対象）:
$x_{t-1} = \frac{1}{\sqrt{\alpha_t}}\left(x_t - \frac{\beta_t}{\sqrt{1-\bar{\alpha}_t}} \cdot \underbrace{\varepsilon_\theta(x_t, t)}_{\substack{\text{NN による}\\\text{ノイズ予測}}}\right) + \sigma_t z$

$\varepsilon_\theta$ の中身は U-Net（CNN ベース、10. U-Net と同じ構造）:
入力: ノイズ画像 $x_t$ + 時刻 $t$（埋め込みベクトル）
出力: 同じサイズのノイズ予測 $\hat{\varepsilon}$（画像→画像変換）
→ 学習目標: $\| \varepsilon - \varepsilon_\theta(x_t, t) \|^2$ を最小化（U-Net がノイズ予測器として訓練される）

📊 グラフ（Forward / Reverse のステップ別可視化）

💡 解説

GANより安定した学習で高品質画像生成（Stable Diffusion, DALL-E, Midjourney）
テキスト条件付き生成（CLIP連携）で「猫がピアノを弾く」画像を生成可能
生成に何十〜何百ステップ必要 → GANより推論が遅い
学習に大量のGPU計算資源が必要（数千GPU×数日）
💡 直感的に: きれいな画像に段階的にノイズを加え、その「除去の仕方」を学習する。逆再生するとノイズから画像が生まれる。中身は U-Net（CNN） で「ノイズ予測器」として訓練される。
💡 物理学からの発想: インクが水に拡散していく不可逆過程（熱力学第二法則）— もし「拡散の各ステップが微小なら逆再生も可能」と Sohl-Dickstein (2015) が示し、Ho (2020, DDPM) で実用化。3手法比較で GAN/VAE と対比できる。

📖 詳細解説

① 拡散モデルの全体構造 — 中身は U-Net

拡散モデルは「拡散過程（既知の物理過程）」と「逆拡散過程（NN が学習）」の組み合わせ:

過程処理学習が必要？
Forward（拡散）$x_0 \to x_1 \to \ldots \to x_T$（画像→ノイズ）不要（数式で固定）
Reverse（逆拡散）$x_T \to x_{T-1} \to \ldots \to x_0$（ノイズ→画像）U-Net が学習

U-Net の役割（拡散モデルでは「ノイズ予測器」）:
入力: ノイズ画像 $x_t$（64×64×3 等）+ 時刻 $t$
出力: ノイズ予測 $\hat\varepsilon$（同サイズ、64×64×3）
構造: 10. U-Net と同じ — エンコーダで特徴抽出 → デコーダで画像サイズに復元 + スキップ接続
→ U-Net は元々セグメンテーション用だが、「画像→画像」の変換器として拡散モデルにも採用された

学習の流れ:
1. 学習データ $x_0$ から、ランダムに $t \in [1, T]$ を選ぶ
2. ノイズ $\varepsilon$ をサンプリング → $x_t = \sqrt{\bar\alpha_t} x_0 + \sqrt{1-\bar\alpha_t}\varepsilon$ で計算
3. U-Net に $(x_t, t)$ を入力 → ノイズ予測 $\hat\varepsilon$ を得る
4. 損失 $\| \varepsilon - \hat\varepsilon \|^2$ を最小化（普通の MSE!）
→ GANのような敵対的学習ではないので安定する
② Forward Process の数値例 — 1次元データで追跡

簡略化のため 1 次元のスカラー画像 $x_0 = 1.0$ から始める。Linear schedule で $\beta_1=0.01, \beta_2=0.02, \beta_3=0.03$ とする。

t$\beta_t$$\alpha_t = 1-\beta_t$$\bar\alpha_t = \prod \alpha$$x_t$ サンプル
($\varepsilon = 0.5$ 仮定)
0——1.000$x_0 = 1.000$（元画像）
10.010.990.990$\sqrt{0.99}(1) + \sqrt{0.01}(0.5) = 0.945 + 0.05 = 0.995$
20.020.980.970$\sqrt{0.98}(0.995) + \sqrt{0.02}(0.5) = 0.985 + 0.071 = 1.056$
30.030.970.941$\sqrt{0.97}(1.056) + \sqrt{0.03}(0.5) = 1.040 + 0.087 = 1.127$

累積ジャンプの公式（直接 $x_3$ を計算）:
$x_3 = \sqrt{\bar\alpha_3} \cdot x_0 + \sqrt{1-\bar\alpha_3} \cdot \varepsilon = \sqrt{0.941}(1) + \sqrt{0.059}(0.5) = 0.970 + 0.122 = 1.092$
→ 各ステップで小さなノイズを足すか、累積ノイズで一気にジャンプするか、結果はほぼ同じ（数値誤差のみ）

T=1000 ステップ後の状態: $\bar\alpha_T \approx 0$ → $x_T \approx \varepsilon$（ほぼ純粋なガウスノイズ。元画像の情報は完全に消失）
③ Reverse Process の数値例 — どう画像が「組み立てられる」か

学習済み U-Net がノイズ予測器として動作する。$x_T \approx$ ガウスノイズから始めて、徐々に元の構造を復元する:

ステップ入力U-Net 出力
（ノイズ予測 $\hat\varepsilon$）		出力 $x_{t-1}$
$t=T$$x_T = $ ランダムノイズ「全体の95%がノイズ」$x_{T-1}$（少しだけ画像っぽく）
$t=T/2$$x_{T/2}$（半分ノイズ）「右上に余分なノイズあり」そのノイズを引いた画像
$t=10$$x_{10}$（ほぼ画像）「微小なノイズだけ」完成画像に近い $x_9$
$t=1$$x_1$（ほぼ完成）「ごく小さなノイズ」$x_0$ = 完成!

★ U-Net が画像を「描く」のではない
U-Net は「このノイズ画像のうち、どれがノイズか」を予測するだけ。それを引くと「残った構造」が出てくる。
$z$（初期ノイズ）が違えば、毎回違うノイズが残り → 異なる画像が生成される。
④ 物理学からの発想 — なぜこのアイデアが画像生成に効いたか

熱力学第二法則: 物質は「秩序ある状態」から「無秩序な状態」へ自発的に進む（エントロピー増大）。
例: 水に1滴のインクを落とす → ゆっくり拡散 → 完全に均一になる。逆に「均一な水」から「インク 1滴」に戻ることは マクロには起きない。

Sohl-Dickstein らの発想（2015）:
• 拡散の各ステップが 十分小さければ、各ステップの逆過程はガウス分布で近似できる（数学的に証明）
• ガウス分布は NN で学習できる → 逆拡散を学習すれば「ノイズから画像を再構築」できる

2020年 Ho らの DDPM: U-Net を使い、「平均と分散」ではなく「ノイズ予測」を直接学習させて実用化。GAN を超える品質を達成。

物理拡散モデル
インクの拡散（Forward）画像にノイズを追加
エントロピー増大情報が失われていく ($\bar\alpha_t \searrow 0$)
マクロには不可逆そのままでは元に戻らない
微小ステップなら
各ステップは可逆推定可能		U-Net が逆拡散を学習 → ノイズから画像へ

→ G検定では「拡散モデルは熱力学に着想」「U-Net がノイズ予測器」「GAN との違い（敵対的学習でない）」がよく問われる

18. 画像生成3手法比較 — GAN vs VAE vs 拡散モデル

Arc 3 Scene 1-4 総合

📐 数式

GAN: $\min_G \max_D \; \mathbb{E}[\log D(x)] + \mathbb{E}[\log(1-D(G(z)))]$
→ G vs D の敵対的学習。高品質だが不安定

VAE: $\mathcal{L} = \underbrace{-\mathbb{E}[\log p(x|z)]}_{\text{復元誤差}} + \underbrace{D_{KL}(q(z|x) \| p(z))}_{\text{潜在空間の正則化}}$
→ 圧縮+復元。安定だがぼやける（復元誤差が pixel 平均で最適化されるため）

拡散モデル: $\mathcal{L} = \mathbb{E}[\| \varepsilon - \varepsilon_\theta(x_t, t) \|^2]$
→ ノイズ予測。高品質 + 安定 + 多様だが生成が遅い（数十〜数百ステップ）

📊 グラフ（3手法のトレードオフ）

👀 試してみよう: レーダーチャートで 3 手法の強み・弱みの 形の違い を比較。タイムラインで技術の進化と主役交代の流れを確認。

💡 解説

3手法は全て「学習データにない新しい画像を生成する」という同じ目標に異なるアプローチ
GAN→VAE→拡散モデルは「対立する弱点を次の手法が克服」する進化の連鎖
拡散モデルは品質・安定性・多様性を達成したが速度が犠牲に（数十〜数百ステップ）
Stable Diffusion は VAE＋拡散のハイブリッドで速度問題を緩和 → 実用化
💡 直感的に: GAN は「贋作師 vs 鑑定士」（高品質だが不安定）。VAE は「圧縮→復元」（安定だがぼやける）。拡散モデルは「ノイズ→段階的除去」（高品質+安定だが遅い）。3つの弱点を理解すれば、なぜ拡散モデルが勝ったかがわかる。

📖 詳細解説

① なぜ VAE はぼやけるのか — pixel 平均の罠

VAE の復元誤差は $\| x - \hat{x} \|^2$（ピクセルごとの二乗誤差の平均）。

例: 「猫の目の位置」が本物では少しずつ違う場合:
• 本物画像 A: 目が左寄り
• 本物画像 B: 目が右寄り
• VAE の最適解: $\frac{A+B}{2}$ = 目が両方の中間でぼやける

→ ピクセル平均を最小化すると「ありえる画像の平均」になる = ぼやける
→ GAN は D が「ぼやけた画像は偽物」と判定するので、G はシャープな画像を作らざるを得ない
→ 拡散モデルも「ノイズ予測」なので pixel 平均の罠にハマらない
② Stable Diffusion = VAE + 拡散のハイブリッド

拡散モデルの弱点は「ピクセル空間で数百ステップ」→ 遅い。
解決策: まず VAE で圧縮してから拡散する（Latent Diffusion）。

ステップ処理サイズ
1. VAE Encoder画像 → 潜在空間に圧縮512×512×3 → 64×64×4（48倍圧縮）
2. 拡散過程潜在空間でノイズ追加→除去（U-Net）64×64×4 のまま（高速!）
3. VAE Decoder潜在空間 → 画像に復元64×64×4 → 512×512×3

★ VAE の「ぼやけ」は問題にならない?
Stable Diffusion では VAE は「圧縮→復元」だけで、画像の内容を決めるのは拡散過程。
VAE のぼやけは「最終出力の微細ディテール」にだけ影響 → 拡散モデルの品質で補える。
→ 3手法の弱点を互いに補完して実用化に至った好例。G検定ではこの関係性がよく問われる。

19. CLIP — テキストと画像を同じ空間に埋め込む

Arc 3 Scene 4-5「拡散モデル / マルチモーダルAI」関連

📐 数式

CLIP (Contrastive Language-Image Pre-training, OpenAI 2021):
4億組の (画像, テキスト) ペアを Web から収集し、2 つの Encoder で同じベクトル空間に埋め込む。

2 つの Encoder:
$\mathbf{i} = f_{\text{image}}(I)$　← 画像 Encoder（ViT または ResNet）
$\mathbf{t} = f_{\text{text}}(T)$　← テキスト Encoder（Transformer）
→ 両方とも同じ次元（例: 512次元）のベクトルに変換。これらが同じ空間で比較可能になる

類似度（コサイン類似度）:
$\text{sim}(\mathbf{i}, \mathbf{t}) = \dfrac{\mathbf{i} \cdot \mathbf{t}}{\|\mathbf{i}\| \cdot \|\mathbf{t}\|}$　← -1〜1（正規化後は実質 0〜1）

対照学習の目的関数（バッチサイズ $N$、対角は正例、それ以外は負例）:
$\mathcal{L} = -\dfrac{1}{N} \sum_{i=1}^{N} \log \dfrac{\exp(\text{sim}(\mathbf{i}_i, \mathbf{t}_i) / \tau)}{\sum_{j=1}^{N} \exp(\text{sim}(\mathbf{i}_i, \mathbf{t}_j) / \tau)}$
→ 正例（対応する画像-テキスト）の類似度を ↑、負例（無関係なペア）の類似度を ↓。$\tau$ は温度パラメータ
→ ImageNet ラベルで学習しないので「写真と説明文があれば何でも学習可能」 = 4億ペアで巨大スケール化

📊 グラフ（学習の進行と類似度マトリクス）

👀 試してみよう: エポックを 0→100% に動かすと、対角線（正例）の類似度が上がり、非対角（負例）が下がるのが見える。これが「対照学習」の本質。「ゼロショット分類」モードでは、学習なしで新しい画像を分類する CLIP の応用を確認できる。

💡 解説

2021年 OpenAI: 4億ペアで学習。ImageNet ラベルなしで ImageNet 並みのゼロショット精度
テキストと画像を同じ空間に埋め込み → 検索・分類・生成すべてに応用
Stable Diffusion / DALL-E 2 のテキスト条件付け基盤（"猫がピアノを弾く" を画像化）
Web 由来データ → バイアス（偏見・著作権）の問題
画像と単一テキスト全体の対応のみ → 画像内の領域とテキスト内の単語の細かい対応は弱い
💡 直感的に: 「猫の画像」と「A cat sits」の文を、同じベクトル空間で 近くに置く。「猫の画像」と「A dog plays」は 遠くに置く。これを 4 億ペアで繰り返すと、画像と言葉が共通の意味空間で結ばれる。
💡 拡散モデルとの組み合わせ: Stable Diffusion はテキスト "猫がピアノを弾く" を CLIP のテキスト Encoder でベクトル化 → そのベクトルに「近い画像」が生成されるように、U-Net の逆拡散を誘導（Classifier-free guidance）。CLIP がテキスト条件を「画像生成側に翻訳する辞書」の役割を果たす。

📖 詳細解説

① CLIP の構造 — 2 つの Encoder + 共通空間

Encoder入力構造出力
Image Encoder画像（224×224×3）ViT または ResNet512次元ベクトル $\mathbf{i}$
Text Encoderテキスト（最大76トークン）Transformer（GPT風）512次元ベクトル $\mathbf{t}$

★ ポイント: 全く異なる入力（画像とテキスト）を 同じ次元のベクトル空間 に変換することで、コサイン類似度で比較できるようになる。これが CLIP のすべての応用を可能にする鍵。
② 対照学習の数値例 — 3 ペアのバッチ

バッチサイズ $N=3$（簡略化のため次元 3）:
画像: $\mathbf{i}_1$=猫, $\mathbf{i}_2$=犬, $\mathbf{i}_3$=車
テキスト: $\mathbf{t}_1$="cat", $\mathbf{t}_2$="dog", $\mathbf{t}_3$="car"

学習前（ランダム初期化）の類似度マトリクス:
"cat""dog""car"
🐱0.320.280.31
🐶0.300.330.29
🚗0.310.290.32

→ 全部似たり寄ったり。何の意味もない。

損失計算（行 1: 猫画像）:
$\mathcal{L}_{\text{猫}} = -\log\dfrac{\exp(0.32 / 0.07)}{\exp(0.32/0.07) + \exp(0.28/0.07) + \exp(0.31/0.07)}$
$= -\log\dfrac{99.5}{99.5 + 54.6 + 85.6} = -\log(0.418) = 0.873$
→ 猫画像と "cat" の類似度を上げ、"dog"/"car" との類似度を下げるよう勾配が流れる

学習後の類似度マトリクス（4億ペアで訓練）:
"cat""dog""car"
🐱0.920.180.05
🐶0.210.890.07
🚗0.040.060.94

→ 対角線が高く、それ以外は低い = 画像と対応するテキストが正しく結ばれた。
③ ゼロショット分類 — 学習なしで新クラスを識別

通常の CNN 分類器（ResNet 等）は、ImageNet の 1000 クラスでしか分類できない。新しいクラスを追加するには再学習が必要。

CLIP のゼロショット分類:
1. 入力画像 $I$ を Image Encoder でベクトル化 → $\mathbf{i}$
2. 候補ラベル "猫", "犬", "車", ... を「"a photo of a 猫"」等のテンプレ文に埋めてText Encoderでベクトル化 → $\mathbf{t}_1, \mathbf{t}_2, \ldots$
3. 全候補と類似度を計算 → 最大のものを選択

★ なぜ「ゼロショット」なのか:
• CLIP は「猫」というラベルで学習していない
• Web 上の「a photo of a cat」というキャプション付き画像から、関係を 暗黙的 に学んでいる
• だから新しいクラス（例: "パンダ", "宇宙人"）も、テキストを変えるだけで分類可能

応用例:
• 画像検索: "夕暮れの海"で画像DB検索 → 一致度の高い画像を取得
• Stable Diffusion: "a fantasy castle" のテキストベクトルを拡散モデルに渡し、生成を誘導
• 医療画像: 専門家のラベルなしで「肺炎の画像」を識別（Web の医療キャプションから学習）
④ 拡散モデルとの組み合わせ — Stable Diffusion の核心

Stable Diffusion でテキスト "a cat playing piano" から画像を生成する仕組み:

Step 1: ユーザー入力 "a cat playing piano"
↓
Step 2: CLIP の Text Encoderでベクトル化 → $\mathbf{t}^*$
↓
Step 3: ランダムノイズ $x_T$ から開始
↓
Step 4: U-Net がノイズ予測 — ただし「$\mathbf{t}^*$ に近い画像になる方向に」勾配を傾ける
（Classifier-free guidance: $\hat\varepsilon = \varepsilon_\theta(x_t, \emptyset) + s \cdot (\varepsilon_\theta(x_t, \mathbf{t}^*) - \varepsilon_\theta(x_t, \emptyset))$）
↓
Step 5: 数十ステップの逆拡散後 → 「猫がピアノを弾く」画像が完成
★ CLIP の役割: 拡散モデル単体は「画像生成」しかできない。CLIP が「テキスト→ベクトル」を提供することで、テキストで画像を制御できるようになった。これが 2022 年の Stable Diffusion ブームの技術的核心。
→ G検定では「CLIP は対照学習」「Stable Diffusion = 拡散モデル + CLIP の組み合わせ」がよく問われる

20. モデル圧縮（Pruning） — 不要な重みを刈り取る

Arc 3 Scene 6「現場で使うAI」関連

📐 数式

基本的な発想: 学習済み NN の重みのうち、絶対値が小さい重みは出力にほとんど寄与しない → ゼロにしても精度が大きく落ちない。

マスク表現:
$\hat{W} = W \odot M$　ただし $M_{ij} = \begin{cases} 1 & |W_{ij}| \geq \tau \\ 0 & |W_{ij}| < \tau \end{cases}$
→ $\tau$ は閾値。例えば「下位 80% の重みをゼロにする」

2 種類の Pruning:
① 非構造化 (Unstructured): 個々の重みを独立にゼロ化
   Pros: 高い圧縮率（90%+）。Cons: スパース演算は GPU で速くならない場合あり
② 構造化 (Structured): フィルタ・チャネル・層単位でゼロ化
   Pros: 実際に高速化される。Cons: 圧縮率は低め

Lottery Ticket Hypothesis (2018): 大きなランダム初期化 NN の中に、最初から「当たりくじ」（疎なサブネット）が存在し、それだけで元と同等の精度を出せる。
→ Pruning が「巨大化したパラメータの中から本当に必要な部分を発見する」プロセスだという解釈

📊 グラフ（Pruning率と精度・速度のトレードオフ）

👀 試してみよう: 非構造化なら 80% 削っても精度はほぼ落ちないが速度は伸びにくい。構造化に切り替えると速度は急上昇するが精度低下が早い。「圧縮率 vs 実速度 vs 精度」のトレードオフを体感。

💡 解説

学習済みモデルを 50-90% 圧縮しても精度低下は数%以内（適切な手法なら）
非構造化: 高圧縮率（CNNで90%、Transformerで70%程度可能）
構造化: そのまま GPU で高速化される（フィルタ削除＝計算量直接減）
非構造化はスパース行列専用ハード（NVIDIA Sparse Tensor Core 等）でないと速度向上が限定的
過度に削ると重要な特徴を失う → fine-tune で精度を回復させるのが定石
💡 直感的に: 大きな NN は実は「ほとんど使われていない重み」が大量にある。それを削れば、精度はほぼ維持しつつモデルが小さくなる。「Lottery Ticket Hypothesis」では「巨大NNはくじ引き、当たりは少数。それを引き当てるのが pruning」と説明される。

📖 詳細解説

① Magnitude Pruning の数値例 — 4×4 重み行列

学習済み重み行列 $W$ (4×4):
0.85-0.020.03-0.71
0.05-0.62-0.010.04
-0.040.060.78-0.08
0.02-0.55-0.070.91

Step 1: 16 個の重みの絶対値を取り、降順ソート
$|W|$ = [0.91, 0.85, 0.78, 0.71, 0.62, 0.55, 0.08, 0.07, 0.06, 0.05, 0.04, 0.04, 0.03, 0.02, 0.02, 0.01]

Step 2: 50% Pruning → 上位 8 個を残す。閾値 $\tau = 0.55$

Step 3: $\tau$ 未満の重みをゼロ化:
0.850.000.00-0.71
0.00-0.620.000.00
0.000.000.780.00
0.00-0.550.000.91
→ 50% がゼロ。「実質 8 個の重み」だけで動く NN になる。出力への影響は微小（小さい重みは元から寄与が少ない）

Step 4: Fine-tune（追加学習）で精度を回復
ゼロ化した位置を固定したまま、残りの重みを再調整 → 元の精度の 99%+ を回復することが多い
② 非構造化 vs 構造化 — 実装と速度の違い

非構造化構造化
削る単位個々の重み（最も細かい）フィルタ全体 / チャネル全体 / 層全体
典型的圧縮率90%（CNN）, 70%（Transformer）30-50%
GPU での高速化限定的（密行列演算前提）直接的に高速化（演算量が線形に減る）
必要なライブラリ疎行列専用 (cuSPARSE, Sparse Tensor Core)標準的な PyTorch/TF で OK
用途研究、専用ハード環境エッジデバイス、実用デプロイ

★ ポイント: NVIDIA A100/H100 の Sparse Tensor Core は 2:4 sparsity（4 個中 2 個ゼロ）で 2 倍速になる → 非構造化と構造化の中間として近年注目。
③ Lottery Ticket Hypothesis — Pruning の理論

Frankle & Carbin (MIT, 2018) が提唱した有名な仮説:

仮説: ランダム初期化された大きな NN の中には、最初から「当たりくじ」となる疎なサブネットが存在する。そのサブネットを初期重みのまま独立に学習させても、元の NN と同等以上の精度に到達する。

実験プロトコル:
1. 大きな NN $\theta_0$（ランダム初期化）を保存
2. 普通に学習 → 学習済み $\theta_T$
3. Magnitude pruning で疎なマスク $M$ を作成
4. $M \odot \theta_0$（元の初期化に戻したサブネット）から学習し直す
5. → ほぼ同じ精度に到達する!

意味すること:
• Pruning は「学習で重みを良くする」のではなく、「元から良かった部分を発見する」プロセス
• 巨大 NN が必要な理由は「当たりを引く確率を高めるため」だけかもしれない
→ G検定では「Pruning は学習済みモデルから不要な重みを削除」「構造化 vs 非構造化」が問われる

21. 量子化（Quantization） — 数値精度を下げて軽量化

Arc 3 Scene 6「現場で使うAI」関連

📐 数式

基本的な発想: NN の重み・活性化を FP32（32bit浮動小数点）→ INT8（8bit整数） に変換 → メモリ 1/4、計算高速化、専用ハードで省電力。

線形量子化（Linear / Affine Quantization）:
$x_{\text{int}} = \text{round}\left(\dfrac{x_{\text{float}}}{s}\right) + z$
$x_{\text{float}} \approx s \cdot (x_{\text{int}} - z)$

$s$ = scale（実数→整数の倍率）, $z$ = zero point（0 がどの整数値に対応するか）
INT8 なら $x_{\text{int}} \in [-128, 127]$（signed）または $[0, 255]$（unsigned）

2 種類の量子化:
① PTQ (Post-Training Quantization): 学習済みモデルをそのまま量子化
   Pros: 簡単・速い。Cons: 精度低下が大きい場合あり
② QAT (Quantization-Aware Training): 学習中に量子化誤差をシミュレート
   Pros: 高精度を維持。Cons: 再学習が必要

究極の量子化: INT4（4bit、16 段階）/ INT2 / Binary (1bit)。LLM では INT4 が主流（GPT-4o, Llama 3 等）。

📊 グラフ（bit数と量子化誤差・モデルサイズ）

👀 試してみよう: bit 数を 32→8 にしてもほぼ精度を維持できる。4bit 以下では QAT を使わないと精度が落ちる。LLM の推論では INT4 が主流に。

💡 解説

FP32→INT8 でモデルサイズ 1/4、メモリ帯域 1/4、推論速度 2-4倍
スマホ/エッジデバイスの DSP/NPU は INT8 演算に特化 → 省電力
QAT なら精度低下を 0.1% 程度に抑えられる
4bit 以下では量子化誤差が顕著 → アウトライアーの扱いが問題
PTQ は簡単だが、Activation の動的範囲が大きい層で精度落ちることがある
💡 直感的に: NN の重みは「0.7456423...」のような連続値だが、推論時は「0.75 でも 0.74 でも結果はほぼ同じ」。32bit 必要なのは学習中の細かい勾配計算のため。推論なら 8bit、4bit でも十分。

📖 詳細解説

① 量子化の数値例 — FP32 から INT8 へ

ある層の重み（FP32）: $W = [-2.5, -1.0, 0.0, 1.5, 2.5]$（実数値、5 個）

Step 1: 範囲を決める。$W_{\min} = -2.5, W_{\max} = 2.5$

Step 2: scale と zero_point を計算（INT8 = $[-128, 127]$ にマップ）:
$s = \dfrac{W_{\max} - W_{\min}}{127 - (-128)} = \dfrac{5.0}{255} \approx 0.0196$
$z = -\text{round}\left(\dfrac{W_{\min}}{s}\right) - 128 = -\text{round}(-127.55) - 128 = 128 - 128 = 0$

Step 3: 各重みを量子化:
FP32 重み$x/s + z$round (INT8)復元値 $s \cdot x_{\text{int}}$誤差
-2.5-127.55-128-2.510.01
-1.0-51.02-51-1.000.00
0.00.0000.000.00
1.576.53771.510.01
2.5127.551272.490.01

結果: 平均誤差 ≈ 0.006（0.24%）。FP32 では 32bit×5=160bit 必要だったのが、INT8 では 8bit×5=40bit + scale/zero_point のメタデータ → 約 1/4 のサイズ。
② PTQ vs QAT — どちらを使うか

PTQQAT
正式名Post-Training QuantizationQuantization-Aware Training
処理学習済みモデルの重みを後から量子化学習中に「Fake Quantization」ノードを挿入し、量子化誤差を逆伝播
必要なものキャリブレーション用データ（数百サンプル）完全な学習データ + 再学習
所要時間分単位（速い）時間〜日単位（遅い）
INT8 精度低下0.5〜2%0.1% 以下
INT4 精度低下5〜10%（実用困難）1〜2%（実用可能）

★ 実用の選択: 一般的には PTQ から始めて、精度が足りなければ QAT へ。LLM のような巨大モデルでは再学習コストが高いので、まずは GPTQ/AWQ などの高度な PTQ が使われる。
③ LLM での INT4 量子化 — Llama 3, GPT-4o の現場

70B パラメータの LLM を考えてみよう:
• FP32: 70B × 4byte = 280 GB → 一般家庭の GPU では動かせない
• FP16: 70B × 2byte = 140 GB → 高級 GPU 1〜2 枚必要
• INT8: 70B × 1byte = 70 GB → A100 (80GB) 1 枚で動く
• INT4: 70B × 0.5byte = 35 GB → RTX 4090 (24GB) でも分割で動く!

GPTQ / AWQ 等の手法では、INT4 量子化でも精度低下を 1〜2% に抑える:
• 重要な重み（アウトライアー）は FP16 のまま残す
• キャリブレーションで量子化境界を最適化
• Hessian 情報を使って誤差を補正

→ G検定では「量子化＝計算精度を下げて軽量化」「PTQ vs QAT」が問われる

22. 蒸留（Knowledge Distillation） — 教師から生徒へ知識を転写

Arc 3 Scene 6「現場で使うAI」関連

📐 数式

基本的な発想: 大きな高精度モデル（教師 $T$）の出力を、小さなモデル（生徒 $S$）に模倣させる。生徒は 正解ラベル だけでなく 教師の出力分布（soft labels） から学ぶ。

Soft Label の作り方（Temperature Scaling）:
$p_i^T = \dfrac{\exp(z_i / T)}{\sum_j \exp(z_j / T)}$
$z_i$ はロジット（softmax 前の値）。$T$ = 温度パラメータ（典型値 2〜10）
$T=1$: 通常の softmax。$T \to \infty$: 一様分布に近づく → 「クラス間の関係」が浮かび上がる

蒸留損失:
$\mathcal{L}_{\text{KD}} = \alpha \cdot \underbrace{\text{CE}(y_{\text{true}}, p^S)}_{\substack{\text{正解ラベル}\\\text{との交差エントロピー}}} + (1-\alpha) \cdot T^2 \cdot \underbrace{\text{KL}(p^T_T \| p^S_T)}_{\substack{\text{教師の soft label}\\\text{との KL ダイバージェンス}}}$
$\alpha$ は重み（典型値 0.1〜0.5）。$T^2$ は勾配スケーリング補正

なぜ Soft Label が効くのか: 教師は「猫である確率 90%, 犬 8%, 馬 1.5%, 椅子 0.5%」のようにクラス間の類似性も教える（「猫っぽいけど犬要素もある」）。Hard Label（猫=100%）より情報豊富。

📊 グラフ（Temperature と Soft Label の変化）

👀 試してみよう: T を 1→4 に上げると、隠れていた「犬っぽさ」「馬っぽさ」が浮かび上がる。これが Dark Knowledge。T が大きすぎると情報が薄まる（実用は T=2〜5）。

💡 解説

2015 年 Hinton が提唱（"Distilling the Knowledge in a Neural Network"）
DistilBERT: BERT の 60% サイズ・60% 速度で 97% の精度を達成
TinyBERT, MobileBERT 等で BERT を更に圧縮 → スマホで動く
Teacher の質に強く依存。Teacher が間違えやすい例は Student も間違える
学習に Teacher のフォワード計算が追加で必要 → 学習時間は増える
💡 直感的に: 大学教授（Teacher = 重い高精度モデル）が高校生（Student = 軽量モデル）に教える。教授は単に答えを言うのではなく「これは猫だが、ある角度では犬にも見える」と類似性も教える。生徒はこの「微妙な情報」のおかげで、自分一人で学ぶより遥かに効率的に学習できる。

📖 詳細解説

① 蒸留の数値例 — Teacher のロジットから Soft Label へ

教師モデルが「猫の画像」に対して出力したロジット（softmax 前の生スコア）:
$z = [8, 5, 2, -1, -3]$ （猫, 犬, 馬, 机, 車）

通常の softmax (T=1):
$e^8 = 2981, e^5 = 148, e^2 = 7.4, e^{-1} = 0.37, e^{-3} = 0.05$
合計 $\approx 3137$
$p = [\textbf{0.950}, 0.047, 0.0024, 0.00012, 0.000016]$
→ 「ほぼ猫 100%」だけ。犬・馬の情報は数値的に消失

温度 T=4 の softmax:
$e^{8/4} = 7.39, e^{5/4} = 3.49, e^{2/4} = 1.65, e^{-1/4} = 0.78, e^{-3/4} = 0.47$
合計 $\approx 13.78$
$p^T = [\textbf{0.536}, 0.253, 0.120, 0.057, 0.034]$
→ 「猫 54%, 犬 25%, 馬 12%」のように、クラス間の関係が見える！

これが Dark Knowledge: 教師は「ほぼ確実に猫だが、もし他のクラスを選ぶなら犬 > 馬 > 机 > 車の順」と知っている。Hard Label（猫=1, 他=0）では失われるこの情報を、Soft Label で生徒に伝える。
② 損失関数の構成 — 数値で追跡

生徒が同じ画像で出力した soft label: $p^S = [0.4, 0.3, 0.15, 0.1, 0.05]$（教師に近づけたい）

Step 1: Hard Loss (CE) — 正解ラベル「猫=1」との交差エントロピー:
$\text{CE}(y, p^S) = -\log(0.4) = 0.916$

Step 2: Soft Loss (KL) — 教師の soft label との距離:
$\text{KL}(p^T \| p^S) = \sum_i p^T_i \log(p^T_i / p^S_i)$
$= 0.536 \log(0.536/0.4) + 0.253 \log(0.253/0.3) + ...$
$\approx 0.156 - 0.043 - 0.030 - 0.033 - 0.014 \approx 0.036$

Step 3: 全体損失（α=0.3, T=4）:
$\mathcal{L} = 0.3 \cdot 0.916 + 0.7 \cdot 16 \cdot 0.036 = 0.275 + 0.403 = 0.678$
→ Hard と Soft の両方を最小化する勾配が、生徒モデルに流れる

★ ハイパーパラメータの典型値: $T = 2 \sim 5$, $\alpha = 0.1 \sim 0.5$（Soft loss の重みが大きいと教師の出力に強く依存）
③ 蒸留の実例 — DistilBERT, TinyBERT

モデルパラメータ速度精度（GLUE）
BERT-base (教師)110M1.0×79.5
DistilBERT (生徒)66M (60%)1.6×77.0 (97%)
TinyBERT14.5M (13%)9.4×76.5 (96%)
MobileBERT25M (23%)5.5×77.7 (98%)

★ DistilBERT の詳細:
• Teacher: BERT-base（12 層）
• Student: 6 層の Transformer（教師の隔層から初期化）
• 損失: Hard CE + Soft KL + Cosine 類似度（中間層も合わせる）
• 結果: ファイル 250MB → 150MB、推論 1.6 倍速、精度 97% 維持

応用先: スマホ上でのテキスト分類・検索、組込み AI、リアルタイム推論。
→ G検定では「蒸留＝大きなモデルの知識を小さなモデルに転写」「Soft Label」「DistilBERT」が問われる

23. 軽量アーキテクチャ — MobileNet / EfficientNet

Arc 3 Scene 6「現場で使うAI」関連

📐 数式

基本的な発想: モデルを「小さく作る」のではなく、計算効率の良い演算で構築する。MobileNet の核心は Depthwise Separable Convolution。

通常の畳み込み（Standard Conv）:
入力 $H \times W \times C_{\text{in}}$, 出力 $H \times W \times C_{\text{out}}$, カーネル $K \times K$
計算量: $H \cdot W \cdot K \cdot K \cdot C_{\text{in}} \cdot C_{\text{out}}$

Depthwise Separable Convolution:
① Depthwise Conv: 各チャネル独立に空間方向の畳み込み
   計算量: $H \cdot W \cdot K \cdot K \cdot C_{\text{in}}$
② Pointwise Conv (1×1): チャネル方向の混合
   計算量: $H \cdot W \cdot C_{\text{in}} \cdot C_{\text{out}}$
合計: $H \cdot W \cdot (K^2 \cdot C_{\text{in}} + C_{\text{in}} \cdot C_{\text{out}})$

削減率:
$\dfrac{\text{Depthwise Sep}}{\text{Standard}} = \dfrac{1}{C_{\text{out}}} + \dfrac{1}{K^2}$
$K=3, C_{\text{out}}=256$ なら $\approx 0.115$ → 計算量 1/9 に削減

EfficientNet (Compound Scaling):
$\text{depth} = \alpha^\phi, \quad \text{width} = \beta^\phi, \quad \text{resolution} = \gamma^\phi$
深さ・幅・解像度を 同時に スケール（従来は1軸ずつ）。$\phi$ で全体スケール調整

📊 グラフ（Standard Conv vs Depthwise Separable の演算量比較）

👀 試してみよう: K=3, C_out=256 で計算量が 1/9 に。K=1（1×1 Conv）では削減効果なし → MobileNet が 3×3 を多用する理由。

💡 解説

MobileNet (2017): スマホで動く CNN の決定版。Depthwise Separable Conv で 1/9 計算量
EfficientNet (2019): Compound Scaling で精度・効率の両方を最適化、SOTA を更新
MobileNet v2: Inverted Residual + Linear Bottleneck で精度向上
MobileNet v3: NAS（Neural Architecture Search）で自動設計、Squeeze-and-Excite 採用
表現力では普通の CNN に劣る場合あり → 大規模データセットでは標準 CNN の方が有利な場合も
💡 直感的に: Standard Conv は「空間方向 (H×W) と チャネル方向 (C) を同時に混ぜる」 → 計算重い。Depthwise Separable は「空間と チャネルを分けて処理」 → ほぼ同じ精度で計算量 1/9。MobileNet/EfficientNet はこれを基本ブロックとして組み立てた。

📖 詳細解説

① Depthwise Separable Convolution の数値例

入力: 56×56×128（特徴マップ、128 チャネル）、出力: 56×56×256、カーネル 3×3

Standard Conv の計算量:
$56 \times 56 \times 3 \times 3 \times 128 \times 256 = \mathbf{924\ M\ FLOPs}$
（各出力ピクセルが 3×3×128=1152 回の積和 → 出力 56×56×256=802,816 個 → 約 9.25 億回）

Depthwise Separable Conv:
① Depthwise (チャネル独立に 3×3):
$56 \times 56 \times 3 \times 3 \times 128 = \mathbf{3.6\ M\ FLOPs}$

② Pointwise (1×1 でチャネル混合):
$56 \times 56 \times 1 \times 1 \times 128 \times 256 = \mathbf{102.8\ M\ FLOPs}$

合計: 3.6 + 102.8 = 106.4 M FLOPs（Standard の 11.5%）
削減率 = $\frac{1}{256} + \frac{1}{9} = 0.115$（理論値と一致）

★ 削減の本質: Standard では「空間 × チャネル」の 掛け算 計算量。Depthwise Separable では「空間」と「チャネル」を分離 → 足し算 に変換 → 大削減。
② MobileNet の進化 — v1 / v2 / v3

バージョン年主要技術ImageNet Top-1
MobileNet v12017Depthwise Separable Conv のみ70.6%
MobileNet v22018+ Inverted Residual
+ Linear Bottleneck		72.0%
MobileNet v32019+ NAS で自動設計
+ Squeeze-and-Excite
+ h-swish 活性化		75.2%

Inverted Residual（v2 の核心）:
通常の ResNet: 「太→細→太」で残差接続。
MobileNet v2: 「細→太→細」で残差接続（中間で次元を拡大→ Depthwise Conv → 縮小）
→ Depthwise Conv は表現力が低いので、その前後で次元を一時的に増やす

Squeeze-and-Excite (SE): チャネル方向の重要度を動的に調整するアテンション機構。
③ EfficientNet — Compound Scaling の発想

従来の CNN スケーリング:
• 深く: ResNet-18 → ResNet-50 → ResNet-152（深さだけ）
• 広く: WideResNet（チャネル数だけ）
• 高解像度: 224×224 → 512×512（解像度だけ）

EfficientNet の発想: 3 軸を 同時に スケールする方が効率的:
$\text{depth} = \alpha^\phi, \quad \text{width} = \beta^\phi, \quad \text{resolution} = \gamma^\phi$
制約: $\alpha \cdot \beta^2 \cdot \gamma^2 \approx 2$（計算量を 2 倍にするごとに $\phi$ を 1 ずつ増加）

EfficientNet シリーズ:
モデルパラメータFLOPsImageNet Top-1
EfficientNet-B05.3M0.39B77.3%
EfficientNet-B312M1.8B81.6%
EfficientNet-B766M37B84.4%（当時 SOTA）

★ NAS（Neural Architecture Search）の役割: EfficientNet-B0 のベースアーキテクチャは、強化学習で「精度 × 計算効率」を最適化するようにNN 自体を NN が設計した結果。MobileNet v3 も同様。
→ G検定では「MobileNet = Depthwise Separable Conv」「EfficientNet = Compound Scaling + NAS」がよく問われる

20. データバイアスの影響

Arc 4 Scene 2「AIと社会のフリクション」関連

📐 数式

バイアスの数理:
学習データ比率: $P(\text{Group A}) \gg P(\text{Group B})$
→ モデルは Group A のパターンに最適化される
→ Group B の精度が犠牲になる（公平性の欠如）

対策: リサンプリング、Fairness 制約付き学習、属性別精度の監視

📊 グラフ

💡 解説

Amazon採用AI: 男性優位の過去データで学習 → 女性を低評価（2018年中止）
COMPAS再犯予測: 黒人を白人の2倍「高リスク」と予測
対策: データの多様化、Fairness指標の導入、説明可能AI (XAI)
「公平性」の定義自体が複数あり（機会均等 vs 結果均等）、完全解はない
💡 直感的に: AIは「中立」ではなく、学習データの偏見を増幅する。男性優位の採用データで学習 → 女性を低評価。対策: データ多様化、属性別精度チェック、XAI で判断根拠を検証。

21. ROC曲線とAUC

Arc 4 / 数理チートシート関連

📐 数式

ROC = Receiver Operating Characteristic（受信者操作特性、元はレーダー信号検出理論）
AUC = Area Under the Curve（曲線下面積）

$\text{TPR}$ (True Positive Rate) $= \dfrac{TP}{TP + FN}$ = Recall = 陽性のうち正しく検出した割合
$\text{FPR}$ (False Positive Rate) $= \dfrac{FP}{FP + TN}$ = 陰性のうち誤って陽性にした割合

仕組み: モデルは内部で確率 (例: スパム確率 0.73) を出力する。閾値を変えると:
閾値 0.9 (厳しい) → 確信あるものだけ陽性 → FPR低↓ TPR低↓ (見逃し多)
閾値 0.5 (普通) → バランス
閾値 0.1 (緩い) → ほぼ全部陽性 → FPR高↑ TPR高↑ (誤検出多)
→ 閾値を 1.0→0.0 に動かすと (FPR, TPR) の点が曲線を描く = ROC曲線

AUC の物理的意味:
「ランダムに選んだ陽性サンプルと陰性サンプルに対し、モデルが陽性に高いスコアを出す確率」
AUC=0.8 → 80%の確率で正しく順序付け / AUC=1.0 → 完璧 / AUC=0.5 → ランダム（コイン投げ）

📊 グラフ

💡 解説

閾値に依存しないモデル評価。閾値を1つ選ぶ前に「モデル全体の実力」を比較できる
AUC=1.0に近いほど高性能。0.9以上で「非常に良い」、0.7-0.8で「まあまあ」
不均衡データ（陽性1%/陰性99%のように偏ったデータ）では FPR が小さく見えるためROCが楽観的になる → PR曲線（Precision-Recall）のほうが適切
AUCが同じでも閾値の最適点が異なる場合がある → 用途に応じて閾値を選ぶ必要
💡 直感的に: ROC曲線は「閾値を厳しい(0.9)→緩い(0.1)に動かしたときの、見逃しと誤検出のトレードオフ」を描く。AUCは「ランダムに1人の患者と1人の健常者を選んだとき、患者のほうが高いスコアを出す確率」。曲線が左上に膨らむほど優秀。

22. SVM — マージン最大化

数理チートシート / Arc 1 Scene 4 関連

📐 数式

目的: マージン $\dfrac{2}{\|w\|}$ を最大化
制約: $y_i (w \cdot x_i + b) \geq 1 \quad \forall i$

マージン境界上の点 = サポートベクター（これだけで決定境界が決まる）
カーネルトリック: $K(x_i, x_j) = \phi(x_i) \cdot \phi(x_j)$ ← 高次元への暗黙的写像
→ パーセプトロンの「直線1本」を超えるが、NN 台頭後は主役を譲る

📊 グラフ

💡 解説

マージン最大化 → 汎化性能が理論的に保証される（構造的リスク最小化）
カーネルトリック（RBF, 多項式）で非線形分離も可能
大規模データでは学習が遅い（O(n²)〜O(n³)）
NNの台頭後、画像/NLPでは使われなくなったが、小〜中規模の構造化データでは現役
💡 直感的に: データを分ける直線の「マージン（余裕幅）」を最大化する。マージンが広いほど未知データにも強い（汎化保証）。カーネルトリックで非線形分離も可能。

23. Q学習 — 強化学習の基礎

数理チートシート / Arc 1 Scene 4 関連

📐 数式

$Q(s,a) \leftarrow Q(s,a) + \underbrace{\alpha}_{\text{学習率}} \left[ \underbrace{r}_{\text{即報酬}} + \underbrace{\gamma}_{\text{割引率}} \cdot \underbrace{\max_{a'} Q(s', a')}_{\text{将来の最良}} - Q(s,a) \right]$

$Q(s,a)$: 状態 $s$ で行動 $a$ を取る価値
$\alpha$: 学習率（新情報をどれだけ反映するか）
$r$: 即座の報酬
$\gamma$: 割引率（将来の報酬をどれだけ重視するか。0=目先のみ、0.99=長期重視）
$\max_{a'} Q(s', a')$: 次の状態で最善の行動を取った場合の価値

DQN (Deep Q-Network): Q をニューラルネットで近似
Q学習は Q を表（テーブル）で管理 → 状態数が多いと表がメモリに入らない
DQN は Q(s,a) を NN で近似 → 画像入力（Atari画面）でも直接学習可能
DeepMind (2015): Atari 49ゲームで人間超え。Experience Replay + Target Network で安定化

PPO (Proximal Policy Optimization: 近接方策最適化):
Q学習は「価値」を学ぶ (価値ベース) → PPO は「行動の確率分布」を直接学ぶ (方策ベース)
方策の更新幅を clip で制限 → 急激な変化を防ぎ学習を安定化
OpenAI (2017): ChatGPT の RLHF (人間のフィードバックで方策を改善) で使用

📊 グラフ

💡 解説

AlphaGo (2016): MCTS + DQN系で囲碁世界チャンピオンに勝利
ChatGPT (2022): PPO + RLHF で「人間の好みに沿う回答」を学習
サンプル効率が悪い（大量の試行錯誤が必要）
報酬設計が難しい。報酬ハッキング（意図しない抜け道を見つける）のリスク
📌 Q学習 → DQN → PPO の系譜:
Q学習 (テーブルで価値を管理) → DQN (NNで近似、Atariで人間超え) → PPO (方策を直接学習、ChatGPTのRLHFで使用)
→ 個別ページ: バンディット | MDP | PPO/Actor-Critic 詳細
💡 直感的に: Q学習は「この状態でこの行動をするとどれだけ得か」を表す価値表を試行錯誤で作る。DQN はこの表を NN に置き換えて巨大な状態空間（画像入力等）に対応。PPO は「どう行動するか」の確率分布を直接学ぶ方式で、ChatGPT を「人間が好む回答をする」よう調整するのに使われた。

24. 正規分布（ガウス分布）

数理チートシート関連

📐 数式

$f(x) = \dfrac{1}{\sqrt{2\pi\sigma^2}} \exp\!\left( -\dfrac{(x - \mu)^2}{2\sigma^2} \right)$

$\mu$: 平均（分布の中心）
$\sigma$: 標準偏差（散らばり具合）、$\sigma^2$ = 分散

68-95-99.7 ルール:
$\pm 1\sigma$ 内に 68%、$\pm 2\sigma$ 内に 95%、$\pm 3\sigma$ 内に 99.7% のデータが収まる

📊 グラフ

💡 解説

自然界の多くの現象が正規分布に従う（中心極限定理）
NNの重み初期化、VAEの潜在空間、拡散モデルのノイズに使用
外れ値に弱い（裾が薄い）。金融データなどは正規分布に従わない場合が多い
多次元では「次元の呪い」で直感が効かなくなる
💡 直感的に: 自然界の多くの現象が従う「釣鐘型」の分布。68-95-99.7ルール: ±1σに68%、±2σに95%のデータが入る。NNの重み初期化やVAEのノイズで頻出。

25. ベイズの定理

数理チートシート関連

📐 数式

$P(D \mid +) = \dfrac{\overbrace{P(+ \mid D)}^{\text{感度}} \cdot \overbrace{P(D)}^{\text{事前確率}}}{\underbrace{P(+)}_{\text{全陽性者の確率}}}$

$P(D)$ — 事前確率（有病率）:
検査する前の段階で「この人が病気である確率」。例: 人口の1%が糖尿病 → $P(D) = 0.01$

$P(+ \mid D)$ — 感度 (Sensitivity):
病気の人が検査陽性になる確率。感度95% = 病気の100人中95人が正しく陽性

特異度 (Specificity) = $P(- \mid \neg D)$:
健康な人が検査陰性になる確率。特異度95% = 健康な100人中95人が正しく陰性
→ 偽陽性率 $P(+ \mid \neg D) = 1 - \text{特異度}$ = 健康なのに誤って陽性になる確率 (= 5%)

$P(+)$ — 全陽性者の確率:
$= \underbrace{P(+ \mid D) \cdot P(D)}_{\text{病気で陽性}} + \underbrace{P(+ \mid \neg D) \cdot P(\neg D)}_{\text{健康だけど誤って陽性}}$

$P(D \mid +)$ — 事後確率（陽性的中率）:
検査陽性という情報を得た後の「本当に病気の確率」
= 病気で陽性 / (病気で陽性 + 健康で誤陽性)

具体例 (有病率1%, 感度95%, 特異度95%):
病気で陽性: $0.95 \times 0.01 = 0.0095$
健康で誤陽性: $0.05 \times 0.99 = 0.0495$ ← 健康な人が圧倒的に多い(99%)ので、5%でも絶対数が大きい
$P(D \mid +) = 0.0095 / (0.0095 + 0.0495) = 0.161 =$ 16.1%

📊 グラフ

💡 解説

ナイーブベイズ分類器: スパムフィルタの古典的手法。高速で実用的
有病率が低いと、感度95%でも陽性的中率は驚くほど低い（ベースレートの罠）
事前知識（事前確率）を定量的に推論に組み込める唯一のフレームワーク
事前確率の設定が主観的になりうる（客観ベイズ vs 主観ベイズの論争）

G検定頻出: 有病率1%、感度95%、特異度95% → 陽性的中率≈16%。計算を確実に。

💡 直感的に: 1000人を検査する場面を想像する:
・病気の人: 10人 → うち9.5人が陽性（感度95%）
・健康な人: 990人 → うち49.5人が誤って陽性（偽陽性率5%）
・全陽性者: 9.5 + 49.5 = 59人 → うち本当に病気はたった9.5人 (16%)

なぜこうなるか: 健康な人が圧倒的に多いので、わずかな偽陽性率でも「健康なのに陽性」の人数が「病気で陽性」より多くなる。これがベースレートの罠。

📊 Mini-max 法

_

📐 数式

$\text{value}(n) = \begin{cases} \max_{c \in \text{children}(n)} \text{value}(c) & \text{自分の手番 (MAX)} \\ \min_{c \in \text{children}(n)} \text{value}(c) & \text{相手の手番 (MIN)} \\ \text{evaluation}(n) & n \text{が葉} \end{cases}$

「自分は最大化、相手は最小化」と仮定して再帰的に値を伝播
完全情報・2人ゼロサムゲームで最適。チェス、将棋、オセロの基礎
計算量: $O(b^d)$ ($b$=分岐, $d$=深さ) → 深いゲームで爆発

📊 グラフ

3階層のゲーム木で値の伝播を可視化（葉の値を変えて根の値の変化を確認）。

🎮 この図の読み方（じゃんけん的に考える）:

設定: 2人のプレイヤー（自分=MAX と 相手=MIN）が交互に手番を取るゲーム。
自分は「スコアを最大にしたい」、相手は「スコアを最小にしたい」。

図の構造 (下から上に読む):
• 一番下（灰色の丸）= 葉: ゲームの最終結果スコア（変更可能）
• 赤い丸 (MIN) = 相手の手番: 子の中から最小の値を選ぶ（相手は自分に不利な手を選ぶ）
• 緑の丸 (MAX) = 自分の手番: 子の中から最大の値を選ぶ（自分に有利な手を選ぶ）
• 一番上の赤 (MIN) = 根（ルート）: ゲーム全体の結果

伝播の例 (デフォルト値 3,5,2,9,12,5,4,8):
1️⃣ 最下層 MIN: [3,5]→min=3 / [2,9]→min=2 / [12,5]→min=5 / [4,8]→min=4
2️⃣ 中間層 MAX: [3,2]→max=3 / [5,4]→max=5
3️⃣ 根 MIN: [3,5]→min=3 ← ゲームの結果

💡 ポイント: 自分がどんなに良い手を指しても、相手も最善手を指すと仮定する。だから根の値は「両者が最善を尽くした場合のゲーム結果」。

💡 解説

完全情報ゲームで理論上最適
指数爆発: チェスは $b\approx 35, d\approx 80$ → $35^{80}$ 通り
対策: 探索深さ制限 + 評価関数 + αβ枝刈り (次ページ)
Deep Blue (1997) は Mini-max + αβ + 専用ハードでKasparovに勝利
💡 直感的に: 「自分は最大化、相手は最小化」と仮定してゲーム木を再帰的に評価。両者が最善を尽くした場合の結果を計算する。チェス・将棋AIの基礎。

関連: αβ枝刈り (高速化) | MCTS

📊 αβ 枝刈り (Alpha-Beta Pruning)

_

📐 数式

$\alpha$ = MAX が確保している最低保証値 (現時点で得られる最良の選択肢)
$\beta$ = MIN が許す最大値

枝刈り条件: $\alpha \geq \beta$ → 以降の探索を打ち切り

「これ以上探しても結果は変わらない」と判断できる場合に探索を中止
理論的に最適な順序で枝刈りすると探索量を $O(b^d) \to O(b^{d/2})$ に削減

📊 グラフ

同じ木で α≥β になり枝刈りされる枝を赤色で表示。葉の値を変えると枝刈り箇所が変わる。

💡 解説

Mini-max と同じ結果を出しつつ、探索量を平方根に削減
最良順序探索 (Move Ordering) と組み合わせるとさらに効率化
チェスAIで標準採用。Deep Blue, Stockfish の核心
完全情報・2人ゲーム限定 (囲碁の超巨大分岐には不十分 → MCTS へ)
💡 直感的に: Mini-maxの「これ以上探しても結果は変わらない」枝を刈り取る。探索量を平方根に削減。Deep Blue (1997) の核心技術。

関連: Mini-max | MCTS

📊 主成分分析 (PCA)

_

📐 数式

分散共分散行列 $\Sigma$ の固有値分解: $\Sigma v_i = \lambda_i v_i$

固有ベクトル $v_i$ = 主成分の方向, 固有値 $\lambda_i$ = その方向の分散

第1主成分: $v_1 = \arg\max_{\|v\|=1} v^\top \Sigma v$ (分散最大方向)

寄与率: $\dfrac{\lambda_i}{\sum_j \lambda_j}$
累積寄与率 80% 以上で次元数を決めるのが慣例

📊 グラフ

2次元データの主成分方向を可視化。第1/第2主成分の寄与率も計算。

💡 解説

高次元データを少数の軸に圧縮。可視化・前処理に必須
線形変換のみ → 解釈しやすい・高速
非線形構造を捉えられない → t-SNE/UMAP/AutoEncoder で対応
用途: 次元削減、ノイズ除去、可視化、特徴抽出
💡 直感的に: データの「分散が最大の方向」を主成分として抽出。100次元→2次元に圧縮しても主要な情報を保持。可視化・ノイズ除去・前処理に必須。

関連: k-means (前処理) | 📚 教師なし学習一覧

📊 協調フィルタリング (Collaborative Filtering)

_

📐 数式

アイテムベース: ユーザー $u$ への商品 $i$ の予測評価
$\hat{r}_{ui} = \dfrac{\sum_{j \in N(i)} \text{sim}(i, j) \cdot r_{uj}}{\sum_{j \in N(i)} |\text{sim}(i, j)|}$

行列分解 (SVD系): 評価行列 $R \approx U \cdot V^\top$
$U \in \mathbb{R}^{n \times k}$ = ユーザー潜在特徴, $V \in \mathbb{R}^{m \times k}$ = アイテム潜在特徴

類似度: コサイン類似度 $\text{sim}(i,j) = \dfrac{i \cdot j}{\|i\| \|j\|}$ が標準

📊 グラフ

ユーザー×アイテム評価行列。空白セルが協調フィルタの予測対象。

💡 解説

商品の中身を知らなくても推薦可能
Amazon, Netflix, Spotify の推薦エンジンの基礎
コールドスタート問題: 新規ユーザー/商品は評価データなしで推薦不可
対策: コンテンツベースとのハイブリッド (現代の主流)
💡 直感的に: 「あなたと似た人が買った商品」を推薦。商品の中身を知らなくてOK。新規ユーザー/商品は評価データがない（コールドスタート問題）→ コンテンツベースと併用。

関連: 📚 教師なし学習一覧

📊 マルコフ決定過程 (MDP)

_

📐 数式

5要素: $\langle S, A, P, R, \gamma \rangle$
$S$ = 状態集合 / $A$ = 行動集合
$P(s' \mid s, a)$ = 遷移確率 / $R(s, a)$ = 報酬関数
$\gamma \in [0, 1]$ = 割引率

マルコフ性: $P(s_{t+1} \mid s_t, a_t, s_{t-1}, \dots) = P(s_{t+1} \mid s_t, a_t)$
「現在の状態だけで次が決まる」という仮定 → 過去の履歴を覚える必要なし

価値関数: $V^\pi(s) = \mathbb{E}\left[ \sum_{t=0}^\infty \underbrace{\gamma^t}_{\substack{\text{将来の}\\\text{割引}}} \underbrace{r_t}_{\text{報酬}} \mid s_0 = s \right]$

📊 グラフ

4×4 グリッドワールドで価値関数 V(s) を可視化。γ を変えると将来重視度が変わる。

💡 解説

RL の数学的フレームワーク。すべての RL 手法の基礎
用途: ロボット制御、ゲームAI、自動運転、レコメンド
マルコフ性が成り立たない場合 (履歴依存) は POMDP に拡張が必要
価値反復・方策反復で最適方策が求まる
💡 直感的に: 「現在の状態だけで次が決まる」フレームワーク。5要素(S,A,P,R,γ)で定義。全てのRL手法の数学的基盤。γが大きいほど将来重視。

関連: 📊 Q学習 (MDPの価値学習) | バンディット (1状態MDP)

📊 多腕バンディット (Multi-Armed Bandit)

_

📐 数式

$K$ 本のアーム (選択肢)、各アームの真の報酬期待値 $\mu_k$ は未知
時刻 $t$ にアーム $a_t$ を選択 → 報酬 $r_t \sim \mathcal{N}(\mu_{a_t}, \sigma^2)$

目的: $T$ 回の試行で
$\displaystyle\max \sum_{t=1}^T r_t$ または $\displaystyle\min \text{Regret} = T\mu^* - \sum_{t=1}^T \mu_{a_t}$

$\mu^* = \max_k \mu_k$ = 最適アームの期待報酬
探索 vs 活用: 未知のアームを試すか (探索)、既知の最良アームを選ぶか (活用)

📊 グラフ

5本のアームを 100 回試行。「ランダム」と「最良固定」の累積報酬を比較。

💡 解説

A/Bテストの理論的基礎。広告配信・推薦の数学モデル
状態が1つだけのMDP → シンプルだが本質的
解法: ε-greedy / UCB / Thompson Sampling (次ページ)
「ランダム」も「greedy」もRegretは線形に増加 → より賢い戦略が必要
💡 直感的に: K本のスロットマシン、どれを引くか？「未知を試す(探索)」vs「既知の最良を選ぶ(活用)」のジレンマ。A/Bテスト・広告配信の数学モデル。

関連: ε-greedy | UCB | MDP

📊 ε-greedy 方策

_

📐 数式

$a_t = \begin{cases} \text{ランダムにアーム選択} & \text{確率 } \varepsilon \\ \arg\max_a \hat{Q}(a) & \text{確率 } 1 - \varepsilon \end{cases}$

$\varepsilon$ で探索/活用のバランスを直接制御
$\varepsilon$-decay: $\varepsilon_t = \varepsilon_0 / \sqrt{t}$ で徐々に活用に寄せる戦略も

最もシンプルな探索戦略。DQN 等でも採用される実用標準。

📊 グラフ

ε を変えて累積報酬の差を観察。0なら探索しない、1なら完全ランダム。

💡 解説

実装極めて簡単。DQN等のRL実装で第一選択
ε で探索/活用を直接制御可能
ε=0.1 でも 10% は無駄に悪手を選び続ける
不確実性を考慮しない (どのアームも等確率で探索) → UCB が改善
💡 直感的に: 10%の確率でランダム(探索)、90%で既知の最良(活用)。最もシンプルな探索戦略。DQNでも採用。ε=0は探索なし=最初の運次第。

関連: UCB (vs) | バンディット | 📊 Q学習

📊 Subword Tokenization

_

📐 数式

BPE (Byte Pair Encoding):
1. 文字レベルから開始: ['l','o','w','e','r']
2. 最頻出のペアをマージ: 'lo' → 'lo'
3. 語彙サイズに達するまで反復

例: "unhappiness" → ["un", "happi", "ness"]

未知語問題を解消: 任意の単語をサブワードに分解可能
GPT (BPE), BERT (WordPiece), T5 (SentencePiece)

📊 グラフ

サブワード語彙数を変えてトークン化結果がどう変わるか観察。

💡 解説

未知語に対応 (任意の文字列を分解可能)
GPT/BERT/Llama 等の現代LLMの基盤
日本語では1文字=1トークンに近い (英語より非効率)
SentencePiece (Google) は言語非依存で広く使われる
💡 直感的に: 「unhappiness」→「un+happi+ness」のように分割。未知語に対応。GPT(BPE)、BERT(WordPiece)の基盤。日本語は1文字≈1トークンで非効率な傾向。

関連: Word2Vec | 📊 Transformer

📊 RAG (Retrieval-Augmented Generation)

_

📐 数式

2段階処理:
1. Retrieval: 質問 $q$ に対して関連文書 $D = \{d_1, \dots, d_k\}$ を検索
  BM25 + ベクトル検索 (cos類似度) のハイブリッドが主流
2. Generation: $\text{LLM}(q, D)$ で回答生成

LLM の知識を「検索結果」で動的に拡張 → 最新情報・社内文書・ハルシネーション対策
古典的 BM25 が再評価される好例

📊 グラフ

RAG のアーキテクチャ。BM25 + ベクトル検索のハイブリッド構成。

💡 解説

ハルシネーション軽減: 検索結果に基づく回答
最新情報・社内文書も参照可能 (LLM再学習不要)
ChatGPT 「Chat with PDF」、社内ナレッジBot の標準パターン
2023+: 古典 BM25 が LLM 時代に蘇った代表例
💡 直感的に: LLMに「検索結果を読ませて回答させる」。最新情報・社内文書も参照可能。ハルシネーション軽減。BM25+ベクトル検索のハイブリッドが主流。ChatGPTの「ファイル参照」はRAG。

関連: TF-IDF | BM25 | Word2Vec

📊 グリッドサーチ vs ランダムサーチ

_

📐 数式

グリッドサーチ: 全組合せを探索 → $|\Theta_1| \times |\Theta_2| \times \cdots$
ランダムサーチ: 各点をランダムに $N$ 回サンプリング

Bergstra & Bengio (2012): 重要なパラメータが少数の場合、ランダムが効率的

📊 グラフ

2次元探索空間でのグリッド vs ランダムの比較。

💡 解説

グリッド: 再現性最高、シンプル
グリッド: パラメータ数が増えると組合せ爆発
ランダム: 重要次元のサンプルが多くなる傾向 → 効率的
scikit-learn: GridSearchCV / RandomizedSearchCV
💡 直感的に: 全組合せを網羅的に試す。再現性最高だが、パラメータ数が増えると組合せ爆発。実はランダムのほうが効率的な場合が多い(Bergstra 2012)。

関連: ベイズ最適化 (より賢い)

1. ベイズ最適化 (Bayesian Optimization)

_

📐 数式

概要: 評価コストが高い関数（NN 学習に数時間 etc.）の最適解を、最小限の試行回数で見つける戦略。GP（サロゲートモデル）+ 獲得関数（次の探索点を決める）の 2 部品で構成。

ベイズ最適化のループ:
Step 1: 現在の観測データ $\mathcal{D} = \{(x_i, y_i)\}$ で GP を更新 → $\mu(x), \sigma(x)$
Step 2: 獲得関数 $\alpha(x)$ を最大化する $x_{\text{next}}$ を選ぶ
Step 3: $y_{\text{next}} = f(x_{\text{next}})$ を実際に評価（高コスト!）
Step 4: $\mathcal{D} \leftarrow \mathcal{D} \cup \{(x_{\text{next}}, y_{\text{next}})\}$ → Step 1 へ

獲得関数（次にどこを試すか）:
EI (Expected Improvement):
$\alpha_{\text{EI}}(x) = \underbrace{(\mu(x) - f_{\text{best}})}_{\substack{\text{改善幅の}\\\text{期待値}}} \Phi(Z) + \underbrace{\sigma(x)}_{\substack{\text{不確実性}\\\text{（探索）}}} \phi(Z)$, $Z = \dfrac{\mu(x) - f_{\text{best}}}{\sigma(x)}$
第 1 項: 現時点で良さそうな場所を活用（exploitation）
第 2 項: 不確実な場所を探索（exploration）→ $\sigma$ が大きい = まだ試していない = 探索価値あり

UCB (Upper Confidence Bound): $\alpha_{\text{UCB}}(x) = \mu(x) + \underbrace{\kappa}_{\substack{\text{探索vs活用}\\\text{バランス}}} \cdot \sigma(x)$
$\kappa$ 大 → 探索重視（不確実な場所を優先）。$\kappa$ 小 → 活用重視（現時点で最良の場所付近を深掘り）

📊 グラフ（ベイズ最適化の反復過程 + 獲得関数）

👀 試してみよう: 反復 1→15 に動かすと、GP（黄線）が真の関数（緑点線）に近づく。獲得関数（紫）のピーク（★）が「不確実 or 改善見込みの高い場所」を選ぶ様子を観察。EI→UCB に切り替えると探索パターンが変わる。

💡 解説

少ない試行（10-50 回）で最適解に到達 → NN ハイパラ調整に最適（1 回の学習に数時間かかる場合）
探索 vs 活用のバランスを獲得関数で自動制御
不確実な場所を優先的に試す → ランダムサーチより効率的
逐次的（前回の結果を待って次の点を決める）→ 大規模並列化が難しい
高次元（20 次元以上）では GP の精度が低下 → TPE や他の手法が有利
💡 直感的に: 宝探しに例えると — GP が「ここは金が出そう（予測高）」「ここはまだ掘ってない（不確実性大）」の地図を作り、獲得関数 が「次にどこを掘るか」を決める。掘るたびに地図が精密になり、効率的に宝に辿り着く。
💡 グリッドサーチ / ランダムサーチとの違い: グリッド/ランダムは「前の試行結果を無視して次の点を決める」。ベイズ最適化は「前の試行から学んで次にどこを試すのが最も有益かを計算する」。少ない試行回数で最適解に到達できる理由はここにある。→ グリッド/ランダムサーチ

関連: ガウス過程 (GP) | 獲得関数 | TPE (Optuna) | グリッド/ランダムサーチ

📖 詳細解説

① ベイズ最適化の 1 ラウンドを数値で追跡

学習率の最適化を例に。目的関数 $f(\text{lr})$ = validation accuracy（1 回の評価 = NN の全 epoch 学習 → 数時間）

現在の観測データ: $\mathcal{D} = \{(0.001, 85.2\%), (0.01, 91.5\%), (0.1, 78.3\%)\}$
$f_{\text{best}} = 91.5\%$ (lr=0.01)

Step 1: GP で予測（任意の lr に対して $\mu(lr), \sigma(lr)$ を出力）:
候補 lrGP 予測 $\mu$不確実性 $\sigma$EI 値解釈
0.00589.1%2.3%0.42既知の領域（0.001と0.01の間）
0.0390.8%4.1%1.87← EI 最大! 予測も高く不確実性も大きい
0.0585.5%5.2%1.15不確実だが予測が低め
0.0191.5%0.1%0.01既に観測済み → 新情報なし

Step 2: lr=0.03 を選択（EI 最大）→ NN を学習（数時間）→ $f(0.03) = 93.1\%$ !
Step 3: $\mathcal{D}$ に追加 → $f_{\text{best}} = 93.1\%$ に更新 → GP を再学習 → 次のラウンドへ

★ ポイント: lr=0.03 は「予測値がそこそこ高い」かつ「不確実性が大きい」 → EI が「試す価値がある」と判断。結果として $f_{\text{best}}$ を更新できた。ランダムサーチなら何十回も無駄な試行が必要。
② 探索 vs 活用のトレードオフ — 獲得関数の設計思想

獲得関数式特徴使いどころ
EI$E[\max(f-f_{\text{best}}, 0)]$探索と活用を自然にバランス。最も人気汎用（デフォルト推奨）
UCB$\mu + \kappa\sigma$$\kappa$ で明示的にバランス調整可能探索の度合いを制御したい場合
PI$P(f > f_{\text{best}})$活用偏重（改善確率のみ、改善量を無視）微調整フェーズ

探索（Exploration）: $\sigma$ が大きい場所 = まだ試していない場所を優先
→ 「もしかしたら良い場所があるかも」を確認
活用（Exploitation）: $\mu$ が大きい場所 = 現時点で良さそうな場所を深掘り
→ 確実に良い結果を得ようとする

★ EI が人気な理由: EI は「改善量の期待値」を計算するので、$\sigma$ が大きくても $\mu$ が低すぎれば探索しない（改善見込みが低いから）。探索と活用の自動バランスが EI の最大の強み。
③ 実用: NN ハイパーパラメータ最適化の全体像

典型的な設定:
• 最適化対象: 学習率 (0.0001-0.1)、バッチサイズ (16-256)、層数 (2-8)、ドロップアウト率 (0-0.5)
• 目的関数: validation accuracy（1 回の評価 = 全 epoch 学習 → 数時間）
• 予算: 50 回の試行

手法50 回試行の結果最適解到達の効率
グリッドサーチ4 次元 × 粗いグリッド → 大半が無駄低い（次元の呪い）
ランダムサーチランダムに 50 点 → 運任せ中程度
ベイズ最適化 (GP)前の結果から学んで次の点を選択高い（10-20 回で収束）
TPE (Optuna)GP の代わりに TPE で高速近似高い + 並列化可能

Optuna での実装（Python）:
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=50)  # 内部で TPE が自動的に次の点を提案
→ Optuna は GP ではなく TPE（Tree-structured Parzen Estimator）を使用 → 高速・並列化可能。GP 版は GPyOpt, BoTorch (Meta) が代表的

1. ガウス過程 (Gaussian Process)

_

📐 数式

概要: ガウス過程は「関数全体を確率変数として扱う」非パラメトリックモデル。NN のように重みを学習するのではなく、データ点間の類似度（カーネル）だけで予測+不確実性を同時に出力する。

ガウス過程の定義:
$f(x) \sim \mathcal{GP}\!\left(\underbrace{\mu(x)}_{\substack{\text{平均関数}\\\text{(事前の予想)}}},\ \underbrace{k(x, x')}_{\substack{\text{カーネル関数}\\\text{(点間の相関)}}}\right)$
→ 任意の有限個の入力 $\{x_1, \ldots, x_n\}$ での出力 $\{f(x_1), \ldots, f(x_n)\}$ が多変量ガウス分布に従う

RBF（ガウス）カーネル:
$k(x, x') = \underbrace{\sigma_f^2}_{\substack{\text{信号}\\\text{分散}}} \exp\!\left(-\dfrac{\|x - x'\|^2}{\underbrace{2\ell^2}_{\substack{\text{length}\\\text{scale}}}}\right)$
$\ell$ 大 → 遠い点も相関 → 滑らかな関数 を仮定
$\ell$ 小 → 近い点のみ相関 → 急変する関数 を仮定
$\sigma_f^2$ → 関数の振幅の大きさ（出力のスケール）

事後分布（観測データが与えられた後の予測）:
$\mu_*(x_*) = \underbrace{k_*^T K^{-1} y}_{\substack{\text{観測データの}\\\text{加重平均}}}$
$\sigma_*^2(x_*) = \underbrace{k_{**}}_{\substack{\text{事前}\\\text{分散}}} - \underbrace{k_*^T K^{-1} k_*}_{\substack{\text{観測で減った}\\\text{不確実性}}}$

$K$ = 観測点間のカーネル行列（$n \times n$）。$k_*$ = 新しい点と観測点の相関ベクトル
$\mu_*$ = 予測平均（最も起こりそうな値）。$\sigma_*^2$ = 予測分散（不確実性）
→ 観測点に近いほど $k_*^T K^{-1} k_*$ が大きくなり、$\sigma_*^2$ が小さくなる（確信度が高い）
→ 観測点から離れると $\sigma_*^2$ が大きい（不確実 = もっとデータが欲しい）

📊 グラフ（GP の予測と不確実性の可視化）

💡 解説

予測値 + 不確実性を同時に出力 → 「次にどこを調べるべきか」がわかる（ベイズ最適化の核心）
少ないデータでも強い（ベイズ的に事前分布を活用）
カーネルの選択で「関数の性質」を表現（滑らか/周期的/線形 etc.）
計算量 $O(n^3)$（カーネル行列の逆行列）→ 大規模データ（数万点以上）に不向き
高次元入力（100次元+）ではカーネルの設計が難しい
💡 直感的に: 「データが多い場所は自信を持って予測。データがない場所は正直に "わからない" と言う」— これが GP の本質。NN は常に自信満々な予測を返すが、GP は不確実性を定量化できる。ベイズ最適化では「不確実な場所を優先的に調べる」ことで効率的に最適解を見つける。
💡 ベイズ最適化との関係: GP = 「関数を推定する」部分（サロゲートモデル）。ベイズ最適化 = 「GP の予測+不確実性を使って次にどこを評価するかを決める」戦略。GP なしにベイズ最適化は成り立たない。→ ベイズ最適化

関連: ベイズ最適化 | 獲得関数 | TPE (Optuna)

📖 詳細解説

① カーネル行列とは — 2 観測点での具体計算

観測データ: $(x_1, y_1) = (-1, 0.5)$, $(x_2, y_2) = (1, 1.5)$。RBF カーネル、$\ell = 1.0$。

Step 1: カーネル行列 $K$（2×2）を計算:
$K_{11} = k(-1, -1) = \exp\left(-\frac{0}{2}\right) = 1.000$
$K_{12} = k(-1, 1) = \exp\left(-\frac{4}{2}\right) = 0.135$
$K_{22} = k(1, 1) = 1.000$
$K = \begin{bmatrix} 1.000 & 0.135 \\ 0.135 & 1.000 \end{bmatrix}$
→ 対角は 1.0（自分自身との相関=完全一致）。(−1, 1) は距離 2 → 相関 0.135（弱い）

Step 2: 新しい点 $x_* = 0$ の予測:
$k_* = \begin{bmatrix} k(0, -1) \\ k(0, 1) \end{bmatrix} = \begin{bmatrix} \exp(-0.5) \\ \exp(-0.5) \end{bmatrix} = \begin{bmatrix} 0.607 \\ 0.607 \end{bmatrix}$
→ $x_* = 0$ は $x_1 = -1$ と $x_2 = 1$ に等距離 → 両方と同じ相関

Step 3: 予測平均:
$K^{-1} = \frac{1}{1-0.135^2}\begin{bmatrix} 1 & -0.135 \\ -0.135 & 1 \end{bmatrix} \approx \begin{bmatrix} 1.018 & -0.138 \\ -0.138 & 1.018 \end{bmatrix}$

$\mu_*(0) = k_*^T K^{-1} y = [0.607, 0.607] \begin{bmatrix} 1.018 & -0.138 \\ -0.138 & 1.018 \end{bmatrix} \begin{bmatrix} 0.5 \\ 1.5 \end{bmatrix}$
$= [0.607, 0.607] \begin{bmatrix} 0.302 \\ 1.458 \end{bmatrix} = 0.183 + 0.885 = \mathbf{1.068}$
→ 両方の観測値の加重平均（$y_1=0.5$ と $y_2=1.5$ の中間寄り）

Step 4: 予測分散:
$\sigma_*^2(0) = k_{**} - k_*^T K^{-1} k_* = 1.0 - [0.607, 0.607] \begin{bmatrix} 0.534 \\ 0.534 \end{bmatrix} = 1.0 - 0.649 = \mathbf{0.351}$
$\sigma_* = \sqrt{0.351} \approx 0.593$
→ 95% 信頼区間: $1.068 \pm 1.96 \times 0.593 = [-0.09, 2.23]$ → 観測点から離れているのでまだ不確実
② カーネルの種類と選択 — 「関数の性質」を仮定する

カーネルの選択 = 「この関数はどんな形をしているか」の事前仮定:

カーネル数式仮定する関数の性質用途
RBF（ガウス）$\exp(-\|x-x'\|^2/2\ell^2)$無限回微分可能（非常に滑らか）最も汎用的。ベイズ最適化の標準
Matérn 5/2$(1+\sqrt{5}r+5r^2/3)e^{-\sqrt{5}r}$2回微分可能（RBFよりやや粗い）物理シミュレーション
Periodic$\exp(-2\sin^2(\pi|x-x'|/p)/\ell^2)$周期 $p$ で繰り返す季節性のある時系列
Linear$\sigma_b^2 + \sigma_v^2 (x-c)(x'-c)$線形関数線形回帰のベイズ版

★ ポイント: カーネルの足し算・掛け算で新しいカーネルを作れる（例: RBF + Periodic = 滑らか + 周期性）。カーネルのハイパーパラメータ $\ell$ は周辺尤度の最大化で自動決定できる。
③ GP と NN の比較 — いつ GP を使うか

ガウス過程 (GP)ニューラルネット (NN)
パラメータノンパラメトリック（データ数に依存）パラメトリック（重みの数を固定）
不確実性自然に出力（$\mu \pm \sigma$）出力しない（MC Dropout 等で近似）
少データ強い（ベイズ事前分布で補正）弱い（大量データ前提）
大データ$O(n^3)$ で破綻$O(n)$ で SGD 学習可能
高次元入力次元の呪い（カーネル設計困難）深層学習で特徴抽出
主な用途ベイズ最適化、能動学習、
時系列予測、少数ショット		画像認識、NLP、
大規模回帰・分類

★ 使い分けの指針:
• データ 1000 点以下 + 不確実性が必要 → GP
• データ 数万点以上 + 高次元入力 → NN
• ハイパーパラメータ最適化（数十〜数百回の試行）→ GP + ベイズ最適化（Optuna の内部で使用）

📊 獲得関数 (Acquisition Function)

_

📐 数式

EI (Expected Improvement): $\mathbb{E}[\max(f(x) - f_{\text{best}}, 0)]$
UCB (Upper Confidence Bound): $\mu(x) + \kappa \sigma(x)$
PI (Probability of Improvement): $P(f(x) > f_{\text{best}})$

EI が最も人気: 期待改善量を最大化 → 探索vs活用の自然なバランス

📊 グラフ

同じ GP モデルに3種の獲得関数を適用。次の探索点が異なることを観察。

💡 解説

EI: 期待改善量。最も人気・実用的
UCB: シンプル、理論保証あり ($\kappa$ で探索強度調整)
PI: 控えめ過ぎる傾向 (改善確率のみで量を考慮しない)
💡 直感的に: 「確実に良さそうな点(活用)」と「不確実だが可能性がある点(探索)」のバランスを取る関数。EI(期待改善量)が最も人気。UCBはバンディットのUCBと同じ発想。

関連: ベイズ最適化 | UCB方策 (バンディット版)

📊 TPE (Tree-structured Parzen Estimator)

_

📐 数式

良い試行 $g(x)$ と悪い試行 $\ell(x)$ を別々にカーネル密度推定:
$g(x) = p(x \mid f(x) < f^*)$, $\ell(x) = p(x \mid f(x) \geq f^*)$

次の試行点: $\arg\max_x \dfrac{g(x)}{\ell(x)}$

「良い試行が出やすい / 悪い試行が出にくい」点を選ぶ
GP より高速、階層パラメータ・カテゴリ変数も自然に扱える → Optuna 標準

📊 グラフ

過去の試行を「良い (上位25%)」「悪い (下位75%)」に分け、g(x)/ℓ(x) 比が高い点を選択。

💡 解説

Optuna (Preferred Networks 製) のデフォルト
階層的・カテゴリカルパラメータも自然に扱える
GP より計算高速
Pruning (早期打切り) と組合せて実用最強
💡 直感的に: 試行を「良い/悪い」に2分して別々にモデル化。GPより高速でカテゴリカル変数も扱える。Optuna(日本発)のデフォルト。Pruning(早期打切り)と組合せて実用最強。

関連: ベイズ最適化 (vs) | 📚 ハイパラ最適化全般

1. グラフ構造 — データをノードとエッジで表現する

_

📐 数式

概要: グラフ $G = (V, E)$ は「もの（ノード $V$）」と「もの同士の関係（エッジ $E$）」で世界を表現するデータ構造。テーブル・画像・テキストでは表しにくい「関係性」を自然に扱える。

グラフの基本要素:
$G = (\underbrace{V}_{\substack{\text{ノード集合}\\\text{(ユーザー, 分子, 論文 etc.)}}},\ \underbrace{E}_{\substack{\text{エッジ集合}\\\text{(関係, 結合, 引用 etc.)}}},\ \underbrace{X}_{\substack{\text{ノード特徴量}\\\text{(属性ベクトル)}}})$

隣接行列 $A \in \{0,1\}^{|V| \times |V|}$: $A_{ij} = 1$ ならノード $i$ と $j$ にエッジがある
次数 $d_v = \sum_j A_{vj}$: ノード $v$ の接続数

グラフの種類:
• 無向グラフ: SNS の友人関係（A↔B = B↔A）。$A$ は対称行列
• 有向グラフ: 論文の引用（A→B ≠ B→A）、Web のリンク
• 重み付きグラフ: 道路ネットワーク（距離=重み）、取引ネットワーク（金額=重み）
• 二部グラフ: ユーザー↔商品（推薦システム）。2 種類のノード

ナレッジグラフ（特殊な有向ラベル付きグラフ）:
$(h, r, t)$ = (主語, 関係, 目的語) のトリプレット:
例: (東京, 首都_of, 日本), (GPT-4, 開発元, OpenAI), (猫, is_a, 動物)
Google Knowledge Graph（検索結果のインフォボックス）、Wikidata がこの形式

📊 グラフ（データ形式の比較 + グラフ種別の可視化）

👀 試してみよう: 4 つのグラフ種別を切り替えて、同じ「ノード + エッジ」の枠組みが全く異なるドメインで使えることを確認。ナレッジグラフだけ「エッジにラベル（関係名）がある」のがポイント。

💡 解説

グラフ構造は「関係性」を自然に表現できる唯一のデータ形式
テーブルでは失われる「誰と誰が繋がっているか」の情報を保持
ノード分類、リンク予測、グラフ分類の 3 タスクで強力
グラフの構築自体が難しい場合がある（何をノード/エッジにするかの設計判断）
大規模グラフ（数億ノード）のストレージと処理は専用インフラが必要
💡 直感的に: テーブルは「個体の属性」、画像は「空間の配置」、テキストは「単語の並び」を扱う。グラフは「もの同士の関係」を扱う。友人関係、分子結合、取引ネットワーク — 「関係が本質」のデータにはグラフが最適。
💡 いつグラフを使うか: 自分のデータに「ノード間の関係（接続構造）」がある → グラフ + GNN を検討。テーブルデータ（行×列）なら XGBoost、画像なら CNN/ViT、テキストなら Transformer が第一候補。→ メッセージパッシング でグラフ上の NN を学ぶ

関連: メッセージパッシング (GNN) | GCN | GAT | 📚 GNN Index

📖 詳細解説

① データ形式の比較 — いつ何を使うか

データ形式構造得意なこと代表モデル例
テーブル行 × 列（固定長）個体の属性による分類・回帰XGBoost, LightGBM顧客データ, 医療記録
画像2D グリッド（H×W×C）空間パターン認識CNN, ViT写真, 医療画像, 衛星画像
テキスト/系列1D 系列（可変長）順序・文脈の理解Transformer, BERT/GPT文章, 音声, 時系列
グラフノード + エッジ（不定形）関係性・接続構造の理解GCN, GAT, GraphSAGESNS, 分子, 知識ベース

★ 判断基準: 「データの本質が個体の属性にあるか、個体間の関係にあるか」。不正検知で「口座の属性」だけ見るならテーブル、「送金ネットワークの構造」を見るならグラフ。
② グラフの 3 大タスク

タスク入力出力業務例
ノード分類グラフ + 一部のラベル未ラベルノードのクラス不正口座検出、論文カテゴリ分類
リンク予測一部のエッジが欠損したグラフ存在しうるエッジの確率推薦（友人/商品/薬）
グラフ分類複数のグラフ（各 1 ラベル）グラフ全体のクラス分子の毒性予測（分子 1 個 = 1 グラフ）

→ ノード分類は GCN/GAT、リンク予測は GraphSAGE/TransE、グラフ分類は GIN (Graph Isomorphism Network) が代表的
③ ナレッジグラフの特徴 — 通常のグラフとの違い

通常のグラフナレッジグラフ
エッジ接続の有無のみ（0 or 1）関係の種類がラベル付き（開発元, is_a, 首都_of）
方向無向が多い常に有向（主語→目的語）
ノード数数千〜数百万数百万〜数十億（Wikidata: 1億+）
主な手法GCN, GAT, GraphSAGETransE, ComplEx, R-GCN
代表的応用SNS, 分子, 交通検索（Google）, QA, 推薦, RAG

ナレッジグラフ + LLM の融合（最新トレンド）:
• LLM は「言葉で知識を持つ」が、ハルシネーション（嘘）が問題
• ナレッジグラフは「事実を構造化して持つ」が、自然言語理解が弱い
• 両者を組み合わせて「事実に基づいた回答」を実現 → GraphRAG（Microsoft）
→ 業務では「社内のナレッジグラフ × LLM」で FAQ 自動回答、意思決定支援等に活用

1. GNN メッセージパッシング — グラフの畳み込み

_

📐 数式

概要: GNN (Graph Neural Network) は「グラフ構造のデータ」を扱う NN。SNS の友人関係、分子の原子結合、論文の引用ネットワーク等。各ノードが近傍から情報を集めて自分の表現を更新する — これが メッセージパッシング。

メッセージパッシングの一般形:
$h_v^{(l+1)} = \underbrace{\text{UPDATE}}_{\substack{\text{自分の}\\\text{表現を更新}}}\!\left(h_v^{(l)},\ \underbrace{\text{AGGREGATE}}_{\substack{\text{近傍の情報}\\\text{を集約}}}\!\left(\left\{\underbrace{h_u^{(l)}}_{\substack{\text{近傍ノード}\\\text{の特徴量}}} : u \in \mathcal{N}(v)\right\}\right)\right)$

$h_v^{(l)}$ = ノード $v$ の $l$ 層目の特徴ベクトル。$\mathcal{N}(v)$ = $v$ の近傍ノード集合
$l$ 層重ねると $l$ ホップ先 の情報が到達。2 層 → 友人の友人まで、3 層 → 友人の友人の友人まで

AGGREGATE の代表的な実装:
Mean（GCN）: $\text{AGG} = \frac{1}{|\mathcal{N}(v)|}\sum_{u \in \mathcal{N}(v)} h_u$
Attention（GAT）: $\text{AGG} = \sum_{u \in \mathcal{N}(v)} \alpha_{vu} \cdot h_u$ ← 重要な近傍に注目
Max Pool（GraphSAGE）: $\text{AGG} = \max_{u \in \mathcal{N}(v)} \text{MLP}(h_u)$

→ CNN の畳み込みとの対応: CNN は「固定グリッド（3×3）の近傍を集約」。GNN は「グラフの隣接ノードを集約」。どちらも「局所情報を統合して表現を作る」同じ発想

📊 グラフ（L 層のメッセージ到達範囲）

💡 解説

GNN の共通フレームワーク。GCN, GAT, GraphSAGE 等はすべてメッセージパッシングの一種
グラフ構造を直接扱える（CNN は固定グリッド、RNN は系列のみ）
応用: SNS（推薦）、化学（分子物性予測）、交通（経路最適化）、生物学（タンパク質構造 = AlphaFold）
Over-smoothing: 層を重ねすぎると全ノードが同じ表現に収束 → 通常 2-4 層が限界
大規模グラフ（数百万ノード）では近傍サンプリングが必要 → GraphSAGE で解決
💡 直感的に: 「SNS で自分のプロフィールを、友人の情報を参考に更新する」のを全員が同時にやる。1 ラウンド（1 層）で直接の友人の情報が届き、2 ラウンドで友人の友人まで。3 ラウンド以上やると全員が似たプロフィールに（Over-smoothing）。

関連: GCN（Mean 集約） | GAT（Attention 集約） | 📚 GNN Index

📖 詳細解説

① メッセージパッシング 1 ラウンドの数値例

3 ノードのグラフ: A—B—C（A と B が接続、B と C が接続）
初期特徴量: $h_A^{(0)} = [1, 0]$, $h_B^{(0)} = [0, 1]$, $h_C^{(0)} = [1, 1]$
AGGREGATE = Mean, UPDATE = 自分 + 集約（重み $W$ は省略）

ノード B の更新（$\mathcal{N}(B) = \{A, C\}$）:
$\text{AGG}(B) = \text{Mean}(h_A, h_C) = \frac{[1,0] + [1,1]}{2} = [1.0, 0.5]$
$h_B^{(1)} = h_B^{(0)} + \text{AGG}(B) = [0,1] + [1.0, 0.5] = [1.0, 1.5]$
→ B は A と C 両方の情報を取り込んだ

ノード A の更新（$\mathcal{N}(A) = \{B\}$）:
$h_A^{(1)} = [1,0] + [0,1] = [1.0, 1.0]$
→ A は B の情報だけ取り込んだ（C の情報は 1 ホップでは届かない。2 層目で届く）
② Over-smoothing — なぜ層を重ねすぎるとダメか

層数 L情報到達範囲効果
1-2直接の近傍〜友人の友人局所構造を捉える。最も効果的
3-4グラフの大部分広範囲の情報。精度が頭打ちに
5+全ノードOver-smoothing: 全ノードが同じ表現に → 分類不能

直感: 全員が全員の平均情報を持つ → 全員が同じになる = 「個性がなくなる」
対策: Jumping Knowledge（各層の出力を concat）、Residual Connection、DropEdge
③ GNN の応用分野 — なぜ業務で重要か

分野ノードエッジタスク代表モデル
SNS・推薦ユーザー友人関係リンク予測（推薦）PinSage (Pinterest)
創薬・化学原子化学結合分子物性予測MPNN, SchNet
タンパク質アミノ酸残基空間的近接構造予測AlphaFold 2
不正検知口座/取引送金関係異常ノード検出GCN + 異常検知
交通・物流交差点/拠点道路/路線渋滞予測/経路最適化STGCN

★ 業務での判断基準: 入力データに「ノード間の関係（グラフ構造）」が含まれるなら GNN を検討。テーブルデータなら XGBoost、画像なら CNN/ViT、テキストなら Transformer が第一候補。

1. GCN — グラフ畳み込みネットワーク

_

📐 数式

概要: GCN (Graph Convolutional Network, Kipf & Welling 2017) は、メッセージパッシングを 正規化された隣接行列の行列演算 で実装した最もシンプルな GNN。GNN ブームの起爆剤。

GCN の更新式:
$H^{(l+1)} = \sigma\!\left(\underbrace{\tilde{D}^{-1/2} \tilde{A} \tilde{D}^{-1/2}}_{\substack{\text{正規化隣接行列}\\\text{（近傍の平均集約）}}} \underbrace{H^{(l)}}_{\substack{\text{現在の}\\\text{特徴量}}} \underbrace{W^{(l)}}_{\substack{\text{学習可能}\\\text{な重み}}}\right)$

$\tilde{A} = A + I$　← 隣接行列 + 自己ループ（自分自身も近傍として扱う）
$\tilde{D}_{ii} = \sum_j \tilde{A}_{ij}$　← 次数行列（各ノードの接続数）
$\tilde{D}^{-1/2} \tilde{A} \tilde{D}^{-1/2}$　← 対称正規化（次数の違いを吸収）

→ $\tilde{D}^{-1/2} \tilde{A} \tilde{D}^{-1/2}$ の $(v, u)$ 成分 = $\frac{1}{\sqrt{\tilde{d}_v \tilde{d}_u}}$（接続数で割って正規化）
→ 行列演算なので 全ノードを一括処理 → GPU で高速

📊 グラフ（GCN の特徴伝播を可視化）

💡 解説

2017年 Kipf & Welling: シンプルな行列演算で GNN ブームを起こす。Cora 等の論文引用ネットワークで SOTA
正規化隣接行列 → 次数の異なるノードを公平に扱う
行列演算 → GPU で高速。数千ノードなら秒で学習
トランスダクティブ: 学習時にグラフ全体が必要。新規ノードの追加に弱い
近傍の集約が「平均」のみ → 重要な近傍と無関係な近傍を区別しない → GAT で解決
💡 直感的に: 各ノードが「隣人の特徴の平均 + 自分の特徴」を新しい特徴として採用する。これを行列演算で一括計算するので高速。ただし全隣人を平等に扱うため、重要な隣人を見分けられない（→ GAT）。

関連: メッセージパッシング | GAT（Attention 版）

📖 詳細解説

① GCN の行列計算 — 3 ノードでの完全展開

3 ノードグラフ: A—B—C（A-B, B-C が接続）。各ノードの初期特徴 $h$（2 次元）:
$H^{(0)} = \begin{bmatrix} h_A \\ h_B \\ h_C \end{bmatrix} = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{bmatrix}$

Step 1: 隣接行列 + 自己ループ:
$A = \begin{bmatrix} 0&1&0\\1&0&1\\0&1&0 \end{bmatrix},\ \tilde{A} = A+I = \begin{bmatrix} 1&1&0\\1&1&1\\0&1&1 \end{bmatrix}$

Step 2: 次数行列: $\tilde{D} = \text{diag}(2, 3, 2)$
$\tilde{D}^{-1/2} = \text{diag}(1/\sqrt{2}, 1/\sqrt{3}, 1/\sqrt{2})$

Step 3: 正規化:
$\hat{A} = \tilde{D}^{-1/2}\tilde{A}\tilde{D}^{-1/2} = \begin{bmatrix} 0.500 & 0.408 & 0 \\ 0.408 & 0.333 & 0.408 \\ 0 & 0.408 & 0.500 \end{bmatrix}$
→ 対角（自己ループ）= $1/\tilde{d}_v$。非対角 = $1/\sqrt{\tilde{d}_v \tilde{d}_u}$

Step 4: 特徴伝播（$W$ は単位行列と仮定して簡略化）:
$H^{(1)} = \sigma(\hat{A} H^{(0)})$
$= \sigma\begin{bmatrix} 0.5(1,0)+0.408(0,1) \\ 0.408(1,0)+0.333(0,1)+0.408(1,1) \\ 0.408(0,1)+0.5(1,1) \end{bmatrix}$
$= \sigma\begin{bmatrix} 0.500, 0.408 \\ 0.816, 0.741 \\ 0.500, 0.908 \end{bmatrix}$

★ 観察: B は A と C 両方の情報を混合 → $h_B^{(1)} = [0.816, 0.741]$ は A の $[1,0]$ と C の $[1,1]$ の加重平均。A は B の情報だけ取り込み、C にはまだ届かない（1 ホップ）。
② GCN vs GAT vs GraphSAGE — いつ何を使うか

手法集約方法新規ノード特徴
GCN正規化平均（固定重み）✗（トランスダクティブ）最もシンプル。小規模グラフに
GATAttention（学習重み）○（インダクティブ可能）重要な近傍を学習。解釈性高い
GraphSAGE近傍サンプリング + 任意集約◎（ミニバッチ学習）大規模グラフに最適。Pinterest で実用化

★ 業務での選択:
• 小規模（~数千ノード）+ 固定グラフ → GCN（最もシンプル）
• 解釈性が重要 or 近傍の重要度が異なる → GAT
• 大規模（数百万ノード）or ノードが動的に追加 → GraphSAGE

1. GAT — グラフ注意ネットワーク

_

📐 数式

概要: GAT (Graph Attention Network, Veličković 2018) は、GCN の「全近傍を平等に平均」する問題を Attention で解決。Transformer の Self-Attention と同じ発想をグラフに適用。

Attention 重みの計算:
$e_{vu} = \text{LeakyReLU}\!\left(\underbrace{\mathbf{a}^\top}_{\substack{\text{学習可能な}\\\text{注意ベクトル}}} \left[\underbrace{W h_v}_{\substack{\text{自分の}\\\text{変換}}} \| \underbrace{W h_u}_{\substack{\text{近傍の}\\\text{変換}}}\right]\right)$

$\alpha_{vu} = \dfrac{\exp(e_{vu})}{\sum_{k \in \mathcal{N}(v)} \exp(e_{vk})}$　← softmax で正規化（合計 = 1）

ノード更新:
$h_v^{(l+1)} = \sigma\!\left(\sum_{u \in \mathcal{N}(v)} \underbrace{\alpha_{vu}}_{\substack{\text{学習された}\\\text{重み}}} \cdot W h_u\right)$

GCN: 重み = $\frac{1}{\sqrt{d_v d_u}}$（固定）vs GAT: 重み = $\alpha_{vu}$（データから学習）
→ 重要な近傍に $\alpha$ 大、無関係な近傍に $\alpha$ 小 → 解釈性も向上（「なぜこのノードに注目？」がわかる）

Multi-Head Attention:
$h_v' = \|_{k=1}^{K} \sigma\!\left(\sum_{u \in \mathcal{N}(v)} \alpha_{vu}^{(k)} \cdot W^{(k)} h_u\right)$
$K$ 個のヘッドで異なる「視点」から近傍を集約 → Transformer の Multi-Head と同じ発想

📊 グラフ（Attention 重みの可視化）

💡 解説

2018 Veličković: Attention をグラフに適用。GCN を多くのタスクで上回る
重要な近傍に高い $\alpha$ → ノイジーな近傍の影響を抑制
Multi-Head で多角的な集約（文法/意味/構造 等の異なる「視点」）
$\alpha$ の可視化で「なぜこのノードに注目したか」がわかる → 解釈性
Attention 計算のオーバーヘッド（GCN より重い）
💡 直感的に: GCN が「全隣人の意見を平等に聞く」なら、GAT は「重要な隣人の意見を重点的に聞く」。誰が重要かはデータから学習する。Transformer の Self-Attention が「全単語を見て重要な単語に注目する」のと全く同じ発想。

関連: GCN（均等集約） | Self-Attention（NLP版） | メッセージパッシング

📖 詳細解説

① GAT の Attention 重み計算 — 数値例

ノード A の近傍が B, C, D。特徴量（2 次元）と重み $W$（2×2 単位行列で簡略化）:
$h_A = [1, 0], h_B = [0.8, 0.5], h_C = [0.2, 0.9], h_D = [0.7, 0.3]$
注意ベクトル $\mathbf{a} = [0.5, -0.3, 0.4, 0.2]$（4 次元: 連結 $[Wh_v \| Wh_u]$ に対応）

Step 1: Attention スコア $e_{vu}$ を計算:
$e_{AB} = \text{LeakyReLU}(\mathbf{a}^T [h_A \| h_B]) = \text{LeakyReLU}(0.5 \cdot 1 + (-0.3) \cdot 0 + 0.4 \cdot 0.8 + 0.2 \cdot 0.5) = \text{LeakyReLU}(0.92) = 0.92$
$e_{AC} = \text{LeakyReLU}(0.5 + 0 + 0.08 + 0.18) = 0.76$
$e_{AD} = \text{LeakyReLU}(0.5 + 0 + 0.28 + 0.06) = 0.84$

Step 2: softmax で正規化:
$\alpha_{AB} = \frac{e^{0.92}}{e^{0.92}+e^{0.76}+e^{0.84}} = \frac{2.51}{2.51+2.14+2.32} = \mathbf{0.360}$
$\alpha_{AC} = 0.307, \quad \alpha_{AD} = 0.333$

Step 3: 重みづけ集約:
$h_A' = \sigma(0.360 \cdot [0.8,0.5] + 0.307 \cdot [0.2,0.9] + 0.333 \cdot [0.7,0.3])$
$= \sigma([0.288+0.061+0.233, 0.180+0.276+0.100]) = \sigma([0.582, 0.556])$

★ GCN との差: GCN なら $\alpha = 1/3 = 0.333$ で均等。GAT は B に $0.360$（やや重視）、C に $0.307$（やや軽視）と、データから学習した重みで集約。
② GCN vs GAT — 不正検知での比較例

金融取引ネットワーク: ノード=口座、エッジ=送金関係。タスク=不正口座の検出。

シナリオ: 口座 X の近傍に「正常口座 10 個 + 不正口座 1 個」がある場合:

GCNGAT
集約重み全 11 ノードに $1/11 \approx 0.09$不正口座に $\alpha = 0.45$、正常に $\alpha \approx 0.05$
不正の影響9% しか反映されない → 見逃す45% が反映 → 検出できる
解釈性「なぜ不正と判定？」→ 説明不能「口座 Y との Attention 0.45」→ 説明可能

★ 業務インパクト: 不正検知・異常検出では「なぜそう判断したか」の説明が規制上必要（XAI）。GAT の $\alpha$ 可視化は直接的な説明になる。

📊 データ並列 (Data Parallelism)

_

📐 数式

同じモデルを $K$ 個の GPU にコピー。各 GPU が異なるミニバッチを処理。
勾配を All-Reduce で集約: $\nabla L = \dfrac{1}{K} \displaystyle\sum_{k=1}^K \nabla L_k$

PyTorch: `DistributedDataParallel (DDP)` が標準。Ring All-Reduce で通信効率化
制約: モデルが1台のGPUメモリに収まる必要がある

📊 グラフ

💡 解説

最もシンプル。PyTorch DDP で数行で実装
スケーラビリティ良好 (Ring All-Reduce)
モデルが GPU メモリに収まらない場合は不可 → モデル並列へ
効率: 理論 $K$ 倍 → 実測 $0.85K$ 倍 (通信オーバーヘッド)
💡 直感的に: 同じモデルを各GPUにコピーし、異なるバッチを処理して勾配を集約。最もシンプルなGPU並列化。PyTorch DDPで数行で実装可能。

関連: モデル並列 | Mixed Precision

📊 モデル並列 / パイプライン並列

_

📐 数式

モデル並列: モデルを層で分割
GPU0: Layer 1-25, GPU1: Layer 26-50, ...

パイプライン並列 (GPipe): マイクロバッチで流れ作業
GPU0: $B_1 \to B_2 \to B_3$ / GPU1: $\quad B_1 \to B_2$ / GPU2: $\quad\quad B_1$

テンソル並列 (Megatron-LM): 1つの行列演算を分割
$Y = X \cdot W \to W$ を列で分割し各GPUで計算 → 結合

3D 並列: データ × パイプライン × テンソル を組合せ
例: 1024 GPU = 8(data) × 16(pipeline) × 8(tensor)

📊 グラフ

💡 解説

GPT-3 (175B), Llama 3 (405B) は 3D 並列で数千 GPU を使用
DeepSpeed + Megatron-LM の組合せが事実上の標準
バブル (GPU空き時間) の最小化が複雑
実装難易度が高い (フレームワーク依存)
💡 直感的に: モデルが1GPUに収まらない場合に層で分割。パイプライン並列で流れ作業にしてGPU空き時間(バブル)を最小化。GPT-3/Llama等の巨大LLM学習で必須。

関連: データ並列 | Mixed Precision/ZeRO

📊 連合学習 (Federated Learning)

_

📐 数式

FedAvg: $w_{\text{global}}^{(t+1)} = \displaystyle\sum_{k=1}^K \dfrac{n_k}{n} w_k^{(t)}$

1. サーバーが global モデル $w$ を各クライアントに配布
2. 各クライアントがローカルデータで SGD 数ステップ
3. 更新後の $w_k$ (パラメータ差分) をサーバーに送信
4. サーバーが加重平均で集約

データは端末から出ない → プライバシー保護

📊 グラフ

💡 解説

プライバシー保護: データを集中させない
用途: Google Gboard, 医療データ, 金融
データの非IID性 (各端末のデータ分布が異なる) で精度低下
通信コスト (パラメータ送受信)
💡 直感的に: 「データを集めず、モデルだけを集める」。各端末でローカル学習→パラメータ差分をサーバーに送信→集約。プライバシー保護。Google Gboardで実用化。

関連: データ並列 | 📚 分散学習全般

📊 Mixed Precision Training / ZeRO

_

📐 数式

Mixed Precision:
Forward/Backward: FP16 (半精度) → 2倍高速、メモリ半減
Weight Update: FP32 (単精度) → 数値精度を維持
$\text{Loss Scaling}$: 勾配に大きな係数を掛けて underflow 防止

ZeRO (Zero Redundancy Optimizer):
Stage 1: Optimizer state を $K$ GPU に分散 → メモリ $\times 8$ 削減
Stage 2: + 勾配も分散
Stage 3: + パラメータも分散 → 事実上無制限のモデルサイズ

📊 グラフ

💡 解説

Mixed Precision: NVIDIA Tensor Core で 2-3 倍高速化。LLM 学習の標準
ZeRO (DeepSpeed): Stage 3 で事実上無制限のモデルサイズ
BF16 (Brain Float): FP16 より広いダイナミックレンジ。Google 提案
FP16 は勾配の underflow/overflow に注意が必要
💡 直感的に: FP32→FP16/BF16で計算を2倍高速化+メモリ半減。ZeROでoptimizer状態を分散し、事実上無制限のモデルサイズに対応。LLM学習の標準。

関連: データ並列 | モデル並列

📊 Permutation Importance

_

📐 数式

特徴量 $j$ の Permutation Importance:
$\text{PI}_j = \text{score}_{\text{original}} - \text{score}_{\text{permuted}(j)}$

特徴量 $j$ の値をランダムにシャッフル → 性能がどれだけ下がるかを測定
大きく下がる = その特徴量は重要

📊 グラフ

💡 解説

最もシンプルなグローバル解釈。任意のモデルに適用可
学習後のデータで計算 → 学習バイアスを受けない
相関のある特徴量が互いに「補い合う」→ 重要度が過小評価
scikit-learn: `permutation_importance()`
💡 直感的に: 特徴量をシャッフルして性能がどれだけ下がるかで重要度を測定。最もシンプルなグローバル解釈。任意のモデルに適用可。scikit-learn標準。

関連: SHAP | LIME

📊 Counterfactual Explanations (反実仮想)

_

📐 数式

「もし特徴量 $x_j$ が $v'$ だったら、結果は変わっていた？」

$\arg\min_{x'} d(x, x') \quad \text{s.t. } f(x') \neq f(x)$

最小の変更で結果が変わる入力を見つける
例: 「収入があと50万円高ければ融資が承認されていた」
GDPR Art.22: 自動処理拒否権の対応に適した説明形式

📊 グラフ

💡 解説

「何を変えれば結果が変わるか」→ 行動可能な説明
GDPR Art.22 対応: 自動処理拒否権の実装に最適
ユーザーにとって最も直感的な説明形式
最適な反実仮想の生成が計算的に困難な場合がある
💡 直感的に: 「収入があと50万円高ければ融資が承認されていた」のような行動可能な説明。GDPR対応に最適。ユーザーにとって最も直感的な説明形式。

関連: LIME | SHAP | 📚 XAI

📊 LIME (Local Interpretable Model-agnostic Explanations)

_

📐 数式

予測対象点 $x$ の周辺をサンプリング → ブラックボックス予測 $f(z)$ を局所的に線形モデル $g$ で近似

$\xi(x) = \arg\min_{g \in G} \mathcal{L}(f, g, \pi_x) + \Omega(g)$

$\mathcal{L}$ = $f$ と $g$ の予測差 (近傍重み $\pi_x$ で重み付け)
$\Omega(g)$ = $g$ の複雑さ (スパース性ペナルティ)

「複雑モデルでも局所では線形近似可能」という発想。任意のモデルに適用可 (model-agnostic)

📊 グラフ

非線形決定境界を局所的に線形近似する様子。点を変えると局所近似が変化。

💡 解説

任意のブラックボックスモデルに適用可
画像・テキスト・テーブル全対応
局所のみの説明 → グローバル傾向は別途必要
サンプリング方法によって結果がブレる
💡 直感的に: 複雑モデルの予測を、その点の周辺でシンプルな線形モデルで近似して説明。任意のブラックボックスに適用可能。画像・テキスト・テーブル全対応。

関連: SHAP (vs) | Grad-CAM | 📚 XAI 一覧

📊 SHAP (SHapley Additive exPlanations)

_

📐 数式

Shapley 値 (協力ゲーム理論):
$\phi_i = \sum_S \underbrace{\frac{|S|!(|F|-|S|-1)!}{|F|!}}_{\text{重み (組合せ数)}} \underbrace{\left[ f(S \cup \{i\}) - f(S) \right]}_{\substack{\text{特徴量iを加えた}\\\text{ときの予測変化}}}$

特徴量 $i$ の貢献度 = 「$i$ を加えたときの予測値の増加」を全ての特徴量サブセットで平均

予測 = ベース値 + Σ 各特徴量の貢献 (加法性が保証される)
理論的に厳密 (LIME より一貫性あり)。Kaggleの定番

📊 グラフ

住宅価格予測の例: 各特徴量がベース値からどれだけ予測を変動させるか (Waterfall)。

💡 解説

理論的厳密性 (Shapley 値の公理: 効率性・対称性・加法性・無関係性)
グローバル + ローカル両対応
Kaggle・実務で最も人気の解釈手法
計算コスト高 ($2^{|F|}$ サブセット) → TreeSHAP, KernelSHAP などの近似
💡 直感的に: ゲーム理論(Shapley値)で各特徴量の貢献度を計算。LIMEより理論的に厳密(加法性・一貫性保証)。Kaggle・実務の標準的な解釈手法。

関連: LIME (vs) | Grad-CAM | 📚 XAI

📊 t-SNE / UMAP (非線形次元削減)

_

📐 数式

t-SNE: 高次元の近傍関係を低次元で保存
$p_{ij} = \dfrac{\exp(-\|x_i - x_j\|^2 / 2\sigma^2)}{\sum_{k \neq l} \exp(-\|x_k - x_l\|^2 / 2\sigma^2)}$ (高次元類似度)
$q_{ij} = \dfrac{(1 + \|y_i - y_j\|^2)^{-1}}{\sum_{k \neq l} (1 + \|y_k - y_l\|^2)^{-1}}$ (低次元、t分布)
最小化: $\text{KL}(P \| Q)$

PCA は線形 → クラスタが重なる場合に分離不能。t-SNE/UMAP は非線形変換でクラスタを分離

📊 グラフ

4クラスタの高次元データを 2D に投影 (擬似 t-SNE)。Perplexity で局所/大域のバランスを調整。

💡 解説

非線形構造を保存。クラスタ可視化に強力
UMAP は t-SNE より高速 + 大規模OK + 大域構造も保存
距離は保存されない (近傍関係のみ)
Perplexity 等のパラメータに敏感
💡 直感的に: PCAが「直線的」なのに対し、t-SNE/UMAPは「曲がった」構造も保持できる。クラスタの可視化に強力。ただし距離は保存されない。

関連: PCA (線形) | k-means

📊 Thompson Sampling (ベイズ的バンディット)

_

📐 数式

各アーム $a$ の報酬分布を 事後分布 $p(\theta_a \mid D)$ として保持
ベルヌーイ報酬の場合: $\theta_a \sim \text{Beta}(\alpha_a, \beta_a)$

各時刻:
1. 各アームから $\tilde{\theta}_a \sim p(\theta_a \mid D)$ をサンプリング
2. $\arg\max_a \tilde{\theta}_a$ を選択
3. 報酬を観測 → 事後分布を更新 (Beta分布なら $\alpha$ or $\beta$ を+1)

不確実性を「サンプリング」で組み込む賢い方法。実用上 UCB より強いことが多い

📊 グラフ

UCB / ε-greedy / Thompson の3戦略を比較。Thompson が最も累積報酬が高い傾向。

💡 解説

ベイズ的に正しい探索。実用上 UCB より強いことが多い
Beta分布なら計算が高速 (αとβをカウントするだけ)
Yahoo!, Microsoft 等の広告配信システムで実用化
理論解析がやや複雑 (UCBの方が証明はシンプル)
💡 直感的に: 各選択肢の報酬分布をベイズ的に保持し、サンプリングで選択。実用上UCBより強いことが多い。広告配信(Yahoo!, Microsoft)で実用化。

関連: UCB | ε-greedy | 📊 ベイズの定理

📊 PPO (Proximal Policy Optimization)

_

📐 数式

REINFORCE (方策勾配): $\nabla J(\theta) = \mathbb{E}\left[ \nabla \log \pi_\theta(a|s) \cdot R \right]$

Actor-Critic: Actor $\pi_\theta$ + Critic $V_\phi$
$\nabla J(\theta) = \mathbb{E}\left[ \nabla \log \pi_\theta(a|s) \cdot A(s,a) \right]$, $A = R - V_\phi(s)$

PPO 目的関数 (clipped):
$L^{\text{CLIP}}(\theta) = \mathbb{E}\!\left[ \min\!\left( r_t(\theta) A_t, \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) A_t \right) \right]$
$r_t(\theta) = \dfrac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{\text{old}}}(a_t|s_t)}$

clip で更新幅を制限 → 学習を安定化。ChatGPT の RLHF で採用

📊 グラフ

Clip なし vs Clip あり (PPO) の方策更新。clip で過大な更新を抑制。

💡 解説

学習が極めて安定。ハイパーパラメータ調整が容易
ChatGPT の RLHF で採用。LLM ファインチューニングの標準
OpenAI Five (Dota 2), AlphaStar 等のゲームAIでも使用
サンプル効率は方策外手法 (DQN等) より劣る
💡 直感的に: 方策の更新幅をclipで制限して安定化。ChatGPTのRLHFで採用。「良い行動を少し強化、悪い行動を少し弱化」を安全に繰り返す。

関連: Q学習 (vs) | MDP | 📚 強化学習

📊 標準化 vs 正規化 (前処理)

_

📐 数式

正規化 (Min-Max Scaling): $x' = \dfrac{x - x_{\min}}{x_{\max} - x_{\min}}$ → $[0, 1]$
範囲を揃える。NN入力、画像 (0-255 → 0-1) で必須

標準化 (Z-score): $x' = \dfrac{x - \mu}{\sigma}$ → 平均 0, 分散 1
外れ値に頑健 (μ, σ は中央値・MADで代用も可)

距離ベース (k-NN, k-means) → 標準化推奨 / NN → 正規化が一般的

📊 グラフ

同じデータに3種のスケーリングを適用。スケールがどう変わるか比較。

💡 解説

正規化: 範囲が決まっている (画像、確率)。NN入力で標準
標準化: 統計的解釈が容易 (μ=0, σ=1)。外れ値に比較的頑健
外れ値が極端な場合 → ロバスト標準化 (median/IQR) を検討
scikit-learn: StandardScaler / MinMaxScaler / RobustScaler
💡 直感的に: 正規化(Min-Max)は範囲を[0,1]に、標準化(Z-score)は平均0分散1に。NN入力は正規化、距離ベース手法(k-NN,SVM)は標準化が標準。外れ値が強いとMin-Maxは歪む。

関連: 📚 前処理一覧

📊 欠損値補完 (Imputation)

_

📐 数式

欠損のメカニズム:
MCAR (Missing Completely At Random): 完全ランダム欠損
MAR (Missing At Random): 他の変数で説明可能
MNAR (Missing Not At Random): 欠損自体が情報

補完手法:
平均/中央値/最頻値補完: $\hat{x}_i = \bar{x}$ (シンプル、分散を歪める)
KNN補完: $k$近傍の平均で補完 (関係性を保持)
MICE (多重代入法): 他変数から回帰で予測 → 反復
線形補間: 時系列で前後の値から推定

📊 グラフ

欠損データに3つの補完法を適用。分散の歪みに注意。

💡 解説

削除は確実だがデータ量を失う
平均補完は分散を歪める (元の分散より小さくなる)
推奨: KNN補完 / MICE / 木系モデルの組込み補完
MNAR の場合は単純補完では不十分 → ドメイン知識が必要
💡 直感的に: 平均補完は簡単だが分散を歪める。KNN補完やMICEが推奨。欠損自体が情報の場合もある(MNAR)。安易な補完は危険 → ドメイン知識が重要。

関連: 📚 前処理一覧 | 標準化

📊 特徴量エンジニアリング

_

📐 数式

対数変換: $x' = \log(x + 1)$ (右に歪んだ分布を正規分布に近づける)
Box-Cox 変換: $x' = \dfrac{x^\lambda - 1}{\lambda}$ (一般化対数変換)
多項式特徴量: $[x_1, x_2] \to [x_1, x_2, x_1^2, x_2^2, x_1 x_2]$
ビニング: 連続値 → カテゴリ (年齢 → 「20代」「30代」)
交互作用項: $x_3 = x_1 \cdot x_2$ (ドメイン知識から作成)

📊 グラフ

右に歪んだデータ (収入分布のような) を対数変換で正規分布に近づける。

💡 解説

線形モデルの精度が大幅向上することが多い
Kaggle で重要なスキル (NN登場前は最重要)
DLは特徴量を自動学習 → エンジニアリング不要 (ただしテーブルデータでは今も有効)
ドメイン知識との組合せが鍵
💡 直感的に: 右に歪んだデータ(収入分布等)をlog変換で正規分布に近づける。線形モデルの精度が大幅向上する場合がある。DLは自動学習するが、テーブルデータでは今も有効。

関連: 📚 前処理一覧 | 標準化

📊 Grad-CAM (Gradient-weighted Class Activation Mapping)

_

📐 数式

$L^c_{\text{Grad-CAM}} = \text{ReLU}\!\left( \displaystyle\sum_k \alpha^c_k A^k \right)$
$\alpha^c_k = \dfrac{1}{Z} \displaystyle\sum_{i,j} \dfrac{\partial y^c}{\partial A^k_{ij}}$

$A^k$ = 最終畳み込み層の $k$ 番目特徴マップ
$\alpha^c_k$ = クラス $c$ に対する $k$ 番目特徴マップの重み (勾配の平均)

「CNN が画像のどこを見て判定したか」をヒートマップで可視化

📊 グラフ

合成画像で CNN が「猫」と判定した時の注目領域 (擬似 Grad-CAM)。中心強度を変えて挙動を観察。

💡 解説

CNN の判断根拠を直感的に可視化
医療画像 (X線/CT) でどこを見て癌と診断したかの説明に必須
CNN 専用 (Transformer/MLP には別手法)
関連: Grad-CAM++, Score-CAM (改良版)
💡 直感的に: CNNの最終畳み込み層の勾配から「どこを見て判断したか」をヒートマップで表示。医療画像(X線でどこを見て癌と診断したか)で必須。

関連: 📊 CNN | LIME | SHAP | 📚 XAI

📊 SMOTE (Synthetic Minority Oversampling Technique)

_

📐 数式

少数クラスのサンプル $x_i$ について:
1. $k$近傍 (典型的に $k=5$) から1つランダム選択 → $x_{nn}$
2. 補間で合成サンプル生成: $x_{\text{new}} = x_i + \lambda (x_{nn} - x_i)$, $\lambda \in [0,1]$

単純なオーバーサンプリング (重複) と異なり、多様性のある合成データを生成
注意: テストデータには適用しない (リーク防止)

📊 グラフ

不均衡データ (Class 1: 90%, Class 0: 10%) → SMOTE で少数派を水増し。

💡 解説

不正検知・医療診断などの不均衡データで有効
単純複製 (Random Oversampling) より過学習リスク低
ノイズも増幅される可能性 → クラス境界がぼやける
関連: ADASYN (適応的SMOTE), Borderline-SMOTE, Tomek Links 削除と組合せ
💡 直感的に: 少数クラスの近傍間を補間して合成サンプルを生成。単純な複製より多様性が増す。不正検知・医療診断で有効。テストデータには絶対に適用しない。

関連: 📊 評価指標 (F1で評価) | 📚 前処理

📊 Z-score 異常検知 (1次元)

_

📐 数式

$z = \dfrac{x - \mu}{\sigma}$
判定: $|z| > k$ → 異常 (典型的に $k = 3$, つまり 99.7% から外れる)

正規分布が前提。68-95-99.7ルール: ±1σ=68%, ±2σ=95%, ±3σ=99.7%

📊 グラフ

💡 解説

最もシンプル。実装即座、計算高速
正規分布前提。歪んだ分布では誤検知/見逃し多発
外れ値が μ, σ を歪める → ロバスト版 (median/MAD) 推奨
💡 直感的に: 平均から何σ離れているかで異常を判定。3σ超え=99.7%の外側。正規分布前提で、1次元データに最適。歪んだ分布ではロバスト版(median/MAD)を使う。

関連: マハラノビス (多変量版) | 📊 正規分布

📊 マハラノビス距離 (多変量異常検知)

_

📐 数式

$d^2(x) = \underbrace{(x - \mu)^\top}_{\text{平均からのズレ}} \underbrace{\Sigma^{-1}}_{\substack{\text{相関を}\\\text{考慮した重み}}} \underbrace{(x - \mu)}_{\text{ズレ}}$

$\mu$ = 平均ベクトル, $\Sigma$ = 分散共分散行列
判定: $d^2 > \chi^2_{p, \alpha}$ → 異常 (自由度 $p$ のχ²分布)

特徴量間の相関を考慮 → 単純な Z-score では検出できない斜め方向の外れ値も検出

📊 グラフ

💡 解説

特徴量間の相関を考慮 → 多変量で正確
χ² 分布で異常閾値が理論的に決まる
線形の異常境界しか引けない (楕円形)
$\Sigma$ の推定に十分なサンプルが必要
💡 直感的に: 特徴量の相関を考慮した「楕円形の距離」。2つの特徴量が相関していても正しく異常を検出。χ²分布で閾値を理論的に設定可能。

関連: Z-score (1次元) | One-Class SVM (非線形)

📊 One-Class SVM

_

📐 数式

通常のSVMは2クラス分離。One-Class SVM は「正常データを囲む超球」を学習:

$\displaystyle\min_{w, \rho, \xi} \dfrac{1}{2}\|w\|^2 + \dfrac{1}{\nu n}\displaystyle\sum_i \xi_i - \rho$
$\text{s.t. } w \cdot \phi(x_i) \geq \rho - \xi_i, \quad \xi_i \geq 0$

$\nu$: 異常データの割合の上限 (典型的に $\nu = 0.05$)
カーネル法 (RBF) で非線形領域も学習可能

📊 グラフ

💡 解説

非線形領域も学習可 (RBFカーネル)
少量データでも動く
大規模データで遅い ($O(n^2)$〜$O(n^3)$)
パラメータ ($\nu$, γ) チューニングが必要
💡 直感的に: 正常データだけで「正常な範囲」を学習し、外側を異常と判定。RBFカーネルで非線形領域もOK。少量データに強いが大規模で遅い。

関連: 📊 SVM | Isolation Forest

📊 LOF (Local Outlier Factor)

_

📐 数式

$k$近傍距離 $d_k(x)$, 到達距離 $\text{rd}_k(x, y) = \max(d_k(y), d(x, y))$
局所密度 $\text{lrd}_k(x) = \dfrac{1}{\text{平均到達距離}}$

$\text{LOF}_k(x) = \dfrac{\underbrace{\text{近傍の平均密度}}_{\text{周囲がどれだけ密か}}}{\underbrace{\text{xの局所密度}}_{\text{自分がどれだけ密か}}}$

LOF $\approx 1$: 正常 / LOF $\gg 1$: 周囲より密度が低い = 異常

📊 グラフ

💡 解説

局所異常を検出: クラスタ密度が場所で異なるデータに強い
k の選択に敏感 (5〜20が一般的)
$O(n^2)$ で大規模データに不向き
scikit-learn: `LocalOutlierFactor`
💡 直感的に: 「自分の周りの密度 vs 近傍の密度」を比較。密度が場所によって異なるデータに強い。LOF>>1なら周囲より低密度=異常。

関連: Isolation Forest | One-Class SVM

📊 Autoencoder 異常検知

_

📐 数式

正常データだけで AE を訓練: 入力 → 圧縮 → 復元
$\hat{x} = D(E(x))$, 学習: $\min \|x - \hat{x}\|^2$

推論時: 復元誤差 $\|x - \hat{x}\|^2 > \tau$ → 異常

正常データの「本質」を低次元で学習 → 異常データは復元できず誤差大

📊 グラフ

💡 解説

画像・音声・センサー等の高次元データに強い
VAE 版もあり (確率分布で異常を判定)
学習に時間とデータが必要
DLベース異常検知の定番
💡 直感的に: 正常データの「復元の仕方」を学習。異常データは上手く復元できない→復元誤差が大きい=異常。画像・音声・センサーのDLベース異常検知の定番。

関連: Isolation Forest | 📊 拡散モデル

📊 Isolation Forest (異常検知)

_

📐 数式

アイデア: 異常データは「少数で違う」 → ランダム分割ですぐに孤立する

異常スコア: $s(x, n) = 2^{-E[h(x)] / c(n)}$
$h(x)$ = データ $x$ が分離されるまでの分割深さ
$c(n)$ = $n$個のデータでのBSTの平均探索長 = $2H(n-1) - 2(n-1)/n$

スコア $\to 1$: 異常 (すぐ孤立) / $\to 0.5$: 正常

📊 グラフ

正常データ (クラスタ) と異常データ (外れ値) を Isolation Forest がどう区別するか。

💡 解説

高速 ($O(n \log n)$)、大規模・高次元データに強い
scikit-learn 標準。実務で最も人気の異常検知
用途: 不正検知、製造業の品質管理、ネットワーク侵入検知
クラスタ密度が場所によって異なる場合、LOF のほうが適切
💡 直感的に: 異常データは「少数で違う」→ ランダム分割ですぐに孤立する。分割の深さが浅い=異常。高速・高次元OK。scikit-learn標準で実務最人気。

関連: 📚 異常検知一覧

📊 BoW (Bag of Words)

_

📐 数式

文書 $d$ → 単語の出現回数ベクトル $\vec{v}_d \in \mathbb{R}^{|V|}$
$v_{d,t} = \text{count}(t, d)$

単語の順序を捨てる: "犬が猫を追う" = "猫が犬を追う"
次元 = 語彙数 → スパースで巨大なベクトル

📊 グラフ

3つの文書を BoW ベクトル化。各文書の単語頻度行列。

💡 解説

実装極めて簡単。古典NLPの基礎
語順情報が消失
疎で巨大 (語彙数次元) → メモリ大
改良: TF-IDF (重み付け), N-gram (順序考慮), Word2Vec (密ベクトル)
💡 直感的に: 文を「単語の出現回数ベクトル」にする最もシンプルな方法。順序が消える(犬が猫を追う=猫が犬を追う)が、分類の基礎として今も使われる。

関連: TF-IDF | N-gram

📊 TF-IDF

_

📐 数式

TF (Term Frequency): $\text{TF}(t, d) = \dfrac{n_{t,d}}{\sum_{t'} n_{t',d}}$
文書 $d$ における単語 $t$ の頻度

IDF (Inverse Document Frequency): $\text{IDF}(t) = \log \dfrac{N}{|\{d : t \in d\}|}$
少数の文書にしか現れない単語ほど高い IDF

TF-IDF: $\text{TF-IDF}(t, d) = \text{TF}(t, d) \times \text{IDF}(t)$
「その文書に頻出 + 他の文書には少ない」単語が高スコア → 文書の特徴単語

📊 グラフ

4文書 × 6単語の TF-IDF 行列。"the" のような一般語は IDF が低く、特徴語は高い。

💡 解説

検索エンジンの古典的スコアリング (BM25 の前身)
実装シンプル、高速、解釈可能
2023+: RAG (Retrieval-Augmented Generation) で再評価 → BM25 と組合せて Hybrid Search
単語の意味を捉えない (Word2Vec/BERT が必要なケース)
💡 直感的に: 「その文書に多い+他の文書には少ない」単語を高スコアに。一般語(the/は)のスコアを自動で下げる。検索エンジンの古典で、RAGで再評価。

関連: Word2Vec | 📚 NLP/BM25

📊 BM25 (検索ランキング)

_

📐 数式

$\text{BM25}(d, q) = \displaystyle\sum_{t \in q} \text{IDF}(t) \cdot \dfrac{\text{TF}(t, d)(k_1 + 1)}{\text{TF}(t, d) + k_1(1 - b + b \cdot |d|/\text{avgdl})}$

$k_1 \approx 1.2$ (TFの飽和), $b \approx 0.75$ (文書長正規化)

TF-IDFの改良版: 文書長で正規化 + TF飽和
Elasticsearch 等の検索エンジンの標準

📊 グラフ

TF-IDF と BM25 の比較: BM25 は TF が増えても飽和する。

💡 解説

TF-IDFより理論的・実用的に優れる
Elasticsearch, Solr, Lucene の標準ランキング
2023+: RAG (Retrieval-Augmented Generation) で再評価
単語の意味は捉えない (Word2Vec/BERT が必要なケース)
💡 直感的に: TF-IDFの改良版。文書長で正規化+TFの飽和(同じ単語が10回出ても2倍程度)。Elasticsearch標準。RAGのretrieval側で現役。

関連: TF-IDF (前身) | RAG (応用)

📊 N-gram

_

📐 数式

連続する $N$ 単語を1単位に。
2-gram (bigram): "I love AI" → ["I love", "love AI"]
3-gram (trigram): "I love AI" → ["I love AI"]

言語モデル: $P(w_n \mid w_{n-N+1}, \dots, w_{n-1})$
部分的な順序を保持。スペル訂正・機械翻訳の基礎 (現代は Transformer に置き換え)

📊 グラフ

💡 解説

語順を部分的に保持 (BoW より情報量多い)
次元爆発: $|V|^N$ → スパース性が深刻
古典的言語モデル (n-gram モデル) → Transformer に置き換え
スペル訂正、機械翻訳 (古典)、文字レベルNNで今も使用
💡 直感的に: 連続するN単語を1単位に。2-gramなら部分的な語順を保持。古典的言語モデルの基礎だが、次元爆発が課題。Transformerに置き換えられた。

関連: BoW | Subword

📊 Word2Vec (単語埋め込み)

_

📐 数式

Skip-gram: 中心語 $w_t$ → 周辺語 $w_{t-c}, \dots, w_{t+c}$ を予測
$P(w_o \mid w_t) = \dfrac{\exp(v_o^\top v_t)}{\sum_{w} \exp(v_w^\top v_t)}$

CBOW: 周辺語 → 中心語を予測

分布仮説: 同じ文脈で使われる単語は似た意味

学習後、単語ベクトル $v_w$ で「king − man + woman ≈ queen」のような意味演算が可能

📊 グラフ

2D 単語ベクトル空間で意味関係を可視化。「王様 − 男 + 女 = 女王」を実演。

💡 解説

2013年のNLP革命。「単語のベクトル空間表現」を実用化
意味演算: $v(\text{king}) - v(\text{man}) + v(\text{woman}) \approx v(\text{queen})$
1単語に1ベクトル (静的) → 多義語 ("bank") を扱えない → ELMo, BERT へ進化
後継: GloVe, FastText, BERT, GPT (文脈依存埋め込み)
💡 直感的に: 「同じ文脈で使われる単語は似た意味」から密ベクトルを学習。king-man+woman≈queen。2013年のNLP革命。ただし1単語1ベクトル(多義語に弱い)→BERTへ。

関連: TF-IDF (古典) | 📊 Attention/BERT | 📚 NLP系譜

📊 UCB 方策 (Upper Confidence Bound)

_

📐 数式

$a_t = \arg\max_a \left[ \underbrace{\hat{Q}(a)}_{\substack{\text{活用}\\\text{(推定報酬)}}} + c \underbrace{\sqrt{\dfrac{\ln t}{N(a)}}}_{\substack{\text{探索}\\\text{(不確実性ボーナス)}}} \right]$

$\hat{Q}(a)$ = 推定平均報酬 (活用項)
$\sqrt{\frac{\ln t}{N(a)}}$ = 不確実性 (探索項)
$c$ = 探索強度 (大きいほど探索重視、$c \approx 2$ が標準)

「不確実性が高いアームを優先的に試す」 → 賢い探索
理論保証: Regret は $O(\log T)$ で抑えられる (ε-greedy は $O(T)$)

📊 グラフ

UCB と ε-greedy の比較。試行回数が増えると差が顕著になる。

💡 解説

理論的最適に近い: Regret が $O(\log T)$
不確実性を明示的に考慮 → 賢い探索
MCTS の選択ステップでも UCB1 が使われる (AlphaGo)
関連: Thompson Sampling (ベイズ的代替、実用的に強い)
💡 直感的に: 「あまり試していない選択肢」にボーナスを与えて優先的に試す。不確実性を明示的に考慮する賢い探索。MCTSのノード選択でも使用。

関連: ε-greedy (vs) | 📊 MCTS (UCB活用) | 📚 ベイズ最適化

📊 潜在的ディリクレ配分法 (LDA)

_

📐 数式

生成モデル:
1. 各文書 $d$ に対し: $\theta_d \sim \text{Dirichlet}(\alpha)$ ← トピック分布
2. 各トピック $k$ に対し: $\phi_k \sim \text{Dirichlet}(\beta)$ ← 単語分布
3. 各単語位置 $n$ に対し:
   トピック $z_{dn} \sim \text{Multinomial}(\theta_d)$
   単語 $w_{dn} \sim \text{Multinomial}(\phi_{z_{dn}})$

学習 = 観測単語から潜在トピック分布を推定 (Variational EM や Gibbs Sampling)

📊 グラフ

文書ごとのトピック分布と、トピックごとの単語分布。

💡 解説

教師なしで潜在トピックを発見
用途: ニュース分類、研究論文の傾向分析、レビュー要約
トピック数 $K$ を事前指定する必要
現代の代替: BERTopic (BERT + UMAP + HDBSCAN)
💡 直感的に: 文書集合から「潜在的なトピック」を自動発見。ニュース記事を「政治/経済/スポーツ」に自動分類するように、各文書のトピック混合比率を推定。

関連: 📊 ベイズの定理 | 📚 NLP

📊 k-means 法

_

📐 数式

目的関数: $\displaystyle\\min_{\mu} \sum_i \underbrace{\min_k \|x_i - \mu_k\|^2}_{\substack{\text{最も近い重心}\\\text{までの距離の二乗}}}$

アルゴリズム:
1. $K$個の重心 $\mu_k$ をランダム配置
2. 各点 $x_i$ を最も近い重心に割当
3. 各クラスタの平均で重心を更新: $\mu_k = \dfrac{1}{|C_k|}\sum_{x_i \in C_k} x_i$
4. 収束まで反復

EM アルゴリズムの特殊ケース。「ハード割当」 (どこに属するかを0/1で決める)

📊 グラフ

K (クラスタ数) と反復回数を変えて、重心の収束過程を観察。

💡 解説

高速 ($O(nKT)$)、実装シンプル、scikit-learn 標準
$K$ を事前指定する必要 (エルボー法・シルエット係数で決定)
球状クラスタを仮定。形状が複雑なら DBSCAN/階層型へ
初期値依存性あり → k-means++ で改善
💡 直感的に: K個の「重心」にデータを割り当て、重心を更新し、を繰り返す。球状のクラスタに強い。Kはエルボー法で決める。

関連: 階層的クラスタリング | PCA (前処理)

📊 階層的クラスタリング (Hierarchical)

_

📐 数式

凝集型: 各点を1クラスタに → 最も近い2クラスタを順次併合

クラスタ間距離の定義:
最短距離 (単連結): $d(A,B) = \displaystyle\min_{a \in A, b \in B} \|a - b\|$
最長距離 (完全連結): $d(A,B) = \displaystyle\max_{a \in A, b \in B} \|a - b\|$
群平均: $d(A,B) = \dfrac{1}{|A||B|} \displaystyle\sum_{a \in A, b \in B} \|a - b\|$
ウォード法: $\displaystyle\Delta J = \dfrac{|A||B|}{|A|+|B|} \|\bar{a} - \bar{b}\|^2$ ← クラスタ内分散の増加が最小になる併合

$K$ 不要。デンドログラム (樹形図) で階層構造を可視化

📊 グラフ

距離指標 (Linkage) による結果の違い。デンドログラムを切る位置で K が決まる。

💡 解説

$K$ を事前指定不要 (デンドログラムを切る位置で決定)
階層構造が可視化される
計算量 $O(n^2 \log n)$ → 大規模データに不向き
ウォード法が最も多用される (クラスタ内分散最小化)
💡 直感的に: データ同士をボトムアップで併合していく。デンドログラム（樹形図）で階層構造が見え、好きな高さで切ってKを決める。ウォード法が最も一般的。

関連: k-means (vs)

📊 モンテカルロ木探索 (MCTS)

_

📐 数式

4ステップを反復: Selection → Expansion → Simulation → Backpropagation

UCB1 (子ノード選択基準):
$\arg\max_a \left[ \bar{x}_a + c \sqrt{\dfrac{\ln N_{\text{parent}}}{N_a}} \right]$
$\bar{x}_a$ = アーム $a$ の平均勝率, $N_a$ = 訪問回数, $c$ = 探索強度

第2項は「あまり訪問していない手を試す」探索ボーナス → 探索 vs 活用のバランス

📊 グラフ

シミュレーション回数を増やすと、各手の勝率推定がどう収束するか観察。

💡 解説

評価関数不要: ランダムシミュレーションのみで局面評価
囲碁のような超巨大分岐 (b≈250) でも実用的
AlphaGo (2016): MCTS + DL で世界チャンピオンに勝利
AlphaZero: 自己対戦のみで囲碁・将棋・チェス全制覇
💡 直感的に: ランダムにゲームを最後まで模擬し、勝率で手を評価。評価関数不要で囲碁のような超巨大ゲームにも対応。AlphaGo = MCTS + DL。

関連: Mini-max | αβ | 📊 Q学習

📊 幅優先探索 (BFS, Breadth-First Search)

_

📐 数式

データ構造: FIFO キュー (先入れ先出し)

計算量: 時間 $O(V + E)$ / 空間 $O(V)$
$V$ = ノード数, $E$ = エッジ数

擬似コード:
queue = [start]
while queue not empty:
  v = queue.popleft()
  visit(v)
  for u in neighbors(v):
    if u not visited:
      queue.append(u) 浅い階層から順に網羅 → 最短経路保証

📊 グラフ

グリッド迷路でスタートから各セルへの探索順序を可視化（数字 = 訪問順）。

💡 解説

最短経路保証 (重みなしグラフ)
完全性: 解が存在すれば必ず見つける
メモリ消費 $O(b^d)$ ($b$ = 分岐数、$d$ = 深さ) → 深いグラフで爆発
用途: ソーシャルネットワーク (友達のN次), GPSナビ, パズル最短解
💡 直感的に: 同心円状に浅い順に探索。最短経路保証だがメモリを食う。GPSナビ、SNSの「友達の友達」検索で使用。

関連: DFS (vs) | Mini-max | MCTS

📊 深さ優先探索 (DFS, Depth-First Search)

_

📐 数式

データ構造: LIFO スタック (後入れ先出し) または再帰

計算量: 時間 $O(V + E)$ / 空間 $O(\text{深さ})$

擬似コード (再帰):
function dfs(v):
  visit(v)
  for u in neighbors(v):
    if u not visited:
      dfs(u) 1つの分岐を最後まで掘ってから戻る → 最短経路は保証されない

📊 グラフ

同じ迷路で訪問順がBFSとどう違うかを比較。

💡 解説

メモリ効率: $O(\text{深さ})$ で BFS より圧倒的に少ない
バックトラッキング: 数独・パズル解法、迷路解探索の定番
最短経路の保証なし
無限深さで止まらない可能性 → 深さ制限付き DFS が実用的
💡 直感的に: 1つの分岐を最後まで掘ってから戻る。メモリ効率が良いが最短は保証されない。数独やパズル解法のバックトラッキングの基礎。

関連: BFS (vs)

📊 ナイーブベイズ (Naive Bayes)

_

📐 数式

ベイズの定理 + 「特徴量の条件付き独立」を仮定:
$P(y \mid x) \propto \underbrace{P(y)}_{\substack{\text{事前確率}\\\text{(スパムの基本確率)}}} \cdot \prod_i \underbrace{P(x_i \mid y)}_{\substack{\text{各単語の}\\\text{出現確率}}}$

スパムフィルタの例: 単語 $w_i$ がメール $d$ に含まれるとき
$P(\text{spam} \mid d) \propto P(\text{spam}) \displaystyle\prod_{w \in d} P(w \mid \text{spam})$

「ナイーブ (素朴)」= 単語が独立という強すぎる仮定。実際は相関するが、実用上は十分な精度

📊 グラフ

スパム判定例: 各単語のスパム確率を変えて、メール全体のスパム判定がどうなるか体感。

単語P(w|spam)P(w|ham)
"無料" 0.7 0.05
"勝者" 0.6 0.02
"会議" 0.05 0.4

💡 解説

実装が極めて簡単・高速。少データでも動く
スパムフィルタの古典的標準。テキスト分類で実用的
「特徴量独立」の仮定が強い → 相関の強いデータでは精度低下
RAGの retrieval や、ベースライン手法として今も現役
💡 直感的に: 「単語が独立」という強すぎる仮定だが、スパム判定で実用的精度。「無料+勝者→スパム確率高」を各単語の確率の掛け算で高速に計算。

関連: 📊 ベイズの定理 (基礎) | ロジスティック回帰 (vs) | 📚 NLP/TF-IDF

📊 ブースティング (AdaBoost / GBDT / XGBoost / LightGBM)

_

📐 数式

逐次的なアンサンブル:
$F_m(x) = F_{m-1}(x) + \gamma_m h_m(x)$
弱学習器 $h_m$ を順次追加。$h_m$ は前の誤差に重点的にフィット

勾配ブースティング (GBDT):
$h_m = \arg\min_h \displaystyle\sum_i \left( -\dfrac{\partial L(y_i, F_{m-1}(x_i))}{\partial F_{m-1}(x_i)} - h(x_i) \right)^2$
各反復で「損失関数の負の勾配」（残差）に新しい木をフィットさせる

XGBoost/LightGBM = GBDT の高速・正則化版実装。Kaggleで圧倒的人気

📊 グラフ

反復回数を増やすと、誤差が指数的に減少。多すぎると過学習。

💡 解説

テーブルデータで NN を上回る性能 (Kaggle で圧倒的人気)
XGBoost/LightGBM = 実用的な GBDT 実装。早期打ち切り、正則化込み
並列化が難しい (逐次学習) → RFより遅い
過学習しやすい → 早期打ち切り、学習率調整が重要
💡 直感的に: 弱い木を順次追加し、前の木の「間違い」に重点を置いて次の木を学習。XGBoost/LightGBMはKaggleで圧倒的人気。テーブルデータではNNより強いことが多い。

関連: RF (vs バギング) | 決定木 (構成要素) | 📚 ハイパラ最適化

📊 ランダムフォレスト (Random Forest)

_

📐 数式

バギング (Bootstrap Aggregating):
1. 学習データから $T$ 個のブートストラップサンプル（重複許可で抽出）を作成
2. 各サブセットで決定木を学習 → $T$ 個の木
3. 各分岐で特徴量もランダムにサブセット選択 ← RFの肝

予測: $\hat{y} = \begin{cases} \text{mode}(\hat{y}_1, \dots, \hat{y}_T) & \text{分類} \\ \dfrac{1}{T} \displaystyle\sum_{t=1}^T \hat{y}_t & \text{回帰} \end{cases}$

各木が「少しずつ違う視点」で学習 → アンサンブルで分散を低減

📊 グラフ

木の数を変えて、決定境界がどう滑らかになるか観察。

💡 解説

単一の決定木より過学習に強い（分散低減）
並列学習可（各木は独立） → 高速
特徴量重要度を自動算出
解釈性は単一の決定木より低下（多数決の理由が見えない）
💡 直感的に: 多数の決定木の「多数決」。各木は少しずつ違うデータ・特徴量で学習 → アンサンブルで分散を低減。並列学習可能で実装も簡単。

関連: 決定木 (構成要素) | ブースティング (vs バギング)

📊 決定木 (Decision Tree)

_

📐 数式

木の各ノードで「特徴量 $x_j$ が閾値 $\theta$ より大きいか？」で分岐。

分割基準 (どこで分割するかを決める指標):
ジニ不純度: $\text{Gini} = 1 - \sum_c \underbrace{p_c^2}_{\substack{\text{クラスcの}\\\text{割合の二乗}}}$ ← 0=純粋, 0.5=混在
エントロピー: $H(S) = -\displaystyle\sum_{c} p_c \log p_c$
情報利得: $\text{IG} = \underbrace{H(\text{親})}_{\text{分割前}} - \sum_k \frac{|S_k|}{|S|} \underbrace{H(S_k)}_{\text{分割後}}$ ← 大きいほど良い分割

「IG が最大になる分割」を選ぶ。これを再帰的に繰り返して木を構築。

📊 グラフ

木の深さを変えると決定境界がどう変わるかを観察。深すぎると過学習。

💡 解説

解釈性が極めて高い: IF-THEN ルールに変換可能
前処理ほぼ不要 (スケーリング不要、欠損値も扱える)
単独では過学習しやすい (深い木 = 学習データ丸暗記)
アンサンブル (RF/GBT) の構成要素として大活躍
💡 直感的に: IF-THENルールの木。「面積>50m²なら→築年数<10年なら→高い」。解釈性最強だが単独では過学習しやすい。RF/GBTの構成要素。

関連: ランダムフォレスト | ブースティング | 📊 過学習

📊 自己回帰モデル (AR / ARIMA)

🧬 古典ML / 🎓 教師あり学習 / 🎯 時系列予測

📐 数式

AR(p): $x_t = \underbrace{c}_{\substack{\text{定数}\\\text{(トレンド)}}} + \underbrace{\phi_1 x_{t-1}}_{\substack{\text{1ステップ前}\\\text{の影響}}} + \underbrace{\phi_2 x_{t-2}}_{\substack{\text{2ステップ前}}} + \cdots + \underbrace{\varepsilon_t}_{\substack{\text{ノイズ}\\\text{(予測不能)}}}$

$\phi_k$: 過去 $k$ ステップの影響度。$|\phi|<1$ で安定（定常）、$|\phi| \to 1$ で持続的トレンド
$c$: 長期トレンド / $\varepsilon_t$: 予測不能なランダム成分（ホワイトノイズ）

ARIMA(p,d,q): $p$=AR次数 / $d$=差分回数 (非定常→定常) / $q$=MA次数
→ 📐 各項の詳細・GPTとの関係 →

📊 グラフ

$\phi$ を変えて時系列の挙動を観察。1に近いと持続性が高く、負だと振動。

💡 解説

時系列の古典手法。株価・気温・売上予測の標準
解釈可能（各ラグの影響度がわかる）
線形・定常性の仮定が強い → 現実の時系列では限界
GPT/Transformer は「言語版の高度な AR」と捉えられる
非定常データは ARIMA で差分化、季節性は SARIMA で対応
💡 直感的に: 「過去の自分で未来の自分を予測する」。昨日の株価が高ければ今日も高い傾向（$\phi > 0$）。GPT が「次の単語」を予測するのも同じ構造。AR は数値版、GPT は言語版の自己回帰。

関連: 📊 RNN/LSTM (時系列のDL版) | 📊 Attention/Transformer

📊 ロジスティック回帰

🧬 古典ML / 🎓 教師あり学習 / 🎯 分類

📐 数式

2クラス: $P(y=1 \mid x) = \underbrace{\sigma}_{\substack{\text{Sigmoid}\\\text{実数→確率}}} \left( \underbrace{w \cdot x + b}_{\substack{\text{線形回帰と同じ}\\\text{(実数出力)}}} \right) = \dfrac{1}{1 + e^{-(w \cdot x + b)}}$

$w \cdot x + b > 0$ → $\sigma > 0.5$ → クラス1 / $< 0$ → クラス0 / $= 0$ → 決定境界

多クラス: $P(y=k) = \text{softmax}(z_k) = \dfrac{e^{z_k}}{\sum_j e^{z_j}}$ ← 全クラスの確率の合計=1になるよう正規化

損失: $L = -\dfrac{1}{n} \sum_i \underbrace{y_i \log \hat{y}_i}_{\substack{\text{正解=1のとき}\\\hat{y} \to 1\text{で損失}\to 0}} + \underbrace{(1-y_i) \log(1-\hat{y}_i)}_{\substack{\text{正解=0のとき}\\\hat{y} \to 0\text{で損失}\to 0}}$

MSE ではなくクロスエントロピーを使う理由: 勾配が $\hat{y} - y$ とシンプルになる
→ 📐 各項の詳細な導出 →

📊 グラフ

2クラス分類で決定境界とシグモイド出力を可視化。

💡 解説

確率を出力できる（信頼度がわかる）
解釈性が高い: 係数 $w_i$ がオッズ比の対数
NN の出力層と完全に等価。古典ML と DL の橋渡し
線形分離可能な問題のみ（非線形は SVM/カーネル or NN 必須）
💡 直感的に: 線形回帰の出力（実数）に「Sigmoid フタ」をかぶせて 0〜1 に押し込めたもの。出力は確率として読める。スパム判定なら「80%の確率でスパム」。NN の最終層 ($\text{FC} + \text{Softmax}$) は、ロジスティック回帰の多層版。

関連: 📊 活性化関数 (Sigmoid) | 線形回帰 | 📊 SVM | 📊 混同行列

📊 Elastic Net (L1 + L2)

🧬 古典ML / 🎓 教師あり学習 / 🎯 回帰 + L1+L2
📌 Elastic Net = L1 + L2 の組合せ。→ L1 vs L2 の比較 | Ridge (L2) | Lasso (L1)

📐 数式

$L(w) = \underbrace{\text{MSE}}_{\text{フィット}} + \lambda \left[ \underbrace{\alpha \sum_j |w_j|}_{\substack{\text{L1: スパース化}\\\text{(不要な重みを0に)}}} + \underbrace{(1-\alpha) \sum_j w_j^2}_{\substack{\text{L2: 安定化}\\\text{(相関グループを保持)}}} \right]$

$\alpha$: L1 と L2 の混合比 → $\alpha=1$ Lasso / $\alpha=0$ Ridge / $0<\alpha<1$ 両方
Lasso の弱点（相関特徴量から1つしか残さない）を L2 が補完する
→ 📐 各項の詳細 →

📊 グラフ

α (L1の比率) を変えて、Lasso と Ridge の中間を体感。

💡 解説

L1 のスパース性 + L2 の安定性。両方のメリット
相関のある特徴量グループを「まとめて選ぶ」（Lasso の弱点を解消）
ハイパーパラメータが2つ ($\lambda, \alpha$) に増える → CVで探索
scikit-learn の `ElasticNet` でデフォルト α=0.5
💡 直感的に: Lasso は「精鋭を残す」、Ridge は「全員を少しずつ使う」。Elastic Net は「精鋭を中心に使いつつ、関連する仲間もチームごと残す」。面積と部屋数のように相関する特徴量を、Lasso のように片方だけ捨てずに両方活かせる。

関連: Lasso | Ridge | 📚 ハイパーパラメータ最適化

📊 Lasso 回帰 (L1 正則化)

🧬 古典ML / 🎓 教師あり学習 / 🎯 回帰 + 特徴選択
📌 Lasso = L1正則化を使った回帰。→ L1 vs L2 の比較グラフ | Ridge (L2版)

📐 数式

損失関数: $L(w) = \underbrace{\dfrac{1}{n} \displaystyle\sum_{i} (y_i - \hat{y}_i)^2}_{\text{データフィット}} + \underbrace{\lambda}_{\text{強さ}} \underbrace{\displaystyle\sum_{j} |w_j|}_{\substack{\text{重みの絶対値和}\\\text{→ 0にする力}}}$

Ridge ($w_j^2$, 放物線) vs Lasso ($|w_j|$, V字): V字の先端にハマると $w_j$ がちょうど0に
$w_j = 0$ は「特徴量 $j$ を使わない」= 自動的な特徴選択
$\lambda$↑ → 0 になる係数が増える → 重要な特徴量だけが残る

解析解なし: $|w_j|$ は $w_j=0$ で微分不能 → 反復法で解く
→ 📐 座標降下法・ISTAとは？ 詳細 →

📊 グラフ

λ を上げると係数が次々に 0 になる様子（Ridge との違い）。

💡 解説

自動的な特徴選択。重要な特徴量だけが残り、解釈性が向上
高次元データ（特徴量数 ≫ サンプル数）で威力
解析解なし（反復法で解く）。Ridge より遅い
相関のある特徴量グループから1つしか選ばない傾向 → Elastic Net で対処
💡 直感的に: 100個の特徴量から「本当に重要な10個」を自動で選び出す。不要な特徴量の重みを完全に0にする「自動カット機能」付きの回帰。Ridge が「全員を少しずつ使う」なら、Lasso は「精鋭だけ残して他は解雇」。

関連: 線形回帰 | Ridge | Elastic Net | 📊 L1 vs L2 比較

📊 Ridge 回帰 (L2 正則化)

🧬 古典ML / 🎓 教師あり学習 / 🎯 回帰 + L2正則化
📌 Ridge = L2正則化を使った回帰。→ L1 vs L2 の比較グラフ | Lasso (L1版)

📐 数式

損失関数: $L(w) = \underbrace{\dfrac{1}{n} \displaystyle\sum_{i=1}^n (y_i - \hat{y}_i)^2}_{\substack{\text{データフィット項}\\\text{予測精度を上げたい}}} + \underbrace{\lambda}_{\substack{\text{ペナルティ}\\\text{の強さ}}} \underbrace{\displaystyle\sum_{j=1}^p w_j^2}_{\substack{\text{重みの二乗和}\\\text{大きい重みを罰する}}}$

第1項: 予測と正解のズレ → 小さくしたい
第2項: 重みの大きさ → 小さく保ちたい（$w_j^2$ = 全重みを均等に縮小、0にはしない）
$\lambda$: 2つのバランスを制御する「つまみ」。$\lambda=0$ → 線形回帰 / $\lambda \to \infty$ → 全重み→0

解析解: $\hat{w} = (X^\top X + \lambda I)^{-1} X^\top y$
→ 📐 なぜλIで正則に？ 多重共線性とは？ 導出の詳細 →

📊 グラフ

正則化強度 λ を上げると、係数が小さくなる様子を観察。

💡 解説

多重共線性に強い。$X^\top X + \lambda I$ は常に逆行列を持つ
解析解あり。線形回帰と同じスピード
特徴選択しない（係数が完全に0にはならない）→ Lasso が必要な場合あり
NN の Weight Decay = L2 正則化と等価
💡 直感的に: 「データにフィットしたいけど、重みが暴走するのは困る」→ 重みにブレーキ（$\lambda$）をかける。ブレーキが強すぎると何も学ばない、弱すぎると過学習。CV で最適な強度を見つける。特徴量が相関していても（多重共線性）、$\lambda I$ で行列を安定化して解ける。

関連: 線形回帰 | Lasso | Elastic Net | 📊 L1 vs L2 比較

📊 線形回帰 (Linear Regression)

🧬 古典ML / 🎓 教師あり学習 / 🎯 回帰

📐 数式

予測モデル: $\hat{y} = \underbrace{w_1}_{\substack{\text{特徴量1の}\\\text{影響度}}} x_1 + \underbrace{w_2}_{\substack{\text{特徴量2の}\\\text{影響度}}} x_2 + \cdots + \underbrace{b}_{\substack{\text{ベース値}\\\text{(切片)}}}$

$w_j$ = 特徴量 $x_j$ が1単位増えたとき予測がどれだけ変わるか（偏回帰係数）
例: $w_{\text{面積}}=40$ → 面積1m²増 = 価格40万円↑

損失関数 (MSE): $L(w) = \dfrac{1}{n} \displaystyle\sum_{i=1}^n \underbrace{(y_i - \hat{y}_i)^2}_{\substack{\text{各データ点の}\\\text{予測ズレの二乗}}}$
二乗する理由: ①正負の相殺を防ぐ ②大きなズレをより強く罰する

最小二乗法（解析解）: $\hat{w} = (X^\top X)^{-1} X^\top y$
→ 📐 Xとは？ なぜこの式で解けるか？ 導出の詳細 →

📊 グラフ

ノイズが大きいデータに線形回帰を適用。データ点と最適直線の関係を観察。

💡 解説

解釈性が最高: 各特徴量の係数 $w_i$ がそのまま影響度
解析解が存在 (反復学習不要)。計算高速
非線形パターンを捉えられない（多項式特徴量で対応可）
多重共線性（特徴量が相関）があると不安定 → Ridge/Lassoで対処
💡 直感的に: データ点の真ん中に「一番ズレが少ない直線」を引く。各特徴量の「傾き」がそのまま影響の大きさを表す。最もシンプルで、最も解釈しやすいモデル。NN の全結合層 ($y = Wx + b$) は線形回帰の一般化。

関連: Ridge | Lasso | ロジスティック回帰 | 📊 評価指標

📚 Index: 探索アルゴリズム

_

古典AI（記号主義）の中核手法。第1次AIブームで発展。

📊 幅優先探索 (BFS) ← 最短経路保証、FIFOキュー

📊 深さ優先探索 (DFS) ← メモリ効率、再帰/スタック

📊 Mini-max 法 ← 2人ゲームの最適戦略

📊 αβ枝刈り ← Mini-maxの高速化

📊 モンテカルロ木探索 (MCTS) ← AlphaGo、UCB1

📚 Index: 回帰モデル

_

古典機械学習の基礎。教師あり学習で連続値や確率を予測。

📊 線形回帰 ← 最小二乗法、解析解

📊 Ridge回帰 (L2) ← 多重共線性対策、Weight Decay

📊 Lasso回帰 (L1) ← スパース化、特徴選択

📊 Elastic Net ← L1+L2のハイブリッド

📊 ロジスティック回帰 ← 分類、Sigmoid、NN出力層と同等

📊 自己回帰 AR/ARIMA ← 時系列予測、GPTの先祖

📚 Index: 木・アンサンブル・SVM

_

構造化データ（テーブル）でNNを上回ることが多い古典機械学習の主役。

📊 決定木 ← 解釈性最強、ジニ不純度/情報利得

📊 ランダムフォレスト ← バギング、並列学習

📊 ブースティング (XGBoost等) ← 逐次学習、Kaggle最強

📊 ナイーブベイズ ← スパムフィルタ、条件付き独立

📊 SVM ← マージン最大化、カーネル法

📚 Index: 教師なし学習・推薦

_

正解ラベルなしでデータの構造を発見する手法群。

📊 k-means 法 ← クラスタリングの基礎

📊 階層的クラスタリング ← ウォード法、デンドログラム

📊 PCA (主成分分析) ← 線形次元削減

📊 t-SNE / UMAP ← 非線形次元削減・可視化

📊 協調フィルタリング ← 推薦、コールドスタート問題

📊 LDA (トピックモデル) ← 潜在トピック発見

📚 Index: 強化学習詳細

_

エージェントが環境と相互作用しながら最適行動を学習。

📊 マルコフ決定過程 (MDP) ← 5要素、フレームワーク

📊 多腕バンディット ← 探索 vs 活用

📊 ε-greedy 方策 ← 最もシンプルな探索

📊 UCB 方策 ← 不確実性ベース、O(log T) regret

📊 Thompson Sampling ← ベイズ的探索、実用最強

📊 Q学習 ← 価値関数、DQN

📊 PPO / Actor-Critic ← 方策勾配、ChatGPT RLHF

📚 Index: データ前処理

_

機械学習プロジェクトの時間の8割を占める実装の中核。

📊 標準化 vs 正規化 ← スケーリング

📊 欠損値補完 ← 平均/KNN/MICE

📊 特徴量エンジニアリング ← 対数変換、多項式

📊 SMOTE (不均衡データ対策) ← オーバーサンプリング

One-hot / Label エンコーディング

One-hot: "赤"→[1,0,0] (順序なし) / Label: "S,M,L"→0,1,2 (順序あり)

Target エンコーディング

カテゴリ → 目的変数の平均値。高基数カテゴリに有効。リーク注意

📚 Index: 異常検知

_

「普通とは違う」を発見する。不正検知・品質管理・侵入検知。

📊 Z-score ← 1次元、正規分布前提

📊 マハラノビス距離 ← 多変量、相関考慮

📊 One-Class SVM ← 非線形、カーネル

📊 Isolation Forest ← 高速、大規模OK

📊 LOF ← 局所密度ベース

📊 Autoencoder 異常検知 ← DL、復元誤差

時系列異常検知

LSTM-AE / Prophet: 季節性・トレンド考慮。サーバー監視で実用

📚 Index: 自然言語処理 (古典〜現代)

_

テキストを数値に変換する技術の系譜: BoW → TF-IDF → BM25 → Word2Vec → BERT → GPT

📊 BoW (Bag of Words) ← 最もシンプル、順序消失

📊 TF-IDF ← 重み付け、検索の古典

📊 BM25 ← Elasticsearch標準、RAGで復活

📊 N-gram ← 部分順序、スペル訂正

📊 Word2Vec ← 意味ベクトル革命 (2013)

📊 Subword (BPE/WordPiece) ← GPT/BERT基盤

📊 RAG ← BM25+LLMのハイブリッド

形態素解析 / Stop Words

日本語: MeCab/Janome。BERT時代では多くの前処理が不要に

📚 Index: ベイズ最適化・AutoML

_

「最適なハイパーパラメータ」を効率的に探す技術。

📊 グリッド / ランダムサーチ ← 基礎手法

📊 ベイズ最適化 ← GP + 獲得関数、少試行で最適

📊 ガウス過程 (GP) ← 不確実性付き予測

📊 獲得関数 (EI/UCB/PI) ← 次の探索点を決定

📊 TPE (Optuna) ← 実用最強、日本発

AutoML / NAS

AutoML: 特徴量+モデル+ハイパラを全自動化 / NAS: NN構造自体を自動設計 (EfficientNet)

📚 Index: グラフニューラルネット (GNN)

_

グラフ構造データを扱うDL: SNS, 化学, 推薦, 道路網。

📊 メッセージパッシング ← GNNの共通フレームワーク

📊 GCN ← Kipf 2017、GNNブームの起爆剤

📊 GAT ← Attention応用、重要度学習

GraphSAGE / MPNN

GraphSAGE: 大規模グラフ・新規ノード対応 / MPNN: 分子物性予測 (AlphaFold前身)

課題: Over-smoothing

層を重ねすぎると全ノードが同じ表現に。解決策: Graph Transformer, Jumping Knowledge

📚 Index: 分散学習

_

巨大モデルを複数GPU/サーバーで学習する技術。LLM時代の必須知識。

📊 データ並列 ← DDP、最もシンプル

📊 モデル並列 / パイプライン / テンソル並列 ← 巨大モデル分割

📊 連合学習 (Federated) ← プライバシー保護

📊 Mixed Precision / ZeRO ← メモリ効率化

Gradient Checkpointing

活性化を再計算してメモリ削減 (30%遅化)。Transformer学習ではほぼ必須

GPT-3/4 の規模感

GPT-3: 1024×V100, 数ヶ月, 1287MWh / GPT-4: 25000×A100, 3ヶ月, ~50GWh

📚 Index: モデル解釈性 (XAI)

_

「なぜAIがそう判断したか」を人間に説明する技術。倫理・規制対応の核。

📊 LIME ← 局所線形近似、model-agnostic

📊 SHAP ← Shapley値、理論的厳密、Kaggle標準

📊 Permutation Importance ← 最もシンプルなグローバル解釈

📊 Grad-CAM ← CNN注目領域ヒートマップ

📊 Counterfactual 説明 ← 「何を変えれば」、GDPR対応

Attention 可視化 / TCAV

Attention: Transformerの重みを直接表示 (批判あり) / TCAV: 人間概念レベルの説明 (Google)

Mechanistic Interpretability

Anthropic主導。LLMの内部回路を逆エンジニアリング。AI Safety の最新研究

解釈性 vs 精度のトレードオフ

線形回帰(解釈性◎,精度△) ↔ DNN(精度◎,解釈性△)。GAM が中間策