Het trainen van een neuraal netwerk omvat een iteratief proces waarbij het model zich geleidelijk verbetert door zijn gewichten en biases aan te passen om de verliesfunctie te minimaliseren. Dit proces staat bekend als gradiënt-gebaseerde optimalisatie en volgt een gestructureerd algoritme.

Algemeen algoritme

De dataset wordt eerst meerdere keren door het netwerk gehaald in een lus, waarbij elke volledige doorgang een epoch wordt genoemd. Tijdens elke epoch worden de gegevens geschud om te voorkomen dat het model patronen leert op basis van de volgorde van de trainingsvoorbeelden. Schudden helpt om willekeur te introduceren, wat leidt tot een robuuster model.

Voor elk trainingsvoorbeeld voert het model voorwaartse propagatie uit, waarbij invoer laag voor laag door het netwerk gaat en een uitvoer oplevert. Deze uitvoer wordt vervolgens vergeleken met de werkelijke doelwaarde om het verlies te berekenen.

Vervolgens past het model backpropagatie toe en worden de gewichten en biases in elke laag bijgewerkt om het verlies te verminderen.

Dit proces wordt herhaald voor meerdere epochs, waardoor het netwerk zijn parameters geleidelijk kan verfijnen. Naarmate de training vordert, leert het netwerk steeds nauwkeurigere voorspellingen te doen. Het zorgvuldig afstemmen van hyperparameters zoals het leerpercentage is echter cruciaal om een stabiele en efficiënte training te waarborgen.

Het leerpercentage ($\alpha$) bepaalt de stapgrootte bij het bijwerken van de gewichten. Als het te hoog is, kan het model de optimale waarden overschrijden en niet convergeren. Als het te laag is, verloopt de training traag en kan het vastlopen in een suboptimale oplossing. Het kiezen van een geschikt leerpercentage balanceert snelheid en stabiliteit tijdens de training. Typische waarden liggen tussen 0.001 en 0.1, afhankelijk van het probleem en de netwerkomvang.

De onderstaande grafiek toont hoe een geschikt leerpercentage het verlies gestaag laat afnemen met een optimaal tempo:

Tot slot speelt stochastische gradient descent (SGD) een essentiële rol in de efficiëntie van het trainen. In plaats van gewichten bij te werken na verwerking van de volledige dataset, werkt SGD de parameters bij na elk individueel voorbeeld. Dit maakt de training sneller en introduceert kleine variaties in de updates, wat het model kan helpen lokale minima te ontwijken en een betere algehele oplossing te bereiken.

De fit()-methode

De fit()-methode in de Perceptron-klasse is verantwoordelijk voor het trainen van het model met behulp van stochastische gradient descent.

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