Új lapon nyílik meg

24. lecke

Modellértékelés komolyan: Precision, Recall, F1, Confusion matrix, ROC-AUC

7 rész17 kódpélda1 ábra

Miért nem elég az egyszerű „pontosság" (accuracy)?

Miről szól ez a lecke?

Egy 95%-os pontosságú modell is lehet használhatatlan — ha például a spamek többségét átengedi. Ez a lecke megmutatja, miért kevés önmagában a pontosság (accuracy), és bevezeti a valódi értékelési eszközöket: a konfúziós mátrixot, a precisiont, a recallt, az F1-pontszámot, valamint a ROC-görbét és az AUC-t. A 21. lecke spamszűrőjén mindet ki is próbálod.

Amit ebben a leckében megtanulsz
  • A konfúziós mátrix (confusion matrix): a minden más mérőszám alapja
  • Precision (pontosság-specifikusan): "ha a modell spam-et mond, mennyire hihetek…
  • Recall (felidézés): "az összes valódi spam közül hányat talált meg a modell?"
  • F1-score: egyetlen szám, ami mindkettőt figyelembe veszi
  • Gyakorlati példa: a 21. lecke spam-szűrőjének részletes kiértékelése
  • ROC-görbe és AUC: a "döntési küszöb" hatásának vizsgálata
Tudnivalók
  • Olvasási idő: kb. 5 perc (a kódok kipróbálásával több)
  • 7 rész · 17 kódpélda
  • A végén gyakorló feladatok ellenőrzik a tudásodat

A 21. leckében a spam-szűrő modellünket egyetlen számmal értékeltük: "pontosság" (hány % esetben találta el a helyes választ). Ez a lecke megmutatja, miért veszélyes ez önmagában, és bevezeti azokat a mélyebb eszközöket, amiket a valós AI-fejlesztők használnak.

SzéljegyzetA 21. leckében a modellünk 95% pontosságot ért el (például) — ez nem elég jó hír?

Nézzük meg ezt a következő, sokkoló példával: képzeld el, hogy 1000 email közül csak 10 a tényleges spam (990 nem spam). Egy "lusta" modell, ami mindig azt mondja "nem spam" (soha nem ellenőriz semmit!), 990/1000 = 99% pontosságot érne el — mégis teljesen hasznavehetetlen, mert egyetlen spam-et sem szűrt ki. Ez a lecke pontosan ezt a rejtett csapdát leplezi le.

PYTHON● ● ●
import torch
import torch.nn as nn
import numpy as np
Tévesztési mátrix: helyes és hibás jóslatok négy mezőben
A tévesztési mátrix megmutatja, hogyan téved a modell — a puszta pontosság kevés. A két zöld mező a helyes döntés, a két piros a kétféle hiba; ezekből számoljuk a precisiont és a recallt.

Rész 1 — A konfúziós mátrix (confusion matrix): a minden más mérőszám alapja

Egy osztályozási feladatnál (21. lecke) a modell döntésének négyféle kimenetele lehet (2 osztályra egyszerűsítve — "spam" vs. "nem spam"):

  1. Igaz pozitív (True Positive, tp): a modell "spam"-et mondott, és valóban spam volt. -> eltalálta.
  2. Igaz negatív (True Negative, tn): a modell "nem spam"-et mondott, és valóban nem spam volt. -> eltalálta.
  3. Hamis pozitív (False Positive, fp): a modell "spam"-et mondott, de valójában nem volt az. -> tévedett ("félreverte a harangot").
  4. Hamis negatív (False Negative, fn): a modell "nem spam"-et mondott, de valójában spam volt. -> tévedett ("átengedte a betolakodót").

Ezt a négy számot egy táblázatba (mátrixba) rendezve kapjuk a konfúziós mátrixot:

Modell: „nem spam"Modell: „spam"
Valós: nem spamTNFP
Valós: spamFNTP

