iCt Horse

1. Waarom één neuron niet genoeg is

In Module 1 ontdekten we dat een perceptron XOR niet kan leren. Dat komt omdat één neuron slechts een rechte lijn kan trekken door de data. XOR vereist een gebogen grens.

De oplossing: stapel meerdere neuronen op in lagen. Elk neuron in de eerste laag leert een eigen rechte lijn. De volgende laag combineert die lijnen tot complexere vormen. Hoe meer lagen, hoe ingewikkelder de patronen die het netwerk kan herkennen.

2. De architectuur van een neural network

Een neural network bestaat uit drie soorten lagen:

Elke verbinding tussen twee neuronen heeft een gewicht. Elk neuron heeft een bias. In een netwerk met 2 inputs, 4 hidden neuronen en 1 output zijn er al 2×4 + 4×1 = 12 gewichten en 4 + 1 = 5 biases. Bij GPT-4 zijn dat er honderden miljarden.

Feedforward: van input naar output

Data stroomt altijd in één richting: van links naar rechts. Elk neuron:

1. Ontvangt outputs van de vorige laag
2. Vermenigvuldigt ze met zijn gewichten
3. Telt de bias op
4. Past de activatiefunctie toe
5. Stuurt het resultaat naar de volgende laag

3. XOR oplossen met een hidden layer

Laten we stap voor stap bekijken hoe twee hidden neuronen samen XOR oplossen:

4. Backpropagation: het netwerk trainen

In Module 2 leerden we gradient descent voor één neuron. Bij een netwerk met meerdere lagen moeten we de fout terugpropageren — van de output terug naar elke laag.

Het algoritme in 4 stappen:

1. Forward pass — stuur de input door het netwerk en bereken de output
2. Bereken de loss — vergelijk output met het verwachte antwoord
3. Backward pass — bereken de gradient van elk gewicht via de chain rule
4. Update — pas alle gewichten aan met gradient descent

De chain rule visueel

Stel je een ketting voor van bewerkingen: input → hidden → output → loss. De chain rule zegt: de invloed van een gewicht op de loss is het product van alle tussenstappen.

5. Activatiefuncties: waarom niet-lineair?

Zonder activatiefunctie is een neural network — hoe diep ook — wiskundig equivalent aan een enkel lineair neuron. De activatiefunctie voegt de niet-lineariteit toe die het netwerk krachtig maakt.

6. Python code: een neural network from scratch

Een compleet 2-laags netwerk dat XOR leert — zonder libraries, alleen wiskunde:

import random
import math

# --- Activatiefuncties ---
def sigmoid(x):
    return 1 / (1 + math.exp(-max(-500, min(500, x))))

def sigmoid_deriv(output):
    return output * (1 - output)   # afgeleide t.o.v. output

# --- Netwerk: 2 inputs → 2 hidden → 1 output ---
# Gewichten willekeurig initialiseren
wh = [[random.uniform(-1,1) for _ in range(2)] for _ in range(2)]  # 2x2
bh = [random.uniform(-1,1) for _ in range(2)]                  # 2 biases
wo = [random.uniform(-1,1) for _ in range(2)]                  # 2→1
bo = random.uniform(-1,1)                                     # 1 bias

# XOR training data
data = [([0,0], 0), ([0,1], 1), ([1,0], 1), ([1,1], 0)]
lr = 2.0

for epoch in range(10000):
    total_loss = 0
    for inputs, target in data:
        # --- Forward pass ---
        hidden = []
        for j in range(2):
            s = sum(inputs[i] * wh[j][i] for i in range(2)) + bh[j]
            hidden.append(sigmoid(s))

        out_sum = sum(hidden[j] * wo[j] for j in range(2)) + bo
        output = sigmoid(out_sum)

        # --- Loss ---
        loss = (target - output) ** 2
        total_loss += loss

        # --- Backward pass ---
        # Output layer gradients
        d_output = (output - target) * sigmoid_deriv(output)

        for j in range(2):
            wo[j] -= lr * d_output * hidden[j]
        bo -= lr * d_output

        # Hidden layer gradients
        for j in range(2):
            d_hidden = d_output * wo[j] * sigmoid_deriv(hidden[j])
            for i in range(2):
                wh[j][i] -= lr * d_hidden * inputs[i]
            bh[j] -= lr * d_hidden

    if epoch % 1000 == 0:
        print(f"Epoch {epoch:5d} | Loss: {total_loss:.6f}")

# --- Test ---
print("\nResultaten:")
for inputs, target in data:
    hidden = [sigmoid(sum(inputs[i]*wh[j][i] for i in range(2))+bh[j]) for j in range(2)]
    output = sigmoid(sum(hidden[j]*wo[j] for j in range(2))+bo)
    print(f"  {inputs} → {output:.4f}  (verwacht {target})")

7. Van speelgoed naar echte AI

Onze demo's gebruiken netwerken met 2-25 neuronen. Echte AI-systemen zijn onvoorstelbaar groter:

* Geschatte waarden — OpenAI publiceert geen exacte architectuurdetails.

Maar het principe is identiek: lagen van neuronen, gewichten, biases, activatiefuncties, en backpropagation. Het verschil zit in de schaal en in slimme architectuurkeuzes — zoals Transformers, die we in Module 6 behandelen.

Samenvatting

• Een neural network stapelt meerdere lagen neuronen: input → hidden → output.
• Hidden layers ontdekken tussenliggende features die individuele neuronen niet kunnen zien.
• Twee hidden neuronen zijn genoeg om XOR op te lossen: OR + NAND = XOR.
• Backpropagation propageert de fout terug door het netwerk via de chain rule.
• Niet-lineaire activatiefuncties (ReLU, sigmoid) geven het netwerk zijn kracht.
• Echte AI-systemen gebruiken exact dezelfde principes, maar dan met miljarden parameters.