Perceptron is de naam van het eenvoudigste neuraal netwerk, bestaande uit slechts één neuron. Om echter complexere problemen te kunnen oplossen, creëren we een model genaamd multilayer perceptron (MLP). Een multilayer perceptron bestaat uit één of meer verborgen lagen. De structuur van een multilayer perceptron ziet er als volgt uit:

1. Een invoerlaag: ontvangt de invoergegevens;
2. Verborgen lagen: deze lagen verwerken de gegevens en halen patronen eruit.
3. Uitvoerlaag: produceert de uiteindelijke voorspelling of classificaties.

In het algemeen bestaat elke laag uit meerdere neuronen, en de uitvoer van de ene laag wordt de invoer voor de volgende laag.

Laaggewichten en Biases

Voordat we een laag implementeren, 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 enkele 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 te representeren, waarbij elke rij overeenkomt met de gewichten van een specifieke 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 input naar de $i$-de neuron, dus de eerste rij bevat de gewichten van de eerste neuron en de tweede rij bevat de gewichten van de tweede neuron. Element $b_i$ stelt de bias voor van de $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 berekenen van de gewogen som van de inputs, het toevoegen van de bias, en het toepassen van de activatiefunctie.

Eerder, voor een enkele neuron, implementeerde je de gewogen som 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 uitgangen 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 (uitgangen) is.

Laagklasse

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

• 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 getrokken 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 ...