Att träna ett neuralt nätverk innebär en iterativ process där modellen gradvis förbättras genom att justera sina vikter och bias för att minimera förlustfunktionen. Denna process kallas gradientbaserad optimering och följer en strukturerad algoritm.

Allmän algoritm

Datasettet förs först genom nätverket flera gånger i en slinga, där varje fullständig genomgång kallas en epok. Under varje epok blandas data för att förhindra att modellen lär sig mönster baserat på ordningen av träningsdata. Blandning bidrar till att införa slumpmässighet, vilket leder till en mer robust modell.

För varje träningsdataexempel utför modellen framåtpropagering, där indata passerar genom nätverket, lager för lager, och genererar ett utdata. Detta utdata jämförs sedan med det faktiska målvärdet för att beräkna förlusten.

Därefter tillämpar modellen backpropagering och uppdaterar vikter och bias i varje lager för att minska förlusten.

Denna process upprepas under flera epoker, vilket gör att nätverket gradvis kan förfina sina parametrar. När träningen fortskrider lär sig nätverket att göra alltmer korrekta prediktioner. Noggrann justering av hyperparametrar såsom inlärningshastighet är dock avgörande för att säkerställa stabil och effektiv träning.

Inlärningshastigheten ($\alpha$) bestämmer steglängden vid viktuppdateringar. Om den är för hög kan modellen överskrida de optimala värdena och misslyckas med att konvergera. Om den är för låg blir träningen långsam och kan fastna i en suboptimal lösning. Ett lämpligt val av inlärningshastighet balanserar hastighet och stabilitet under träningen. Typiska värden ligger mellan 0.001 och 0.1, beroende på problem och nätverksstorlek.

Diagrammet nedan visar hur en lämplig inlärningshastighet möjliggör att förlusten minskar stadigt i optimal takt:

Slutligen spelar stokastisk gradientnedstigning (SGD) en avgörande roll för träningseffektiviteten. Istället för att beräkna viktuppdateringar efter att hela datamängden bearbetats, uppdaterar SGD parametrarna efter varje enskilt exempel. Detta gör träningen snabbare och introducerar små variationer i uppdateringarna, vilket kan hjälpa modellen att undvika lokala minima och nå en bättre övergripande lösning.

Metoden fit()

Metoden fit() i klassen Perceptron ansvarar för att träna modellen med hjälp 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 = ...