MNIST från grunden

MNIST är 70 000 handskrivna siffror i 28×28 gråskala — fältets «Hej världen». En enkel modell når 97 %, ett litet CNN över 99 %.

Men träffsäkerheten är inte det intressanta. Det intressanta är vilka 1 % som blir fel.

Förväxlingsmatrisen visar det. Rad = facit, kolumn = gissning:

facit\gissn   0    1    2    3    4    5    6    7    8    9
    4       970    0    1    0    0    0    3    2    1    5
    9         2    1    0    2    9    1    0    5    3  986

Raden för 4 säger: 970 rätt, och de flesta felen gick till 9. Det är inte slumpmässigt — 4 och 9 liknar varandra när de skrivs slarvigt, och nätet gör samma misstag som en människa skulle göra.

De vanliga förväxlingarna i MNIST är just 4↔9, 3↔5, 7↔1 och 8↔3. Att modellen gör begripliga fel är ett gott tecken.

import torch, torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from sklearn.metrics import confusion_matrix, classification_report
import numpy as np

tf = transforms.Compose([transforms.ToTensor(),
                         transforms.Normalize((0.1307,), (0.3081,))])
train = datasets.MNIST("data", train=True, download=True, transform=tf)
test = datasets.MNIST("data", train=False, transform=tf)
tl = DataLoader(train, batch_size=128, shuffle=True)
vl = DataLoader(test, batch_size=512)

modell = 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),
    nn.Flatten(), nn.Dropout(0.25), nn.Linear(32 * 7 * 7, 10),
)
opt = torch.optim.Adam(modell.parameters(), lr=1e-3)

for epok in range(3):
    modell.train()
    for x, y in tl:
        loss = nn.functional.cross_entropy(modell(x), y)
        opt.zero_grad(); loss.backward(); opt.step()

modell.eval()
pred, facit = [], []
with torch.no_grad():
    for x, y in vl:
        pred += modell(x).argmax(1).tolist(); facit += y.tolist()

print(f"träffsäkerhet {np.mean(np.array(pred) == np.array(facit)):.4f}")   # ~0.988

# Det som faktiskt är intressant
M = confusion_matrix(facit, pred)
np.fill_diagonal(M, 0)
for _ in range(4):
    i, j = np.unravel_index(M.argmax(), M.shape)
    print(f"  {i} klassas som {j}: {M[i, j]} gånger")
    M[i, j] = 0
#   4 klassas som 9: 9 gånger
#   3 klassas som 5: 7 gånger
#   7 klassas som 1: 6 gånger
#   8 klassas som 3: 5 gånger

print(classification_report(facit, pred, digits=3))

Nästa steg efter matrisen: plocka fram de faktiskt felklassade bilderna och titta på dem. I MNIST är en påfallande andel av felen sådana att en människa också tvekar — och några är rentav felmärkta i originaldatan. Det sätter ett tak för hur bra någon modell kan bli, och är värt att veta innan man jagar de sista tiondelarna.

Fem experiment på samma modell. Kör grundversionen, notera träffsäkerheten, och ändra en sak i taget.

Ändring	Förväntat utfall
Ta bort Normalize	långsammare konvergens, något sämre
Ta bort båda conv-lagren (bara Linear)	~92 % i stället för ~99 %
Ta bort Dropout	bättre på träning, marginellt sämre på test
lr=1e-1 i stället för 1e-3	tränar inte alls, eller mycket instabilt
Träna på 1 000 bilder i stället för 60 000	~95 % — förvånansvärt bra

Den sista raden är den mest lärorika: MNIST är för lätt för att skilja bra metoder från dåliga. Nästan allt fungerar, vilket gör datasetet utmärkt för att lära sig verktygen och olämpligt för att jämföra modeller.

Om du vill ha ett ärligare test: kör samma modell på Fashion-MNIST (samma format, kläder i stället för siffror). Träffsäkerheten faller till omkring 91 %, och skillnaderna mellan metoder blir plötsligt synliga.

Och det verkliga slutprovet: skriv en siffra själv på papper, fotografera den, skala till 28×28 gråskala och invertera. Modellen som fick 99 % kommer troligen att ha fel. Det är domänskifte i sin renaste form — MNIST-siffrorna är centrerade, storleksnormaliserade och skrivna med en viss sorts penna, och din bild är inget av det.