Co je neuronová síť — principy a první model v Pythonu
Neuronové sítě jsou základem moderní umělé inteligence, ale jejich principy jsou překvapivě jednoduché. V tomto článku si vysvětlíme, jak fungují, a vytvoříme si první funkční model v Pythonu pomocí několika řádků kódu.
Co jsou neuronové sítě a jak fungují
Neuronové sítě jsou matematické modely inspirované fungováním lidského mozku. V jejich základu stojí umělý neuron (perceptron), který přijímá vstupní signály, zpracovává je pomocí váhových koeficientů a bias hodnoty, a produkuje výstup prostřednictvím aktivační funkce.
Každý neuron v síti provádí jednoduchou operaci: výstup = aktivační_funkce(suma(vstupy × váhy) + bias). Když spojíme více neuronů do vrstev a vrstvy propojíme, získáme neuronovou síť schopnou řešit složité problémy.
Základní komponenty neuronové sítě
Neuronová síť se skládá ze tří typů vrstev:
- Vstupní vrstva (Input Layer) – přijímá data a předává je dál
- Skryté vrstvy (Hidden Layers) – zpracovávají data pomocí váhových transformací
- Výstupní vrstva (Output Layer) – produkuje finální predikci
Každé spojení mezi neurony má svou váhu (weight), která určuje, jak silně jeden neuron ovlivňuje druhý. Během trénování se tyto váhy postupně upravují pomocí backpropagation algoritmu.
Implementace jednoduché neuronové sítě v PyTorchu
Pro praktickou ukázku vytvoříme neuronovou síť, která dokáže klasifikovat data ze známého Iris datasetu. Síť bude mít jednu skrytou vrstvu a použije ReLU aktivační funkci.
Příprava dat a prostředí
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import numpy as np
# Načtení Iris datasetu
iris = load_iris()
X = iris.data # 4 features: sepal length/width, petal length/width
y = iris.target # 3 classes: setosa, versicolor, virginica
# Rozdělení na trénovací a testovací data
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# Normalizace dat
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# Převod na PyTorch tensory
X_train_tensor = torch.FloatTensor(X_train_scaled)
X_test_tensor = torch.FloatTensor(X_test_scaled)
y_train_tensor = torch.LongTensor(y_train)
y_test_tensor = torch.LongTensor(y_test)
Definice architektury neuronové sítě
class SimpleNeuralNetwork(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(SimpleNeuralNetwork, self).__init__()
# Definice vrstev
self.hidden = nn.Linear(input_size, hidden_size)
self.output = nn.Linear(hidden_size, output_size)
# Aktivační funkce
self.relu = nn.ReLU()
self.softmax = nn.Softmax(dim=1)
def forward(self, x):
# Forward pass - průchod dat sítí
x = self.hidden(x) # Lineární transformace
x = self.relu(x) # Aplikace ReLU aktivace
x = self.output(x) # Výstupní vrstva
return x
# Vytvoření instance modelu
model = SimpleNeuralNetwork(
input_size=4, # 4 features z Iris datasetu
hidden_size=10, # 10 neuronů ve skryté vrstvě
output_size=3 # 3 třídy pro klasifikaci
)
print(f"Model architektura:\n{model}")
Trénování neuronové sítě
Pro trénování potřebujeme definovat loss funkci a optimalizátor. Pro klasifikaci použijeme CrossEntropyLoss a Adam optimalizátor.
# Definice loss funkce a optimalizátoru
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
# Trénovací smyčka
epochs = 1000
losses = []
for epoch in range(epochs):
# Forward pass
outputs = model(X_train_tensor)
loss = criterion(outputs, y_train_tensor)
# Backward pass a optimalizace
optimizer.zero_grad() # Vymazání gradientů
loss.backward() # Backpropagation
optimizer.step() # Aktualizace vah
losses.append(loss.item())
# Výpis pokroku každých 100 epoch
if (epoch + 1) % 100 == 0:
print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
print("Trénování dokončeno!")
Evaluace modelu
# Testování na testovacích datech
model.eval() # Přepnutí do evaluačního módu
with torch.no_grad():
test_outputs = model(X_test_tensor)
_, predicted = torch.max(test_outputs.data, 1)
# Výpočet přesnosti
total = y_test_tensor.size(0)
correct = (predicted == y_test_tensor).sum().item()
accuracy = 100 * correct / total
print(f'Přesnost na testovacích datech: {accuracy:.2f}%')
# Detailní pohled na predikce
print("\nSrovnání skutečných a predikovaných hodnot:")
for i in range(min(10, len(y_test))):
actual = iris.target_names[y_test[i]]
predicted_class = iris.target_names[predicted[i]]
print(f"Skutečná: {actual:12} | Predikovaná: {predicted_class:12}")
Jak neuronová síť "učí"
Proces učení neuronové sítě probíhá ve čtyřech krocích:
- Forward Propagation – data procházejí sítí dopředu a vytváří predikci
- Loss Calculation – porovnání predikce se skutečnou hodnotou
- Backpropagation – výpočet gradientů pomocí řetízkového pravidla
- Weight Update – úprava vah na základě gradientů
Klíčovou roli hraje optimalizátor, který určuje, jak rychle a efektivně se síť učí. Adam optimalizátor kombinuje výhody momentum a adaptivního learning rate, což často vede k rychlejší konvergenci.
Aktivační funkce a jejich význam
ReLU (Rectified Linear Unit) je nejpopulárnější aktivační funkce pro skryté vrstvy. Její jednoduchost (max(0, x)) přináší několik výhod:
# Porovnání různých aktivačních funkcí
import matplotlib.pyplot as plt
x = torch.linspace(-5, 5, 100)
relu = torch.relu(x)
sigmoid = torch.sigmoid(x)
tanh = torch.tanh(x)
# ReLU: f(x) = max(0, x)
# Sigmoid: f(x) = 1 / (1 + e^(-x))
# Tanh: f(x) = (e^x - e^(-x)) / (e^x + e^(-x))
print("ReLU výhody:")
print("- Rychlé výpočty")
print("- Řeší vanishing gradient problém")
print("- Sparsity - mnoho neuronů je neaktivních")
Rozšíření a praktické tipy
Pro zlepšení výkonu neuronové sítě můžeme použít několik technik:
class ImprovedNeuralNetwork(nn.Module):
def __init__(self, input_size, hidden_sizes, output_size, dropout_rate=0.2):
super(ImprovedNeuralNetwork, self).__init__()
layers = []
prev_size = input_size
# Vytvoření více skrytých vrstev
for hidden_size in hidden_sizes:
layers.append(nn.Linear(prev_size, hidden_size))
layers.append(nn.ReLU())
layers.append(nn.Dropout(dropout_rate)) # Regularizace
prev_size = hidden_size
# Výstupní vrstva
layers.append(nn.Linear(prev_size, output_size))
self.network = nn.Sequential(*layers)
def forward(self, x):
return self.network(x)
# Použití pokročilejší architektury
advanced_model = ImprovedNeuralNetwork(
input_size=4,
hidden_sizes=[16, 8], # Dvě skryté vrstvy
output_size=3,
dropout_rate=0.3
)
Shrnutí
Neuronové sítě jsou mocným nástrojem pro řešení komplexních problémů strojového učení. Pochopení základních principů – od struktury neuronů přes forward a backward propagation až po optimalizaci – je klíčové pro efektivní práci s deep learningem. PyTorch poskytuje intuitivní rozhraní pro implementaci a experimentování s různými architekturami. Začít s jednoduchými modely jako v našem příkladu je ideální způsob, jak si osvojit základy před přechodem na složitější architektury typu CNN nebo Transformer.