Poland IT Hub

Sieci neuronowe to fundament współczesnej sztucznej inteligencji, pozwalający rozwiązywać złożone problemy klasyfikacji, regresji i przetwarzania danych.

Spis treści

Python stał się preferowanym językiem ich implementacji dzięki bogatemu ekosystemowi bibliotek, intuicyjnej składni i silnej społeczności. Poniższy poradnik prowadzi od podstaw po zaawansowane architektury – z praktycznymi przykładami kodu i wyjaśnieniami krok po kroku.

Podstawy sztucznych sieci neuronowych i ich struktury

Sieć neuronowa przetwarza dane wejściowe (liczbowe) i generuje przewidywania na wyjściu, czerpiąc inspirację ze struktury biologicznego mózgu.

Każdy neuron przyjmuje wektor wejść i przekształca go do pojedynczej wartości wyjściowej poprzez zestaw operacji matematycznych.

Strukturę typowej sieci tworzą trzy rodzaje warstw:

  • warstwa wejściowa – przyjmuje surowe dane i przekazuje je dalej bez przetwarzania;
  • warstwy ukryte – wykonują większość obliczeń i uczą się zależności (liniowych oraz nieliniowych);
  • warstwa wyjściowa – generuje ostateczną predykcję lub klasyfikację.

Połączenia między neuronami mają przypisane wagi, które skalują sygnał. Zsumowany sygnał trafia do funkcji aktywacji, która wprowadza nieliniowość i umożliwia modelowi uczenie się złożonych wzorców.

Koncepcje matematyczne i kluczowe komponenty

Struktura neuronu i obliczenia forward pass

Neuron wylicza sumę ważoną wejść i dodaje składową niezależną (bias):

z = w1*x1 + w2*x2 + ... + wn*xn + b

Następnie wynik z jest przepuszczany przez funkcję aktywacji, co pozwala modelowi uogólniać wiedzę poza proste relacje liniowe.

Funkcje aktywacji

Najczęściej używane funkcje aktywacji i ich właściwości to:

  • Sigmoid – mapuje wartości do zakresu [0, 1], dobrze reprezentuje prawdopodobieństwa; sigma(x) = 1 / (1 + e^(-x)); w głębokich sieciach może powodować zanikające gradienty;
  • ReLU – szybka i skuteczna w warstwach ukrytych; ReLU(x) = max(0, x); bywa podatna na problem „umierających” neuronów (stałe zera);
  • Tanh – wyjście w zakresie [-1, 1], często stabilizuje uczenie dzięki wycentrowaniu wokół zera; tanh(x) = (2/(1+e^(-2x))) - 1;
  • Softmax – stosowana na wyjściu dla klasyfikacji wieloklasowej; zamienia logity na rozkład prawdopodobieństwa; softmax(zi) = e^(zi) / Σ e^(zj).

Przygotowanie danych do trenowania sieci neuronowych

Jakość przygotowania danych ma kluczowy wpływ na skuteczność modelu i tempo konwergencji podczas treningu.

Normalizacja i standaryzacja danych

Normalizacja ujednolica skale cech i stabilizuje obliczenia gradientów.

Normalizacja min–max: x' = (x - min(x)) / (max(x) - min(x)). Standaryzacja z-score: x' = (x - μ) / σ – zalecana, gdy rozkład cech jest zbliżony do normalnego.

Ujednolicone skale zwykle przyspieszają uczenie i poprawiają dokładność, zwłaszcza w głębokich sieciach.

Przygotowanie i podział zbioru danych

Praktyczne kroki porządkowania i przygotowania danych obejmują:

  • usunięcie lub korektę wartości odstających,
  • uzupełnienie braków (imputacja) odpowiednimi metodami,
  • skalowanie/normalizację cech do spójnego zakresu,
  • podział na zbiory treningowy, walidacyjny (i testowy) dla rzetelnej oceny generalizacji.

Tworzenie sieci neuronowych za pomocą TensorFlow i Keras

Keras to wysokopoziomowe API zintegrowane z TensorFlow, idealne do szybkiego prototypowania i pracy produkcyjnej.

Instalacja i konfiguracja

Aby zainstalować TensorFlow (z wbudowanym Keras), użyj polecenia:

pip install tensorflow

Budowanie modelu sekwencyjnego

Poniższy kod pokazuje prosty model do klasyfikacji binarnej (dane Pima Indians Diabetes):

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
import numpy as np

# Załaduj dataset
dataset = np.loadtxt('pima-indians-diabetes.csv', delimiter=',')

# Podziel na wejścia (X) i wyjścia (y)
X = dataset[:, 0:8]
y = dataset[:, 8]

# Definiuj model
model = Sequential()
model.add(Dense(12, input_shape=(8,), activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(1, activation='sigmoid'))

# Kompiluj model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Trenuj model
model.fit(X, y, epochs=150, batch_size=10)

# Ewaluuj model
_, accuracy = model.evaluate(X, y)
print('Accuracy: %.2f' % (accuracy * 100))

Model oczekuje 8 cech wejściowych (input_shape=(8,)). Warstwa Dropout(0.2) redukuje przeuczenie, losowo dezaktywując 20% neuronów podczas treningu.

Kompilacja i konfiguracja modelu

Kompilacja określa funkcję straty i optymalizator. Dla klasyfikacji binarnej standardem jest binary_crossentropy z optymalizatorem Adam lub SGD, a jako metrykę często stosuje się accuracy.

Tworzenie sieci neuronowych za pomocą PyTorch

PyTorch oferuje elastyczne, dynamiczne grafy obliczeniowe i jest niezwykle popularny w badaniach naukowych oraz szybkim eksperymentowaniu.

Dla szybkiego porównania kluczowych cech obu podejść warto przeanalizować różnice:

Framework Graf obliczeniowy Poziom API Atuty Typowe zastosowania
TensorFlow + Keras statyczny (z możliwością eager mode) wysokopoziomowe (Keras), niższy poziom w TF dojrzałość produkcyjna, skalowanie, deployment produkcja, MLOps, szybkie prototypy
PyTorch dynamiczny średnio-/niskopoziomowe elastyczność, łatwe debugowanie, badania R&D, prace eksperymentalne

Definicja modelu w PyTorch

Model definiuje się jako klasę dziedziczącą po nn.Module; warstwy w __init__, przepływ danych w forward:

import torch
import torch.nn as nn
import torch.optim as optim

class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
self.fc1 = nn.Linear(784, 128)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(128, 64)
self.fc3 = nn.Linear(64, 10)
self.dropout = nn.Dropout(0.2)

def forward(self, x):
x = x.view(x.size(0), -1) # spłaszczenie wejścia
x = self.fc1(x)
x = self.relu(x)
x = self.dropout(x)
x = self.fc2(x)
x = self.relu(x)
x = self.fc3(x)
return x

# Utwórz instancję modelu
model = NeuralNetwork()

# Zdefiniuj funkcję straty i optymalizator
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

Warstwy liniowe mają postać nn.Linear(wejścia, wyjścia), a wagi inicjalizowane są automatycznie.

Proces treningu w PyTorch

Trening przebiega w pętli: forward pass → obliczenie straty → wsteczny przepływ gradientów → aktualizacja wag:

num_epochs = 10
batch_size = 32

# Załóżmy, że mamy X_train i y_train będące tensorem PyTorch
for epoch in range(num_epochs):
total_loss = 0.0
for i in range(0, len(X_train), batch_size):
# weź batch danych
batch_X = X_train[i:i+batch_size]
batch_y = y_train[i:i+batch_size]

# forward pass
outputs = model(batch_X)
loss = criterion(outputs, batch_y)

# backward pass i optymalizacja
optimizer.zero_grad()
loss.backward()
optimizer.step()

total_loss += loss.item()

print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {total_loss/len(X_train):.4f}')

Krytyczne kroki to zerowanie gradientów, obliczenie gradientów i aktualizacja parametrów optymalizatorem.

Propagacja wsteczna i optymalizacja wag

Propagacja wsteczna to podstawowy algorytm uczenia wielowarstwowych sieci, pozwalający efektywnie aktualizować wagi tak, by minimalizować funkcję straty.

Mechanizm propagacji wstecznej

Algorytm oblicza pochodne straty względem parametrów, „przepychając” błąd od końca do początku sieci. Na tej podstawie wagi są korygowane w kierunku spadku funkcji celu.

Aktualizacja wag przy prostym spadku gradientowym ma postać:

w_now = w_old - η * (∂L/∂w)

Funkcje straty

Najczęściej stosowane funkcje straty to:

  • Mean Squared Error (MSE) – dla regresji; silniej karze duże błędy; MSE = (1/N) * Σ (y - ŷ)^2;
  • Binary Cross-Entropy – dla klasyfikacji binarnej; dobrze modeluje niepewność probabilistyczną;
  • Categorical Cross-Entropy – dla klasyfikacji wieloklasowej; współpracuje z wyjściem Softmax.

Algorytmy optymalizacji

Stochastic Gradient Descent (SGD) aktualizuje wagi na podstawie gradientów z minibatchy; bywa niestabilny przez szum, ale jest przewidywalny i prosty.

Adam łączy momentum i RMSProp, śledząc średnie pierwszego i drugiego momentu gradientów; zwykle zapewnia szybką i stabilną konwergencję.

Zaawansowane architektury sieci neuronowych

Konwolucyjne sieci neuronowe (CNN)

CNN są szczególnie efektywne w analizie obrazów, automatycznie ucząc się cech takich jak krawędzie, tekstury i kształty.

Warstwa konwolucyjna wykorzystuje filtry (jądra) do tworzenia map cech, a warstwa poolingu redukuje wymiar przy zachowaniu najważniejszych informacji.

Przykład prostej CNN w Keras:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

model = Sequential([
Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
MaxPooling2D((2, 2)),
Conv2D(64, (3, 3), activation='relu'),
MaxPooling2D((2, 2)),
Flatten(),
Dense(128, activation='relu'),
Dense(10, activation='softmax')
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=10, batch_size=128)

Rekurencyjne sieci neuronowe (RNN)

RNN przetwarzają sekwencje (teksty, szeregi czasowe) dzięki stanom ukrytym, które przenoszą informacje w czasie.

Long Short-Term Memory (LSTM) łagodzi problem zanikających gradientów, a Gated Recurrent Unit (GRU) upraszcza architekturę przy zbliżonej skuteczności.

Trenowanie, regularyzacja i zapobieganie przeuczeniu

Epoki, batch size i learning rate

Kluczowe hiperparametry treningu i ich rola:

  • epoch – pełne przejście przez zbiór treningowy; zwykle dziesiątki do setek epok;
  • batch size – liczba próbek na aktualizację wag; mniejsze batch’e zwiększają częstotliwość aktualizacji, większe stabilizują gradient;
  • learning rate – wielkość kroku w kierunku gradientu; zbyt wysoki powoduje oscylacje, zbyt niski spowalnia uczenie.

Przeuczenie (overfitting) i niedouczenie (underfitting)

Przeuczenie to wysoka dokładność na treningu i niższa na walidacji; niedouczenie to słaba skuteczność na obu zbiorach przez zbyt prosty model.

Aby ograniczyć przeuczenie, stosuj:

  • regularyzację L1/L2 – kary na duże wagi ograniczają nadmierne dopasowanie;
  • Dropout – losowe wyłączanie neuronów uogólnia reprezentacje;
  • Early stopping – przerywanie treningu po braku poprawy na walidacji.

Aby zmniejszyć niedouczenie, rozważ:

  • zwiększenie złożoności modelu – więcej warstw/neuronów;
  • wydłużenie treningu – więcej epok, harmonogram uczenia;
  • lepszy feature engineering – bogatsze, bardziej informatywne cechy.

Ewaluacja modelu i metryki wydajności

Metryki klasyfikacji

Najważniejsze metryki oceny jakości klasyfikatorów:

  • accuracy – odsetek poprawnych klasyfikacji; (TP+TN)/(TP+TN+FP+FN);
  • precision – odsetek trafnych pozytywnych predykcji; TP/(TP+FP);
  • recall – wykrywalność klas pozytywnych; TP/(TP+FN);
  • F1 – średnia harmoniczna precision i recall; 2 * (P*R)/(P+R).

Walidacja krzyżowa

Walidacja k‑krotna dzieli dane na k fałd, ucząc model k razy i testując na każdej części raz. Wynik to średnia miar ze wszystkich przebiegów, co zapewnia rzetelniejszą ocenę generalizacji.