Lære Implementering av Backpropagation | Nevralt Nettverk fra Bunnen Av

Generell tilnærming

Ved fremoverpropagering tar hvert lag $l$ utgangene fra forrige lag, $a^{l-1}$ , som input og beregner sine egne utganger. Derfor tar forward()-metoden i Layer-klassen vektoren av forrige utganger 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

Derivatet av ReLU-aktiveringsfunksjonen er som følger, der $z_i$ er et element i vektoren av pre-aktiveringer $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

Derivert 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 blir operasjonen brukt på hele vektoren $z$ , samt på dens derivert. NumPy utfører automatisk 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() er ansvarlig for beregning av gradientene ved hjelp av 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 skalarprodukt i NumPy. Attributtet .T transponerer et array.

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 2. Kapittel 8

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

Awesome!

Completion rate improved to 4

Sveip for å vise menyen