Fra problem til datasett

Tenk deg at et studenthus vil anslå neste døgns strømforbruk. Det er fristende å åpne et modellbibliotek med én gang, men først må vi bestemme hva prediksjonen skal brukes til. Skal vi anslå et antall kilowattimer, varsle om forbruket går over en grense, eller finne døgn med lignende mønster? De tre målene krever ulike labels, metrikker og evalueringsoppsett.

I veiledet læring har hvert treningseksempel et kjent fasitsvar. Er svaret et tall, som kilowattimer, er det regresjon. Er det en kategori, som «over grensen» eller ikke, er det klassifikasjon. I uveiledet læring finnes ingen fasit, og vi leter etter struktur i dataene alene: grupper av lignende døgn (clustering), færre dimensjoner eller uvanlige døgn. En klynge er ikke automatisk en «ekte» type, og en label er ikke automatisk riktig bare fordi den står i en database.

En feature er en inputvariabel modellen får ved prediksjonstidspunktet. En label er verdien veiledet læring skal predikere. Tidspunktet er avgjørende: målt forbruk klokken 23 er en gyldig feature for å forutsi morgendagen, men lekkasje hvis oppgaven er å varsle dagens topp klokken 08. En nyttig vane er å skrive én setning før du samler data: Gitt informasjon som er tilgjengelig ved tidspunkt T, prediker Y for enhet E over horisont H.

I scikit-learn er formene faste. Featurene ligger i en matrise X med form $(n,d)$, én rad per eksempel, og labelene i en vektor y med form $(n,)$. Veiledede modeller trenes med fit(X, y), uveiledede med fit(X).

import numpy as np
from sklearn.cluster import KMeans
from sklearn.linear_model import LinearRegression

rng = np.random.default_rng(1)
temp = rng.uniform(-5, 25, 60)            # feature 1: temperatur
helg = rng.integers(0, 2, 60)             # feature 2: helg (0/1)
X = np.column_stack([temp, helg])         # form (60, 2): én rad per dag
y = 40 + 3 * temp + 25 * helg + rng.normal(0, 8, 60)   # label: solgte is
print(f"X {X.shape}, y {y.shape}")

veiledet = LinearRegression().fit(X, y)   # lærer fra X OG y
grupper = KMeans(n_clusters=2, n_init=10, random_state=0).fit(X)   # bare X
try:
    LinearRegression().fit(X)             # veiledet uten fasit
except TypeError as feil:
    print("fit(X) uten y:", str(feil)[:60])

temp_ny = 18  # @param 0..25
dag = [[temp_ny, 1]]                      # en helgedag
print(f"veiledet: {veiledet.predict(dag)[0]:.0f} solgte is ved {temp_ny} grader")
print(f"uveiledet: dagen havner i gruppe {grupper.predict(dag)[0]}, uten noe salgstall")

En kategorisk feature har verdier som er navn og ikke tall: drivstofftype, fylke, blodtype. Modellen trenger tall, og den fristende løsningen er å nummerere kategoriene: bensin = 0, diesel = 1, el = 2 og hybrid = 3. Det skaper to problemer. For det første får kategoriene en rekkefølge de ikke har. For det andre får de avstander: el ligger «dobbelt så langt» fra bensin som diesel gjør. En lineær modell ganger koden med én vekt, så effekten av drivstoff tvinges til å endre seg i like store steg fra bensin til hybrid, og det er meningsløst.

ƒOne-hot-koding løser dette ved å gi hver kategori sin egen 0/1-kolonne. En elbil blir $(0,0,1,0)$, og alle kategoriene ligger like langt fra hverandre. Modellen kan da lære en egen vekt for hver kategori.

En feature med $K$ kategorier gir $K$ kolonner, så antall features etter kodingen er ƒantall features etter one-hot. Med drop="first" fjernes én kolonne per feature, og den droppede kategorien blir referansen som de andre vektene måles mot. Det gjøres av og til i lineære modeller med konstantledd, fordi de $K$ kolonnene alltid summerer til 1 og dermed overlapper med konstantleddet.

Kategoriene er noe enkoderen lærer i fit. En kategori som bare dukker opp i test eller produksjon, må håndteres eksplisitt, og med handle_unknown="ignore" blir den en rad med bare nuller. Ordinale kategorier med en ekte rekkefølge, som størrelsene S, M og L, kan derimot fint kodes som ett heltall.

import warnings
import numpy as np
from sklearn.preprocessing import OneHotEncoder

