iCt Horse

1. Van brein naar machine

Alle kunstmatige intelligentie is geïnspireerd op één ding: het menselijk brein. Je brein bevat ongeveer 86 miljard neuronen, elk verbonden met duizenden andere. Wanneer je een hond ziet, vuren specifieke neuronen — ze ontvangen signalen, verwerken ze, en sturen het resultaat door.

In 1958 bedacht Frank Rosenblatt het perceptron — het eerste kunstmatige neuron. Het idee is simpel:

1. Ontvang inputs (getallen)
2. Vermenigvuldig elke input met een gewicht (weight)
3. Tel alles op en voeg een bias toe
4. Pas een activatiefunctie toe
5. Produceer een output

2. De wiskunde achter een neuron

Een neuron met twee inputs berekent:

Laten we elk onderdeel bekijken:

Activatiefuncties

De drie meest gebruikte:

3. Voorbeeld: een AND-gate bouwen

Een AND-gate geeft alleen 1 als beide inputs 1 zijn. Kunnen we een neuron leren om dit te doen?

Met de juiste gewichten en bias werkt dit. Bijvoorbeeld: w1=1, w2=1, bias=-1.5

• (0,0): 0×1 + 0×1 + (-1.5) = -1.5 → step → 0
• (0,1): 0×1 + 1×1 + (-1.5) = -0.5 → step → 0
• (1,0): 1×1 + 0×1 + (-1.5) = -0.5 → step → 0
• (1,1): 1×1 + 1×1 + (-1.5) = 0.5 → step → 1

Het werkt! Maar hoe vindt een neuron die gewichten? Dat is waar training om de hoek komt kijken.

4. Hoe een perceptron leert

Het leerproces is verrassend simpel:

1. Begin met willekeurige gewichten
2. Bereken de output voor een trainingsvoorbeeld
3. Vergelijk met het verwachte antwoord
4. Pas aan: als het antwoord fout is, schuif de gewichten een klein beetje de goede kant op
5. Herhaal tot het klopt

De aanpassingsregel:

5. Python code: je eerste neuron

Kopieer deze code en draai het in Python om een perceptron te trainen:

import random

# Activatiefunctie: step
def step(x):
    return 1 if x >= 0 else 0

# Perceptron klasse
class Perceptron:
    def __init__(self, n_inputs, learning_rate=0.1):
        self.weights = [random.uniform(-1, 1) for _ in range(n_inputs)]
        self.bias = random.uniform(-1, 1)
        self.lr = learning_rate

    def predict(self, inputs):
        total = sum(w * x for w, x in zip(self.weights, inputs))
        total += self.bias
        return step(total)

    def train(self, inputs, expected):
        prediction = self.predict(inputs)
        error = expected - prediction
        # Pas gewichten en bias aan
        for i in range(len(self.weights)):
            self.weights[i] += self.lr * error * inputs[i]
        self.bias += self.lr * error
        return error

# Training data: AND-gate
data = [
    ([0, 0], 0),
    ([0, 1], 0),
    ([1, 0], 0),
    ([1, 1], 1),
]

# Train de perceptron
p = Perceptron(n_inputs=2)

for epoch in range(20):
    errors = 0
    for inputs, expected in data:
        errors += abs(p.train(inputs, expected))
    if errors == 0:
        print(f"Geleerd in {epoch + 1} epochs!")
        break

# Test
print(f"Weights: {p.weights}, Bias: {p.bias:.2f}")
for inputs, expected in data:
    result = p.predict(inputs)
    status = "correct" if result == expected else "FOUT"
    print(f"{inputs} -> {result} (verwacht {expected}) {status}")

6. De beperking: het XOR-probleem

Probeer in de demo hierboven de XOR-gate te trainen. Het lukt niet! XOR (exclusieve OR) geeft 1 als precies één input 1 is — maar niet als beide 1 zijn.

Waarom kan een perceptron dit niet leren? Omdat een perceptron een rechte lijn trekt om de data te scheiden. Bij AND en OR is dat mogelijk, maar bij XOR liggen de punten zo dat geen enkele rechte lijn ze scheidt.

Dit probleem werd in 1969 wiskundig bewezen door Minsky & Papert, en het zorgde ervoor dat AI-onderzoek bijna stilstond (de "AI winter"). De oplossing — meerdere lagen neuronen — behandelen we in Module 3.

Samenvatting

• Een kunstmatig neuron ontvangt inputs, vermenigvuldigt ze met gewichten, telt een bias op, en past een activatiefunctie toe.
• Gewichten bepalen hoe belangrijk elke input is. De bias verschuift de beslissingsgrens.
• Een perceptron leert door gewichten aan te passen op basis van fouten.
• Activatiefuncties (step, sigmoid, ReLU) bepalen hoe het neuron "vuurt".
• Eén neuron kan lineaire problemen oplossen (AND, OR) maar niet XOR — daarvoor heb je meerdere lagen nodig.