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

Suggested prompts:

Can you explain how the backward() method uses the stored attributes in the Layer class?

What is the purpose of the derivative() method in the activation function classes?

Could you provide an example of how forward and backward propagation work together in a simple neural network?

Awesome!

Completion rate improved to 4

Sveip for å vise menyen