Miért nem elég az egyetlen 'pontosság' szám, ha már van ez a négy részletesebb szám? Mert a hamis pozitív és a hamis negatív hiba gyakran nagyon különböző súlyú, valós következménnyel jár! Egy spam-szűrőnél: ha a modell egy fontos ügyfél-emailt tévesen "spam"-nek minősít (hamis pozitív), az ügyfél elveszítheti az üzenetet — ez akár üzleti kárt is okozhat. Ha viszont egy valós spam átcsúszik (hamis negatív), az "csak" kellemetlen, de kevésbé súlyos. Egy orvosi diagnosztikai AI-nál (emlékeztető a 14b lecke döntési fa példájára) ez pont fordítva lehet: egy hamis negatív (a rendszer "egészségesnek" mondja a beteg pácienst) sokkal veszélyesebb lehet, mint egy hamis pozitív (felesleges további vizsgálat). Egy egyetlen "pontosság" szám ezt a különbséget elrejti.

Rész 2 — Precision (pontosság-specifikusan): "ha a modell spam-et mond, mennyire hihetek neki?"

Képlet:

Precision = tp / (tp + fp)

Magyarul mit jelent ez a tört? A nevező (tp + fp) az összes olyan eset, amikor a modell "spam"-et mondott (függetlenül attól, hogy igaza volt-e). a számláló (tp) csak azok az esetek, amikor tényleg igaza is volt. Tehát a precision azt méri: "a modell 'spam' riasztásai közül hány % volt valóban találat?" — ha a precision alacsony, a modell "túlérzékeny", sok valódi, jó emailt is spam-nek bélyegez (sok hamis pozitív).

Rész 3 — Recall (felidézés): "az összes valódi spam közül hányat talált meg a modell?"

Képlet:

Recall = tp / (tp + fn)

SzéljegyzetMiben különbözik ez a precision-től?

A nevező itt más: (tp + fn) az összes tényleges, valós spam (függetlenül attól, hogy a modell felismerte-e). a recall azt méri: "az összes igazi spam közül hány %-ot kapott el a modell?" — ha a recall alacsony, a modell "túl engedékeny", sok valódi spam átcsúszik rajta észrevétlenül (sok hamis negatív).

Ez a kettő (precision és recall) gyakran egymás "ellen" hat — ha a modellt "óvatosabbá" teszed (mindent spam-nek jelöl, hogy biztosan ne csúsztasson át semmit), a recall nő, de a precision romlik (mert sok jó emailt is spam-nek jelöl). Ez a "precision-recall kompromisszum" a gépi tanulás egyik alapvető, gyakorlati döntési kérdése.

Rész 4 — F1-score: egyetlen szám, ami mindkettőt figyelembe veszi

Képlet (a precision és recall "harmonikus átlaga"):

F1 = 2 * (Precision * Recall) / (Precision + Recall)

Miért nem egy egyszerű átlag ((Precision + Recall) / 2), miért 'harmonikus' átlag? A harmonikus átlag speciális tulajdonsága: erősen "bünteti", ha az egyik érték nagyon alacsony, még akkor is, ha a másik nagyon magas. Példa: ha Precision=1.0 (100%) és Recall=0.01 (1%), az egyszerű átlag (1.0+0.01)/2 = 0.505 (50.5%) lenne — ez Félrevezetően jónak tűnik. A harmonikus átlag (F1) ezzel szemben kb. 0.02 (2%) lenne — sokkal pontosabban tükrözi, hogy a modell valójában nagyon rossz (hiszen a valós spamek 99%-át nem veszi észre!). az F1-score ezért egy megbízhatóbb, "őszintébb" összefoglaló szám, mint a sima átlag vagy a pontosság (accuracy).

Rész 5 — Gyakorlati példa: a 21. lecke spam-szűrőjének részletes kiértékelése

Újra felépítjük a 21. lecke modelljét, de most tudatosan egy "kiegyensúlyozatlan" (imbalanced) adathalmazzal dolgozunk — több "nem spam" példával, mint "spam"-mel — ez sokkal jobban hasonlít a valóságra (a legtöbb email nem spam), és jól bemutatja, miért fontos a részletes értékelés.

