Å trene et nevralt nettverk innebærer en iterativ prosess der modellen gradvis forbedres ved å justere sine vekter og biaser for å minimere tapsfunksjonen. 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 output. Denne outputen 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. Imidlertid er nøye justering av hyperparametere som læringsrate avgjørende for å sikre stabil og effektiv trening.

Læringsraten ($\alpha$) bestemmer steglengden ved oppdatering av vekter. Dersom den er for høy, kan modellen overskyte de optimale verdiene og ikke konvergere. Dersom den er for lav, blir treningen treg og kan sette seg fast i en suboptimal løsning. Valg av 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 treningseffektivitet. I stedet for å beregne vektoppdateringer etter å ha prosessert 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

fit()-metoden i Perceptron-klassen har ansvar for å trene modellen ved bruk 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 = ...