Basis algebra

Lineaire algebra en calculus vormen het wiskundige fundament onder machine learning. Hier worden kort de concepten behandelt die je nodig hebt om te begrijpen hoe AI-modellen werken en leren. Je hoeft dit niet uit je hoofd te kennen, maar het is handig om de begrippen te snappen.

Vectoren

Een vector is een geordende lijst van getallen. In machine learning representeren vectoren vaak datapunten, features of gewichten.

Notatie

Een vector wordt meestal weergegeven als een kolom of rij van getallen:

$$\vec{v} = \begin{bmatrix} v_1 \ v_2 \ v_3 \end{bmatrix}$$

Vectoroperaties

Operatie	Beschrijving	Voorbeeld
Optellen	Element voor element optellen	$[1, 2] + [3, 4] = [4, 6]$
Scalaire vermenigvuldiging	Elk element vermenigvuldigen met een getal	$2 \cdot [1, 2] = [2, 4]$
Lengte (norm)	Afstand van oorsprong tot punt	$\|\vec{v}\| = \sqrt{v_1^2 + v_2^2 + ...}$

import numpy as np

v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])

# Optellen
som = v1 + v2  # [5, 7, 9]

# Scalaire vermenigvuldiging
scaled = 2 * v1  # [2, 4, 6]

# Lengte (Euclidische norm)
lengte = np.linalg.norm(v1)  # √14 ≈ 3.74

Matrices

Een matrix is een rechthoekige tabel van getallen, georganiseerd in rijen en kolommen. Matrices worden gebruikt om datasets, transformaties en neurale netwerk-gewichten te representeren.

Notatie

Een matrix met $m$ rijen en $n$ kolommen:

$$A = \begin{bmatrix} a_{11} & a_{12} & a_{13} \ a_{21} & a_{22} & a_{23} \end{bmatrix}$$

Dit is een $2 \times 3$ matrix (2 rijen, 3 kolommen).

Matrixoperaties

Operatie	Voorwaarde	Resultaat
Optellen	Zelfde dimensies	Element voor element optellen
Scalaire vermenigvuldiging	-	Elk element vermenigvuldigen
Matrixvermenigvuldiging	Kolommen A = Rijen B	Nieuwe matrix
Transpose	-	Rijen en kolommen omwisselen

import numpy as np

A = np.array([[1, 2], 
              [3, 4]])
B = np.array([[5, 6], 
              [7, 8]])

# Optellen
som = A + B

# Matrixvermenigvuldiging
product = A @ B  # of np.dot(A, B)

# Transpose
A_T = A.T  # [[1, 3], [2, 4]]

!!! note "Dimensies bij vermenigvuldiging" Bij matrixvermenigvuldiging $A \times B$: als A de dimensie $(m \times n)$ heeft en B de dimensie $(n \times p)$, dan heeft het resultaat dimensie $(m \times p)$. Let op: $A \times B \neq B \times A$ in de meeste gevallen!

Dot product (inwendig product)

Het dot product (of inwendig product) van twee vectoren levert een enkel getal op. Dit concept is fundamenteel voor het berekenen van gelijkenissen en voor de werking van neurale netwerken.

Berekening

$$\vec{a} \cdot \vec{b} = a_1 b_1 + a_2 b_2 + ... + a_n b_n = \sum_{i=1}^{n} a_i b_i$$

Alternatief, met hoeken:

$$\vec{a} \cdot \vec{b} = |\vec{a}| \cdot |\vec{b}| \cdot \cos(\theta)$$

Interpretatie

Dot product	Betekenis
Positief	Vectoren wijzen (deels) dezelfde kant op
Nul	Vectoren staan loodrecht op elkaar
Negatief	Vectoren wijzen (deels) tegenovergestelde kanten op

Toepassingen in AI

Neurale netwerken: elke neuron berekent een gewogen som (dot product) van inputs
Cosine similarity: gelijkenis tussen vectoren (bijv. word embeddings)
Projecties: een vector projecteren op een andere

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Dot product
dot = np.dot(a, b)  # 1*4 + 2*5 + 3*6 = 32

