Propagacja wsteczna

Poniżej pokazano kod programu w języku Python, który uczy małą sieć neuronową (2 wejścia, 2 neurony w warstwie ukrytej, 1 wyjście) działania jako bramka logiczna XOR.

1. Struktura sieci

Wejścia: x1, x2

Warstwa ukryta: 2 neurony, funkcja aktywacji: funkcja sigmoidalna

Wyjście: 1 neuron, funkcja aktywacji: funkcja sigmoidalna

Funkcja straty: entropia krzyżowa

2. Kroki uczenia w jednej epoce:

2.1 Forward pass (przejście do przodu)

Obliczenie macierzy aktywacji warstwy ukrytej:

${\displaystyle H=\sigma (X\cdot W1^{T}+b1)}$

gdzie:

${\displaystyle X}$ – macierz danych uczących (4x2 dla XOR)

${\displaystyle W1}$ – macierz wag warstwy ukrytej (2x2)

${\displaystyle W1^{T}}$ – macierz transponowana wag warstwy ukrytej (2x2)

${\displaystyle b1}$ – macierz biasów warstwy ukrytej (1x2)

${\displaystyle \sigma }$ – funkcja sigmoidalna

Obliczenie wyjścia sieci:

${\displaystyle Y=\sigma (H\cdot W2^{T}+b2)}$

gdzie:

${\displaystyle H}$ – macierz aktywacji warstwy ukrytej

${\displaystyle W2}$ – macierz wag wyjścia (1x2)

${\displaystyle W2^{T}}$ – macierz transponowana wag wyjścia (2x1)

${\displaystyle b2}$ – bias wyjścia (1x1)

przy czym dla XOR(2):

${\displaystyle X=\left[{\begin{matrix}0&0\\0&1\\1&0\\1&1\end{matrix}}\right]}$, ${\displaystyle W1={\begin{bmatrix}w_{11}&w_{12}\\w_{21}&w_{22}\end{bmatrix}}}$, ${\displaystyle b1={\begin{bmatrix}b_{1}&b_{2}\end{bmatrix}}}$,

${\displaystyle H={\begin{bmatrix}h_{11}&h_{12}\\h_{21}&h_{22}\\h_{31}&h_{32}\\h_{41}&h_{42}\end{bmatrix}}}$ , ${\displaystyle W2^{T}={\begin{bmatrix}w_{11}\\w_{12}\end{bmatrix}}}$, ${\displaystyle b2={\begin{bmatrix}b_{2}\end{bmatrix}}}$,

2.2 Obliczenie błędu (loss)

Bramka XOR dokonuje klasyfikacji binarnej. Jako funkcję kosztu do jej treningu stosuje się entropię krzyżową (co jest typowe dla treningu sieci neuronowych będących klasyfikatorami binarnymi):

${\displaystyle Loss=-{\frac {1}{N}}\sum [y\log(Y)+(1-y)\log(1-Y)]}$

gdzie:

${\displaystyle y}$ – wartości prawdziwe (próbki uczące)

${\displaystyle Y}$ – przewidywania sieci

${\displaystyle N}$– liczba próbek uczących (4 dla XOR)

przy czym ${\displaystyle \sum }$ oznacza sumowanie po wszystkich próbkach uczących ${\displaystyle y}$ i odpowiadających im przewidywaniach sieci ${\displaystyle Y}$;

${\displaystyle y=\left[{\begin{matrix}0\\1\\1\\0\end{matrix}}\right]}$ - wektor oczekiwanych wyników z sieci, odpowiadających macierzy danych uczących ${\displaystyle X}$.

2.3 Propagacja wsteczna

Gradienty dla warstwy wyjściowej:

${\displaystyle dZ2=Y-y}$

${\displaystyle dW2={\frac {1}{N}}dZ2^{T}\cdot H}$

${\displaystyle db2=mean(dZ2)}$

Gradienty dla warstwy ukrytej:

