Lidsky řečeno
Jeden úředník umí posoudit jen jednu věc. Úřad ale funguje, protože si lidé předávají práci. První přepážka ověří doklady, druhá spočítá poplatek a vedoucí z jejich závěrů rozhodne. Neuronová síť je takový úřad: neurony v jedné vrstvě si připraví dílčí závěry a další vrstva z nich skládá rozhodnutí.
Tři neurony vyřeší XOR
V minulé lekci jeden neuron na XOR nestačil. Stačí ale tři. XOR se dá říct i takhle: „aspoň jeden vstup je 1, ale ne oba“. To je OR a zároveň NAND, a obě tyhle funkce jeden neuron zvládne. Třetí neuron je spojí přes AND.
x1 ──┬──> [OR] ───┐
│ ├──> [AND] ──> výstup
x2 ──┴──> [NAND] ──┘
vstupy skrytá vrstva výstupní vrstvaVáhy tentokrát nastavíme ručně, ať je vidět, co se uvnitř děje.
import numpy as np
def neuron(x, w, b):
return int(np.dot(x, w) + b > 0)
for x in [(0, 0), (0, 1), (1, 0), (1, 1)]:
h1 = neuron(x, (1, 1), -0.5) # OR
h2 = neuron(x, (-1, -1), 1.5) # NAND
y = neuron((h1, h2), (1, 1), -1.5) # AND
print(x, "-> skryté", (h1, h2), "-> výstup", y)
(0, 0) -> skryté (0, 1) -> výstup 0 (0, 1) -> skryté (1, 1) -> výstup 1 (1, 0) -> skryté (1, 1) -> výstup 1 (1, 1) -> skryté (1, 0) -> výstup 0
Dívej se na prostřední sloupec. Skrytá vrstva body přemístila. Oba body (0, 1) a (1, 0) se slily do (1, 1), zatímco (0, 0) a (1, 1) skončily v (0, 1) a (1, 0). V nových souřadnicích už jedna přímka stačí. Přesně tohle dělají skryté vrstvy: přeskupují data tak, aby poslední vrstva měla snadnou práci.
Vrstva je matice
Psát každý neuron zvlášť by nešlo. Vrstva o h neuronech je jedna matice vah a jeden vektor biasů. Sloupec matice patří jednomu neuronu.
X (n, d) n příkladů, d vlastností
W1 (d, h) z d vstupů do h neuronů
b1 (h,)
H = tanh(X @ W1 + b1) (n, h)
W2 (h, k) z h neuronů do k výstupů
b2 (k,)
z = H @ W2 + b2 (n, k)Průchodu daty od vstupu k výstupu se říká dopředný průchod (forward pass). Vnitřní rozměry na sebe musí navazovat jako kostky domina.
import numpy as np
rng = np.random.RandomState(0)
X = rng.randn(5, 2)
W1 = rng.randn(2, 4)
b1 = np.zeros(4)
W2 = rng.randn(4, 1)
b2 = np.zeros(1)
H = np.tanh(X @ W1 + b1)
z = H @ W2 + b2
p = 1 / (1 + np.exp(-z))
print("X", X.shape)
print("H", H.shape)
print("z", z.shape)
print("p", p.shape)
print(p.ravel().round(3))
X (5, 2) H (5, 4) z (5, 1) p (5, 1) [0.044 0.034 0.371 0.142 0.223]
Netrénovaná síť s náhodnými vahami dává náhodné odpovědi. Architektura se obvykle zapisuje jako seznam šířek: tato je 2-4-1.
Vstup má tvar (32, 3), skrytá vrstva má 8 neuronů a výstupní 2. Jaký tvar má W2 a jaký výstup z?
Matice vah má tvar (vstupy vrstvy, neurony vrstvy). Počet řádků dat se nemění, takže výstup je 32 krát 2.
Doplň dopředný průchod
Doplň výpočet sítě s jednou skrytou vrstvou a sigmoidou na výstupu.
Kolik má síť parametrů
Napiš funkci pocet_parametru(sirky). Dostane seznam šířek, třeba [2, 4, 1], a vrátí počet všech vah a biasů. Každá vrstva po vstupu má vstupy * neurony vah a neurony biasů.
def pocet_parametru(sirky):
return 0
Jak síti říct, že se plete
Síť se učí tak, že zmenšuje jedno číslo: ztrátu (loss). Ztráta měří, jak moc se předpovědi liší od skutečnosti. Pro ano/ne se používá binární křížová entropie. Když je víc tříd, výstupní vrstva má jeden výstup na třídu a funkce softmax z těch skóre udělá pravděpodobnosti, které dávají dohromady 1.
softmax: P_i = exp(z_i) / součet všech exp(z_j)
ztráta: -log(P správné třídy)import numpy as np
def softmax(z):
e = np.exp(z)
return e / e.sum()
p = softmax(np.array([2.0, 1.0, -1.0]))
print("pravděpodobnosti:", p.round(3))
print("součet:", round(float(p.sum()), 3))
for popis, jistota in [("jistě správně", 0.99), ("nejistě", 0.5), ("skoro špatně", 0.1), ("jistě špatně", 0.01)]:
print(f"{popis:14} P={jistota:<5} ztráta={-np.log(jistota):.2f}")
pravděpodobnosti: [0.705 0.259 0.035] součet: 1.0 jistě správně P=0.99 ztráta=0.01 nejistě P=0.5 ztráta=0.69 skoro špatně P=0.1 ztráta=2.30 jistě špatně P=0.01 ztráta=4.61
Ztráta skoro nic nestojí, když má síť pravdu, a prudce roste, když se mýlí a je si přitom jistá. Sebevědomé nesmysly jsou nejdražší. To je přesně chování, které při učení chceš.
Softmax pro celou dávku
Napiš softmax(z) pro matici tvaru (n, k). Každý řádek se převádí zvlášť. Výsledek má stejný tvar a každý řádek dává součet 1.
import numpy as np
def softmax(z):
e = np.exp(z)
return e / e.sum()
Křížová entropie
Napiš krizova_entropie(P, y). P je matice pravděpodobností (n, k), y pole správných tříd délky n. Vrať průměr -log(P správné třídy) jako jedno číslo.
import numpy as np
def krizova_entropie(P, y):
return 0.0
Trénink na XOR
Teď přijde ostré učení. Smyčka má pořád stejné čtyři kroky: dopředný průchod, ztráta, gradienty, úprava vah. Gradient říká, kterým směrem a jak moc se ztráta mění s každým parametrem. Vzorce v části „gradienty“ zatím ber jako hotové, odkud se berou, ukáže další lekce.
import numpy as np
def sigmoida(z):
return 1 / (1 + np.exp(-z))
def trenuj(X, y, skryte, lr, kroky, seed=0):
rng = np.random.RandomState(seed)
n = len(X)
W1, b1 = rng.randn(X.shape[1], skryte), np.zeros(skryte)
W2, b2 = rng.randn(skryte, 1), np.zeros(1)
for _ in range(kroky):
# dopředný průchod
H = np.tanh(X @ W1 + b1)
p = sigmoida(H @ W2 + b2)
# gradienty
e = p - y
d = (e @ W2.T) * (1 - H ** 2)
# úprava vah
W1 -= lr * X.T @ d / n
b1 -= lr * d.mean(axis=0)
W2 -= lr * H.T @ e / n
b2 -= lr * e.mean(axis=0)
return sigmoida(np.tanh(X @ W1 + b1) @ W2 + b2)
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
y = np.array([[0], [1], [1], [0]], dtype=float)
for skryte in (1, 2, 3, 4):
p = trenuj(X, y, skryte, lr, int(kroky))
print(f"{skryte} skryté neurony:", p.ravel().round(2))
1 skryté neurony: [0. 0.67 0.67 0.67] 2 skryté neurony: [0. 0.5 1. 0.5] 3 skryté neurony: [0. 1. 1. 0.] 4 skryté neurony: [0. 1. 1. 0.]
Správná odpověď je 0, 1, 1, 0. Jeden neuron na to nestačí. Zajímavý je řádek se dvěma: dva neurony by v principu stačily, ručně jsme to viděli výše, jenže trénink z tohoto náhodného startu uvízl v lokálním minimu. Síť s rezervou neuronů to má mnohem snazší. Proto se v praxi sítě dělají širší, než by teoreticky stačilo.
Síť, která se odmítá učit
Síť má zvládnout XOR, ale po tréninku pořád vrací 0.5. Kód běží bez chyby. Který řádek za to může?
Síť kreslí kruh
XOR má čtyři body. Teď je jich dvě stě: síť má poznat, jestli bod leží uvnitř kruhu. Vzorec kruhu nikde nedostane, jen příklady. Stranou necháme sto dalších bodů, které při tréninku neuvidí, a na nich změříme skutečnou úspěšnost. Nakonec si necháme vypsat mapu, kde # znamená „uvnitř“.
import numpy as np
def sigmoida(z):
return 1 / (1 + np.exp(-z))
rng = np.random.RandomState(1)
body = rng.uniform(-2, 2, (300, 2))
tridy = ((body ** 2).sum(axis=1) < 1.5).astype(float)[:, None]
X, y = body[:200], tridy[:200]
X_test, y_test = body[200:], tridy[200:]
h = int(skryte)
W1, b1 = rng.randn(2, h), np.zeros(h)
W2, b2 = rng.randn(h, 1), np.zeros(1)
lr = 1.0
def predikce(Q):
return sigmoida(np.tanh(Q @ W1 + b1) @ W2 + b2)
for _ in range(3000):
H = np.tanh(X @ W1 + b1)
e = sigmoida(H @ W2 + b2) - y
d = (e @ W2.T) * (1 - H ** 2)
W1 -= lr * X.T @ d / len(X)
b1 -= lr * d.mean(axis=0)
W2 -= lr * H.T @ e / len(X)
b2 -= lr * e.mean(axis=0)
print("trénink:", round(float(((predikce(X) > 0.5) == y).mean()), 2))
print("test: ", round(float(((predikce(X_test) > 0.5) == y_test).mean()), 2))
for b in np.linspace(1.9, -1.9, 13):
radek = np.column_stack([np.linspace(-1.9, 1.9, 39), np.full(39, b)])
print("".join("#" if v else "." for v in predikce(radek).ravel() > 0.5))
trénink: 1.0 test: 0.95 ....................................... ....................................... ....................##................. ............############............... ..........#################............ .........#####################......... ........########################....... ...........#####################....... .............##################........ ...............##############.......... ................#####.................. ....................................... .......................................
Posuň skryte na 1, 2, 3 a sleduj mapu. Jeden neuron umí jen rozdělit plochu na dvě části. Každý další přidá jeden „řez“ a z několika řezů se poskládá něco jako kruh.
Více tříd: tři spirály
Skoro stejný kód zvládne i víc tříd. Výstupní vrstva má jeden sloupec na třídu, místo sigmoidy je softmax a správné odpovědi jsou zapsané one-hot: třída 2 ze tří je [0, 0, 1]. Vzorce pro gradient zůstanou doslova stejné, jen e = P - Y je teď matice. Tři spirály se do sebe zavíjejí a žádná přímka je neoddělí.
import numpy as np
def spirala(na_tridu, tridy, rng):
X, y = [], []
for c in range(tridy):
t = np.linspace(0, 1, na_tridu)
uhel = 4 * t + c * 2 * np.pi / tridy + rng.randn(na_tridu) * 0.15
X.append(np.column_stack([t * np.cos(uhel), t * np.sin(uhel)]))
y += [c] * na_tridu
return np.vstack(X), np.array(y)
def softmax(z):
e = np.exp(z - z.max(axis=1, keepdims=True))
return e / e.sum(axis=1, keepdims=True)
rng = np.random.RandomState(0)
X, y = spirala(50, 3, rng)
Y = np.eye(3)[y]
n, h, lr = len(X), 32, 1.0
W1, b1 = rng.randn(2, h), np.zeros(h)
W2, b2 = rng.randn(h, 3) * 0.1, np.zeros(3)
for krok in range(4001):
H = np.tanh(X @ W1 + b1)
P = softmax(H @ W2 + b2)
if krok % 1000 == 0:
ztrata = -np.log(P[np.arange(n), y]).mean()
presnost = (P.argmax(axis=1) == y).mean()
print(f"krok {krok:4} ztráta {ztrata:.2f} přesnost {presnost:.2f}")
e = P - Y
d = (e @ W2.T) * (1 - H ** 2)
W1 -= lr * X.T @ d / n
b1 -= lr * d.mean(axis=0)
W2 -= lr * H.T @ e / n
b2 -= lr * e.mean(axis=0)
krok 0 ztráta 1.09 přesnost 0.55 krok 1000 ztráta 0.05 přesnost 0.99 krok 2000 ztráta 0.04 přesnost 0.99 krok 3000 ztráta 0.03 přesnost 0.99 krok 4000 ztráta 0.03 přesnost 0.99
Co znamená který tvar
Síť má architekturu 4-16-3 a dávku 10 příkladů. Spoj tvar s objektem.
Proč má test jiné body než trénink?
Úspěšnost na trénovacích bodech může být vysoká i u modelu, který si data jen zapamatoval. O použitelnosti vypovídají data, která nikdy neviděl.
Pod kapotou · šířka, hloubka a numerika softmaxu
Věta o univerzální aproximaci (Cybenko 1989, Hornik 1991; Leshno a kol. 1993 pro každou nepolynomiální aktivaci) říká, že jedna dost široká skrytá vrstva přiblíží spojitou funkci na kompaktní množině libovolně přesně. Neříká nic o tom, kolik neuronů to bude stát ani zda je gradientní sestup najde. Hloubka se vyplácí, protože skládání umí znovu využít mezivýsledky. U ReLU sítí může počet lineárních oblastí růst s hloubkou exponenciálně, zatímco u šířky jen polynomiálně (při pevném vstupním rozměru).
ReLU síť je ve skutečnosti po částech lineární funkce. Toho využívají formální verifikace i metody vysvětlování.
Symetrie vah znamená i to, že optimum není jediné: libovolná permutace neuronů ve vrstvě dá stejnou funkci. Proto nemá smysl porovnávat váhy dvou natrénovaných sítí po složkách a proto průměrování vah nezávisle trénovaných modelů bez zarovnání obvykle nefunguje.
Softmax se nemění, když ke všem skórům řádku přičteš konstantu. Odečtení maxima v spirala tedy výsledek nezmění, jen zabrání přetečení exp. Ztrátu počítej přímo z logitů: z[správná] - logsumexp(z). V PyTorchi proto nn.CrossEntropyLoss čeká surové logity a softmax před ní je tichá chyba, která model nerozbije, jen zhorší učení.
import numpy as np
z = np.array([1000.0, 1001.0, 998.0])
with np.errstate(over="ignore", invalid="ignore"):
naivne = np.exp(z) / np.exp(z).sum()
posun = np.exp(z - z.max())
print("naivně: ", naivne)
print("s posunem:", (posun / posun.sum()).round(4))
naivně: [nan nan nan] s posunem: [0.2595 0.7054 0.0351]
Konvence: tady je příklad řádek a počítá se X @ W. Učebnice často píší W x se sloupcovými vektory, takže tam najdeš transponované tvary. PyTorch má nn.Linear(d, h).weight uložené jako (h, d), ačkoli vstupní dávka má tvar (n, d).
Opakování
Vyzkoušej si: Hřiště pro malou síť
Natrénuj v prohlížeči malou síť na XOR, kruhu nebo spirále. Měň počet neuronů a rychlost učení a sleduj hranici a ztrátu.