Perceptron is de naam van het eenvoudigste neuraal netwerk, bestaande uit slechts één neuron. Om echter meer complexe 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 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 input 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 berekenen van de gewogen som van de inputs, het toevoegen van de bias, en het toepassen van de activatiefunctie.

Eerder, voor een enkele neuron, werd de gewogen som van de inputs geïmplementeerd door het berekenen van een dotproduct tussen de inputvector en de gewichtsvector en het toevoegen van de bias.

Aangezien elke rij van de gewichtenmatrix de gewichtsvector voor een specifiek neuron bevat, hoeft nu alleen een dotproduct te worden uitgevoerd tussen elke rij van de matrix en de inputvector. Dit is 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 dit 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 maken. De attributen hiervan zijn:

• inputs: een vector van inputs (n_inputs is het aantal inputs);
• outputs: een vector van ruwe uitvoerwaarden (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 methode forward(), 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 ...