For nå ønsker vi å bygge et nevralt nettverk med én enkelt nevron. Som et eksempel kan vi bruke det til en binær klassifiseringsoppgave, som for eksempel spamdeteksjon, der 0 representerer en ham (ikke-spam) e-post og 1 representerer en spam e-post.

Nevronen vil ta numeriske egenskaper relatert til e-poster som innganger og produsere en utgang mellom 0 og 1, som representerer sannsynligheten for at en e-post er spam.

Dette skjer trinn for trinn:

1. Hver inngang blir multiplisert med en tilsvarende vekt. Vektene er lærbare parametere som bestemmer viktigheten av hver inngang;
2. Alle de vektede inngangene blir summert sammen;
3. En ekstra parameter kalt bias blir lagt til inngangssummen. Bias gjør det mulig for nevronen å forskyve utgangen opp eller ned, og gir fleksibilitet til modellen;
4. Inngangssummen sendes deretter gjennom en aktiveringsfunksjon. Siden vi kun har én enkelt nevron, som direkte produserer den endelige utgangen (en sannsynlighet), bruker vi sigmoid-funksjonen, som komprimerer verdier til området $(0, 1)$.

Nevronklasse

Et nevron må lagre sine vekter og bias, noe som gjør en klasse til en naturlig måte å gruppere disse relaterte egenskapene på.

class Neuron:
    def __init__(self, n_inputs):  
        self.weights = ...
        self.bias = ...

• weights: en liste med tilfeldig initierte verdier som bestemmer hvor viktig hver input (n_inputs er antall input) er for nevronet;
• bias: en tilfeldig initiert verdi som hjelper nevronet å ta fleksible beslutninger.

Vekter og bias bør tilfeldig initieres med små verdier mellom -1 og 1, trukket fra en uniform fordeling, for å bryte symmetri og sikre at ulike nevroner lærer ulike egenskaper.

For å oppsummere, tilbyr NumPy funksjonen random.uniform() for å generere et tilfeldig tall eller en matrise (ved å spesifisere argumentet size) av tilfeldige tall fra en uniform fordeling innenfor intervallet [low, high).

import numpy as np

np.random.uniform(low, high, size=...)

Fremoverpropagering

I tillegg bør Neuron-klassen inkludere en activate()-metode, som beregner den vektede summen av inputene og anvender aktiveringsfunksjonen (sigmoid i vårt tilfelle).

Faktisk, hvis vi har to vektorer av lik lengde (weights og inputs), kan den vektede summen beregnes ved hjelp av skalarproduktet av disse vektorene:

Dette gjør det mulig å beregne den vektede summen i én kodelinje ved å bruke funksjonen numpy.dot(), slik at man slipper å bruke en løkke. Bias kan deretter legges direkte til resultatet for å få input_sum_with_bias. Utdata beregnes så ved å anvende sigmoid-aktiveringsfunksjonen:

def activate(self, inputs):
    input_sum_with_bias = ...
    output = ...

    return output

Aktiveringsfunksjoner

Formelen for sigmoid-funksjonen er som følger, der $z$ representerer den vektede summen av input med bias lagt til (rå utgangsverdi) for denne nevronen:

Ved å bruke denne formelen kan sigmoid implementeres som en enkel funksjon i Python:

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

Formelen for ReLU-funksjonen er som følger, som i hovedsak setter utgangen lik $z$ hvis den er positiv og 0 ellers:

def relu(z):
    return np.maximum(0, z)