Lära Utmaning: Träna Perceptronen

Avsnitt 1. Kapitel 17

single

Svep för att visa menyn

Innan du fortsätter med att träna perceptronen, kom ihåg att den använder binär korsentropiförlustfunktion som diskuterats tidigare. Det sista viktiga begreppet innan implementering av backpropagation är formeln för derivatan av denna förlustfunktion med avseende på utgångsaktiveringar, $a^n$. Nedan visas formlerna för förlustfunktionen och dess derivata:

\begin{aligned} L &= -(y \log(\hat{y}) + (1-y) \log(1 - \hat{y}))\\ da^n &= \frac {\hat{y} - y} {\hat{y}(1 - \hat{y})} \end{aligned}

Där $a^n = \hat{y}$

För att verifiera att perceptronen tränas korrekt skriver metoden fit() även ut genomsnittlig förlust vid varje epok. Detta beräknas genom att ta medelvärdet av förlusten över alla träningsdata i den epoken:

for epoch in range(epochs):
    loss = 0

    for i in range(training_data.shape[0]):
        loss += -(target * np.log(output) + (1 - target) * np.log(1 - output))

average_loss = loss[0, 0] / training_data.shape[0]
print(f'Loss at epoch {epoch + 1}: {average_loss:.3f}')

L = -\frac1N \sum_{i=1}^N (y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i))

Slutligen är formlerna för att beräkna gradienter i varje lager följande:

\begin{aligned} dz^l &= da^l \odot f'^l(z^l)\\ dW^l &= dz^l \cdot (a^{l-1})^T\\ db^l &= dz^l\\ da^{l-1} &= (W^l)^T \cdot dz^l \end{aligned}

Implementationsdetaljer att komma ihåg

Vid översättning av dessa formler till Python-kod för metoden backward(), kom ihåg NumPy-operationerna som diskuterats i tidigare kapitel:

Operatorn $\odot$ betecknar elementvis multiplikation, vilket görs med den vanliga *-operatorn i Python.
Operatorn $\cdot$ betecknar en skalärprodukt, implementerad med funktionen np.dot().
Superskriptet $T$ betecknar en matristransponering, hanteras med attributet .T.
För att beräkna $f'^l(z^l)$ kan du dynamiskt anropa derivatan av lagrets aktiveringsfunktion med self.activation.derivative(self.outputs).

Detta gör att den generella strukturen för metoden backward() ser ut så här:

def backward(self, da, learning_rate):
    dz = ... # using da and self.activation.derivative()
    d_weights = ... # using np.dot() and .T
    d_biases = ...
    da_prev = ...

    self.weights -= learning_rate * d_weights
    self.biases -= learning_rate * d_biases

    return da_prev

På samma sätt, när allt sätts ihop i fit()-metoden, kom ihåg att du behöver iterera genom nätverket baklänges för att sprida felet. Den allmänna strukturen ser ut så här:

def fit(self, training_data, labels, epochs, learning_rate):
    # ... (Epoch loop and data shuffling) ...
            # Forward propagation
            output = ...

            # Computing the gradient of the loss function w.r.t. output (da^n)
            da = ...

            # Backward propagation through all layers
            for layer in self.layers[::-1]:
                da = ... # Call the backward() method of the layer

Exempeldata för träning (X_train) tillsammans med motsvarande etiketter (y_train) lagras som NumPy-arrayer i filen utils.py. Dessutom är instanser av aktiveringsfunktionerna också definierade där:

relu = ReLU()
sigmoid = Sigmoid()

Uppgift

Svep för att börja koda

Målet är att slutföra träningsprocessen för en flerskiktsperceptron genom att implementera backpropagation och uppdatera modellparametrarna.

Följ dessa steg noggrant:

Implementera metoden backward() i klassen Layer:

Beräkna följande gradienter:
- dz: derivatan av förlusten med avseende på pre-aktiveringsvärdena, med hjälp av derivatan av aktiveringsfunktionen;
d_weights: gradienten av förlusten med avseende på vikterna, beräknad som skalärprodukten av dz och den transponerade inmatningsvektorn;
d_biases: gradienten av förlusten med avseende på bias, lika med dz;
da_prev: gradienten av förlusten med avseende på aktiveringen i föregående lager, erhållen genom att multiplicera den transponerade viktmatrisen med dz.
Uppdatera vikter och bias med hjälp av inlärningshastigheten.

Slutför metoden fit() i klassen Perceptron:

Beräkna modellens utdata genom att anropa metoden forward();
Beräkna förlusten med hjälp av korsentropiformeln;
Beräkna $da^n$ $d a^{n}$ — derivatan av förlusten med avseende på utdataaktiveringen;
- Loopa bakåt genom lagren och utför backpropagation genom att anropa varje lagers backward()-metod.

Kontrollera träningsbeteendet:

Om allt är korrekt implementerat bör förlusten stadigt minska för varje epok när en inlärningshastighet på 0.01 används.

Lösning

Byt till skrivbordet för praktisk övningFortsätt där du är med ett av alternativen nedan

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 17

single

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal