Ubalanserte datasett

Klasseubalanse betyr at klassene er svært ulikt representert: én svindel per tusen transaksjoner, 2,5 % skadde pakker eller noen få syke blant mange friske i en screening. Den sjeldne klassen kalles minoritetsklasse. Det er nesten alltid den vi leter etter, så den kalles positiv. Det første tallet du bør regne ut, er ƒpositiv klasseandel, $\pi =n_{+}/(n_{+}+n_{-})$.

Problemet er at accuracy teller alle riktige svar likt, og den negative klassen dominerer. En triviell modell som alltid svarer «negativ», en majoritetsbaseline, får accuracy $1-\pi$ uten å ha lært noe som helst. Med $\pi =0,025$ blir det 97,5 %. Enhver modell må sammenlignes med dette tallet, ikke med 50 %.

Ta en modell for transportskader på 1000 forsendelser, der 25 er skadet. Den finner 18 av de 25 skadene (TP = 18, FN = 7), men lager også 24 falske alarmer (FP = 24), så TN = 951.

Accuracy er $(18+951)/1000=0,969$, altså lavere enn baselinen på 0,975. Likevel er modellen langt mer nyttig: den finner 72 % av skadene, mens baselinen finner null. Accuracy rangerer de to modellene i feil rekkefølge. Det er accuracy-fella: ved sterk ubalanse sier accuracy mest om hvor sjelden den positive klassen er, og lite om hvor godt modellen finner den.

Under ubalanse trenger vi metrikker der den sjeldne klassen ikke drukner. Recall for den positive klassen, $TP/(TP+FN)$, sier hvor stor andel av de sjeldne tilfellene vi finner. Precision, $TP/(TP+FP)$, sier hvor mange av varslene som er ekte. Sammen med F1 og selve forvirringsmatrisen gir de et ærlig bilde. Accuracy bør bare rapporteres side om side med baselinen.

ROC-kurven og AUC kan derimot se misvisende gode ut. FPR deler på alle negative, og når de er mange, blir selv mange falske alarmer en liten andel. Tenk på en screening av 20 000 personer der 100 er syke: FPR 0,02 høres lite ut, men gir nesten 400 falske alarmer mot høyst 100 ekte funn. Precision avslører dette, fordi den sammenligner falske alarmer direkte med ekte funn.

Derfor er precision–recall-kurven (PR-kurven) ofte mer informativ enn ROC når den positive klassen er sjelden. Grunnlinjen i et PR-plott er positivandelen $\pi$: en modell som gjetter, har precision $\pi$ uansett recall. En PR-kurve som ligger like over $\pi$, er svak selv om ROC-AUC ser høy ut. Arealet under PR-kurven oppsummeres ofte som average precision.

Resampling endrer klassefordelingen i treningsdataene, slik at minoriteten får større tyngde. Hvorfor hjelper det? Med 1400 normale og 200 feil kommer sju av åtte bidrag til tapet fra majoriteten, og modellen lærer fort at «normal» nesten alltid lønner seg. Når klassene veier likere under treningen, må modellen faktisk lære hva som skiller dem. De to enkleste variantene er:

• •Undersampling: fjern tilfeldige majoritetseksempler til ønsket forhold er nådd. Treningssettet krymper.
• •Oversampling: trekk minoritetseksempler med tilbakelegging og legg til kopier til ønsket forhold er nådd. Treningssettet vokser.

Målforholdet skrives ofte $r=n_{\text{min}}/n_{\text{maj}}$ etter resampling, der $r=1$ betyr 1:1. Da gir ƒmajoritet etter undersampling og ƒminoritet etter oversampling

Undersampling beholder alle minoritetseksemplene og kutter majoriteten ned til $n_{\text{min}}/r$. Oversampling beholder alle majoritetseksemplene og fyller minoriteten opp til $r\cdot n_{\text{maj}}$, så antall nye kopier er $r\cdot n_{\text{maj}}-n_{\text{min}}$.

Resampling gjøres bare på treningsdata, etter splitten. Validerings- og testsettet beholder den virkelige fordelingen, ellers måler de ikke det modellen vil møte i bruk.

Begge teknikkene har en pris. Undersampling kaster informasjon. Med 1400 normale og 200 feil forsvinner 1200 normale eksempler ved 1:1, og blant dem kan det være sjeldne varianter av normal drift som modellen trengte for å unngå falske alarmer. Det fungerer best når majoriteten er enorm og svært ensartet.

Tilfeldig oversampling lager ingen ny informasjon, bare kopier. Hvis hvert minoritetseksempel brukes 15 ganger, får de samme få punktene stor tyngde i tapet, og en fleksibel modell, som et dypt tre eller k-NN med liten $k$, kan lære akkurat disse punktene utenat. Resultatet er overtilpasning til minoriteten: høy recall på trening og skuffende recall på nye data.

SMOTE demper problemet ved å lage syntetiske minoritetspunkter i stedet for kopier. For et minoritetspunkt ${\mathbf{x}}_i$ velges en av dets nærmeste minoritetsnaboer ${\mathbf{x}}_{nn}$, og et nytt punkt legges på linjen mellom dem, ƒSMOTE-interpolasjon:

Det gir variasjon, men kan lage urealistiske punkter der klassene overlapper.

Uansett metode må resampling skje etter splitten, og i kryssvalidering inne i hver treningsfold, i en pipeline. Oversampler du før splitten, havner kopier av samme eksempel både i trening og validering, og modellen belønnes for å kjenne igjen kopier. Resampling endrer også klassefordelingen modellen ser, så sannsynlighetene blir systematisk for høye for minoriteten og må kalibreres før de tolkes som risiko.

