Perceptron avser den enklaste typen av neuralt nätverk, som består av endast en neuron. För att hantera mer komplexa problem används en modell som kallas multilagerperceptron (MLP). En multilagerperceptron innehåller ett eller flera dolda lager som gör det möjligt för nätverket att lära sig invecklade mönster i data.

Strukturen för en multilagerperceptron inkluderar:

1. Ingångslager: tar emot indata;
2. Dolda lager: bearbetar data och extraherar meningsfulla mönster;
3. Utgångslager: producerar den slutliga prediktionen eller klassificeringen.

Varje lager består av flera neuroner, och utgången från ett lager fungerar som indata till nästa lager.

Lagerns vikter och bias

Innan implementering av 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, lagras dess vikter 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å biasvärden).

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, addera bias, och tillämpa aktiveringsfunktionen.

Tidigare, för en enskild neuron, implementerades den viktade summan av indata genom att beräkna en skalärprodukt mellan indatavektorn och viktvektorn samt addera 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 det precis detta som matrismultiplikation gör:

För att addera bias till utdata från respektive neuron ska även en biasvektor 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 utgångsvärden (innan aktiveringsfunktionen tillämpas) för 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 en enskild neuron 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 logiskt 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 ...