🤔 1. なぜアーキテクチャの設計が重要か

万能近似定理は「十分な幅の MLP は任意の関数を近似できる」と言うが、 実用にはデータの構造に合った帰納バイアスが必要：

• 画像 → 局所性・並進不変性 → CNN
• 系列 → 時間依存 → RNN / Transformer
• グラフ → ノード間関係 → GNN
• 3Dメッシュ → 不変性 → 等変ネット

🖼 2. 畳み込みニューラルネットワーク (CNN)

2.1 畳み込み層

入力画像 $X$ にカーネル $K$ をスライドさせながら積和：

$$Y_{i,j} = \sum_{m,n} X_{i+m, j+n} K_{m,n} + b$$

1 カーネルが 1 つの特徴を検出（エッジ・テクスチャ等）。 多数のカーネルで多数の特徴マップを出力。

2.2 主要パラメータ

• カーネルサイズ：3×3 や 5×5 が定番
• ストライド：何画素飛ばすか
• パディング：周囲をゼロで埋める
• チャネル数：入力カラー=3、 出力は任意（深いほど多い）

2.3 プーリング

• Max Pooling：領域の最大値
• Average Pooling：領域の平均
• Global Average Pooling：チャネル全体の平均 → FC 層代替

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

import torch.nn as nn
class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(64, 128, 3, padding=1), nn.ReLU(), nn.AdaptiveAvgPool2d(1),
        )
        self.classifier = nn.Linear(128, num_classes)
    def forward(self, x):
        x = self.features(x).flatten(1)
        return self.classifier(x)

2.4 代表的なCNNアーキテクチャ

• LeNet (1998)：CNN の原型
• AlexNet (2012)：ImageNet 圧勝 → 深層学習ブーム
• VGG (2014)：3x3 畳み込みを深く積む
• Inception/GoogLeNet (2014)：分岐構造
• ResNet (2015)：残差接続で 152 層が学習可能
• DenseNet (2016)：全層接続
• EfficientNet (2019)：深さ・幅・解像度を協調スケール
• ConvNeXt (2022)：Transformer 時代の CNN 再考

2.5 ResNet と残差接続

$$\mathbf{y} = F(\mathbf{x}) + \mathbf{x}$$

「恒等関数を足す」だけで深い NN の勾配消失を劇的に緩和。 深層学習史上最重要発明の 1 つ。

2.6 U-Net

セグメンテーション（ピクセル単位分類）の標準。 Encoder で圧縮→Decoder で復元、 同階層をスキップ接続。 医療画像・衛星画像で活躍。

🔁 3. RNN・LSTM・GRU

3.1 RNN（再帰型ニューラルネット）

$$\mathbf{h}_t = \tanh(W_h \mathbf{h}_{t-1} + W_x \mathbf{x}_t + \mathbf{b})$$

隠れ状態 $\mathbf{h}_t$ が「記憶」を持ち越す。 ただし長期依存で勾配消失/爆発が起きやすい。

3.2 LSTM（Long Short-Term Memory, 1997）

3 つのゲート（入力・忘却・出力）+ セル状態 $C_t$ で長期記憶を制御：

$$f_t = \sigma(W_f \cdot [\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_f)$$

$$C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t$$

$\odot$ は要素積。 ゲートが「何を忘れ・記憶し・出力するか」を学習。

3.3 GRU（Gated Recurrent Unit, 2014）

LSTM 簡略版。 更新ゲート・リセットゲートの 2 つ。 パラメータが少なくほぼ同等の性能。

1
2
3
4
5
6
7
8
9

import torch.nn as nn
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, num_classes):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_classes)
    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])

3.4 双方向 RNN

前向き + 後向きの 2 つの RNN を連結。 全系列を見て予測（過去・未来両方）。

👁 4. Attention 機構

系列の各位置に重みを付け、 重要な部分に「注目」する。 元は機械翻訳（Bahdanau 2014）。

4.1 Self-Attention（自己注意）

Query・Key・Value を入力から計算し、 各位置と全位置の関係を学習：

$$\mathrm{Attention}(Q, K, V) = \mathrm{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right) V$$

記号読み：$Q, K, V$ は「キュー・ケイ・ブイ」、 すべて入力の線形変換。 $d_k$ で割るのは softmax の勾配安定化。

4.2 Multi-Head Attention

複数の Attention を並列に実行、 異なる関係性を捉える。 通常 8〜16 ヘッド。

4.3 計算量

系列長 $n$ で $O(n^2 d)$。 長系列で重い → FlashAttention・Sparse Attention・Linear Attention 等の高速化。

⚡ 5. Transformer（"Attention is All You Need", 2017）

RNN を捨て Self-Attention のみで構築。 並列学習可能で大規模化が容易。

5.1 構造

• Encoder：Multi-Head Self-Attention + Feed-Forward + 残差・LayerNorm
• Decoder：Masked Self-Attention + Cross-Attention + Feed-Forward
• 位置エンコーディング：系列の順序情報を sin/cos で注入

1
2
3
4
5
6
7
8

import torch
import torch.nn as nn
# PyTorch 標準の Transformer
model = nn.Transformer(d_model=512, nhead=8, num_encoder_layers=6, num_decoder_layers=6)

# Encoder のみ（BERT 系）
encoder_layer = nn.TransformerEncoderLayer(d_model=512, nhead=8, batch_first=True)
encoder = nn.TransformerEncoder(encoder_layer, num_layers=6)

5.2 BERT（2018）

Transformer Encoder のみ。 双方向 Masked Language Model + Next Sentence Prediction で事前学習。 分類・抽出系タスクに強い。

5.3 GPT 系

Transformer Decoder のみ。 次の単語予測で自己回帰的に生成。 GPT-3（2020）以降、 大規模化で zero-shot/few-shot 能力が出現。

5.4 Vision Transformer (ViT)

画像を 16×16 パッチに分割し、 トークン列として Transformer に投入。 大規模事前学習で CNN を上回るケース増加。

🔤 6. 埋め込み (Embedding)

カテゴリ・単語等の離散シンボルを密ベクトルに変換。 NN の入り口の標準技。

代表例

• Word2Vec (2013)：単語をベクトル化、 "king − man + woman ≈ queen"
• GloVe (2014)：共起統計に基づく
• FastText (2016)：サブワード対応
• BERT/SBERT/E5 等：文脈付き埋め込み
• CLIP (2021)：画像とテキストの統一埋め込み

🔄 7. 転移学習

大規模データで事前学習したモデルを、 自分の問題に流用。 少データで高精度が出る現代深層学習の主流。

7.1 ファインチューニング戦略

• Feature Extraction：事前学習部分を凍結、 最終層のみ学習
• Full Fine-tuning：全層を再学習（過学習に注意）
• Layer-wise：層ごとに学習率を変える
• LoRA：低ランク行列で効率的に微調整（LLM で標準）
• Adapter：追加モジュールだけ学習
• Prompt Tuning：プロンプト埋め込みだけ学習

1
2
3
4

from transformers import AutoModelForSequenceClassification, AutoTokenizer, Trainer
model = AutoModelForSequenceClassification.from_pretrained('bert-base-japanese-v3', num_labels=2)
tokenizer = AutoTokenizer.from_pretrained('bert-base-japanese-v3')
# Trainer で fine-tuning（HuggingFace 標準パターン）

🕸 8. グラフニューラルネットワーク（参考）

ノードと辺で構造化されたデータ（SNS、 分子、 知識グラフ）向け。

• GCN (2017)：畳み込みのグラフ版
• GraphSAGE (2017)：近傍サンプリング
• GAT (2018)：Attention を組合せ

📊 9. アーキテクチャ早見表

⚠️ 10. 深層学習の落とし穴

🏋️ 11. 練習問題

注意：深層学習はテーブルデータの SSDSE-B 47 行では本領発揮しません。 公開画像・テキストデータセットを併用してください。

1
2
3
4
5
6
7

import torch
import torchvision
from torchvision import transforms
trans = transforms.Compose([transforms.ToTensor()])
train = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=trans)
test = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=trans)
# 学習ループは前述の SimpleCNN を参考

1
2
3
4

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer
tokenizer = AutoTokenizer.from_pretrained('cl-tohoku/bert-base-japanese-v3')
model = AutoModelForSequenceClassification.from_pretrained('cl-tohoku/bert-base-japanese-v3', num_labels=2)
# Trainer で fine-tune

📝 12. 報告フォーマット

❌ NG例

「Transformer を使って良い結果が出ました。」

✅ OK例

「日本語感情分類タスク（n_train=8,000、 n_test=2,000、 2クラス）で、 ベースライン LightGBM (TF-IDF) Macro-F1 = 0.78 に対し、 bert-base-japanese-v3 を batch_size=16, lr=2e-5, 3epoch で fine-tune した結果 0.91 を達成。 GPU は V100、 学習時間 12 分。 アテンション可視化で『否定語』周辺に強い注目が確認された。 過学習対策として early stopping (patience=2) を使用。」

🐍 13. ライブラリ早見表

📜 14. 深層学習アーキテクチャの歴史

• 1989：LeCun の LeNet（CNN の祖、 手書き数字）
• 1997：Hochreiter & Schmidhuber の LSTM
• 2012：AlexNet が ImageNet 圧勝
• 2014：VGG、 GoogLeNet、 GAN、 Word2Vec、 Seq2Seq
• 2015：ResNet、 BatchNorm、 Adam
• 2017：Transformer "Attention Is All You Need"
• 2018：BERT、 GPT-1
• 2019：GPT-2、 EfficientNet、 NeurIPS の大規模化議論
• 2020：GPT-3、 ViT、 CLIP
• 2021：DALL·E、 Codex、 拡散モデル普及
• 2022：ChatGPT、 Stable Diffusion、 ConvNeXt
• 2023：GPT-4、 LLaMA、 Mamba (SSM)
• 2024-2025：マルチモーダル基盤モデル、 エージェント、 効率化

💼 15. 実務応用

• 画像：医療画像診断（U-Net）、 自動運転（YOLO）、 顔認証
• 音声：音声認識（CTC・Whisper）、 音声合成（VITS）
• NLP：機械翻訳、 文書要約、 質問応答、 チャットボット
• 生成：画像生成（Stable Diffusion）、 動画生成（Sora）
• 科学：タンパク質構造予測（AlphaFold）、 天文画像処理
• 推薦：埋め込みベース推薦、 系列推薦（SASRec）
• 金融：時系列予測、 異常検知

✅ 16. 深層学習プロジェクト チェックリスト

• □ データの性質に合ったアーキテクチャを選んだか？
• □ 事前学習モデルを活用したか？
• □ 入力を適切に正規化したか？
• □ Data Augmentation を実施したか？
• □ 学習率スケジュール（cosine 等）を使ったか？
• □ Dropout・Weight Decay・Early Stopping で過学習を抑えたか？
• □ 訓練/検証 損失曲線を可視化したか？
• □ 推論時に model.eval() を呼んだか？
• □ 複数 seed で再現性確認したか？
• □ ベースライン（GBDT・線形）と比較したか？
• □ モデルカードを作成したか？

🎓 17. 深層学習を成功させる実践のコツ

17.1 デバッグの順番

1. ごく小さいサブセット（1〜2 バッチ）でモデルがオーバーフィットできるか確認
2. できなければアーキテクチャ・損失関数のバグ
3. できたら通常データで学習、 訓練損失が下がるか確認
4. 検証損失が改善するか確認
5. 過学習を抑える調整に進む

17.2 学習率の選び方

• 初手：Adam で 1e-3、 fine-tune は 1e-5〜5e-5
• LR Range Test：徐々に上げて損失が爆発する直前を見る
• Cosine Annealing：滑らかに下げる（Transformer 標準）
• Warmup：最初の数百ステップで徐々に上げる（大バッチ必須）

17.3 バッチサイズ

• 大きい：勾配ノイズ小、 速い、 GPU メモリ要
• 小さい：汎化性能が良いことが多い
• Gradient Accumulation で実効的に大バッチ化

17.4 GPU メモリ削減

• 混合精度学習（AMP）
• Gradient Checkpointing
• 勾配累積
• FlashAttention
• LoRA・量子化（QLoRA）

🤗 18. Hugging Face エコシステム

事前学習モデルのデファクト標準。 数万のモデルが公開されている。

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

from transformers import pipeline
# 感情分析
clf = pipeline('sentiment-analysis', model='cl-tohoku/bert-base-japanese-v3')
print(clf('この商品は素晴らしいです'))

# テキスト生成
gen = pipeline('text-generation', model='rinna/japanese-gpt-neox-3.6b')
print(gen('日本の首都は'))

# ゼロショット分類
zsc = pipeline('zero-shot-classification', model='facebook/bart-large-mnli')
print(zsc('I love this movie', candidate_labels=['positive','negative']))

# 画像分類
img = pipeline('image-classification', model='google/vit-base-patch16-224')

❓ 19. よくある質問

Q. Transformer は CNN を完全に置き換えますか？

A. 大規模事前学習があれば ViT が勝つことが多いですが、 中小規模では CNN が依然強力。 ConvNeXt 等の現代 CNN は ViT と互角。

