0 dní v řadě · 0 bodů

Neuronové sítě a moderní AI · 35 min

Konvoluční sítě

Proč obrázky potřebují jinou síť. Napíšeš konvoluci v NumPy, spočítáš tvary a natrénuješ malou CNN, která pozná vzor i na nové pozici.

Hloubka
Úkoly
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,}")
Výstup
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š.

text
data:   0  0  5  5  5  0
jádro: -1  1
       ─────
        0            -1*0 + 1*0
           -1  1
           5         -1*0 + 1*5

Já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)
Výstup
[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)
Výstup
(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.

Úkol

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
Výstup
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:

ParametrVýznam
in_channelskolik kanálů přichází (šedý obraz 1, barevný 3)
out_channelskolik různých filtrů se učí, tedy kolik map vznikne
kernel_sizevelikost okénka
strideo kolik pixelů se okénko posouvá
paddingkolik pixelů se přidá na každý okraj

Výška a šířka výstupu se počítají stejným vzorcem:

text
výstup = floor((n + 2*p - k) / s) + 1

n vstup, k jádro, p padding, s stride
from 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))
Výstup
bez paddingu: 30
padding 1 zachová velikost: 32
stride 2 zmenší na polovinu: 16
pooling 2x2: 16
Úkol

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]
Výstup

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.

Najdi chybu

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))
Výstup
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())
Výstup
[[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ů")
Výstup
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ů
Kvíz

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?

Kvíz

Kolik parametrů má vrstva Conv2d(3, 16, kernel_size=3) s posunem (bias)?

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)
Výstup
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.

python
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é.

python
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.

python
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)
Roztřiď

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)))
Výstup
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")
Výstup
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á.

Kartičky

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ů.