CMD + K

Kapittel 8Begreper & formler · Ubalanserte datasett
Referanseside · Kapittel 8

Begreper & referanser

Alle nøkkelbegrepene, formlene og referansene fra Ubalanserte datasett, samlet på én side. Bruk denne som oppslag når du leser, øver flashcards eller tar quiz.

Øv med flashcards20 kort fra dette kapittelet

Begreper

Sentrale begreper fra kapittelet med korte definisjoner.

01Klasseubalanse

En klassefordeling der én eller flere klasser har langt færre observasjoner enn de andre.

02Minoritetsklasse

Klassen med færrest observasjoner i datasettet.

03Resampling

Å endre hvilke treningsobservasjoner som brukes eller hvor ofte de brukes for å påvirke klassefordelingen.

04Oversampling

Å øke representasjonen til en klasse ved å trekke eksisterende eller syntetiske observasjoner flere ganger.

05Undersampling

Å redusere antall treningsobservasjoner fra en overrepresentert klasse.

06Klassevekt

En faktor som lar feil på enkelte klasser bidra mer til tapsfunksjonen.

07Terskeljustering

Å velge beslutningsterskel etter ønsket forhold mellom feiltyper, uten å trene modellen på nytt.

08Kostnadssensitiv læring

Trening eller beslutning som tar hensyn til at ulike feil kan ha ulik praktisk kostnad.

09Majoritetsbaseline

En triviell modell som alltid predikerer majoritetsklassen. Accuracy-en er lik majoritetsandelen , og den er minstekravet en ekte modell må slå.

10SMOTE

Synthetic Minority Over-sampling Technique: lager nye minoritetseksempler ved å interpolere mellom et minoritetspunkt og en av dets nærmeste minoritetsnaboer, i stedet for å kopiere rader.

Formler

Hver formel: hva den heter, hvordan den ser ut, og hva symbolene betyr.

vektet-bce

Vektet binary cross-entropy

Klassevektene og lar ulike feiltyper påvirke treningen forskjellig.

Jgjennomsnittlig vektet tap
nantall observasjoner
w_1vekt for positiv klasse
w_0vekt for negativ klasse
y_isann label
p_ipredikert positiv sannsynlighet
balansert-klassevekt

Balansert klassevekt

En vanlig balansering gir større vekt til klasser med færre av de observasjonene.

w_cvekt for klasse c
ntotalt antall observasjoner
Kantall klasser
n_cantall observasjoner i klasse c
positiv-klasseandel

Positiv klasseandel

Klasseandelen beskriver hvor sjelden den positive klassen er før modellen vurderes.

πandel positive observasjoner
n_+antall positive
n_-antall negative
kostnadsbasert-terskel

Kostnadsbasert Bayes-terskel

Når sannsynlighetene er kalibrerte, flytter relative feilutgifter den optimale terskelen.

τbeslutningsterskel
C_FPkostnad ved falsk positiv
C_FNkostnad ved falsk negativ
undersampling-antall

Majoritet etter undersampling

Antall majoritetseksempler som beholdes når majoriteten kuttes til forholdet . Alle minoritetseksempler beholdes.

n_maj′majoritet etter undersampling
n_minantall i minoritetsklassen
rønsket forhold minoritet/majoritet
oversampling-antall

Minoritet etter oversampling

Antall minoritetseksempler etter oversampling til forholdet . Antall nye kopier er .

n_min′minoritet etter oversampling
n_majantall i majoritetsklassen
rønsket forhold minoritet/majoritet
smote-interpolasjon

SMOTE-interpolasjon

Et syntetisk minoritetspunkt legges på linjestykket mellom et minoritetspunkt og en av dets nærmeste minoritetsnaboer.

x_iminoritetspunkt
x_nnen av de nærmeste minoritetsnaboene
utilfeldig tall mellom 0 og 1

Kodesnutter

Kodesnutter fra kapittelet, vist literal.

Kode

Metrikker langs terskelen

Python
import numpy as npimport 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 skaderx = rng.normal(2.5 * y, 1.0)                     # en måling der skadene ligger 2,5 høyerescore = 1 / (1 + 19 * np.exp(3.125 - 2.5 * x))   # kalibrert P(skade | x) med 5 % priorterskel = 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()

Prøv: Dra terskel og finn lavest «kostnad» når en oversett skade koster ti falske alarmer: ligger den nær τ = 1/11, og hva ville «accuracy» valgt?

Kode

Vektet binary cross-entropy fra bunnen

Python
import numpy as np y = np.array([1, 0, 0, 0, 1, 0, 0, 0])p = np.array([0.35, 0.10, 0.20, 0.15, 0.80, 0.30, 0.05, 0.40])  # predikert P(y=1)w1 = 4.0  # @param 0.5..10 0.5w0 = 1.0                                  # vekt for negative (y=0); w1 er vekten for positive ledd_pos = -w1 * y * np.log(p)            # bare aktivt når y = 1ledd_neg = -w0 * (1 - y) * np.log(1 - p)  # bare aktivt når y = 0tap = ledd_pos + ledd_neg for i in range(len(y)):    merke = f"  (positiv, vekt {w1})" if y[i] else ""    print(f"eksempel {i}: y = {y[i]}, p = {p[i]:.2f}, bidrag {tap[i]:.3f}{merke}")print(f"vektet BCE = {tap.mean():.4f}")print(f"andel av tapet fra de to positive: {ledd_pos.sum() / tap.sum():.2f}")

Prøv: Dra w1 og se «andel av tapet fra de to positive» stige fra uvektet ved 1 og oppover.

Kode

Balanserte klassevekter i scikit-learn

Python
import numpy as npfrom sklearn.linear_model import LogisticRegressionfrom sklearn.metrics import precision_score, recall_scorefrom sklearn.model_selection import train_test_splitfrom sklearn.utils.class_weight import compute_class_weight rng = np.random.default_rng(8)n_neg = 950n_pos = 50  # @param 10..500 10X = np.r_[rng.normal(0, 1, (n_neg, 2)), rng.normal(1.5, 1, (n_pos, 2))]y = np.r_[np.zeros(n_neg, dtype=int), np.ones(n_pos, dtype=int)]X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, stratify=y, random_state=0) vekter = compute_class_weight("balanced", classes=np.array([0, 1]), y=y_tr)   # n / (K · n_c)print(f"balanserte vekter: w0 = {vekter[0]:.3f}, w1 = {vekter[1]:.3f}")for cw in (None, "balanced"):    pred = LogisticRegression(class_weight=cw).fit(X_tr, y_tr).predict(X_te)    print(f"class_weight={str(cw):8s}  recall={recall_score(y_te, pred):.2f}  "          f"precision={precision_score(y_te, pred, zero_division=0):.2f}")

Prøv: Dra n_pos opp og se «balanserte vekter» nærme seg 1 og forskjellen på «class_weight=None» og «balanced» krympe.

Læringsmål

Hva du skal kunne etter å ha lest kapittelet.

  1. 01Forklar accuracy-fella og sammenlign en modell med majoritetsbaselinen
  2. 02Velg metrikker og kurver som avslører feil på minoritetsklassen, og forklar hvorfor PR ofte er bedre enn ROC
  3. 03Regn ut antall eksempler etter under- og oversampling til et gitt klasseforhold
  4. 04Forklar hvorfor tilfeldig oversampling kan gi overtilpasning, og hvor i arbeidsflyten resampling skal skje
  5. 05Regn ut balanserte klassevekter og plasser og riktig i vektet BCE
  6. 06Velg en terskel ut fra kostnaden ved falske positive og falske negative