0 dní v řadě · 0 bodů

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

Neuron a aktivační funkce

Postavíš umělý neuron v NumPy, poznáš sigmoidu, tanh a ReLU, naučíš ho logické funkce a uvidíš, kde jeho schopnosti končí.

Hloubka
Úkoly
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.

text
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í funkce

Tipni 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")
Výstup
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)
Výstup
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}")
Výstup
[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í.

Úkol

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
Výstup
Kvíz

Co se stane s neuronem bez biasu, když jsou všechny vstupy nulové?

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.

FunkceVzorecRozsah výstupuKde se používá
schod1 pokud z > 0, jinak 00 nebo 1historicky, učit se s ní nedá gradientem
sigmoida1 / (1 + exp(-z))0 až 1výstup pro pravděpodobnost ano/ne
tanh(exp(z) - exp(-z)) / (exp(z) + exp(-z))-1 až 1menší sítě, rekurentní sítě
ReLUmax(0, z)0 až nekonečnový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))
Výstup
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()
Výstup
Spoj dvojice

Spoj funkci s jejím výstupem

Ke každé funkci přiřaď, co o ní platí.

Úkol

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
Výstup
Najdi chybu

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

text
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ýstup
váhy: [7.414 7.414]  bias: -11.294
p:    [0.    0.02  0.02  0.972]
0/1:  [0 0 0 1]
Slož kód

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.

Úkol

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

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

text
x2
1   [1]-------[0]
     |         |
     |         |
0   [0]-------[1]
     0         1   x1

Jednič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.

Kvíz

Proč neuron se sigmoidou nezvládne XOR?

Kvíz

Do které vrstvy se ReLU typicky nehodí?

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

Historicky: 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.

Kartičky

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.