warnings.filterwarnings("ignore", message="Found unknown categories")
drivstoff = np.array([["el"], ["diesel"], ["bensin"], ["el"], ["hybrid"]])
dropp_forste = 0  # @param 0..1
enc = OneHotEncoder(drop="first" if dropp_forste else None,
                    sparse_output=False, handle_unknown="ignore").fit(drivstoff)

print(f"kategorier {enc.categories_[0].tolist()} gir {len(enc.get_feature_names_out())} kolonner")
for kat in ["bensin", "diesel", "el", "hydrogen"]:
    print(f"{kat:9s}", enc.transform([[kat]])[0])

koder = {"bensin": 0, "diesel": 1, "el": 2, "hybrid": 3}   # heltallskoder
a, b, c = enc.transform([["bensin"], ["el"], ["diesel"]])
print(f"bensin–el:     koder {koder['el'] - koder['bensin']}, one-hot {np.linalg.norm(a - b):.3f}")
print(f"bensin–diesel: koder {koder['diesel'] - koder['bensin']}, one-hot {np.linalg.norm(a - c):.3f}")

To features kan beskrive samme observasjon med svært ulike tallområder: årsinntekt i hundretusener av kroner og antall kjøp mellom 0 og 30. For en metode som regner avstander, som k-nærmeste naboer eller k-means, vil inntekten dominere fullstendig, fordi en forskjell på 10 000 kroner teller mer enn hele kjøpsskalaen. Modellen leser tallstørrelse, ikke måleenhet.

ƒStandardisering trekker fra snittet $\mu$ og deler på standardavviket $\sigma$, slik at featuren får snitt 0 og standardavvik 1 på treningsdataene. Verdien leses som antall standardavvik fra sentrum. ƒMin–maks-skalering flytter i stedet minste treningsverdi til 0 og største til 1. Min–maks er følsom for ekstreme verdier, fordi én uteligger bestemmer hele skalaen.

Begge metodene lærer tall fra treningsdataene. En testverdi utenfor treningsområdet kan derfor havne under 0 eller over 1 med min–maks, eller langt ute med standardisering. Det er ikke en feil, men nyttig informasjon: punktet ligger utenfor det modellen har sett. StandardScaler deler for øvrig på $n$, ikke $n-1$, når den regner ut $\sigma$.

Skalering trengs ikke alltid. Den er viktig for avstandsbaserte metoder, for modeller som trenes med gradient descent, der ulike skalaer gjør tapslandskapet til en smal dal, og for regularisering, som straffer alle vekter likt. Beslutningstrær sammenligner bare én feature med en terskel om gangen og påvirkes ikke av at en feature skaleres lineært.

import numpy as np
from sklearn.preprocessing import MinMaxScaler, StandardScaler

enhet = 1  # @param 1..1000
# Kunder: [årsinntekt, antall kjøp siste år]. Inntekten måles i enheter på «enhet» kroner.
X = np.array([[420_000, 2], [455_000, 30], [600_000, 3], [430_000, 28]]) / [enhet, 1]
ny = np.array([[445_000, 3]]) / [enhet, 1]

def naermeste(navn, X, ny):
    d = np.linalg.norm(X - ny, axis=1)
    avst = " · ".join(f"k{i} {x:.0f}" if x >= 100 else f"k{i} {x:.2f}" for i, x in enumerate(d))
    print(f"{navn:14s} nærmeste = kunde {d.argmin()}   avstand {avst}")

naermeste("uskalert:", X, ny)
std = StandardScaler().fit(X)             # fit på kjente kunder
naermeste("standardisert:", std.transform(X), std.transform(ny))
mm = MinMaxScaler().fit(X)
naermeste("min–maks:", mm.transform(X), mm.transform(ny))

Alt som lærer tall fra data, er en del av modellen: snitt og standardavvik i en scaler, minimum og maksimum, medianen i en imputer, kategoriene i en one-hot-enkoder og hvilke features en utvelger beholder. I scikit-learn har alle disse stegene samme grensesnitt. fit lærer tallene, transform bruker dem, og fit_transform gjør begge deler på de samme dataene.

Regelen er enkel: `fit` bare på treningsdata, `transform` på alt annet. Validering, test og produksjonsdata skal transformeres med tallene som ble lært på treningssettet.

Python
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)   # lær mu og sigma på trening
X_val_s = scaler.transform(X_val)           # samme mu og sigma
X_test_s = scaler.transform(X_test)         # samme mu og sigma