I stedet for å endre dataene kan vi endre hvor mye hver feil koster i tapet. En klassevekt $w_c$ ganges med tapet til hvert eksempel i klasse $c$. Den vanligste oppskriften lar vekten være omvendt proporsjonal med klassens størrelse, ƒbalansert klassevekt:

der $n$ er antall eksempler, $K$ antall klasser og $n_c$ antall i klasse $c$. Logikken: klasse $c$ har $n_c$ eksempler med vekt $n/(K{n}_c)$ hver, så klassens samlede vekt blir $n/K$, lik for alle klasser. En sjelden klasse får vekt over 1 og en vanlig under 1. Er klassene like store, blir alle vektene 1.

Klassevekter ligner oversampling, fordi vekt 5 virker i tapet omtrent som å kopiere eksemplet fem ganger. Men ingen rader dupliseres, datasettet blir ikke større, og ingen kopier kan lekke over i validering. I scikit-learn er dette class_weight="balanced", og compute_class_weight regner ut vektene med nøyaktig denne formelen.

Figuren viser vektene for 1800 friske og 200 syke. Sjekk at begge klassene får samme totale vekt.

Klassevektene brukes inne i tapsfunksjonen. For binær klassifikasjon blir binary cross-entropy vektet slik, ƒvektet binary cross-entropy:

der $p_i$ er predikert sannsynlighet for positiv klasse. Les leddene ett om gangen. Når $y_i=1$, er bare det første leddet aktivt, og tapet er $-w_1\log p_i$, som blir stort når modellen gir en ekte positiv lav $p_i$. Når $y_i=0$, er bare det andre leddet aktivt: $-w_0\log (1-p_i)$. Vekten for den positive klassen, $w_1$, skal altså stå foran $y_i\log p_i$, og $w_0$ foran $(1-y_i)\log (1-p_i)$. Bytter du dem, straffer du feil på den vanlige klassen hardere og gjør ubalansen verre.

Hva skjer under treningen? For logistisk regresjon blir den deriverte av hvert eksempels tap med hensyn på scoren $w_{y_i}(p_i-y_i)$, altså den vanlige $p_i-y_i$ ganget med vekten. En oversett positiv dytter vektene $w_1$ ganger så hardt som før. Beslutningsgrensen flyttes inn mot majoriteten, flere eksempler predikeres positive, recall øker og precision synker. Prisen er at sannsynlighetene ikke lenger er kalibrerte, fordi modellen har lært en verden der positive er vanligere enn de er.

Det tredje verktøyet rører verken data eller tap. Terskeljustering skjer etter treningen: modellen gir scorer, og vi velger hvor grensen skal gå. Standardterskelen 0,5 er bare en konvensjon. Under ubalanse ligger scorene til de positive ofte under 0,5, fordi modellen har lært at positive er sjeldne. Senker vi terskelen, predikeres flere positive, recall øker og precision synker. Hever vi den, skjer det motsatte. Rangeringen og AUC er uendret; vi velger bare et annet punkt på kurven. Tiltaket er billig, reversibelt og kan justeres når kapasitet eller kostnader endrer seg.

Hvor skal terskelen ligge? I kostnadssensitiv læring setter vi pris på feilene. Anta at sannsynlighetene er kalibrerte, at en falsk positiv koster $C_{FP}$ og en falsk negativ $C_{FN}$. Flagger vi et eksempel med sannsynlighet $p$, er forventet kostnad $(1-p)C_{FP}$, for kostnaden påløper bare hvis eksemplet var negativt. Lar vi det gå, er forventet kostnad $p{C}_{FN}$. Flagg når det første er minst, altså når $p>\tau$ med ƒKostnadsbasert Bayes-terskel:

Jo dyrere en oversett positiv er, desto lavere terskel. Terskelen velges på valideringsdata, aldri på testsettet. Er det i stedet kapasiteten som begrenser, for eksempel 50 manuelle kontroller per dag, velger man heller de 50 høyeste scorene.

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(4172)
y = np.r_[np.zeros(950, dtype=int), np.ones(50, dtype=int)]   # 1000 forsendelser, 50 skader
x = rng.normal(2.5 * y, 1.0)                     # en måling der skadene ligger 2,5 høyere
score = 1 / (1 + 19 * np.exp(3.125 - 2.5 * x))   # kalibrert P(skade | x) med 5 % prior
terskel = 0.50  # @param 0.05..0.95 0.05

def metrikker(t):
    pred = score >= t
    tp, fp = np.sum(pred & (y == 1)), np.sum(pred & (y == 0))
    fn = np.sum(~pred & (y == 1))
    return tp / max(tp + fp, 1), tp / (tp + fn), np.mean(pred == y), 10 * fn + fp

p, r, a, kost = metrikker(terskel)
print(f"τ = {terskel:.2f}: precision {p:.2f}, recall {r:.2f}, accuracy {a:.3f}")
print(f"kostnad når en oversett skade koster som ti falske alarmer: {kost}")

ts = np.linspace(0.05, 0.95, 91)
kurver = np.array([metrikker(t)[:3] for t in ts])
plt.figure()
for kol, navn in enumerate(["precision", "recall", "accuracy"]):
    plt.plot(ts, kurver[:, kol], label=navn)
plt.plot([terskel, terskel], [0, 1], label=f"valgt τ = {terskel:.2f}")
plt.xlabel("terskel τ")
plt.legend()
plt.tight_layout()
plt.show()

Tabellen samler de fire tiltakene: hvor i arbeidsflyten de virker, og hva du må passe på.