Lidsky řečeno
Představ si, že se rozhoduješ, jestli jet na kolo. Svítí slunce? Máš volno? Jede i kamarád? Každá z těch věcí má pro tebe jinou váhu. Volno je zásadní, kamarád jen příjemný bonus. V hlavě to sečteš a když je součet dost velký, jedeš. Umělý neuron nedělá nic víc.
Vážený součet a rozhodnutí
Neuron je malá funkce. Dostane několik čísel, každé vynásobí jeho vahou, všechno sečte a přičte jedno číslo navíc, kterému se říká bias (posun). Výsledek je skóre. Kladná váha znamená „tohle mluví pro“, záporná „tohle mluví proti“. Bias říká, jak moc se neuronu chce už předem.
skóre z = w1*x1 + w2*x2 + ... + wn*xn + b
výstup y = f(z)
x vstupy w váhy b bias f aktivační funkceTipni si, co vyjde. Slunce svítí, volno nemáš a kamarád jede.
vstupy = [1, 0, 1] # slunce, volno, kamarád
vahy = [2, 3, 1]
bias = -4
z = bias
for x, w in zip(vstupy, vahy):
z += x * w
print("skóre:", z)
print("jedu" if z > 0 else "zůstanu doma")
skóre: -1 zůstanu doma
Projdi si cyklus tlačítkem krokovat a sleduj, jak z roste. Pak změň vstupy na [0, 1, 1]. Volno má největší váhu, a přesto to nestačí, dokud nesvítí slunce nebo nezměníš bias.
Vážený součet je skalární součin, takže v NumPy stačí jeden výraz. A když dáš vstupy více lidí pod sebe do matice, spočítáš všechny najednou. Řádek matice je jeden příklad, sloupec je jedna vlastnost.
import numpy as np
w = np.array([2, 3, 1])
b = -4
x = np.array([1, 0, 1])
print("jeden člověk:", x @ w + b)
X = np.array([
[1, 0, 1],
[0, 1, 1],
[1, 1, 0],
[1, 1, 1],
])
print("čtyři lidé: ", X @ w + b)
jeden člověk: -1 čtyři lidé: [-1 0 1 2]
Operátor @ je maticové násobení. X má tvar (4, 3), w má délku 3 a výsledek má délku 4: jedno skóre na řádek.
Neuron jako logické hradlo
Když zvolíš váhy správně, neuron počítá logické funkce. Hradlo AND vrací 1 jen tehdy, když jsou oba vstupy 1. Posouvej váhy a bias a sleduj, kdy se tabulka změní.
import numpy as np
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
w = np.array([w1, w2])
z = X @ w + b
y = (z > 0).astype(int)
for radek, skore, rozhodnuti in zip(X, z, y):
print(radek, f"skóre {skore:+.1f} -> {rozhodnuti}")
[0 0] skóre -1.5 -> 0 [0 1] skóre -0.5 -> 0 [1 0] skóre -0.5 -> 0 [1 1] skóre +0.5 -> 1
Geometricky je rovnice w1*x1 + w2*x2 + b = 0 přímka. Na jedné její straně neuron říká 1, na druhé 0. Váhy určují její sklon, bias ji posouvá. To si zapamatuj, na konci lekce to bude rozhodující.
Nastav hradlo OR
Hradlo OR vrací 1, když je aspoň jeden vstup 1. Nastav w1, w2 a b tak, aby neuron pro vstupy [0,0], [0,1], [1,0], [1,1] dal 0, 1, 1, 1.
w1 = 0
w2 = 0
b = 0
Co se stane s neuronem bez biasu, když jsou všechny vstupy nulové?
Každý člen w * 0 je nula. Bez biasu musí rozhodovací přímka procházet počátkem, což neuron zbytečně svazuje.
Aktivační funkce
Tvrdé rozhodnutí „větší než nula“ má vadu. Malá změna váhy obvykle nezmění vůbec nic, a pak se nedá poznat, kterým směrem váhu posunout. Proto se skóre posílá přes hladší aktivační funkci.
| Funkce | Vzorec | Rozsah výstupu | Kde se používá |
|---|---|---|---|
| schod | 1 pokud z > 0, jinak 0 | 0 nebo 1 | historicky, učit se s ní nedá gradientem |
| sigmoida | 1 / (1 + exp(-z)) | 0 až 1 | výstup pro pravděpodobnost ano/ne |
| tanh | (exp(z) - exp(-z)) / (exp(z) + exp(-z)) | -1 až 1 | menší sítě, rekurentní sítě |
| ReLU | max(0, z) | 0 až nekonečno | výchozí volba ve skrytých vrstvách |
import numpy as np
np.set_printoptions(precision=3, suppress=True)
def schod(z):
return (z > 0).astype(float)
def sigmoida(z):
return 1 / (1 + np.exp(-z))
def relu(z):
return np.maximum(0, z)
z = np.array([-4.0, -1.0, 0.0, 1.0, 4.0])
print("z ", z)
print("schod ", schod(z))
print("sigmoida ", sigmoida(z))
print("tanh ", np.tanh(z))
print("relu ", relu(z))
z [-4. -1. 0. 1. 4.] schod [0. 0. 0. 1. 1.] sigmoida [0.018 0.269 0.5 0.731 0.982] tanh [-0.999 -0.762 0. 0.762 0.999] relu [0. 0. 0. 1. 4.]
Všimni si, že sigmoida i tanh se na krajích skoro nehýbou. Mezi z = 4 a z = 400 je u nich prakticky stejný výstup. Říká se tomu saturace a ještě nás bude trápit.
Tvary funkcí jsou nejlíp vidět v grafu.
import numpy as np
import matplotlib.pyplot as plt
z = np.linspace(-5, 5, 300)
plt.figure(figsize=(7, 4))
plt.plot(z, 1 / (1 + np.exp(-z)), label="sigmoida")
plt.plot(z, np.tanh(z), label="tanh")
plt.plot(z, np.maximum(0, z), label="ReLU")
plt.ylim(-1.2, 2.2)
plt.axhline(0, color="gray", linewidth=0.5)
plt.axvline(0, color="gray", linewidth=0.5)
plt.xlabel("skóre z")
plt.ylabel("výstup")
plt.legend()
plt.show()
Spoj funkci s jejím výstupem
Ke každé funkci přiřaď, co o ní platí.
Napiš ReLU a sigmoidu
Doplň funkce relu(z) a sigmoida(z). Obě musí fungovat pro celé pole NumPy, prvek po prvku, tedy bez cyklu a bez if.
import numpy as np
def relu(z):
return z
def sigmoida(z):
return z
Obrácená sigmoida
Funkce má pro velké kladné skóre vracet číslo blízké 1. Vrací ale opak.
Proč nestačí samé přímky
Aktivační funkce není ozdoba. Bez ní by sebedelší řetěz vrstev nedokázal víc než jedna jediná vrstva. Lineární krok následovaný lineárním krokem je totiž zase jeden lineární krok. Ověříš si to na čísle: dvě matice jdou nahradit jejich součinem. Jakmile mezi ně vložíš tanh, přestane to platit.
import numpy as np
rng = np.random.RandomState(0)
A = rng.randn(2, 3)
B = rng.randn(3, 1)
X = rng.randn(5, 2)
C = A @ B
print("bez aktivace jde o jednu vrstvu:", np.allclose((X @ A) @ B, X @ C))
print("s tanh už ne: ", np.allclose(np.tanh(X @ A) @ B, X @ C))
bez aktivace jde o jednu vrstvu: True s tanh už ne: False
Neuron se učí sám
Váhy zatím nastavuješ ručně. Učení znamená, že je najde algoritmus z příkladů. Výstup bereme jako pravděpodobnost p, porovnáme ho se správnou odpovědí y a každou váhu trochu posuneme tak, aby chyba klesla. Pro sigmoidu a logistickou ztrátu vychází velmi jednoduché pravidlo. Stejné už znáš z logistické regrese, odvodíme ho v lekci o backpropagation.
p = sigmoida(x @ w + b)
w = w - lr * (p - y) * x
b = b - lr * (p - y)lr je učicí krok (learning rate), tedy jak velký kus se jde najednou. Když neuron říká moc (p > y), váhy aktivních vstupů klesnou. Když říká málo, stoupnou. Tady se neuron učí AND. Zkus nastavit kroky na 0 a pak je postupně zvyšovat.
import numpy as np
np.set_printoptions(precision=3, suppress=True)
def sigmoida(z):
return 1 / (1 + np.exp(-z))
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
y = np.array([0, 0, 0, 1], dtype=float)
w = np.zeros(2)
b = 0.0
for _ in range(int(kroky)):
p = sigmoida(X @ w + b)
w -= lr * X.T @ (p - y) / len(y)
b -= lr * (p - y).mean()
p = sigmoida(X @ w + b)
print("váhy:", w, " bias:", round(b, 3))
print("p: ", p)
print("0/1: ", (p > 0.5).astype(int))
váhy: [7.414 7.414] bias: -11.294 p: [0. 0.02 0.02 0.972] 0/1: [0 0 0 1]
Slož jeden krok učení
Seřaď řádky tak, aby neuron nejdřív spočítal předpověď a teprve potom upravil váhy. Jeden řádek je navíc.
Nauč neuron OR
Doplň do cyklu úpravu w a b, aby se neuron sám naučil hradlo OR. Data ani počet kroků neměň.
import numpy as np
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
y = np.array([0, 1, 1, 1], dtype=float)
w = np.zeros(2)
b = 0.0
lr = 0.5
for _ in range(1000):
p = 1 / (1 + np.exp(-(X @ w + b)))
# doplň úpravu w a b
Kde jeden neuron končí
XOR vrací 1, když se vstupy liší. Vypadá to nevinně. Stejný algoritmus ale tentokrát selže, ať ho necháš běžet jak dlouho chceš. Začínáme z náhodných vah, aby nešlo o smůlu při startu.
import numpy as np
np.set_printoptions(precision=3, suppress=True)
def sigmoida(z):
return 1 / (1 + np.exp(-z))
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
y = np.array([0, 1, 1, 0], dtype=float)
rng = np.random.RandomState(0)
w = rng.randn(2)
b = rng.randn()
for _ in range(5000):
p = sigmoida(X @ w + b)
w -= 0.5 * X.T @ (p - y) / len(y)
b -= 0.5 * (p - y).mean()
p = sigmoida(X @ w + b)
ztrata = -(y * np.log(p) + (1 - y) * np.log(1 - p)).mean()
print("p:", p)
print("ztráta:", round(float(ztrata), 3))
p: [0.5 0.5 0.5 0.5] ztráta: 0.693
Neuron rezignoval a na všechno říká „půl na půl“. Důvod je geometrický. Nakresli si čtyři body do čtverce:
x2
1 [1]-------[0]
| |
| |
0 [0]-------[1]
0 1 x1Jedničky leží na jedné úhlopříčce, nuly na druhé. Žádná přímka je od sebe neoddělí, a neuron nic jiného než přímku nakreslit neumí. Řešení přijde v další lekci: několik neuronů za sebou.
Proč neuron se sigmoidou nezvládne XOR?
Sigmoida jen plynule přechází přes hranici, ale ta hranice je pořád x @ w + b = 0, tedy přímka. Ani delší trénink ani jiný krok na tom nic nezmění.
Do které vrstvy se ReLU typicky nehodí?
ReLU není shora omezená, takže její výstup nejde číst jako pravděpodobnost. Ve skrytých vrstvách je naopak běžnou výchozí volbou.
Pod kapotou · saturace, mrtvé neurony a numericky stabilní ztráta
Sklon sigmoidy je p * (1 - p), maximálně 0.25 v nule. Sklon tanh je 1 - tanh(z)**2, maximálně 1. U ReLU je 1 pro kladné skóre a 0 pro záporné. V nule derivace neexistuje, frameworky prostě berou subgradient (typicky 0). Neuron, jehož skóre je záporné pro všechna data, má nulový gradient a sám se neprobudí. To je dying ReLU, obvyklá stopa po příliš velkém kroku. Mírní ho rozumná inicializace, menší lr, normalizace nebo varianty jako LeakyReLU a GELU.
V produkci se sigmoida před výpočtem ztráty obvykle vůbec nepočítá. Pro velké |z| se 1 - p zaokrouhlí na nulu a logaritmus dá nekonečno. Pro správnou třídu 0 je přesná ztráta log(1 + exp(z)), což np.logaddexp(0, z) spočítá bez přetečení. Stejný důvod stojí za BCEWithLogitsLoss v PyTorchi: model vrací surová skóre (logity), ne pravděpodobnosti.
import numpy as np
z = np.array([-800.0, -40.0, 0.0, 40.0, 800.0])
with np.errstate(over="ignore", divide="ignore"):
p = 1 / (1 + np.exp(-z))
naivni = -np.log(1 - p) + 0.0
stabilni = np.logaddexp(0, z)
print("skóre naivní stabilní")
for a, n, s in zip(z, naivni, stabilni):
print(f"{a:6.0f} {n:8.3f} {s:8.3f}")
skóre naivní stabilní
-800 0.000 0.000
-40 0.000 0.000
0 0.693 0.693
40 inf 40.000
800 inf 800.000Historicky: model McCullocha a Pittse je z roku 1943, Rosenblattův perceptron z konce padesátých let a omezení jednovrstvých sítí rozebrali Minsky a Papert v knize Perceptrons (1969). S biologickým neuronem má dnešní „neuron“ společnou hlavně inspiraci. Nečti to jako model mozku.
Opakování
Vyzkoušej si: Jeden neuron
Měň váhy, práh, vstupy a aktivační funkci a sleduj výstup i rozhodovací přímku.