Lære Implementering av Tilbakepropagering

Sveip for å vise menyen

Generell tilnærming

Ved fremoverpropagering tar hvert lag $l$ utdataene fra forrige lag, $a^{l-1}$ , som inndata og beregner sine egne utdata. Derfor tar forward()-metoden i Layer-klassen vektoren av forrige utdata som eneste parameter, mens resten av nødvendig informasjon lagres i klassen.

Ved bakoverpropagering trenger hvert lag $l$ kun $da^l$ for å beregne de respektive gradientene og returnere $da^{l-1}$ , så backward()-metoden tar $da^l$ -vektoren som parameter. Resten av nødvendig informasjon er allerede lagret i Layer-klassen.

Derivater av aktiveringsfunksjoner

Siden derivater av aktiveringsfunksjoner er nødvendige for bakoverpropagering, bør aktiveringsfunksjoner som ReLU og sigmoid implementeres som klasser i stedet for frittstående funksjoner. Denne strukturen gjør det mulig å definere begge komponentene tydelig:

Selve aktiveringsfunksjonen — implementert med __call__()-metoden, slik at den kan brukes direkte i Layer-klassen med self.activation(z);
Dens derivat — implementert med derivative()-metoden, som gir effektiv beregning under bakoverpropagering via self.activation.derivative(z).

Å representere aktiveringsfunksjoner som objekter gjør det enkelt å sende dem til ulike lag og bruke dem dynamisk under både fremover- og bakoverpropagering.

ReLu

Derivaten til ReLU-aktiveringsfunksjonen er som følger, der $z_i$ er et element i vektoren av preaktiveringer $z$ :

f'(z_i) = \begin{cases} 1, z_i > 0\\ 0, z_i \le 0 \end{cases}

class ReLU:
    def __call__(self, z):
        return np.maximum(0, z)

    def derivative(self, z):
        return (z > 0).astype(float)

Sigmoid

Den deriverte av sigmoid aktiveringsfunksjon er som følger:

f'(z_i) = f(z_i) \cdot (1 - f(z_i))

class Sigmoid:
    def __call__(self, x):
        return 1 / (1 + np.exp(-z))

    def derivative(self, z):
        sig = self(z)
        return sig * (1 - sig)

For begge aktiveringsfunksjonene brukes operasjonen på hele vektoren $z$ , samt på dens deriverte. NumPy utfører beregningen elementvis, noe som betyr at hvert element i vektoren behandles uavhengig.

For eksempel, hvis vektoren $z$ inneholder tre elementer, beregnes den deriverte slik:

f'(z) = f'\left( \begin{bmatrix} z_1\\ z_2\\ z_3 \end{bmatrix} \right) = \begin{bmatrix} f'(z_1)\\ f'(z_2)\\ f'(z_3) \end{bmatrix}

Metoden backward()

Metoden backward() har ansvaret for å beregne gradientene ved å bruke følgende formler:

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

a^{l-1} og $z^l$ lagres som henholdsvis inputs og outputs attributter i Layer-klassen. Aktiveringsfunksjonen $f$ lagres som attributtet activation.

Når alle nødvendige gradienter er beregnet, kan vektene og biasene oppdateres siden de ikke lenger trengs for videre beregning:

\begin{aligned} W^l &= W^l - \alpha \cdot dW^l\\ b^l &= b^l - \alpha \cdot db^l \end{aligned}

Dermed er learning_rate ( $\alpha$ ) en annen parameter for denne metoden.

def backward(self, da, learning_rate):
    dz = ...
    d_weights = ...
    d_biases = ...
    da_prev = ...

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

    return da_prev

Merk

Operatoren * utfører elementvis multiplikasjon, mens funksjonen np.dot() utfører dot-produkt i NumPy. Attributtet .T transponerer et array.

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 15

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

Seksjon 1. Kapittel 15