Oppiskele Takaisinkytkennän Toteutus | Neuroverkon Rakentaminen Alusta Alkaen

Pyyhkäise näyttääksesi valikon

Yleinen lähestymistapa

Eteenpäinlevityksessä jokainen kerros $l$ ottaa edellisen kerroksen $a^{l-1}$ tuottamat arvot syötteenä ja laskee omat lähtönsä. 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 esiactivaatioiden vektorin $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 jatkolaskentaan:

\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. Attribuutti .T transponoi taulukon.

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 2. Luku 8

Kysy tekoälyä

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

Osio 2. Luku 8