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 forrige output som sin eneste parameter, mens resten af den nødvendige information er gemt 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 sin parameter. Resten af den 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 struktureres som klasser i stedet for selvstændige funktioner. Dette gør det muligt at definere både:

Selve aktiveringsfunktionen (implementeret via __call__()-metoden), så den kan anvendes direkte i Layer-klassen ved brug af self.activation(z);
Dens afledte (implementeret via derivative()-metoden), hvilket muliggør effektiv tilbagepropagering og bruges i Layer-klassen som self.activation.derivative(z).

Ved at strukturere aktiveringsfunktioner som objekter kan de nemt videregives til Layer-klassen og bruges dynamisk.

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 disse aktiveringsfunktioner anvendes de på hele vektoren $z$ , og det samme gælder for deres afledte. NumPy anvender internt operationen på hvert element i vektoren. For eksempel, hvis vektoren $z$ indeholder 3 elementer, er udledningen som følger:

f'(z) = f'( \begin{bmatrix} z_1\\ z_2\\ z_3 \end{bmatrix} ) = \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 biaser 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

Awesome!

Completion rate improved to 4

Stryg for at vise menuen