I detta exempel är målet att bygga ett neuralt nätverk med en enda neuron. Det ska användas för en binär klassificeringsuppgift, såsom skräppostdetektion, där 0 motsvarar ett ham (icke-skräppost) e-postmeddelande och 1 motsvarar ett skräppostmeddelande.

Neuronen tar emot numeriska egenskaper som extraherats från e-postmeddelanden som indata och producerar ett utdata mellan 0 och 1, vilket representerar sannolikheten att ett givet e-postmeddelande är skräppost.

Så här går det till steg för steg:

1. Varje indata multipliceras med en motsvarande vikt; vikterna är lärbara parametrar som avgör betydelsen av varje indata;
2. Alla viktade indata summeras;
3. En bias-term läggs till summan av indata, vilket gör det möjligt för neuronen att förskjuta sitt utdata och ger modellen ytterligare flexibilitet;
4. Summan skickas genom en aktiveringsfunktion. Eftersom en enda neuron direkt producerar det slutliga utdata (en sannolikhet), används sigmoidfunktionen för att komprimera värden till intervallet $(0, 1)$.

Neuronklass

En neuron behöver lagra sina vikter och bias, vilket gör en klass till ett naturligt sätt att gruppera dessa relaterade egenskaper.

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

• weights: en lista med slumpmässigt initierade värden som avgör hur viktig varje indata (n_inputs är antalet indata) är för neuronen;
• bias: ett slumpmässigt initierat värde som hjälper neuronen att fatta flexibla beslut.

Vikter och bias ska slumpmässigt initieras med små värden mellan -1 och 1, dragna från en likformig fördelning, för att bryta symmetri och säkerställa att olika neuroner lär sig olika egenskaper.

Sammanfattningsvis tillhandahåller NumPy funktionen random.uniform() för att generera ett slumpmässigt tal eller en array (genom att ange argumentet size) av slumpmässiga tal från en likformig fördelning inom intervallet [low, high).

import numpy as np

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

Framåtriktad Propagering

Neuron-klassen bör inkludera en activate()-metod som beräknar den viktade summan av indata och sedan applicerar aktiveringsfunktionen (sigmoidfunktionen i detta fall).

När två vektorer av samma längd — weights och inputs — finns tillgängliga, kan den viktade summan effektivt beräknas med hjälp av skalärprodukten av dessa vektorer.

Detta gör det möjligt att beräkna den viktade summan i en enda kodrad med funktionen numpy.dot(), vilket eliminerar behovet av en loop. Bias kan sedan läggas direkt till resultatet för att få input_sum_with_bias. Utdata beräknas sedan genom att applicera sigmoid-aktiveringsfunktionen:

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

    return output

Aktiveringsfunktioner

Formeln för sigmoid-funktionen är följande, där $z$ representerar den viktade summan av indata med bias tillagd (råutgångsvärde) för denna specifika neuron:

Med denna formel kan sigmoid implementeras som en enkel funktion i Python:

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

Formeln för ReLU-funktionen är följande, vilket i princip sätter utgången lika med $z$ om den är positiv och 0 annars:

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