För tillfället vill vi bygga ett neuralt nätverk med en enda neuron. Som exempel kan vi använda det för en binär klassificeringsuppgift, såsom skräppostdetektion, där 0 representerar ett ham (icke-skräppost) e-postmeddelande och 1 representerar ett skräppostmeddelande.

Neuronen tar numeriska egenskaper relaterade till e-post som indata och producerar ett utdata mellan 0 och 1, vilket representerar sannolikheten att ett 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 ytterligare parameter kallad bias läggs till indatasumman. Bias gör det möjligt för neuronen att förskjuta sitt utdata uppåt eller nedåt, vilket ger flexibilitet till modellen;
4. Indatasumman skickas sedan genom en aktiveringsfunktion. Eftersom vi bara har en enda neuron, som direkt producerar slututdata (en sannolikhet), använder vi sigmoidfunktionen, som komprimerar 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 bör 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.

För att sammanfatta, NumPy tillhandahåller 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

Dessutom bör klassen Neuron inkludera en metod activate(), som beräknar den viktade summan av indata och applicerar aktiveringsfunktionen (sigmoid i vårt fall).

Om vi har två vektorer av samma längd (weights och inputs), kan den viktade summan 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 därefter 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 tillagd bias (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)