Lære Utfordring: Trening av Perseptronen

Seksjon 1. Kapittel 17

single

Sveip for å vise menyen

Før du går videre med å trene perseptronen, husk at den bruker binær kryssentropi-tapfunksjonen som ble diskutert tidligere. Det siste nøkkelkonseptet før implementering av tilbakepropagering er formelen for den deriverte av denne tapfunksjonen med hensyn til utgangsaktiveringene, $a^n$. Nedenfor er formlene for tapfunksjonen og dens deriverte:

\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 å verifisere at perseptronen trenes korrekt, skriver fit()-metoden også ut gjennomsnittlig tap ved hver epoke. Dette beregnes ved å ta gjennomsnittet av tapet over alle treningsdata i den aktuelle 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))

Til slutt er formlene for å beregne 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}

Implementasjonsdetaljer å huske på

Når du oversetter disse formlene til Python-kode for backward()-metoden, husk NumPy-operasjonene som ble diskutert i de forrige kapitlene:

Operatoren $\odot$ betegner elementvis multiplikasjon, som utføres med standard *-operator i Python.
Operatoren $\cdot$ betegner et skalarprodukt, implementert med funksjonen np.dot().
Superskriptet $T$ betegner en matrise-transponering, håndteres med attributtet .T.
For å beregne $f'^l(z^l)$ , kan du dynamisk kalle den deriverte av lagets aktiveringsfunksjon med self.activation.derivative(self.outputs).

Dette gir den generelle strukturen til backward()-metoden slik:

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åte, når du setter alt sammen i fit()-metoden, må du huske at du må iterere bakover gjennom nettverket for å propagere feilen. Den generelle strukturen ser slik ut:

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

Eksempeldata for trening (X_train) sammen med tilhørende etiketter (y_train) er lagret som NumPy-arrays i utils.py-filen. I tillegg er instanser av aktiveringsfunksjonene også definert der:

relu = ReLU()
sigmoid = Sigmoid()

Oppgave

Sveip for å begynne å kode

Målet ditt er å fullføre treningsprosessen for en flerlags perceptron ved å implementere tilbakepropagering og oppdatere modellparametrene.

Følg disse trinnene nøye:

Implementer backward()-metoden i Layer-klassen:

Beregn følgende gradienter:
- dz: den deriverte av tapet med hensyn til pre-aktiveringsverdiene, ved å bruke den deriverte av aktiveringsfunksjonen;
- d_weights: gradienten av tapet med hensyn til vektene, beregnet som prikkproduktet av dz og den transponerte input-vektoren;
d_biases: gradienten av tapet med hensyn til biasene, lik dz;
da_prev: gradienten av tapet med hensyn til aktiveringene i forrige lag, oppnådd ved å multiplisere den transponerte vektmatrisen med dz.
Oppdater vektene og biasene ved hjelp av læringsraten.

Fullfør fit()-metoden i Perceptron-klassen:
- Beregn modellens output ved å kalle forward()-metoden;
- Beregn tapet ved å bruke kryssentropi-formelen;

Beregn $da^n$ $d a^{n}$ — den deriverte av tapet med hensyn til utgangsaktiveringene;
- Gå bakover gjennom lagene og utfør tilbakepropagering ved å kalle hver lag sin backward()-metode.

Kontroller treningsatferden:

Hvis alt er implementert korrekt, skal tapet jevnt synke for hver epoke når du bruker en læringsrate på 0.01.

Løsning

Bytt til skrivebordet for virkelighetspraksisFortsett der du er med et av alternativene nedenfor

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 17

single

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår