電腦看到的圖,長這樣 ↓

用「規則」寫看看?

為什麼是 CNN,不是普通的 FC?

給模型三個內建假設

一個 neuron 「能看到」原始輸入的多大範圍

拿一個小窗戶在圖上滑,每滑一次做點積

Kernel:                 計算左上 3×3:
[ 1  0 -1]               1·1 + 2·0 + 3·(-1)
[ 1  0 -1]             + 4·1 + 5·0 + 6·(-1)
[ 1  0 -1]             + 7·1 + 8·0 + 9·(-1)
                       = -6

關於 Kernel,要記住四件事

記住:3×3 是工業界共識

看起來沒做事,其實是現代架構的關鍵

取區域代表值,降尺寸、增 RF

Input 4×4              MaxPool 2×2

[1  3 | 2  4]
[2  1 | 0  5]    →     [3  5]
[----- | -----]         [4  9]
[4  0 | 7  9]
[1  2 | 8  3]

為什麼要 Pooling?

為什麼現代架構不再用 FC?

把每層的輸入標準化

y = γ · (x - μ) / σ + β

YOLO 各代用過的非線性

親手調 kernel,看不同 filter 的效果

2015 · 何愷明 · 改變 deep learning 的論文

把 CNN 疊得很深,train loss 居然變高

20 層 CNN  →  train error: 5%
56 層 CNN  →  train error: 11%   (蛤?)

梯度消失 (Gradient Vanishing)

不學 H(x),改學 F(x) = H(x) - x

兩種長相對比

看模型大小決定用哪個

ResNet 五階段架構

把 BN, ReLU 從 conv 之後移到之前

親眼看普通 CNN vs ResNet 的梯度差異

物件偵測 vs 分類

🖼️ → CNN → "貓 (95%)"

🖼️ → Detector → 貓 (x1,y1,x2,y2)
                  狗 (x3,y3,x4,y4)
                  ...

Two-stage vs One-stage Detector

把偵測當 regression 問題,一次到底

Multi-part Sum-Squared Error

Better, Faster, Stronger · 七大改進

預先定義常見 box 形狀,模型只預測「微調」

bx = σ(tx) + cx       # 中心 x
by = σ(ty) + cy       # 中心 y
bw = pw · e^(tw)      # anchor 寬 × 縮放
bh = ph · e^(th)      # anchor 高 × 縮放

類 FPN 架構,影響後面所有 YOLO

高解析度 ⊕ 高語意 = 兩邊都要

三段式架構 · Backbone-Neck-Head

把 feature map 切成兩半

擴大 RF · 雙向特徵融合

輸入 Feature (13×13×512)
  ├─→ MaxPool 5×5  → 13×13×512
  ├─→ MaxPool 9×9  → 13×13×512
  ├─→ MaxPool 13×13 → 13×13×512
  └─→ Identity     → 13×13×512
  → Concat → 13×13×2048

不增加推論成本 vs 略增成本

從 IoU → GIoU → DIoU → CIoU

IoU = 交集面積 / 聯集面積

DIoU = IoU - dist²/diag²

不是學術論文,但因為好用紅了

RepVGG · 結構重參數化

分類跟回歸分開預測

E-ELAN · Lead + Aux Head · COCO 56.8% AP

整合多任務 · C2f · Anchor-Free + DFL

理解演進邏輯,才知道未來會往哪走

看 grid 跟 anchor 怎麼覆蓋整張圖

PyTorch 所有模型的爸爸

class SimpleCNN(nn.Module):
    def __init__(self):
        # 定義「有什麼」
        super().__init__()
        ...

    def forward(self, x):
        # 定義「怎麼用」
        ...
        return x

完整一個分類模型

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        # ── 在 __init__ 定義零件 ──────────────────────
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool  = nn.MaxPool2d(2, 2)
        self.relu  = nn.ReLU()
        self.fc    = nn.Linear(64 * 8 * 8, num_classes)

    def forward(self, x):
        # ── 在 forward 定義組裝方式 ──────────────────
        x = self.relu(self.conv1(x))    # (B, 32, 32, 32)
        x = self.pool(x)                 # (B, 32, 16, 16)
        x = self.relu(self.conv2(x))    # (B, 64, 16, 16)
        x = self.pool(x)                 # (B, 64,  8,  8)
        x = x.view(x.size(0), -1)        # 攤平 (B, 4096)
        x = self.fc(x)                   # (B, 10)
        return x

這幾行就是 ResNet 的精髓

class ResidualBlock(nn.Module):
    def __init__(self, in_ch, out_ch, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_ch, out_ch, 3, stride, padding=1)
        self.bn1   = nn.BatchNorm2d(out_ch)
        self.conv2 = nn.Conv2d(out_ch, out_ch, 3, 1, padding=1)
        self.bn2   = nn.BatchNorm2d(out_ch)
        self.relu  = nn.ReLU(inplace=True)

        # ── shape 不一致時用 1×1 conv 對齊 (projection shortcut)
        if stride != 1 or in_ch != out_ch:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_ch, out_ch, 1, stride),
                nn.BatchNorm2d(out_ch))
        else:
            self.shortcut = nn.Identity()

    def forward(self, x):
        identity = self.shortcut(x)
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out = out + identity   # ←── 這就是 skip connection
        return self.relu(out)

記住這個 5 步驟 pattern

# 1. 建立模型、loss、optimizer
model = SimpleCNN().cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# 2. 訓練 loop
for epoch in range(num_epochs):
    model.train()  # 切到訓練
    for images, labels in train_loader:
        images, labels = images.cuda(), labels.cuda()

        outputs = model(images)             # forward
        loss = criterion(outputs, labels)

        optimizer.zero_grad()   # 清梯度!忘了會爆
        loss.backward()         # 自動算梯度
        optimizer.step()        # 更新參數

    model.eval()  # 切到 eval
    with torch.no_grad():
        ...

作業要寫 YOLO,先記住四個改點

(B, S, S, anchors × (5 + classes))

同一物體可能被多 cell 偵測,要去重

點 layer 組模型,即時看 shape 跟 code

# 點左邊加 layer

實作並訓練一個自己設計的 YOLO

重點不是準確率多高

繳交方式 · 規則 · 截止

.
├── model.py       # 模型定義
├── train.py       # 訓練 script
├── README.md      # 設計說明
├── loss_curve.png # 訓練曲線
└── inference demo # 吃一張圖,輸出畫框