Q. LSTM はもう古い？

A. 短系列・低リソースなら現役。 長系列・大規模なら Transformer が標準。 最近は Mamba（SSM）が中間域で注目。

Q. 自前で大規模事前学習は可能？

A. GPT-3 級は数千〜数億ドル。 現実的には公開モデルを fine-tune が標準。 ドメイン特化なら継続事前学習（Domain-Adaptive Pretraining）。

Q. パラメータが多いほど良い？

A. 一般に大きいほど性能向上（scaling law）だが、 推論コスト・遅延・環境負荷とのトレードオフ。 蒸留・量子化で運用効率化。

📈 20. スケーリング則（Scaling Laws）

Kaplan ら 2020 / Hoffmann ら 2022（Chinchilla）。 モデル損失 $L$ はパラメータ数 $N$・データ量 $D$・計算量 $C$ の冪乗則に従う：

$$L(N, D) \approx L_\infty + \frac{A}{N^\alpha} + \frac{B}{D^\beta}$$

Chinchilla 則：与えられた計算量に対し、 $N \propto D$ で釣り合わせるのが最適。 つまり「データ不足の大モデル」より「データ豊富な小〜中モデル」のほうが効率良い。

⚡ 21. モデル量子化と運用効率化

• FP32 → FP16/BF16：メモリ半分、 ほぼ精度維持
• INT8 量子化：さらに 4 倍メモリ削減、 軽い精度低下
• INT4 (GPTQ, AWQ)：LLM の主流、 INT4 でほぼ精度維持
• 知識蒸留 (Distillation)：教師モデル → 小さい生徒モデル
• プルーニング：不要な重みを 0 化
• ONNX：ランタイム横断の形式
• TensorRT / OpenVINO：推論専用最適化

📊 22. 主要ベンチマーク

🌐 23. 状態空間モデル系（SSM・Mamba）

Transformer の長系列計算量 $O(n^2)$ を線形 $O(n)$ にする試み。 2023 年以降の有力候補。

• S4 / S4D (2021-2022)：構造化状態空間モデル
• Mamba (2023)：選択的 SSM、 言語・音声で Transformer に匹敵
• RWKV：RNN ライクな並列学習可能アーキ
• Mamba-2 / Hybrid 系：Attention と SSM のハイブリッド

テーブルデータには不要だが、 長系列処理の最前線として知っておく価値あり。

🎭 24. マルチモーダル学習

画像・テキスト・音声・動画など複数モダリティを統一的に扱う。

• CLIP (2021)：画像-テキストの対照学習
• BLIP / BLIP-2 (2022-2023)：画像キャプション・QA
• Flamingo (2022)：DeepMind の少数 shot 視覚言語モデル
• GPT-4V (2023)：マルチモーダル GPT
• Gemini (2023-2024)：Google のマルチモーダル基盤
• LLaVA (2023)：オープン視覚言語モデル
• Sora (2024)：テキスト→動画

🔗 関連用語

• ニューラルネットワーク基礎
• 機械学習の基礎
• 正則化
• 生成AI
• 自然言語処理
• 時系列分析
• 評価指標

🔖 キーワード索引（補強）

深層学習アーキテクチャに関する概念のチップ集。

🧮 SSDSE-B-2026 で実値計算 — 深層学習の実例

SSDSE-B-2026 は表形式のため CNN/RNN の本領ではないが、 MLP（多層パーセプトロン）の学習練習に使えます。

例：MLP で都道府県の高齢化率を回帰

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

import pandas as pd
import torch
import torch.nn as nn
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', header=1)
num = df.select_dtypes('number').dropna()
X = StandardScaler().fit_transform(num.iloc[:, 1:6].values)
y = num.iloc[:, 0].values.astype('float32')

X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)
X_tr_t = torch.tensor(X_tr, dtype=torch.float32)
y_tr_t = torch.tensor(y_tr).unsqueeze(1)

class MLP(nn.Module):
    def __init__(self, d_in):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(d_in, 32), nn.ReLU(), nn.Dropout(0.2),
            nn.Linear(32, 16), nn.ReLU(),
            nn.Linear(16, 1))
    def forward(self, x): return self.net(x)

model = MLP(X.shape[1])
opt = torch.optim.AdamW(model.parameters(), lr=1e-2, weight_decay=1e-4)
loss_fn = nn.MSELoss()
for ep in range(200):
    opt.zero_grad()
    pred = model(X_tr_t)
    loss = loss_fn(pred, y_tr_t)
    loss.backward(); opt.step()
