Oppiskele Takaisinkytkennän Toteutus | Neuroverkon Rakentaminen Alusta Alkaen

Yleinen lähestymistapa

Eteenpäinlevityksessä jokainen kerros $l$ ottaa edellisen kerroksen tuottamat lähtötiedot, $a^{l-1}$ , syötteenä ja laskee omat lähtötietonsa. Tämän vuoksi forward()-luokan Layer-metodi ottaa edellisen kerroksen lähtövektorin ainoana parametrinaan, kun taas muu tarvittava tieto säilytetään luokan sisällä.

Taaksepäinlevityksessä jokainen kerros $l$ tarvitsee vain $da^l$ laskeakseen vastaavat gradientit ja palauttaakseen $da^{l-1}$ , joten backward()-metodi ottaa $da^l$ -vektorin parametrinaan. Loput tarvittavat tiedot ovat jo tallennettuina Layer-luokkaan.

Aktivointifunktioiden derivaatat

Koska aktivointifunktioiden derivaattoja tarvitaan taaksepäinlevityksessä, aktivointifunktiot kuten ReLU ja sigmoid tulisi toteuttaa luokkina erillisten funktioiden sijaan. Tämä rakenne mahdollistaa molempien osien selkeän määrittelyn:

Varsinainen aktivointifunktio — toteutetaan __call__()-metodilla, jolloin sitä voidaan käyttää suoraan Layer-luokassa muodossa self.activation(z);
Sen derivaatta — toteutetaan derivative()-metodilla, mikä mahdollistaa tehokkaan laskennan taaksepäinlevityksen aikana self.activation.derivative(z).

Aktivointifunktioiden esittäminen olioina helpottaa niiden siirtämistä eri kerroksiin ja dynaamista käyttöä sekä eteen- että taaksepäinlevityksessä.

ReLu

ReLU-aktivointifunktion derivaatta on seuraava, missä $z_i$ on esiaaktivointivektorin $z$ alkio:

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

Sigmoid-aktivointifunktion derivaatta on seuraava:

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)

Molemmissa aktivointifunktioissa operaatio kohdistetaan koko vektoriin $z$ sekä sen derivaattaan. NumPy suorittaa laskennan alkiokohtaisesti, eli jokainen vektorin alkio käsitellään itsenäisesti.

Esimerkiksi, jos vektori $z$ sisältää kolme alkiota, derivaatta lasketaan seuraavasti:

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()-metodi

backward()-metodi vastaa gradienttien laskemisesta alla olevien kaavojen mukaisesti:

\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} ja $z^l$ tallennetaan inputs- ja outputs-attribuutteihin Layer-luokassa. Aktivointifunktio $f$ tallennetaan activation-attribuuttiin.

Kun kaikki tarvittavat gradientit on laskettu, painot ja biasit voidaan päivittää, koska niitä ei enää tarvita jatkolaskennassa:

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

Täten learning_rate ( $\alpha$ ) on toinen tämän metodin parametri.

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

Huomio

*-operaattori suorittaa alkiokohtaisen kertolaskun, kun taas np.dot()-funktio suorittaa pistetulon NumPyssa. .T-attribuutti transponoi taulukon.

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 2. Luku 8

Kysy tekoälyä

Kysy mitä tahansa tai kokeile jotakin ehdotetuista kysymyksistä aloittaaksesi keskustelumme

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

Pyyhkäise näyttääksesi valikon