Hva er galt med scaler.fit_transform(X_test)? Tre ting. Testsettet får sin egen skala, så samme råverdi blir ulike tall i trening og test, og modellen får input i en annen «valuta» enn den ble trent på. Testsettet blir dessuten alltid sentrert rundt 0, selv om det egentlig ligger langt fra treningsdataene, og et reelt skift i dataene skjules. Og i produksjon kommer ofte ett punkt om gangen, og da finnes det ikke noe meningsfullt snitt eller standardavvik å regne ut. Det motsatte feilgrepet er å skalere hele datasettet før splitten. Da har treningen sett statistikk fra testdataene, og den målte scoren blir litt for god.

Datalekkasje betyr at informasjon som ikke ville vært tilgjengelig i ekte bruk, påvirker trening eller modellvalg. Resultatet er alltid det samme: målt score blir bedre enn den reelle, og problemet oppdages først når modellen tas i bruk. Det finnes tre hovedtyper.

Target-lekkasje er når en feature egentlig er en følge av svaret eller først blir kjent etter det. Symptomet er en score som er for god til å være sann, ofte med én feature som dominerer helt. Treningslekkasje er når preprocessing tilpasses på data som inkluderer testsettet: skalering, imputering med medianen av alle rader eller valg av features ut fra hele datasettet. Testlekkasje er når testsettet brukes til å velge modell eller hyperparametere. Prøver du tjue varianter og velger den med best testscore, er testsettet blitt et valideringssett, og scoren er optimistisk.

Den beste beskyttelsen mot treningslekkasje er en pipeline. En Pipeline kobler preprocessing og modell i fast rekkefølge, og pipe.fit(X_train, y_train) tilpasser hvert steg bare på treningsdataene. Når pipelinen brukes i kryssvalidering, tilpasses alle stegene på nytt i hver fold, så valideringsdelen aldri påvirker sin egen preprocessing. Med blandede kolonnetyper kan ColumnTransformer for eksempel kjøre OneHotEncoder på kategoriene og StandardScaler på tallene i ett steg.

Koden lager et datasett av ren støy, der ingen feature har noe med labelen å gjøre.

import numpy as np
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline

rng = np.random.default_rng(0)
X = rng.normal(size=(80, 2000))           # ren støy: ingen feature henger sammen med y
y = rng.integers(0, 2, size=80)
k = 20  # @param 5..200 5

# FEIL: velg de k «beste» featurene på HELE datasettet, kryssvalider etterpå
X_valgt = SelectKBest(f_classif, k=k).fit_transform(X, y)
feil = cross_val_score(LogisticRegression(max_iter=1000), X_valgt, y, cv=5)

# RIKTIG: utvelgelsen ligger i pipelinen og tilpasses på nytt i hver fold
pipe = make_pipeline(SelectKBest(f_classif, k=k), LogisticRegression(max_iter=1000))
riktig = cross_val_score(pipe, X, y, cv=5)

print(f"utvalg før kryssvalidering (lekkasje): {feil.mean():.2f}")
print(f"utvalg inne i pipelinen:              {riktig.mean():.2f}")

Et treningssett brukes til å tilpasse modellparametere og alle preprocessing-steg. Et valideringssett brukes til å sammenligne modeller og velge hyperparametere og terskler. Et testsett ligger urørt til alt er bestemt, og brukes én gang til å anslå hvordan modellen vil gjøre det på nye data.

I scikit-learn gjøres splitten med train_test_split. test_size=0.2 legger 20 % i testdelen, og med treningsandel $r$ blir antall treningseksempler ƒandel i treningssettet. random_state låser stokkingen, slik at splitten kan gjenskapes. stratify=y gir en stratifisert splitt: klasseandelen blir den samme i begge delene. Det betyr mye når én klasse er sjelden, for med 5 % positive kan en tilfeldig testdel fort få 3 % eller 7 %. For tre deler kaller man funksjonen to ganger: først tas testsettet ut, så valideringssettet fra resten.

Tilfeldig splitt forutsetter at radene er uavhengige. Tidsserier skal splittes i tid, med trening på fortiden og test på framtiden, og da skal radene ikke stokkes (shuffle=False). Har samme pasient, kunde eller maskin flere rader, må alle radene til samme enhet havne på samme side, ellers kjenner modellen igjen enheten i stedet for å lære et mønster. En fast seed gjør splitten reproduserbar, men ikke faglig riktig.