PYTHON● ● ●
torch.manual_seed(42)
PYTHON● ● ●
adatok_x = torch.tensor([
    [0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 0], [1, 1, 0],
    [0, 0, 0], [2, 1, 0], [0, 0, 0], [0, 0, 0], [1, 0, 0],
    [7, 6, 1], [8, 7, 1], [6, 5, 1], [9, 8, 1], [5, 4, 1],
    [0, 0, 0], [0, 1, 0], [1, 0, 0], [0, 0, 0], [2, 0, 0],
], dtype=torch.float32)
PYTHON● ● ●
adatok_y = torch.tensor([
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   # 10 "nem spam"
    1, 1, 1, 1, 1,                    # 5 "spam"
    0, 0, 0, 0, 0,                    # további 5 "nem spam"
], dtype=torch.long)
PYTHON● ● ●
print(f"Adathalmaz összetétele: {(adatok_y == 0).sum().item()} nem spam, "
      f"{(adatok_y == 1).sum().item()} spam")
print("(EZ egy TIPIKUS 'KIEGYENSÚLYOZATLAN' adathalmaz — a valóságban")
print(" a legtöbb email valóban nem spam.)\n")
PYTHON● ● ●
class SpamModell(nn.Module):
    def __init__(self):
        super().__init__()
        self.reteg1 = nn.Linear(3, 8)
        self.aktivacio = nn.ReLU()
        self.reteg2 = nn.Linear(8, 2)
PYTHON● ● ●
    def forward(self, x):
        x = self.reteg1(x)
        x = self.aktivacio(x)
        x = self.reteg2(x)
        return x
PYTHON● ● ●
model = SpamModell()
hibafuggveny = nn.CrossEntropyLoss()
optimalizalo = torch.optim.SGD(model.parameters(), lr=0.01)
PYTHON● ● ●
for korszak in range(300):
    joslat = model(adatok_x)
    hiba = hibafuggveny(joslat, adatok_y)
    optimalizalo.zero_grad()
    hiba.backward()
    optimalizalo.step()
PYTHON● ● ●
with torch.no_grad():
    logitek = model(adatok_x)
    joslatok = torch.argmax(logitek, dim=1)
PYTHON● ● ●
def konfuzios_matrix_szamitasa(valos, jelzett):
    """
    Kézzel kiszámolja a konfúziós mátrix négy elemét — hogy
    LÁSD, PONTOSAN HOGYAN épül fel, mielőtt egy KÉSZ
    KÖNYVTÁRI FÜGGVÉNYT használnál rá.
    """
    tp = ((jelzett == 1) & (valos == 1)).sum().item()
    tn = ((jelzett == 0) & (valos == 0)).sum().item()
    fp = ((jelzett == 1) & (valos == 0)).sum().item()
    fn = ((jelzett == 0) & (valos == 1)).sum().item()
    return tp, tn, fp, fn
PYTHON● ● ●
tp, tn, fp, fn = konfuzios_matrix_szamitasa(adatok_y, joslatok)
PYTHON● ● ●
print("KONFÚZIÓS MÁTRIX:")
print(f"  Igaz Pozitív (TP):  {tp}   (helyesen jelzett spam)")
print(f"  Igaz Negatív (TN):  {tn}   (helyesen jelzett nem-spam)")
print(f"  Hamis Pozitív (FP): {fp}   (tévesen spam-nek jelzett)")
print(f"  Hamis Negatív (FN): {fn}   (tévesen átengedett spam)\n")
PYTHON● ● ●
pontossag = (tp + tn) / (tp + tn + fp + fn)
precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
PYTHON● ● ●
print("MÉRŐSZÁMOK:")
print(f"  Pontosság (Accuracy):  {pontossag*100:.1f}%")
print(f"  Precision:             {precision*100:.1f}%")
print(f"  Recall:                {recall*100:.1f}%")
print(f"  F1-score:               {f1*100:.1f}%\n")
Széljegyzet

Ha a Precision és a Recall között nagy a különbség, az azt jelzi, hogy a modell valamelyik irányba eltolódik. Ha például a Recall alacsony, a modell óvatos: kevés e-mailt jelöl spamnek, de amit megjelöl, abban nagyobb valószínűséggel igaza van.

Rész 6 — ROC-görbe és AUC: a "döntési küszöb" hatásának vizsgálata

Emlékeztető a 21. leckéből: a modell végső döntése (argmax) egy rejtett feltételezésre épül: "ha a spam valószínűség > 50%, akkor spam." de ez az 50%-os határ ("küszöb", threshold) nem szent szám — megváltoztatható!

Ha a küszöböt lejjebb viszed (pl. 30%), a modell "érzékenyebb" lesz (több emailt jelöl spam-nek -> a recall nő, de a precision valószínűleg csökken). Ha feljebb viszed (pl. 70%), a modell "óvatosabb" lesz (fordított hatás).

