Modellträning

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 passerar först genom nätverket flera gånger i en slinga, där varje komplett genomgång kallas en epok. Under varje epok blandas datan för att förhindra att modellen lär sig mönster baserat på ordningen av träningsdata. Blandning hjälper till att introducera slumpmässighet, vilket leder till en mer robust modell.

För varje träningsdataexempel utför modellen framåtriktad propagiering, där indata passerar genom nätverket, lager för lager, och producerar 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 backpropagation 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. Under träningens gång lär sig nätverket att göra alltmer träffsäkra 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. Att välja en lämplig 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 gör att förlusten kan minska stadigt i optimal takt:

Slutligen spelar stokastisk gradientnedstigning (SGD) en avgörande roll för tränings­effektiviteten. 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.

fit()-metoden

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 = ...