Perceptron er navnet på det enkleste nevrale nettverket, bestående av kun én nevron. For å kunne løse mer komplekse problemer, lager vi en modell kalt multilags perceptron (MLP). Et multilags perceptron består av ett eller flere skjulte lag. Strukturen til et multilags perceptron ser slik ut:

1. Et inndata-lag: mottar inndataene;
2. Skjulte lag: disse lagene behandler dataene og trekker ut mønstre.
3. Utdata-lag: produserer den endelige prediksjonen eller klassifiseringen.

Generelt består hvert lag av flere nevroner, og utdata fra ett lag blir inndata til neste lag.

Lagets vekter og bias

Før implementering av et lag er det viktig å forstå hvordan man lagrer vektene og biasene til hver nevron i laget. I forrige kapittel lærte du hvordan du lagrer vektene til én nevron som en vektor og dens bias som en skalar (enkelt tall).

Siden et lag består av flere nevroner, er det naturlig å representere vektene som en matrise, der hver rad tilsvarer vektene til en spesifikk nevron. Biasene kan følgelig representeres som en vektor, hvor lengden er lik antall nevroner.

Gitt et lag med $3$ inndata og $2$ nevroner, lagres vektene i en $2 \times 3$ matrise $W$ og biasene lagres i en $2 \times 1$ vektor $b$, som ser slik ut:

Her representerer elementet $W_{ij}$ vekten fra $j$.-input til $i$.-nevron, så første rad inneholder vektene til første nevron, og andre rad inneholder vektene til andre nevron. Elementet $b_i$ representerer biasen til $i$.-nevron (to nevroner – to biaser).

Fremoverpropagasjon

Å utføre fremoverpropagasjon for hvert lag innebærer å aktivere hver av dets nevroner ved å beregne vektet sum av inngangene, legge til bias, og anvende aktiveringsfunksjonen.

Tidligere, for et enkelt nevron, implementerte du vektet sum av inngangene ved å beregne et prikkprodukt mellom inngangsvektoren og vektvektoren og legge til bias.

Siden hver rad i vektmatrisen inneholder vektvektoren for et bestemt nevron, trenger du nå bare å utføre et prikkprodukt mellom hver rad i matrisen og inngangsvektoren. Heldigvis er dette nøyaktig det matrisemultiplikasjon gjør:

For å legge til biasene til utgangene fra de respektive nevronene, bør en vektor av biaser også legges til:

Til slutt anvendes aktiveringsfunksjonen på resultatet — sigmoid eller ReLU, i vårt tilfelle. Den resulterende formelen for fremoverpropagasjon i laget er som følger:

hvor $a$ er vektoren av nevronaktiveringer (utganger).

Lagklasse

Perceptronets grunnleggende byggeklosser er dets lag, derfor er det hensiktsmessig å opprette en egen Layer-klasse. Dens attributter inkluderer:

• inputs: en vektor med innganger (n_inputs er antall innganger);
• outputs: en vektor med rå utgangsverdier (før aktiveringsfunksjonen brukes) for nevronene (n_neurons er antall nevroner);
• weights: en vektmatrise;
• biases: en bias-vektor;
• activation_function: aktiveringsfunksjonen som brukes i laget.

Som i implementasjonen av et enkelt nevron, vil weights og biases bli initialisert med tilfeldige verdier mellom -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

Attributtene inputs og outputs vil bli brukt senere i tilbakepropagering, så det er hensiktsmessig å initialisere dem som NumPy-arrays fylt med nuller.

Foroverpropagering kan implementeres i forward()-metoden, der outputs beregnes basert på inputs-vektoren ved bruk av NumPy, i henhold til formelen ovenfor:

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