Modelltrening

Å 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 om for å forhindre at modellen lærer mønstre basert på rekkefølgen av treningsdataene. Omstokking bidrar til å introdusere tilfeldighet, noe som gir en mer robust modell.

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

Deretter bruker modellen backpropagation og oppdaterer vektene og biasene i hvert lag for å redusere tapet.

Denne prosessen gjentas over flere epoker, slik at nettverket gradvis kan forbedre parameterne sine. 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, blir treningen treg 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 avgjørende rolle for trenings­effektiviteten. 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 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 = ...