Backpropagation — jak se neuronové sítě učí
Backpropagation je srdcem každé neuronové sítě - elegantní algoritmus, který umožňuje strojům učit se z vlastních chyb. Pochopíte, jak tento matematický princip řídí proces učení od rozpoznávání obrázků až po jazykové modely.
Jak funguje backpropagation v neuronových sítích
Backpropagation je algoritmus, který umožňuje neuronovým sítím učit se z chyb postupným šířením gradientů zpět přes síť. Bez tohoto mechanismu by deep learning neexistoval v dnešní podobě. Podívejme se, jak přesně funguje a proč je tak důležitý.
Základní princip forward a backward pass
Učení neuronové sítě probíhá ve dvou fázích. Nejdříve forward pass — data projdou sítí směrem dopředu a vytvoří se predikce. Pak následuje backward pass — chyba se šíří zpět a aktualizují se váhy.
# Forward pass - jednoduchá síť s jednou skrytou vrstvou
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def forward_pass(X, W1, b1, W2, b2):
# Skrytá vrstva
z1 = X.dot(W1) + b1
a1 = sigmoid(z1)
# Výstupní vrstva
z2 = a1.dot(W2) + b2
a2 = sigmoid(z2)
return z1, a1, z2, a2
Výpočet chyby a gradientů
Klíčové je pochopení, jak se počítají gradienty. Použijeme chain rule z matematické analýzy — derivaci složené funkce rozložíme na součin derivací jednotlivých částí.
Pro mean squared error a sigmoid aktivaci vypadá gradient takto:
def compute_gradients(X, y, z1, a1, z2, a2, W1, W2):
m = X.shape[0] # počet vzorků
# Gradient pro výstupní vrstvu
dz2 = a2 - y # derivace MSE loss
dW2 = (1/m) * a1.T.dot(dz2)
db2 = (1/m) * np.sum(dz2, axis=0)
# Gradient pro skrytou vrstvu (chain rule)
da1 = dz2.dot(W2.T)
dz1 = da1 * a1 * (1 - a1) # derivace sigmoidu
dW1 = (1/m) * X.T.dot(dz1)
db1 = (1/m) * np.sum(dz1, axis=0)
return dW1, db1, dW2, db2
Aktualizace vah pomocí gradient descent
Jakmile máme gradienty, můžeme aktualizovat váhy. Gradient descent upraví každou váhu v opačném směru, než ukazuje gradient — tím se postupně dostáváme k minimu loss funkce.
def update_weights(W1, b1, W2, b2, dW1, db1, dW2, db2, learning_rate):
W1 -= learning_rate * dW1
b1 -= learning_rate * db1
W2 -= learning_rate * dW2
b2 -= learning_rate * db2
return W1, b1, W2, b2
# Kompletní tréninkový cyklus
def train_step(X, y, W1, b1, W2, b2, learning_rate=0.01):
# Forward pass
z1, a1, z2, a2 = forward_pass(X, W1, b1, W2, b2)
# Compute loss
loss = np.mean((a2 - y)**2)
# Backward pass
dW1, db1, dW2, db2 = compute_gradients(X, y, z1, a1, z2, a2, W1, W2)
# Update weights
W1, b1, W2, b2 = update_weights(W1, b1, W2, b2,
dW1, db1, dW2, db2, learning_rate)
return W1, b1, W2, b2, loss
Problémy s vanishing a exploding gradients
V hlubokých sítích může docházet k vanishing gradients — gradienty se během backpropagation zmenšují exponenciálně. Opačný problém jsou exploding gradients, kdy gradienty rostou nekonečně.
Řešení zahrnují:
- Gradient clipping — omezení maximální velikosti gradientu
- Lepší aktivační funkce — ReLU místo sigmoidu
- Batch normalization — normalizace vstupů do každé vrstvy
- Residual connections — přímé spojení mezi vzdálenými vrstvami
# Gradient clipping v praxi
def clip_gradients(gradients, max_norm=1.0):
total_norm = 0
for grad in gradients:
total_norm += np.sum(grad**2)
total_norm = np.sqrt(total_norm)
clip_coef = max_norm / (total_norm + 1e-6)
if clip_coef < 1:
for i, grad in enumerate(gradients):
gradients[i] = grad * clip_coef
return gradients
Optimalizace backpropagation
Moderní implementace používají pokročilé optimalizéry, které upravují learning rate nebo přidávají momentum:
class AdamOptimizer:
def __init__(self, learning_rate=0.001, beta1=0.9, beta2=0.999):
self.lr = learning_rate
self.beta1 = beta1
self.beta2 = beta2
self.m = {} # first moment
self.v = {} # second moment
self.t = 0 # time step
def update(self, params, gradients):
self.t += 1
for key in params:
if key not in self.m:
self.m[key] = np.zeros_like(params[key])
self.v[key] = np.zeros_like(params[key])
# Update biased first/second moment estimates
self.m[key] = self.beta1 * self.m[key] + (1 - self.beta1) * gradients[key]
self.v[key] = self.beta2 * self.v[key] + (1 - self.beta2) * gradients[key]**2
# Bias correction
m_hat = self.m[key] / (1 - self.beta1**self.t)
v_hat = self.v[key] / (1 - self.beta2**self.t)
# Update parameters
params[key] -= self.lr * m_hat / (np.sqrt(v_hat) + 1e-8)
Backpropagation v praxi s PyTorch
V reálných projektech používáme frameworky, které backpropagation implementují automaticky:
import torch
import torch.nn as nn
# Definice sítě
class SimpleNet(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super().__init__()
self.hidden = nn.Linear(input_size, hidden_size)
self.output = nn.Linear(hidden_size, output_size)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
x = self.sigmoid(self.hidden(x))
x = self.sigmoid(self.output(x))
return x
# Trénink s automatickým backpropagation
model = SimpleNet(10, 20, 1)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
for epoch in range(1000):
# Forward pass
outputs = model(X)
loss = criterion(outputs, y)
# Backward pass - automaticky!
optimizer.zero_grad()
loss.backward()
optimizer.step()
Shrnutí
Backpropagation je algoritmus, který umožňuje neuronové síti učit se minimalizací chyby prostřednictvím gradient descent. Klíčové jsou tři kroky: forward pass pro výpočet predikce, backward pass pro šíření gradientů a update vah. V praxi používáme optimalizéry jako Adam a frameworky jako PyTorch, které celý proces automatizují. Pochopení principů backpropagation je ale zásadní pro ladění a optimalizaci deep learning modelů.