Å trene et nevralt nettverk innebærer en iterativ prosess der modellen gradvis forbedres ved å justere sine vekter og biaser for å minimere tapfunksjonen. Denne prosessen kalles gradientbasert optimalisering, og følger en strukturert algoritme.

Generell algoritme

Datasettet føres først gjennom nettverket flere ganger i en løkke, der hver komplette gjennomgang kalles en epoke. Under hver epoke blir dataene stokket for å forhindre at modellen lærer mønstre basert på rekkefølgen av treningsdataene. Stokking bidrar til å introdusere tilfeldighet, noe som gir en mer robust modell.

For hvert trenings-eksempel utfører modellen fremoverpropagering, der inputene passerer gjennom nettverket, lag for lag, og produserer en utdata. Denne utdataen sammenlignes deretter med den faktiske målverdien for å beregne tapet.

Deretter anvender modellen tilbakepropagering og oppdaterer vektene og biasene i hvert lag for å redusere tapet.

Denne prosessen gjentas over flere epoker, slik at nettverket gradvis kan finjustere sine parametere. Etter hvert som treningen skrider frem, lærer nettverket å gjøre stadig mer presise prediksjoner. Nøye justering av hyperparametere som læringsrate er imidlertid avgjørende for å sikre stabil og effektiv trening.

Læringsraten ($\alpha$) bestemmer steglengden ved oppdatering av vekter. Hvis den er for høy, kan modellen overskyte de optimale verdiene og ikke konvergere. Hvis den er for lav, går treningen sakte og kan sette seg fast i en suboptimal løsning. Å velge en passende læringsrate balanserer hastighet og stabilitet under trening. Typiske verdier varierer fra 0.001 til 0.1, avhengig av problemstilling og nettverksstørrelse.

Grafen under viser hvordan en passende læringsrate gjør at tapet reduseres jevnt i et optimalt tempo:

Til slutt spiller stokastisk gradientnedstigning (SGD) en viktig rolle for treningseffektiviteten. I stedet for å beregne vektoppdateringer etter å ha behandlet hele datasettet, oppdaterer SGD parameterne etter hvert enkelt eksempel. Dette gjør treningen raskere og introduserer små variasjoner i oppdateringene, noe som kan hjelpe modellen å unnslippe lokale minima og oppnå en bedre total løsning.

fit()-metoden

Metoden fit() i klassen Perceptron har ansvaret for å trene modellen ved hjelp av stokastisk gradientnedstigning.

def fit(self, training_data, labels, epochs, learning_rate):
    # Iterating over multiple epochs
    for epoch in range(epochs):
        # Shuffling the data  
        indices = np.random.permutation(training_data.shape[0])
        training_data = training_data[indices]
        labels = labels[indices]
        # Iterating through each training example
        for i in range(training_data.shape[0]):
            inputs = training_data[i, :].reshape(-1, 1)
            target = labels[i, :].reshape(-1, 1)

            # Forward propagation
            output = ...

            # Computing the gradient of the loss function w.r.t. output
            da = ...

            # Backward propagation through all layers
            for layer in self.layers[::-1]:
                da = ...