Perceptron är namnet på det enklaste neurala nätverket, bestående av endast en neuron. För att kunna lösa mer komplexa problem kommer vi dock att skapa en modell som kallas multilagerperceptron (MLP). En multilagerperceptron består av ett eller flera dolda lager. Strukturen för en multilagerperceptron ser ut så här:

1. Ett inmatningslager: tar emot indata;
2. Dolda lager: dessa lager bearbetar data och extraherar mönster.
3. Utmatningslager: producerar den slutliga prediktionen eller klassificeringen.

Generellt består varje lager av flera neuroner, och utdata från ett lager blir indata till nästa lager.

Lagerns vikter och bias

Innan vi implementerar ett lager är det viktigt att förstå hur man lagrar vikterna och bias för varje neuron i lagret. I föregående kapitel lärde du dig hur man lagrar vikterna för en enskild neuron som en vektor och dess bias som en skalar (enskilt tal).

Eftersom ett lager består av flera neuroner är det naturligt att representera vikterna som en matris, där varje rad motsvarar vikterna för en specifik neuron. Följaktligen kan bias representeras som en vektor, vars längd är lika med antalet neuroner.

Givet ett lager med $3$ indata och $2$ neuroner, kommer dess vikter att lagras i en $2 \times 3$ matris $W$ och dess bias lagras i en $2 \times 1$ vektor $b$, vilket ser ut så här:

Här representerar elementet $W_{ij}$ vikten för en $j$:e indata till den $i$:e neuronen, så den första raden innehåller vikterna för den första neuronen och den andra raden innehåller vikterna för den andra neuronen. Elementet $b_i$ representerar bias för den $i$:e neuronen (två neuroner – två bias).

Framåtriktad Propagering

Att utföra framåtriktad propagering för varje lager innebär att aktivera varje av dess neuroner genom att beräkna den viktade summan av indata, lägga till bias, och tillämpa aktiveringsfunktionen.

Tidigare, för en enskild neuron, implementerade du viktad summa av indata genom att beräkna en skalärprodukt mellan indatavektorn och viktvektorn samt lägga till bias.

Eftersom varje rad i viktmatrisen innehåller viktvektorn för en specifik neuron, behöver du nu endast utföra en skalärprodukt mellan varje rad i matrisen och indatavektorn. Lyckligtvis är detta exakt vad matrismultiplikation gör:

För att lägga till bias till utdata från respektive neuron, ska en biasvektor också adderas:

Slutligen tillämpas aktiveringsfunktionen på resultatet — sigmoid eller ReLU i vårt fall. Den resulterande formeln för framåtriktad propagering i lagret är följande:

där $a$ är vektorn av neuronaktiveringar (utdata).

Lagerklass

Perceptronens grundläggande byggstenar är dess lager, därför är det logiskt att skapa en separat Layer-klass. Dess attribut inkluderar:

• inputs: en vektor av indata (n_inputs är antalet indata);
• outputs: en vektor av råa utdata (innan aktiveringsfunktionen tillämpas) från neuronerna (n_neurons är antalet neuroner);
• weights: en viktmatris;
• biases: en bias-vektor;
• activation_function: aktiveringsfunktionen som används i lagret.

Precis som i implementeringen av enskilda neuroner kommer weights och biases att initialiseras med slumpmässiga värden mellan -1 och 1 dragna från en likformig fördelning.

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

Attributen inputs och outputs kommer att användas senare vid backpropagering, så det är lämpligt att initiera dem som NumPy-arrayer fyllda med nollor.

Framåtpropagering kan implementeras i metoden forward(), där outputs beräknas baserat på inputs-vektorn med hjälp av NumPy, enligt formeln ovan:

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