Pyyhkäise näyttääksesi valikon

Yleinen lähestymistapa

Eteenpäin suuntautuvassa laskennassa jokainen kerros $l$ ottaa edellisen kerroksen tuottamat arvot, $a^{l-1}$ , syötteenä ja laskee omat lähtöarvonsa. Tämän vuoksi forward()-luokan Layer-metodi ottaa edellisen kerroksen lähtöarvovektorin ainoana parametrinaan, kun taas muu tarvittava tieto on tallennettu luokan sisälle.

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

Aktivointifunktioiden derivaatat

Koska aktivointifunktioiden derivaattoja tarvitaan taaksepäin suuntautuvassa laskennassa, aktivointifunktiot kuten ReLU ja sigmoid kannattaa 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äin suuntautuvassa vaiheessa self.activation.derivative(z).

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

ReLu

ReLU-aktivointifunktion derivaatta on seuraava, missä $z_i$ on vektorin $z$ esiaktivaatioiden 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)

Molempien aktivointifunktioiden kohdalla operaatio suoritetaan koko vektorille $z$ sekä sen derivaatalle. 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}

Siksi learning_rate ( $\alpha$ ) on toinen tämän menetelmän 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 funktio np.dot() suorittaa dot-tulon 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

Takaisinkytkennän Toteutus