Lidsky řečeno
Hledáš na velké fotce davu kamaráda. Nečteš ji jako jeden dlouhý seznam barevných teček. Přejíždíš po ní pohledem a pořád hledáš totéž: tvar brýlí, červenou čepici. Je jedno, jestli je čepice vlevo nahoře, nebo dole. Konvoluční síť dělá to samé: po obrázku posouvá malé okénko a v každém místě se ptá na stejnou otázku.
Proč nestačí obyčejná síť
Obrázek je pro počítač tabulka čísel. Barevná fotka 224 × 224 má tři kanály (červený, zelený, modrý), tedy přes 150 tisíc čísel. Když je rozbalíš do jednoho vektoru a pošleš do plně propojené vrstvy, narazíš na dva problémy. Tipni si, kolik parametrů vyjde.
vstup = 224 * 224 * 3
neuronu = 1000
plne_propojena = vstup * neuronu + neuronu
filtru = 64
konvolucni = 3 * 3 * 3 * filtru + filtru
print(f"vstupních čísel: {vstup:>12,}")
print(f"plně propojená vrstva: {plne_propojena:>12,}")
print(f"konvoluční vrstva: {konvolucni:>12,}")
vstupních čísel: 150,528 plně propojená vrstva: 150,529,000 konvoluční vrstva: 1,792
První problém je velikost. Druhý je horší: plně propojená vrstva neví, že sousední pixely spolu souvisí. A kočku vlevo se musí učit zvlášť od kočky vpravo, protože jsou to pro ni úplně jiné vstupy.
Konvoluce staví na dvou předpokladech o obrázcích:
- Lokalita. Hrana nebo roh se pozná z několika sousedních pixelů.
- Sdílení vah. Hrana vypadá stejně kdekoli v obrázku, takže stejný detektor může projít všechna místa.
Konvoluce krok za krokem
Začni v jedné dimenzi. Jádro (anglicky kernel, také filtr) je krátká řada čísel. Přiložíš ho k datům, vynásobíš překrývající se čísla a sečteš. Pak ho posuneš o jedno místo a opakuješ.
data: 0 0 5 5 5 0
jádro: -1 1
─────
0 -1*0 + 1*0
-1 1
5 -1*0 + 1*5Jádro [-1, 1] měří změnu mezi sousedy. Kde je rovina, dá nulu. Kde data skočí, dá velké číslo.
import numpy as np
data = np.array([0, 0, 5, 5, 5, 0, 0])
jadro = np.array([-1, 1])
vystup = []
for i in range(len(data) - len(jadro) + 1):
okno = data[i:i + len(jadro)]
vystup.append(int(okno @ jadro))
print(vystup)
[0, 5, 0, 0, -5, 0]
Ve dvou rozměrech je to totéž, jen jádro je malá tabulka a jezdí po řádcích i sloupcích. NumPy umí všechna okénka připravit najednou funkcí sliding_window_view. Tohle jádro hledá svislou hranu, tedy místo, kde je vlevo tma a vpravo světlo.
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
def conv2d(image, kernel):
windows = sliding_window_view(image, kernel.shape)
return np.sum(windows * kernel, axis=(-2, -1))
image = np.array([
[0, 0, 0, 9, 9, 9],
[0, 0, 0, 9, 9, 9],
[0, 0, 0, 9, 9, 9],
[0, 0, 0, 9, 9, 9],
])
vertical_edge = np.array([
[-1, 0, 1],
[-1, 0, 1],
[-1, 0, 1],
])
result = conv2d(image, vertical_edge)
print(result.shape)
print(result)
(2, 4) [[ 0 27 27 0] [ 0 27 27 0]]
Výsledku se říká mapa příznaků. Velká čísla jsou tam, kde jádro našlo svůj vzor. Mapa je menší než obrázek, protože okénko 3 × 3 se nesmí vysunout přes okraj.
V běžném zpracování obrázků jádra navrhuje člověk. V síti jsou to učitelné parametry: gradientní sestup sám zjistí, jaké vzory se vyplatí hledat.
Napiš konvoluci
Napiš funkci konvoluce2d(obraz, jadro) pro dvourozměrná pole. Vrátí pole tvaru (V - v + 1, S - s + 1), kde (V, S) je tvar obrazu a (v, s) tvar jádra. Stačí obyčejné cykly, sliding_window_view použít nemusíš.
import numpy as np
def konvoluce2d(obraz, jadro):
return obraz
Pod kapotou · konvoluce, nebo korelace?
To, čemu se v hlubokém učení říká konvoluce, je přesně vzato vzájemná korelace: jádro se nepřevrací. Matematická konvoluce ho v obou osách převrací, a proto dává scipy.signal.convolve2d jiný výsledek než nn.Conv2d se stejnými čísly. Odpovídá mu scipy.signal.correlate2d. Při portování vah to je zdroj tiché chyby, pro učení samotné na tom nezáleží, protože se síť naučí převrácené jádro.
Konvoluční vrstva je lineární zobrazení, dá se tedy zapsat maticí. Je to obří řídká matice, kde se na každém řádku opakují tytéž hodnoty. Plně propojená vrstva je obecná matice, konvoluce její silně omezený případ. Odtud plyne úspora i to, že jde o předpoklad o datech (induktivní bias), ne o zadarmo získanou chytrost. Na tabulkových datech s libovolným pořadím sloupců žádný smysl nemá.
Kanály, posun a okraje
Vrstva Conv2d má tyto hlavní volby:
| Parametr | Význam |
|---|---|
in_channels | kolik kanálů přichází (šedý obraz 1, barevný 3) |
out_channels | kolik různých filtrů se učí, tedy kolik map vznikne |
kernel_size | velikost okénka |
stride | o kolik pixelů se okénko posouvá |
padding | kolik pixelů se přidá na každý okraj |
Výška a šířka výstupu se počítají stejným vzorcem:
výstup = floor((n + 2*p - k) / s) + 1
n vstup, k jádro, p padding, s stridefrom math import floor
def out_size(n, k, s=1, p=0):
return floor((n + 2 * p - k) / s) + 1
print("bez paddingu:", out_size(32, 3))
print("padding 1 zachová velikost:", out_size(32, 3, p=1))
print("stride 2 zmenší na polovinu:", out_size(32, 3, s=2, p=1))
print("pooling 2x2:", out_size(32, 2, s=2))
bez paddingu: 30 padding 1 zachová velikost: 32 stride 2 zmenší na polovinu: 16 pooling 2x2: 16
Projdi síť po vrstvách
Napiš funkci prubeh(n, vrstvy). Parametr n je výška obrázku a vrstvy je seznam trojic (k, s, p). Funkce vrátí seznam velikostí po každé vrstvě. Vstupní velikost do seznamu nepatří.
def prubeh(n, vrstvy):
return [n]
Barevný obrázek má v PyTorch tvar (kanály, výška, šířka) a dávka (N, C, H, W). Knihovny na obrázky a NumPy obvykle drží kanály na konci. Tady se chybuje často.
Prohozené osy
Dávka 8 obrázků 32 × 48 se třemi kanály má tvar (8, 32, 48, 3). Pro nn.Conv2d je potřeba (8, 3, 32, 48).
Posun vzoru a pooling
Když se vzor v obrázku posune, posune se i jeho odezva v mapě příznaků. Říká se tomu ekvivariance. Vyzkoušej si to posuvníkem.
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
def conv2d(image, kernel):
return np.sum(sliding_window_view(image, kernel.shape) * kernel, axis=(-2, -1))
cross = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
image = np.zeros((8, 8), dtype=int)
c = int(posun)
image[2:5, c:c + 3] = cross
response = conv2d(image, cross)
row, col = np.unravel_index(response.argmax(), response.shape)
print("nejsilnější odezva:", int(response.max()))
print("na pozici řádek", int(row), "sloupec", int(col))
nejsilnější odezva: 5 na pozici řádek 2 sloupec 2
Pozice se mění, síla odezvy ne. Klasifikátor ale potřebuje vědět jestli tam vzor je, ne přesně kde. K tomu slouží pooling: mapa se shrne do menší. Max pooling z každého políčka bere největší hodnotu, průměrový průměr. Globální průměrování udělá z celé mapy jediné číslo.
import numpy as np
mapa = np.array([
[1, 3, 0, 2],
[4, 2, 1, 1],
[0, 0, 5, 6],
[1, 2, 7, 0],
])
vysledek = np.array([
[mapa[:2, :2].max(), mapa[:2, 2:].max()],
[mapa[2:, :2].max(), mapa[2:, 2:].max()],
])
print(vysledek)
print(mapa.mean())
[[4 2] [2 7]] 2.1875
Díky zmenšování vidí neurony v dalších vrstvách větší kus původního obrázku. Tomu kusu se říká receptivní pole. První vrstvy tak hledají hrany, další jejich kombinace a ty nejhlubší celé části objektů.
layers = [
("conv 3x3", 3, 1),
("conv 3x3", 3, 1),
("pool 2x2", 2, 2),
("conv 3x3", 3, 1),
("pool 2x2", 2, 2),
("conv 3x3", 3, 1),
]
field, step = 1, 1
for name, k, s in layers:
field += (k - 1) * step
step *= s
print(f"{name}: jeden neuron vidí {field}x{field} pixelů")
conv 3x3: jeden neuron vidí 3x3 pixelů conv 3x3: jeden neuron vidí 5x5 pixelů pool 2x2: jeden neuron vidí 6x6 pixelů conv 3x3: jeden neuron vidí 10x10 pixelů pool 2x2: jeden neuron vidí 12x12 pixelů conv 3x3: jeden neuron vidí 20x20 pixelů
Co vrátí vrstva s 16 filtry, když do ní pošleš dávku tvaru (4, 3, 32, 32) a má kernel_size=3, padding=1?
Počet filtrů určuje počet kanálů výstupu. Jádro 3 s paddingem 1 zachová výšku i šířku.
Kolik parametrů má vrstva Conv2d(3, 16, kernel_size=3) s posunem (bias)?
Každý z 16 filtrů má pro každý ze 3 vstupních kanálů 3 × 3 váhy a jeden posun. Velikost obrázku v tom nehraje roli.
Malá CNN, která se opravdu učí
Teď uvidíš hlavní výhodu naživo. Úkol: rozlišit svislou a vodorovnou čáru v obrázku 8 × 8 se šumem. Háček je v tom, že trénovací obrázky mají čáru jen na pozicích 1 až 3, testovací na pozicích 4 až 6. Soupeří dva modely se stejnými daty:
- lineární model vidí každý pixel zvlášť,
- CNN má čtyři filtry
3 × 3, aktivaci ReLU a globální průměrování.
Gradienty CNN jsou spočítané ručně, takže vidíš všechno, co jinak schová PyTorch. Běh trvá zlomek sekundy.
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
rng = np.random.RandomState(4)
SIZE, N = 8, 120
def dataset(positions):
X, y = [], []
for _ in range(N):
label = rng.randint(2)
pos = positions[rng.randint(len(positions))]
image = rng.normal(0, 0.15, (SIZE, SIZE))
if label == 0:
image[:, pos] += 1 # vertical line
else:
image[pos, :] += 1 # horizontal line
X.append(image)
y.append(label)
return np.array(X), np.array(y)
def sigmoid(z):
return 1 / (1 + np.exp(-z))
X_train, y_train = dataset([1, 2, 3])
X_test, y_test = dataset([4, 5, 6])
# Linear model on raw pixels
A, B = X_train.reshape(N, -1), X_test.reshape(N, -1)
w, b = np.zeros(SIZE * SIZE), 0.0
for _ in range(300):
e = sigmoid(A @ w + b) - y_train
w -= 0.1 * A.T @ e / N
b -= 0.1 * e.mean()
def report(name, train_logits, test_logits):
train = np.mean((train_logits > 0) == y_train)
test = np.mean((test_logits > 0) == y_test)
print(f"{name}: trénink {train:.0%}, nové pozice {test:.0%}")
report("lineární model", A @ w + b, B @ w + b)
# CNN: every 3x3 patch goes through the same filters
def patches(X):
return sliding_window_view(X, (3, 3), axis=(1, 2)).reshape(len(X), -1, 9)
P_train, P_test = patches(X_train), patches(X_test)
filters = 4
W = rng.normal(0, 0.3, (9, filters))
c = rng.normal(0, 0.3, filters)
b = 0.0
def cnn(P):
maps = np.maximum(P @ W, 0) # conv + ReLU: (N, places, filters)
pooled = maps.mean(axis=1) # global average pooling
return maps, pooled, pooled @ c + b
for step in range(600):
maps, pooled, z = cnn(P_train)
e = sigmoid(z) - y_train
grad_c = (e[:, None] * pooled).mean(axis=0)
active = (maps > 0) * e[:, None, None]
grad_W = np.einsum("npf,npi->if", active, P_train) / active.shape[0] / active.shape[1] * c
W -= 0.5 * grad_W
c -= 0.5 * grad_c
b -= 0.5 * e.mean()
report("malá CNN", cnn(P_train)[2], cnn(P_test)[2])
strongest = np.argmax(np.abs(c))
print("nejdůležitější naučený filtr:")
print(np.round(W[:, strongest].reshape(3, 3), 1) + 0.0)
lineární model: trénink 100%, nové pozice 0% malá CNN: trénink 100%, nové pozice 100% nejdůležitější naučený filtr: [[-1.6 2.2 -1.4] [-1.4 2.3 -1.7] [-1.4 2.3 -1.5]]
Lineární model má trénink perfektní a na nových pozicích selže úplně. Naučil se totiž pravidlo typu „když svítí tenhle konkrétní pixel, je to svislá čára“. Na nové pozici to platí obráceně. CNN se naučila tvar čáry a je jí jedno, kde leží. Filtr ve výpisu je ten tvar: pruh kladných vah obklopený zápornými.
CNN v PyTorch
Stejnou stavbu v PyTorch napíšeš na pár řádků. Typický blok je konvoluce, normalizace, aktivace a občas pooling. Tvary v komentářích platí pro šedé obrázky 28 × 28.
import torch
from torch import nn
class TinyCNN(nn.Module):
def __init__(self, classes=10):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=3, padding=1, bias=False), # 32 x 28 x 28
nn.BatchNorm2d(32),
nn.ReLU(),
nn.MaxPool2d(2), # 32 x 14 x 14
nn.Conv2d(32, 64, kernel_size=3, padding=1, bias=False), # 64 x 14 x 14
nn.BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(2), # 64 x 7 x 7
nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False), # 128 x 7 x 7
nn.BatchNorm2d(128),
nn.ReLU(),
)
self.pool = nn.AdaptiveAvgPool2d(1) # 128 x 1 x 1
self.head = nn.Linear(128, classes)
def forward(self, x):
x = self.features(x)
x = self.pool(x).flatten(1) # 128
return self.head(x) # logits
model = TinyCNN()
print(model(torch.randn(4, 1, 28, 28)).shape) # torch.Size([4, 10])BatchNorm průběžně normalizuje hodnoty v každém kanálu, takže se hluboké sítě učí stabilněji. Reziduální spojení přičítá vstup bloku k jeho výstupu. Blok se tak učí jen opravu a gradient má krátkou cestu k prvním vrstvám. Díky tomu můžou být sítě velmi hluboké.
class Residual(nn.Module):
def __init__(self, channels):
super().__init__()
self.body = nn.Sequential(
nn.Conv2d(channels, channels, 3, padding=1, bias=False),
nn.BatchNorm2d(channels),
nn.ReLU(),
nn.Conv2d(channels, channels, 3, padding=1, bias=False),
nn.BatchNorm2d(channels),
)
self.act = nn.ReLU()
def forward(self, x):
return self.act(x + self.body(x))Na vlastní úkol se síť málokdy učí od nuly. Transfer learning vezme síť natrénovanou na velké sadě obrázků a vymění jí poslední vrstvu. Váhy se při prvním použití stáhnou.
from torch import nn
from torchvision.models import resnet18, ResNet18_Weights
weights = ResNet18_Weights.DEFAULT
model = resnet18(weights=weights)
preprocess = weights.transforms() # the same preprocessing as in training
for p in model.parameters():
p.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, 5) # new layer is trainable
optimizer = torch.optim.AdamW(model.fc.parameters(), lr=1e-3)Co se učí a co volíš ty
Roztřiď vlastnosti konvoluční sítě.
Pod kapotou · co učebnice říkají příliš zjednodušeně
CNN není invariantní k posunu. Samotná konvoluce je ekvivariantní jen přibližně, kvůli okrajům, a stride s poolingem tuto vlastnost dál narušují, protože podvzorkování způsobuje aliasing. Stačí posun o jeden pixel a výstup se změní:
import numpy as np
def max_pool(x):
return [int(x[i:i + 2].max()) for i in range(0, len(x) - 1, 2)]
signal = np.array([0, 0, 8, 8, 0, 0, 0, 0])
for shift in range(3):
print("posun", shift, max_pool(np.roll(signal, shift)))
posun 0 [0, 8, 0, 0] posun 1 [0, 8, 8, 0] posun 2 [0, 0, 8, 0]
Posun o jeden pixel udělá z jednoho vrcholu dva, teprve posun o celý krok mřížky dá posunutý původní výstup. Zhang (2019) v článku Making Convolutional Networks Shift-Invariant Again navrhl před podvzorkováním vyhlazovat.
Separovatelná konvoluce rozdělí práci na konvoluci po kanálech (groups=in_channels) a následné jádro 1 × 1. Úspora je zhruba násobek k² ku k² + C:
k, c_in, c_out = 3, 256, 256
standard = k * k * c_in * c_out
separable = k * k * c_in + c_in * c_out
print(f"{standard:,} proti {separable:,}, poměr {standard / separable:.1f}x")
589,824 proti 67,840, poměr 8.7x
Paměť při trénování neurčují hlavně váhy, ale mapy příznaků: mapa má C × H × W hodnot a nejvíc stojí vysoké rozlišení v prvních vrstvách. Proto se brzy podvzorkovává.
BatchNorm a malé dávky. Při dávce o několika prvcích jsou odhady průměru zašuměné, sáhni po GroupNorm. Po zmrazení vah při transfer learningu BatchNorm dál mění své průměry, pokud je v režimu train(). Zmrazené části drž v eval(). bias=False před BatchNorm je běžné, protože posun by normalizace stejně smazala.
padding="same" v nn.Conv2d funguje jen se stride=1. U sudého jádra je výplň nesymetrická.
Opakování
Vyzkoušej si: Konvoluční filtr
Vyber nebo uprav jádro 3×3 a sleduj posouvající se okénko i výslednou mapu příznaků.