Lära Implementering av Backpropagation | Neuronnätverk Från Grunden

Allmän metod

Vid framåtriktad propagiering tar varje lager $l$ utdata från föregående lager, $a^{l-1}$ , som indata och beräknar sina egna utdata. Därför tar metoden forward() i klassen Layer vektorn av föregående utdata som sin enda parameter, medan övrig nödvändig information lagras inom klassen.

Vid bakåtriktad propagiering behöver varje lager $l$ endast $da^l$ för att beräkna respektive gradienter och returnera $da^{l-1}$ , så metoden backward() tar vektorn $da^l$ som parameter. Resterande nödvändig information finns redan lagrad i klassen Layer.

Derivator av aktiveringsfunktioner

Eftersom derivator av aktiveringsfunktioner krävs för bakåtriktad propagiering bör aktiveringsfunktioner som ReLU och sigmoid implementeras som klasser istället för fristående funktioner. Denna struktur gör det möjligt att tydligt definiera båda komponenterna:

Själva aktiveringsfunktionen — implementerad med metoden __call__(), så att den kan tillämpas direkt i klassen Layer med self.activation(z);
Dess derivata — implementerad med metoden derivative(), vilket möjliggör effektiv beräkning under bakåtriktad propagiering via self.activation.derivative(z).

Att representera aktiveringsfunktioner som objekt gör det enkelt att överföra dem till olika lager och tillämpa dem dynamiskt under både framåt- och bakåtriktad propagiering.

ReLu

Derivatan av ReLU-aktiveringsfunktionen är följande, där $z_i$ är ett element i vektorn av pre-aktiveringar $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

Derivatan av sigmoidaktiveringsfunktionen är följande:

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)

För båda aktiveringsfunktionerna tillämpas operationen på hela vektorn $z$ , samt på dess derivata. NumPy utför automatiskt beräkningen elementvis, vilket innebär att varje element i vektorn behandlas oberoende.

Till exempel, om vektorn $z$ innehåller tre element, beräknas derivatan 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}

backward()-metoden

Metoden backward() ansvarar för beräkning av gradienterna med hjälp av formlerna nedan:

\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} och $z^l$ lagras som attributen inputs respektive outputs i klassen Layer. Aktiveringsfunktionen $f$ lagras som attributet activation.

När alla nödvändiga gradienter har beräknats kan vikter och bias uppdateras eftersom de inte längre behövs för vidare beräkning:

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

Därför är learning_rate ( $\alpha$ ) en annan parameter för denna metod.

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

Notering

*-operatorn utför elementvis multiplikation, medan funktionen np.dot() utför skalärprodukt i NumPy. Attributet .T transponerar en array.

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 8

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

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

Svep för att visa menyn