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 gradient-based optimization en volgt een gestructureerd algoritme.

Algemeen algoritme

De dataset wordt eerst meerdere keren in een lus door het netwerk gehaald, 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 forward propagation uit, waarbij invoer laag voor laag door het netwerk gaat en een output produceert. Deze output wordt vervolgens vergeleken met de werkelijke doelwaarde om het verlies te berekenen.

Vervolgens past het model backpropagation 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 de learning rate is echter cruciaal om een stabiele en efficiënte training te waarborgen.

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

De onderstaande grafiek toont hoe een geschikte leersnelheid het verlies gelijkmatig 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, past SGD de parameters aan na elk individueel voorbeeld. Dit maakt het trainen 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 = ...