${\displaystyle dZ1=(dZ2\cdot W2)*\sigma '(X\cdot W1^{T}+b1)}$

${\displaystyle dW1={\frac {1}{N}}dZ1^{T}\cdot X}$

${\displaystyle db1=mean(dZ1)}$

gdzie:

${\displaystyle \sigma '(z)}$ – pochodna funkcji sigmoidalnej

Aktualizacja wag i biasów:

${\displaystyle W:=W-lr\cdot dW}$

${\displaystyle b:=b-lr\cdot db}$

gdzie:

${\displaystyle lr}$ – współczynnik uczenia (learning rate)

3. Wizualizacja granicy decyzyjnej

Granica decyzyjna rysowana co plot_interval = 500 epok na siatce punktów. Kolor wskazuje przewidywaną klasę, tytuł wykresu pokazuje numer epoki i wartość funkcji straty Loss.

4. Jak przebiega uczenie sieci?

Ponieważ metoda spadku gradientowego może znaleźć minimum lokalne zamiast minimum globalnego (por. rysunek), to uczenie podzielono na dwa etapy:

Etap 1: Wybiera się początkowo losowe wartości wag i basów, a następnie uczy się sieć metodą backpropagation przez 50 kolejnych epok; jeśli sieć nauczy się poprawnie klasyfikować punkty, to przechodzi się do drugiego etapu; jeśli nie, to ponownie losuje się wartości początkowe wag i biasów; w ten sposób zwiększa się szansę na wybranie takich wag i biasów początkowych, które kierują sieć w stronę globalnego minimum, co oznacza, że sieć nauczyła się przewidywać wyniki zgodnie ze wzorcem uczenia; etap ten powtarza się nie więcej niż ustaloną liczbę razy, w razie braku sukcesu kończy się program.

Etap 2: Kontynuuje się uczenie, jeśli został znaleziony zestaw wag i biasów, które gwarantują sukces; w kolejnych epokach uczenia zmniejsza się funkcja straty Loss, a granica decyzyjna (klasyfikacyjna) coraz lepiej oddziela punkty ${\displaystyle X=[0,0],X=[1,1]}$ klasy ${\displaystyle 0}$ (parzyste) od punktów ${\displaystyle X=[0,1],X=[1,0]}$ klasy ${\displaystyle 1}$ (nieparzyste).

Po zakończeniu uczenia sieci program robi test poprawności działania sieci - wypisuje wyniki klasyfikacji ${\displaystyle y_{pred}}$; są w 100% zgodne z wartościami prawdziwymi (oczekiwanymi) ${\displaystyle y_{true}}$:

${\displaystyle X=[0,0],y_{true}=0,y_{pred}=0}$

${\displaystyle X=[0,1],y_{true}=1,y_{pred}=1}$

${\displaystyle X=[1,0],y_{true}=1,y_{pred}=1}$

${\displaystyle X=[1,1],y_{true}=0,y_{pred}=0}$

import numpy as np
import matplotlib.pyplot as plt

# --- Funkcje aktywacji ---
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    s = sigmoid(x)
    return s * (1 - s)

# --- Strata entropii krzyżowej ---
def cross_entropy(y_true, y_pred):
    y_pred = np.clip(y_pred, 1e-10, 1-1e-10)
    return -np.mean(y_true*np.log(y_pred) + (1-y_true)*np.log(1-y_pred))

# --- Forward pass ---
def xor_network(x1, x2, W1, b1, W2, b2):
    H = sigmoid(np.column_stack([x1, x2]).dot(W1.T) + b1)
    Y = sigmoid(H.dot(W2.T) + b2)
    Y_bin = np.where(Y >= 0.5, 1, 0)
    return Y, H, Y_bin

# --- Jedna iteracja treningu ---
def train_step(X, y, W1, b1, W2, b2, lr):
    A1 = sigmoid(X.dot(W1.T) + b1)
    A2 = sigmoid(A1.dot(W2.T) + b2)
    dZ2 = A2 - y
    W2 -= lr * (dZ2.T.dot(A1) / X.shape[0])
    b2 -= lr * np.mean(dZ2, axis=0)
    dZ1 = dZ2.dot(W2) * sigmoid_derivative(X.dot(W1.T) + b1)
    W1 -= lr * (dZ1.T.dot(X) / X.shape[0])
    b1 -= np.mean(dZ1, axis=0)
    return W1, b1, W2, b2, cross_entropy(y, A2)

# --- Rysowanie granicy decyzyjnej (ze straty) ---
def plot_decision_boundary(X, y, W1, b1, W2, b2, epoch=None, loss=None):
    xx, yy = np.meshgrid(np.linspace(-0.5,1.5,200), np.linspace(-0.5,1.5,200))
    Z, _, _ = xor_network(xx.ravel(), yy.ravel(), W1, b1, W2, b2)
    Z = Z.reshape(xx.shape)
    plt.figure(figsize=(5,4))
    plt.contourf(xx, yy, Z, levels=[0,0.5,1], alpha=0.4, cmap='coolwarm')
    plt.scatter(X[:,0], X[:,1], c=y.flatten(), s=100, edgecolors='k', cmap='coolwarm')
    if epoch is not None and loss is not None:
        plt.title(f"Epoch {epoch}, Loss={loss:.4f}")
    else:
        plt.title("Decision Boundary")
    plt.xlabel("x1")
    plt.ylabel("x2")
    plt.grid(True)
    plt.show()

# --- Dane XOR ---
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y_true = np.array([[0],[1],[1],[0]])

# --- Parametry ---
input_size = 2
hidden_size = 2
output_size = 1
lr = 0.5
initial_epochs = 50
epochs = 3000
plot_interval = 500
max_trials = 1000

# --- Etap 1: Szukanie dobrego startu ---
np.random.seed()
trial = 0
while trial < max_trials:
    trial += 1
    W1, b1 = np.random.randn(hidden_size, input_size), np.random.randn(hidden_size)
    W2, b2 = np.random.randn(output_size, hidden_size), np.random.randn(output_size)

    # Wstępny trening
    for _ in range(initial_epochs):
        W1, b1, W2, b2, loss = train_step(X, y_true, W1, b1, W2, b2, lr)

    _, _, y_bin = xor_network(X[:,0], X[:,1], W1, b1, W2, b2)
    if np.array_equal(y_bin, y_true):
        print(f"Found good start in trial {trial}")
        # Obliczamy loss po initial_epochs
        loss_initial = cross_entropy(y_true, sigmoid(sigmoid(X.dot(W1.T)+b1).dot(W2.T)+b2))
        plot_decision_boundary(X, y_true, W1, b1, W2, b2, epoch=initial_epochs, loss=loss_initial)
        break
else:
    print(f"No good start found in {max_trials} trials. Exiting.")
    exit()

# --- Lista do zapisywania straty w pełnym treningu ---
loss_history = []

# --- Etap 2: Pełny trening ---
for epoch in range(initial_epochs, epochs + initial_epochs):
    W1, b1, W2, b2, loss = train_step(X, y_true, W1, b1, W2, b2, lr)
    loss_history.append(loss)  # zapisujemy loss

    if epoch % plot_interval == 0 or epoch == epochs + initial_epochs - 1:
        plot_decision_boundary(X, y_true, W1, b1, W2, b2, epoch=epoch, loss=loss)

# --- Rysowanie wykresu zmian straty ---
plt.figure(figsize=(6,4))
plt.plot(range(initial_epochs, epochs + initial_epochs), loss_history, marker='o', markersize=3)
plt.xlabel("Epoch")
plt.ylabel("Loss (Cross-Entropy)")
plt.title("Loss vs Epochs")
plt.grid(True)
plt.show()

# --- Test po treningu ---
_, _, y_pred = xor_network(X[:,0], X[:,1], W1, b1, W2, b2)
print("=== TEST SIECI XOR PO NAUCE ===")
for xi, yt, yp in zip(X, y_true, y_pred):
    print(f"X={xi}, y_true={yt[0]}, y_pred={int(yp[0])}")

Uwaga 1: W programie kończy się uczenie sieci, gdy minie ustalona z góry liczba epok uczenia. Można zoptymalizować warunki zakończenia uczenia, wprowadzając dodatkowe kryteria mierzenia dokładności nauczenie się sieci.

Uwaga 2: W liniach 53-56 są dane prawdziwe (treningowe) dla sieci XOR, a w liniach 57-65 dane definiujące architekturę sieci (oraz parametry treningowe). Zmieniając dane treningowe można łatwo zmienić program na uczenie innej funkcji, np. AND, NOT, XOR(3), XOR(4), itd.

Uwaga 3: W programie zastosowano metodę uczenia, w której w każdym pojedynczym kroku iteracyjnym wykonuje się jednocześnie obliczenia na całym zestawie 4 par danych uczących. Takie podejście wymaga rozszerzenia wektora danych ${\displaystyle X}$ do postaci macierzy; przyjęto postać macierzy 4x2, tj. poszczególne wiersze macierzy ${\displaystyle X}$ oznaczają 4 kolejne pary danych wejściowych. Implikuje to postać równań macierzowych, w których np. mamy mnożenie macierzy ${\displaystyle X}$ przez macierz transponowaną ${\displaystyle W^{T}}$, tj. ${\displaystyle XW^{T}}$, zamiast ${\displaystyle WX}$, jak to jest tradycyjnie w opisie działania neuronów, gdy w jednym kroku iteracji wykonuje się obliczenia na pojedynczych danych wejściowych (por. przykład kodu programu w artykule perceptron). Dalej, rozszerzenia wektorów do postaci macierzy wymagają działania na biasach neuronów; w programie nie dokonuje się tego rozszerzenia, ale korzysta się z implementowanego w języku Python domyślnego rozszerzenia wektorów do postaci macierzy, tzw. broadcasting, dlatego nie pokazano tutaj jawnie tego rozszerzenia. Także sumaryczne sygnały w dwóch neuronach warstwy ukrytej sieci są zapisywane teraz nie w wektorze 2-elementowym, ale w macierzy ${\displaystyle H}$ o wymiarze 4x2, w której poszczególnym wierszom odpowiadają sumaryczne sygnały w neuronach wywołane przez kolejne pary danych wejściowych. W końcu sygnał wyjściowy z sieci ma postać macierzy ${\displaystyle Y}$ wymiaru 4x1 - poszczególne 4 wiersze tej macierzy oznaczają wartości wyjściowe z sieci, w odpowiedzi na 4 poszczególne pary danych wejściowych.