# Cosine similarity
cos_sim = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

Afgeleiden

De afgeleide van een functie geeft aan hoe snel de output verandert bij een kleine verandering in de input. Dit is het centrale concept achter het trainen van machine learning modellen, waar gezocht wordt naar de minimale fout.

Basis

De afgeleide van $f(x)$ naar $x$ wordt genoteerd als:

$$f'(x) = \frac{df}{dx} = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h}$$

Intuïtie

Afgeleide	Betekenis
$f'(x) > 0$	Functie stijgt op dit punt
$f'(x) < 0$	Functie daalt op dit punt
$f'(x) = 0$	Mogelijk minimum, maximum of zadelpunt

Veelvoorkomende afgeleiden

Functie	Afgeleide
$f(x) = c$ (constante)	$f'(x) = 0$
$f(x) = x^n$	$f'(x) = n \cdot x^{n-1}$
$f(x) = e^x$	$f'(x) = e^x$
$f(x) = \ln(x)$	$f'(x) = \frac{1}{x}$

Differentiatie

Differentiatie is het proces van het berekenen van afgeleiden. Voor machine learning is het belangrijk om te begrijpen hoe je afgeleiden van samengestelde functies berekent.

De kettingregel (Chain Rule)

De kettingregel is veruit de belangrijkste regel voor machine learning. Deze regel maakt backpropagation mogelijk — het algoritme waarmee neurale netwerken leren.

Als $y = f(g(x))$ (een functie binnen een functie), dan:

$$\frac{dy}{dx} = \frac{dy}{dg} \cdot \frac{dg}{dx}$$

Of in woorden: de afgeleide van de buitenste functie, vermenigvuldigd met de afgeleide van de binnenste functie.

!!! tip "Voorbeeld" Gegeven: $y = (3x + 2)^4$

- Buitenste functie: $u^4$ waar $u = 3x + 2$
- $\frac{dy}{du} = 4u^3$
- $\frac{du}{dx} = 3$
- Kettingregel: $\frac{dy}{dx} = 4(3x + 2)^3 \cdot 3 = 12(3x + 2)^3$

Toepassing: Gradient Descent

Bij het trainen van een model wil je de loss functie minimaliseren. Gradient descent gebruikt afgeleiden om te bepalen in welke richting de parameters moeten worden aangepast:

$$\theta_{\text{nieuw}} = \theta_{\text{oud}} - \alpha \cdot \frac{\partial L}{\partial \theta}$$

Waar:

$\theta$ = modelparameter (gewicht)
$\alpha$ = learning rate
$\frac{\partial L}{\partial \theta}$ = partiële afgeleide van de loss naar de parameter

# Simpel gradient descent voorbeeld
learning_rate = 0.01

# Voor elke parameter
for param in model.parameters():
    # Update: param = param - learning_rate * gradient
    param -= learning_rate * param.grad

Partiële afgeleiden

Bij functies met meerdere variabelen gebruik je partiële afgeleiden: je differentieert naar één variabele terwijl je de andere constant houdt.

$$f(x, y) = x^2 + 3xy$$

$$\frac{\partial f}{\partial x} = 2x + 3y \quad \text{(y constant)}$$

$$\frac{\partial f}{\partial y} = 3x \quad \text{(x constant)}$$

De verzameling van alle partiële afgeleiden heet de gradiënt:

$$\nabla f = \begin{bmatrix} \frac{\partial f}{\partial x} \ \frac{\partial f}{\partial y} \end{bmatrix}$$

!!! note "Waarom dit belangrijk is" In een neuraal netwerk heb je duizenden parameters (gewichten). Om het model te trainen, moet je de partiële afgeleide van de loss berekenen naar élke parameter. De kettingregel maakt dit mogelijk door de berekening laag voor laag terug te propageren — vandaar de naam "backpropagation".