a ROC-görbe (Receiver Operating Characteristic) pontosan ezt ábrázolja: hogyan változik a modell viselkedése (két másik mérőszám, a "true positive rate" és a "false positive rate" segítségével), ha végigpróbálod az összes lehetséges küszöböt 0%-tól 100%-ig.

az AUC (Area Under the Curve — "a görbe alatti terület") egy egyetlen számmá sűríti ezt a görbét: 1.0 = Tökéletes modell (minden küszöbnél tökéletesen megkülönbözteti a két osztályt), 0.5 = a modell nem jobb, mint a véletlen találgatás (pl. egy érmefeldobás).

PYTHON● ● ●
with torch.no_grad():
    valoszinusegek = torch.softmax(model(adatok_x), dim=1)[:, 1]  # a "spam" osztály valószínűsége
PYTHON● ● ●
print("PÉLDA: KÜLÖNBÖZŐ KÜSZÖBÖK HATÁSA (ROC-GÖRBE ALAPJA):")
for kuszob in [0.3, 0.5, 0.7]:
    joslat_ezen_kuszobbel = (valoszinusegek >= kuszob).long()
    tp_k, tn_k, fp_k, fn_k = konfuzios_matrix_szamitasa(adatok_y, joslat_ezen_kuszobbel)
    recall_k = tp_k / (tp_k + fn_k) if (tp_k + fn_k) > 0 else 0
    precision_k = tp_k / (tp_k + fp_k) if (tp_k + fp_k) > 0 else 0
    print(f"  Küszöb={kuszob}: Precision={precision_k*100:.0f}%, Recall={recall_k*100:.0f}%")
Széljegyzet

Figyeld meg, hogyan változik a Precision és Recall aránya a küszöb módosításával. Ezt a küszöböt a konkrét felhasználási célhoz kell igazítani. Egy érzékeny szűrésnél például alacsonyabb küszöb több gyanús esetet foghat meg, ugyanakkor több hamis riasztást is eredményezhet.

Összefoglaló táblázat — mikor melyik mérőszám számít?

MérőszámMit mér?Mikor figyelj rá különösen?
AccuracyÖsszes helyes döntés arányaCsak kiegyensúlyozott adatnál megbízható (a 20. lecke elve is!)
Precision„Ha a modell pozitívot mond, mennyire hihetek neki?"Amikor egy hamis pozitív drága (pl. jó ügyfél-e-mail spamnek jelölése)
Recall„Az összes valós pozitívból mennyit talált meg?"Amikor egy hamis negatív veszélyes (pl. orvosi szűrésnél kihagyott eset)
F1-scoreA precision és a recall kiegyensúlyozott összefoglalásaAmikor mindkettő számít, és egy számra van szükséged az összehasonlításhoz
ROC-AUCA modell megkülönböztető képessége, a konkrét küszöbtől függetlenülAmikor a döntési küszöböt is hangolni akarod
Gyakorlás

1. Futtasd le a kódot — nézd meg a kiírt Precision/Recall értékeket. Ha az egyik sokkal alacsonyabb, mint a másik, mit jelent ez a modelled viselkedéséről (túl óvatos vagy túl érzékeny)?

2. Módosítsd a rész 6 kódját: próbálj ki még több küszöböt (0.1, 0.2, ..., 0.9) — Írd fel egy táblázatba az eredményeket, és gondold végig: melyik küszöböt választanád, ha egy valódi spam-szűrőt építenél egy kisvállalkozás számára (hol van a te személyes határod Precision és Recall között)?

3. Új gyakorlat: telepítsd a scikit-learn könyvtárat (pip install scikit-learn, ha még nincs), és használd a sklearn.metrics.classification_report() kész függvényét (from sklearn.metrics import classification_report) a fenti adatok_y és joslatok tenzorokon (előbb alakítsd őket .NumPy()-vá) — hasonlítsd össze a kész függvény kimenetét a kézzel számolt eredményeiddel — egyeznek-e?

Források és további olvasnivaló

A lecke témájának hivatalos dokumentációi és alapvető cikkei:
• scikit-learn — modellek értékelése — scikit-learn.org