print('最終 loss:', loss.item())

例：sklearn の MLPRegressor で同等処理

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

import pandas as pd
from sklearn.neural_network import MLPRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', header=1)
num = df.select_dtypes('number').dropna()
X = StandardScaler().fit_transform(num.iloc[:, 1:6].values)
y = num.iloc[:, 0].values

mlp = MLPRegressor(hidden_layer_sizes=(32, 16), max_iter=500,
                   alpha=1e-4, random_state=0)
print('CV R²:', cross_val_score(mlp, X, y, cv=5, scoring='r2').mean())

⚠️ 深層学習の落とし穴（補強・各 100 文字以上）

🐍 Python 実装バリエーション（PyTorch / TensorFlow / scikit-learn / JAX）

1. PyTorch — 標準的なトレーニングループ

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

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

class Net(nn.Module):
    def __init__(self, d_in):
        super().__init__()
        self.fc = nn.Sequential(nn.Linear(d_in, 64), nn.ReLU(), nn.Linear(64, 1))
    def forward(self, x): return self.fc(x)

# X, y は事前に標準化済み torch tensor
net = Net(5)
opt = torch.optim.AdamW(net.parameters(), lr=1e-3)
loss_fn = nn.MSELoss()

# ループ例
for epoch in range(100):
    opt.zero_grad()
    # pred = net(X); loss = loss_fn(pred, y); loss.backward(); opt.step()

2. PyTorch Lightning — 高水準ラッパー

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

import pytorch_lightning as pl
import torch
import torch.nn as nn

class LitMLP(pl.LightningModule):
    def __init__(self, d_in):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(d_in, 32), nn.ReLU(), nn.Linear(32, 1))
        self.loss = nn.MSELoss()
    def training_step(self, batch, _):
        x, y = batch
        return self.loss(self.net(x), y)
    def configure_optimizers(self):
        return torch.optim.AdamW(self.parameters(), lr=1e-3)

# trainer = pl.Trainer(max_epochs=50); trainer.fit(LitMLP(5), dataloader)

3. TensorFlow / Keras — 高水準 API

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(32, activation='relu', input_shape=(5,)),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(16, activation='relu'),
    tf.keras.layers.Dense(1)
])
model.compile(optimizer=tf.keras.optimizers.AdamW(1e-3), loss='mse', metrics=['mae'])
# model.fit(X, y, epochs=50, validation_split=0.2, batch_size=8)

4. scikit-learn MLPRegressor — 簡易 MLP

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

from sklearn.neural_network import MLPRegressor, MLPClassifier
from sklearn.preprocessing import StandardScaler

# 表形式の小〜中規模データ向け
mlp = MLPRegressor(
    hidden_layer_sizes=(64, 32),
    activation='relu',
    solver='adam',
    learning_rate_init=1e-3,
    early_stopping=True,
    n_iter_no_change=10,
    max_iter=500,
    random_state=0
)
# mlp.fit(StandardScaler().fit_transform(X), y)

5. Hugging Face transformers — 事前学習モデル fine-tune

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

from transformers import AutoModel, AutoTokenizer, AutoConfig
import torch.nn as nn

class TextClassifier(nn.Module):
    def __init__(self, model_name, n_classes):
        super().__init__()
        self.encoder = AutoModel.from_pretrained(model_name)
        hidden = self.encoder.config.hidden_size
        self.head = nn.Linear(hidden, n_classes)
    def forward(self, input_ids, attention_mask):
        out = self.encoder(input_ids=input_ids, attention_mask=attention_mask)
        cls = out.last_hidden_state[:, 0, :]
        return self.head(cls)

# model = TextClassifier('cl-tohoku/bert-base-japanese-v3', n_classes=4)

🔗 関連用語ネットワーク（前提・並列・発展）

📚 前提となる用語

• NN の基礎
• 誤差逆伝播
• 勾配降下法
• 線形代数
• 最適化

🔀 並列の概念

• ランダムフォレスト
• 勾配ブースティング
• SVM
• ベイズニューラルネット
• アンサンブル学習

🚀 発展的トピック

• 生成 AI — LLM, Diffusion
• 強化学習
• メタ学習
• Few-shot Learning
• ニューロシンボリック AI

🔗 直近の隣人

• 自然言語処理
• 画像認識
• 時系列分析
• 評価指標