Verktøykassa: matte og Python for ML

Anta at vi skal anslå strømforbruket i fire leiligheter. For hver leilighet kjenner vi areal, antall beboere og utetemperatur. Hver enkelt måling er en skalar, altså ett tall. Samler vi de tre målingene for én leilighet, får vi en vektor $x=(x_1,x_2,x_3)$. Legger vi de fire vektorene under hverandre som rader, får vi en matrise $X$ med fire rader og tre kolonner. Konvensjonen i maskinlæring er nesten alltid den samme: én rad per observasjon og én kolonne per feature. Bilder, lyd og video trenger flere akser, og en slik flerdimensjonal array kalles en tensor. En batch med 32 gråtonebilder på $28\times 28$ piksler har for eksempel formen $(32,28,28)$.

En lineær modell gir hver feature en vekt $w_j$ og legger sammen bidragene. Det er ƒskalarprodukt:

Hvert ledd $x_j{w}_j$ er bidraget fra én feature. Fortegnet til $w_j$ sier om featuren trekker resultatet opp eller ned, og størrelsen sier hvor kraftig. Geometrisk er skalarproduktet stort og positivt når vektorene peker omtrent samme vei, null når de står vinkelrett på hverandre, og negativt når de peker hver sin vei.

I figuren gir $x=(3,1)$ og $w=(1,2)$ scoren $3\cdot 1+1\cdot 2=5$. Legg merke til den første formregelen: skalarproduktet krever like mange komponenter i begge vektorene. Tre features krever tre vekter, verken flere eller færre.

import numpy as np

# Én leilighet: areal (10 m²), antall beboere, utetemperatur (°C)
x = np.array([6.5, 2.0, -4.0])
w_temp = -0.8  # @param -1.5..1.5 0.1
w = np.array([1.2, 3.0, w_temp])   # kWh per enhet av hver feature

lokke = sum(x[j] * w[j] for j in range(len(x)))
print(f"løkke {lokke:.2f}   np.dot {np.dot(x, w):.2f}   x @ w {x @ w:.2f}")

for navn, bidrag in zip(["areal", "beboere", "temperatur"], x * w):
    print(f"{navn:10s} bidrar {bidrag:6.2f} kWh")

Med mange observasjoner vil vi regne ut alle scorene på én gang. ƒMatrise-vektor-produkt sier at komponent $i$ i resultatet er skalarproduktet mellom rad $i$ i $X$ og vektoren $w$. Med $X$ av form $(4,3)$ og $w$ av form $(3,)$ får vi fire scorer, én per leilighet. Den generelle regelen er ƒformregel for matriseprodukt:

De indre dimensjonene må være like og «spises opp», mens de ytre blir igjen. Derfor fungerer $(3,2)$ ganger $(2,4)$, mens $(3,2)$ ganger $(3,2)$ ikke gjør det.

I NumPy er @ og np.matmul matriseprodukt, og np.dot gjør det samme for vektorer og vanlige matriser. Stjernen * er noe helt annet: den ganger elementvis og krever at formene passer sammen etter reglene for broadcasting. NumPy sammenligner formene fra høyre. To dimensjoner passer hvis de er like, eller hvis én av dem er 1 eller mangler. Derfor går X - X.mean(axis=0) fint: $(4,3)$ minus $(3,)$ trekker samme snittvektor fra hver rad. Men X - X.mean(axis=1) feiler, fordi $(4,3)$ og $(4,)$ har 3 og 4 bakerst. Med keepdims=True får radsnittet formen $(4,1)$, og da passer det igjen.

Husk også hva axis betyr: aksen du oppgir, er den som forsvinner. X.mean(axis=0) slår sammen radene og gir ett tall per kolonne, mens axis=1 gir ett tall per rad. En endimensjonal array med form $(3,)$ er verken rad- eller kolonnevektor, og w.T endrer den ikke.

import numpy as np

X = np.array([[1.0, 2.0, 0.0],
              [0.0, 1.0, 3.0],
              [2.0, 0.0, 1.0],
              [1.0, 1.0, 1.0]])         # 4 observasjoner, 3 features
w = np.array([2.0, 1.5, 1.0])          # én vekt per feature
print(f"X {X.shape} @ w {w.shape} gir {(X @ w).shape}, mens X * w gir {(X * w).shape}")

akse = 0  # @param 0..1
keepdims = 0  # @param 0..1
snitt = X.mean(axis=akse, keepdims=bool(keepdims))
print(f"X.mean(axis={akse}, keepdims={bool(keepdims)}) har form {snitt.shape}")
try:
    print(f"X - snitt har form {(X - snitt).shape}")   # broadcasting
except ValueError as feil:
    print("formfeil:", str(feil)[:70])

Trening handler om å endre parametere slik at et tap blir mindre. Da trenger vi et mål på lokal endring. En derivert sier hvor mye en funksjonsverdi endres når input endres litt, og ƒderivert definerer den som grensen av en differansekvotient når steget $h$ går mot null. For $f(x)=x^2$ er $f^{\prime }(x)=2x$. Ved $x=1$ er stigningen 2, så en liten økning i $x$ øker $f$ omtrent dobbelt så mye. Ved $x=-1$ er stigningen $-2$, og en liten økning i $x$ senker funksjonsverdien.

Når funksjonen har mange parametere, deriverer vi med hensyn på én om gangen og holder de andre faste. Det gir partiellderiverte, og en gradient samler dem i én vektor, ƒgradient:

Gradienten peker i retningen der $f$ øker raskest. Skal vi senke et tap, går vi derfor et lite steg i motsatt retning, $w\leftarrow w-\eta \nabla f(w)$. Det er gradient descent, som har sitt eget kapittel (kapittel 3).

At gradienten er null, betyr bare at punktet er stasjonært. Det kan være et minimum, et maksimum eller et sadelpunkt. For en konveks funksjon, som MSE-tapet i lineær regresjon, er ethvert stasjonært punkt et globalt minimum. Til slutt trenger du kjerneregelen: avhenger $J$ av $u$ og $u$ av $w$, er $\frac{dJ}{dw}=\frac{dJ}{du}\cdot \frac{du}{dw}$. For $J(w)=(2w-3{)}^2$ gir det $J^{\prime }(w)=2(2w-3)\cdot 2=4(2w-3)$.

En tilfeldig variabel knytter et tall til hvert mulig utfall av et forsøk. La $X$ være gevinsten i et lite spill: 0 poeng med sannsynlighet $0,8$ og 10 poeng med sannsynlighet $0,2$. En forventningsverdi er det sannsynlighetsvektede gjennomsnittet, ƒforventningsverdi for en diskret variabel, her $0\cdot 0,8+10\cdot 0,2=2$. Det er ikke et løfte om neste utfall, som aldri blir 2, men gjennomsnittet over svært mange runder.

Spredningen måles med variansen, den forventede kvadrerte avstanden fra forventningen:

For spillet er $\mathrm{Var}(X)=(0-2{)}^2\cdot 0,8+(10-2{)}^2\cdot 0,2=16$, og standardavviket er $4$. Standardavviket har samme enhet som dataene, mens variansen har enheten i andre.

Med data i stedet for en kjent fordeling bruker vi ƒgjennomsnitt og ƒutvalgsvarians. Utvalgsvariansen deler på $n-1$ for ikke å underestimere spredningen. Legg merke til at np.std i NumPy og StandardScaler i scikit-learn deler på $n$; det dukker opp igjen i kapittel 1.

To regneregler sparer mye tid. Forventning er lineær: $E[aX+bY]=aE[X]+bE[Y]$, også når $X$ og $Y$ er avhengige. Varians er ikke lineær. ƒVarians ved skalering og forskyvning sier at en konstant forskyvning ikke endrer spredningen, mens skalering med $a$ ganger variansen med $a^2$ og standardavviket med $|a|$.

import numpy as np

rng = np.random.default_rng(4172)
utfall = np.array([0, 10])
p = np.array([0.8, 0.2])
E = np.sum(utfall * p)
std = np.sqrt(np.sum((utfall - E) ** 2 * p))
print(f"X teoretisk: E = {E:.2f}, std = {std:.2f}")

a = 2.0  # @param 0..3 0.5
c = 0.0  # @param 0..10 1
trekk = rng.choice(utfall, size=20_000, p=p)
ny = a * trekk + c                     # ny variabel Y = aX + c
print(f"Y simulert:  snitt = {ny.mean():.2f}, std = {ny.std():.2f}")
print(f"Y teoretisk: snitt = {a * E + c:.2f}, std = {abs(a) * std:.2f}")

Et viltkamera ved en vei skal varsle når det står en elg i veikanten. Elgen er der bare 2 % av tiden. Kameraet varsler 90 % av gangene elgen er der, men det varsler også 5 % av gangene den ikke er der, på grunn av busker i vind, rådyr og lysrefleks. Når varselet kommer, hvor sannsynlig er det at det faktisk står en elg der?

Tenk deg 1 000 tidspunkter. Elgen er der i 20 av dem, og kameraet varsler i 18 av disse. Elgen er borte i 980, og kameraet varsler likevel i 49. Av 67 varsler er altså bare 18 ekte, omtrent 27 %. De falske varslene dominerer fordi det er så mange flere tidspunkter uten elg.

ƒBayes’ teorem sier det samme med symboler:

Her er prior $P(A)$ det vi trodde før observasjonen (grunnraten 2 %), likelihood $P(B\mid A)$ hvor sannsynlig observasjonen er hvis hypotesen stemmer (90 %), og posterior $P(A\mid B)$ det vi tror etterpå. Nevneren $P(B)$ kalles evidensen. Den regnes ut med ƒloven om total sannsynlighet ved å summere over alle måter observasjonen kan oppstå på, og den sørger for at posteriorene for alle hypotesene summerer til 1. Telleren alene, likelihood ganger prior, er den unormaliserte posterioren.

Det er lett å forveksle $P(B\mid A)$ med $P(A\mid B)$. At kameraet varsler for 90 % av elgene, betyr ikke at 90 % av varslene er elger. Sammenhengen går via prioren. Det er også grunnen til at en klassifikator som er trent på balanserte data, kan gi for høye sannsynligheter når klassen er sjelden i virkeligheten.

Maskinlæring er full av tilfeldighet: splitting i trening og test, startverdier for vekter, minibatcher og bootstrap-utvalg. For at et forsøk skal kunne gjentas, styrer vi tilfeldigheten med en seed. Den anbefalte måten i NumPy er en egen generator, rng = np.random.default_rng(42), som du trekker fra med rng.normal, rng.integers og rng.choice. Samme seed gir samme tallrekke. Den eldre np.random.seed(42) setter en global tilstand som all annen kode også deler, og er lettere å rote til. En seed gjør resultatet reproduserbart, men ikke riktig: et dårlig forsøksoppsett blir ikke bedre av at det kan gjentas.

Det viktigste skillet er trekking uten og med tilbakelegging. I standardbiblioteket gir random.sample(populasjon, k) $k$ ulike elementer, og feiler hvis $k$ er større enn populasjonen. random.choices(populasjon, k=k) legger tilbake etter hvert trekk, så samme element kan komme flere ganger, og $k$ kan være så stor du vil. I NumPy styres det samme med rng.choice(n, size=k, replace=False) eller replace=True, og rng.permutation(n) stokker alle indeksene.

Valget får konsekvenser senere i faget. Bootstrap i bagging og random forest trekker med tilbakelegging (kapittel 10), mens en replay buffer i DQN typisk henter en minibatch uten tilbakelegging med random.sample (kapittel 15). Trekk med tilbakelegging er dessuten uavhengige: sannsynligheten for et bestemt par utfall er produktet av sannsynlighetene. Uten tilbakelegging avhenger det andre trekket av det første.

import math
import random
import numpy as np

random.seed(12)
lag = ["Rød", "Blå", "Grønn", "Gul", "Lilla", "Oransje"]
k = 4  # @param 1..8

print("choices, med tilbakelegging:", random.choices(lag, k=k))
try:
    print("sample, uten tilbakelegging:", random.sample(lag, k))
except ValueError:
    print(f"sample feiler: kan ikke trekke {k} ulike lag av {len(lag)}")

# Hvor ofte gir k trekk med tilbakelegging minst ett duplikat?
rng = np.random.default_rng(12)
trekk = np.sort(rng.choice(6, size=(10_000, k), replace=True), axis=1)
andel = np.mean(np.any(np.diff(trekk, axis=1) == 0, axis=1))
teori = 1 - math.perm(6, k) / 6 ** k
print(f"andel med duplikat: simulert {andel:.3f}, teori {teori:.3f}")