Perceptron er navnet på det simpleste neurale netværk, som kun består af én neuron. For at kunne løse mere komplekse problemer opretter vi dog en model kaldet multilags perceptron (MLP). En multilags perceptron består af et eller flere skjulte lag. Strukturen af en multilags perceptron ser således ud:

1. Et inputlag: modtager inputdata;
2. Skjulte lag: disse lag behandler dataene og udtrækker mønstre.
3. Outputlag: producerer den endelige forudsigelse eller klassifikation.

Generelt består hvert lag af flere neuroner, og outputtet fra ét lag bliver input til det næste lag.

Lagets vægte og bias

Før implementering af et lag er det vigtigt at forstå, hvordan man gemmer vægtene og bias for hver neuron i laget. I det forrige kapitel lærte du, hvordan vægtene for en enkelt neuron kan gemmes som en vektor og dens bias som en skalar (enkelt tal).

Da et lag består af flere neuroner, er det naturligt at repræsentere vægtene som en matrix, hvor hver række svarer til vægtene for en bestemt neuron. Bias kan derfor repræsenteres som en vektor, hvis længde er lig med antallet af neuroner.

Givet et lag med $3$ input og $2$ neuroner, gemmes vægtene i en $2 \times 3$ matrix $W$ og bias gemmes i en $2 \times 1$ vektor $b$, som ser således ud:

Her repræsenterer elementet $W_{ij}$ vægten af et $j$-te input til den $i$-te neuron, så den første række indeholder vægtene for den første neuron, og den anden række indeholder vægtene for den anden neuron. Elementet $b_i$ repræsenterer bias for den $i$-te neuron (to neuroner – to bias).

Fremadrettet Propagering

At udføre fremadrettet propagering for hvert lag betyder at aktivere hver af dets neuroner ved at beregne den vægtede sum af inputtene, tilføje bias, og anvende aktiveringsfunktionen.

Tidligere, for en enkelt neuron, implementerede du den vægtede sum af inputtene ved at beregne et prikprodukt mellem inputvektoren og vægtvektoren og tilføje bias.

Da hver række i vægtmatricen indeholder vægtvektoren for en bestemt neuron, skal du nu blot udføre et prikprodukt mellem hver række i matricen og inputvektoren. Heldigvis er det præcis, hvad matrixmultiplikation gør:

For at tilføje bias til outputtene fra de respektive neuroner, skal en vektor af bias også tilføjes:

Endelig anvendes aktiveringsfunktionen på resultatet — sigmoid eller ReLU i dette tilfælde. Den resulterende formel for fremadrettet propagering i laget er som følger:

hvor $a$ er vektoren af neuronaktiveringer (output).

Lagklasse

Perceptronens grundlæggende byggesten er dens lag, derfor giver det mening at oprette en separat Layer-klasse. Dens attributter omfatter:

• inputs: en vektor af input (n_inputs er antallet af input);
• outputs: en vektor af rå outputværdier (før aktiveringsfunktionen anvendes) for neuronerne (n_neurons er antallet af neuroner);
• weights: en vægtmatrix;
• biases: en bias-vektor;
• activation_function: aktiveringsfunktionen, der bruges i laget.

Ligesom i implementeringen af en enkelt neuron, vil weights og biases blive initialiseret med tilfældige værdier mellem -1 og 1 trukket fra en uniform fordeling.

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

Attributterne inputs og outputs vil blive brugt senere i backpropagation, så det giver mening at initialisere dem som NumPy-arrays fyldt med nuller.

Fremadpropagering kan implementeres i forward()-metoden, hvor outputs beregnes ud fra inputs-vektoren ved hjælp af NumPy, i henhold til ovenstående formel:

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