Lære Implementering af Backpropagation | Neuralt Netværk fra Bunden

Generel tilgang

Ved fremadpropagering tager hvert lag $l$ outputtet fra det forrige lag, $a^{l-1}$ , som input og beregner sit eget output. Derfor tager forward()-metoden i Layer-klassen vektoren af tidligere output som sin eneste parameter, mens resten af den nødvendige information gemmes i klassen.

Ved tilbagepropagering behøver hvert lag $l$ kun $da^l$ for at beregne de respektive gradienter og returnere $da^{l-1}$ , så backward()-metoden tager $da^l$ -vektoren som parameter. Den resterende nødvendige information er allerede gemt i Layer-klassen.

Afledte af aktiveringsfunktioner

Da afledte af aktiveringsfunktioner er nødvendige for tilbagepropagering, bør aktiveringsfunktioner som ReLU og sigmoid implementeres som klasser i stedet for selvstændige funktioner. Denne struktur gør det muligt at definere begge komponenter tydeligt:

Selve aktiveringsfunktionen — implementeret ved hjælp af __call__()-metoden, så den kan anvendes direkte i Layer-klassen med self.activation(z);
Dens afledte — implementeret ved hjælp af derivative()-metoden, hvilket muliggør effektiv beregning under tilbagepropagering via self.activation.derivative(z).

Repræsentation af aktiveringsfunktioner som objekter gør det nemt at videregive dem til forskellige lag og anvende dem dynamisk under både fremad- og tilbagepropagering.

ReLu

Den afledte af ReLU-aktiveringsfunktionen er som følger, hvor $z_i$ er et element i vektoren af 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

Afledte af sigmoid aktiveringsfunktion 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 aktiveringsfunktioner anvendes operationen på hele vektoren $z$ samt på dens afledte. NumPy udfører automatisk beregningen elementvist, hvilket betyder, at hvert element i vektoren behandles uafhængigt.

For eksempel, hvis vektoren $z$ indeholder tre elementer, beregnes den afledte som:

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 af gradienterne ved hjælp af formlerne nedenfor:

\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$ gemmes som henholdsvis attributterne inputs og outputs i klassen Layer. Aktiveringsfunktionen $f$ gemmes som attributten activation.

Når alle nødvendige gradienter er beregnet, kan vægte og biases opdateres, da de ikke længere er nødvendige for yderligere beregning:

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

Derfor er learning_rate ( $\alpha$ ) en anden parameter for denne metode.

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

Bemærk

*-operatoren udfører elementvis multiplikation, mens funktionen np.dot() udfører dot-produkt i NumPy. Attributten .T transponerer et array.

Var alt klart?

Tak for dine kommentarer!

Sektion 2. Kapitel 8

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

Stryg for at vise menuen