Lære Udfordring: Træning af Perceptronen

Sektion 1. Kapitel 17

single

Stryg for at vise menuen

Inden du fortsætter med at træne perceptronen, skal du huske, at den anvender binary cross-entropy tab-funktionen, som tidligere er blevet gennemgået. Det sidste centrale begreb, inden implementering af backpropagation, er formlen for afledte af denne tab-funktion med hensyn til output-aktiveringerne, $a^n$. Nedenfor ses formlerne for tab-funktionen og dens afledte:

\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}

hvor $a^n = \hat{y}$

For at verificere, at perceptronen trænes korrekt, udskriver fit()-metoden også gennemsnitligt tab ved hver epoke. Dette beregnes ved at tage gennemsnittet af tabet over alle træningseksempler i den pågældende epoke:

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))

Endelig er formlerne til beregning af gradienter i hvert lag som følger:

\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}

Implementeringsdetaljer at huske

Ved oversættelse af disse formler til Python-kode for backward()-metoden, skal du huske de NumPy-operationer, der er gennemgået i de foregående kapitler:

Operatoren $\odot$ angiver elementvis multiplikation, hvilket udføres med den almindelige *-operator i Python.
Operatoren $\cdot$ angiver et dot-produkt, som implementeres med funktionen np.dot().
Superskriptet $T$ angiver en matrixtransponering, som håndteres med attributten .T.
For at beregne $f'^l(z^l)$ kan du dynamisk kalde afledte af lagets aktiveringsfunktion med self.activation.derivative(self.outputs).

Dette giver den generelle struktur for backward()-metoden følgende udseende:

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å samme måde, når alt samles i fit()-metoden, skal du huske, at du skal iterere gennem netværket baglæns for at propagere fejlen. Den generelle struktur ser således ud:

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

De eksemplariske træningsdata (X_train) sammen med de tilsvarende labels (y_train) er gemt som NumPy-arrays i filen utils.py. Derudover er instanser af aktiveringsfunktionerne også defineret der:

relu = ReLU()
sigmoid = Sigmoid()

Opgave

Swipe to start coding

Dit mål er at fuldføre træningsprocessen for en multilags perceptron ved at implementere backpropagation og opdatere modelparametrene.

Følg disse trin nøje:

Implementér backward()-metoden i Layer-klassen:

Beregn følgende gradienter:
dz: afledt af tabet med hensyn til præaktiveringsværdierne, ved brug af den afledte af aktiveringsfunktionen;
d_weights: gradient af tabet med hensyn til vægtene, beregnet som prikproduktet af dz og den transponerede inputvektor;
d_biases: gradient af tabet med hensyn til bias, lig med dz;
da_prev: gradient af tabet med hensyn til aktiveringerne fra det forrige lag, opnået ved at multiplicere den transponerede vægtmatrix med dz.
Opdater vægte og bias ved hjælp af læringsraten.

Fuldfør fit()-metoden i Perceptron-klassen:
- Beregn modeloutput ved at kalde forward()-metoden;

Beregn tabet ved hjælp af krydsentropiformlen;
Beregn $da^n$ $d a^{n}$ — den afledte af tabet med hensyn til outputaktiveringerne;
- Gå baglæns gennem lagene og udfør backpropagation ved at kalde hvert lags backward()-metode.

Kontrollér træningsadfærden:

Hvis alt er implementeret korrekt, bør tabet falde støt for hver epoke, når der bruges en læringsrate på 0.01.

Løsning

Skift til skrivebord for at øve i den virkelige verdenFortsæt der, hvor du er, med en af nedenstående muligheder

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 17

single

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat