Perceptron verwijst naar het eenvoudigste type neuraal netwerk, dat bestaat uit slechts één neuron. Voor het oplossen van complexere problemen wordt een model gebruikt dat bekend staat als een multilayer perceptron (MLP). Een multilayer perceptron bevat één of meer verborgen lagen die het netwerk in staat stellen om complexe patronen in gegevens te leren.

De structuur van een multilayer perceptron omvat:

1. Invoerlaag: ontvangt de invoergegevens;
2. Verborgen lagen: verwerken de gegevens en extraheren betekenisvolle patronen;
3. Uitvoerlaag: levert de uiteindelijke voorspelling of classificatie.

Elke laag bestaat uit meerdere neuronen, en de uitvoer van de ene laag fungeert als de invoer voor de volgende laag.

Laaggewichten en Biases

Voordat een laag wordt geïmplementeerd, is het belangrijk te begrijpen hoe de gewichten en biases van elke neuron daarin worden opgeslagen. In het vorige hoofdstuk heb je geleerd hoe je de gewichten van een enkel neuron als een vector opslaat en de bias als een scalar (enkel getal).

Aangezien een laag uit meerdere neuronen bestaat, is het logisch om de gewichten als een matrix weer te geven, waarbij elke rij overeenkomt met de gewichten van een specifiek neuron. Bijgevolg kunnen biases worden weergegeven als een vector, waarvan de lengte gelijk is aan het aantal neuronen.

Gegeven een laag met $3$ ingangen en $2$ neuronen, worden de gewichten opgeslagen in een $2 \times 3$ matrix $W$ en de biases in een $2 \times 1$ vector $b$, die er als volgt uitzien:

Hier stelt element $W_{ij}$ het gewicht voor van een $j$-de ingang naar het $i$-de neuron, dus de eerste rij bevat de gewichten van het eerste neuron en de tweede rij bevat de gewichten van het tweede neuron. Element $b_i$ stelt de bias voor van het $i$-de neuron (twee neuronen – twee biases).

Voorwaartse propagatie

Het uitvoeren van voorwaartse propagatie voor elke laag betekent het activeren van elk van zijn neuronen door het gewogen totaal van de inputs te berekenen, de bias toe te voegen en de activatiefunctie toe te passen.

Eerder, voor een enkele neuron, implementeerde je het gewogen totaal van de inputs door een dotproduct te berekenen tussen de inputvector en de gewichtsvector en de bias toe te voegen.

Aangezien elke rij van de gewichtenmatrix de gewichtsvector voor een specifiek neuron bevat, hoef je nu alleen maar een dotproduct uit te voeren tussen elke rij van de matrix en de inputvector. Gelukkig is dit precies wat matrixvermenigvuldiging doet:

Om de biases toe te voegen aan de outputs van de respectievelijke neuronen, moet ook een vector van biases worden toegevoegd:

Ten slotte wordt de activatiefunctie toegepast op het resultaat — sigmoid of ReLU, in ons geval. De resulterende formule voor voorwaartse propagatie in de laag is als volgt:

waarbij $a$ de vector van neuronactivaties (outputs) is.

Laagklasse

De fundamentele bouwstenen van de perceptron zijn de lagen, daarom is het logisch om een aparte Layer-klasse te creëren. De attributen hiervan zijn:

• inputs: een vector van inputs (n_inputs is het aantal inputs);
• outputs: een vector van ruwe outputwaarden (voordat de activatiefunctie wordt toegepast) van de neuronen (n_neurons is het aantal neuronen);
• weights: een gewichtenmatrix;
• biases: een biasvector;
• activation_function: de activatiefunctie die in de laag wordt gebruikt.

Net als bij de implementatie van een enkele neuron worden weights en biases geïnitialiseerd met willekeurige waarden tussen -1 en 1 uit een uniforme verdeling.

class Layer:
    def __init__(self, n_inputs, n_neurons, activation_function):
        self.inputs = np.zeros((n_inputs, 1))
        self.outputs = np.zeros((n_neurons, 1))
        self.weights = ...
        self.biases = ...
        self.activation = activation_function

De attributen inputs en outputs zullen later worden gebruikt bij backpropagation, dus het is logisch om deze te initialiseren als NumPy-arrays gevuld met nullen.

Voorwaartse propagatie kan worden geïmplementeerd in de forward()-methode, waarbij outputs worden berekend op basis van de inputs-vector met behulp van NumPy, volgens de bovenstaande formule:

def forward(self, inputs):
    self.inputs = np.array(inputs).reshape(-1, 1)
    # Raw outputs
    self.outputs = ...
    # Applying the activation function
    return ...