CNN 的卷積層和全連結層之間，
要插什麼？

這題的關鍵只有一件事：形狀。只要會讀張量的形狀，四個選項哪個對、哪個會出錯，一眼就看得出來。

輸入        (4, 1, 28, 28)
Conv2d    (4, 16, 28, 28)
ReLU      (4, 16, 28, 28)
MaxPool2d (4, 16, 14, 14)
Conv2d    (4, 32, 14, 14)
ReLU      (4, 32, 14, 14)
MaxPool2d (4, 32, 7, 7)

nn.Flatten()(fmap).shape       → torch.Size([4, 1568])
fmap.view(fmap.size(0), -1)    → torch.Size([4, 1568])   ← 另一種常見寫法
torch.flatten(fmap, 1)         → torch.Size([4, 1568])   ← 函式版要寫 start_dim=1

把觀念合起來：每一層交回什麼形狀

動畫 2打開記憶體：每一層交回什麼形狀2 分 5 秒・有旁白，也有字幕

🔒這支動畫在完整版試看版每頁開放第 1 支動畫

0:00開始 0:06輸入 x 0:14卷積與池化 0:41Flatten 0:56Linear 的權重 1:17陷阱一 1:30陷阱二 1:51整理

每一個形狀、權重大小和參數數量，都是 PyTorch 2.6.0 實際執行的結果。

都在 torch.nn 裡（from torch import nn）。每一個都是類別：先用括號做出一層（物件），再把張量丟進去。

兩個實驗的形狀、錯誤訊息和攤平順序，都和 PyTorch 2.6.0 實際執行的結果逐一比對過（§4 下方說明）。

動畫 3四個選項實際跑，再比準確率2 分 18 秒・有旁白，也有字幕

🔒這支動畫在完整版試看版每頁開放第 1 支動畫

0:00開始 0:15B 和 C 0:42D Softmax 0:58A GAP 1:28準確率 2:02答案

錯誤訊息、參數數量和兩條準確率曲線（每一輪的測試準確率），都是 PyTorch 2.6.0 實際執行的結果（random seed 0）。

常見的錯誤想法

需要 PyTorch（pip install torch；Google Colab 已經內建）。程式 3 另外要 scikit-learn（Colab 也內建）。

程式 1：每一層的形狀，四個選項各接一次

import torch
from torch import nn

torch.manual_seed(0)
features = nn.Sequential(
    nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
    nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
)
x = torch.randn(4, 1, 28, 28)
h = x
for layer in features:                       # 每一層之後的形狀
    h = layer(h)
    print(f'{type(layer).__name__:10}', tuple(h.shape))
fmap = h                                     # (4, 32, 7, 7)

def run(name, f):
    try:
        print(name, '→', tuple(f().shape))
    except RuntimeError as e:
        print(name, '→ RuntimeError:', e)

run('B Flatten＋Linear  ', lambda: nn.Linear(1568, 10)(nn.Flatten()(fmap)))
run('C 直接接 Linear     ', lambda: nn.Linear(1568, 10)(fmap))
run('A GAP 後直接接     ', lambda: nn.Linear(32, 10)(nn.AdaptiveAvgPool2d(1)(fmap)))
run('A GAP＋Flatten     ', lambda: nn.Linear(32, 10)(nn.Flatten()(nn.AdaptiveAvgPool2d(1)(fmap))))
run('D Softmax 後接     ', lambda: nn.Linear(1568, 10)(torch.softmax(fmap, dim=1)))

Conv2d     (4, 16, 28, 28)
ReLU       (4, 16, 28, 28)
MaxPool2d  (4, 16, 14, 14)
Conv2d     (4, 32, 14, 14)
ReLU       (4, 32, 14, 14)
MaxPool2d  (4, 32, 7, 7)
B Flatten＋Linear   → (4, 10)
C 直接接 Linear      → RuntimeError: mat1 and mat2 shapes cannot be multiplied (896x7 and 1568x10)
A GAP 後直接接      → RuntimeError: mat1 and mat2 shapes cannot be multiplied (128x1 and 32x10)
A GAP＋Flatten      → (4, 10)
D Softmax 後接      → RuntimeError: mat1 and mat2 shapes cannot be multiplied (896x7 and 1568x10)

程式 2：攤平的寫法和陷阱

import torch
from torch import nn

fmap = torch.randn(4, 32, 7, 7)

print(nn.Flatten()(fmap).shape)              # 預設 start_dim=1：保留第 0 維（張數）
print(torch.flatten(fmap).shape)             # 函式版預設 start_dim=0：連張數都攤平了
print(torch.flatten(fmap, 1).shape)          # 要寫 start_dim=1 才對
print(fmap.view(fmap.size(0), -1).shape)     # 另一種常見寫法

print(nn.Linear(7, 10)(fmap).shape)          # 只看最後一維：不報錯，形狀卻不是 (4, 10)
lazy = nn.LazyLinear(10)
print(lazy(fmap).shape, lazy.in_features)    # LazyLinear 也一樣：猜成 in_features=7

torch.Size([4, 1568])
torch.Size([6272])
torch.Size([4, 1568])
torch.Size([4, 1568])
torch.Size([4, 32, 7, 10])
torch.Size([4, 32, 7, 10]) 7

程式 3：Flatten 和 GAP，在手寫數字上各訓練 40 輪

import numpy as np
import torch
from torch import nn
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

d = load_digits()                                                      # 1797 張 8×8 手寫數字
X = torch.tensor(d.images / 16.0, dtype=torch.float32).unsqueeze(1)     # (1797, 1, 8, 8)
y = torch.tensor(d.target)
tr, te = train_test_split(np.arange(len(y)), test_size=0.25, random_state=0, stratify=d.target)

def make(head):
    torch.manual_seed(0)
    body = nn.Sequential(nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2))   # → (16, 4, 4)
    if head == 'Flatten':
        return nn.Sequential(body, nn.Flatten(), nn.Linear(16 * 4 * 4, 10))
    return nn.Sequential(body, nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(16, 10))

for head in ('Flatten', 'GAP＋Flatten'):
    m = make(head)
    opt = torch.optim.Adam(m.parameters(), lr=0.01)
    g = torch.Generator().manual_seed(0)
    for epoch in range(40):
        m.train()
        perm = tr[torch.randperm(len(tr), generator=g).numpy()]
        for i in range(0, len(perm), 64):
            b = perm[i:i + 64]
            opt.zero_grad()
            nn.functional.cross_entropy(m(X[b]), y[b]).backward()
            opt.step()
    m.eval()
    with torch.no_grad():
        acc = (m(X[te]).argmax(1) == y[te]).float().mean().item()
    print(f'{head}：全連結層 {sum(p.numel() for p in m[-1].parameters())} 個參數，測試準確率 {acc:.4f}')

Flatten：全連結層 2570 個參數，測試準確率 0.9733
GAP＋Flatten：全連結層 170 個參數，測試準確率 0.7933