Új lapon nyílik meg

37. lecke

Nagy záróprojekt: Minőségosztályozó rendszer

9 rész28 kódpélda1 ábra

Általános, tetszőleges területre alkalmazható példa

Miről szól ez a lecke?

Ez a záróprojekt nem új témát tanít, hanem összefűzi az egész kurzust. Egy olyan rendszert építesz végig, amely termékeket mért tulajdonságaik alapján minőségi kategóriákba sorol: adat-előkészítés, sztenderdizálás, adatfelosztás, osztályozó modell, hiperparaméter-választás, végső kiértékelés, éles becsomagolás, végül jogi és etikai szempontok. Minden lépésnél látod, melyik leckére épül.

Amit ebben a leckében megtanulsz
  • Adat előkészítése (emlékeztető a 15, 22. leckére)
  • Train/val/test felosztás (emlékeztető a 20. leckére)
  • Standardizálás a tanító adat alapján (emlékeztető a 22. leckére)
  • Egyszerű osztályozó modell (emlékeztető a 14b lecke k-NN algoritmusára —…
  • Hiperparaméter-választás a validációs adaton (emlékeztető a 20. leckére: miért…
  • Végső kiértékelés a teszt adaton (emlékeztető a 24. leckére: confusion matrix,…
  • "éles" becsomagolás (emlékeztető a 25. lecke MLOps elveire — illusztratív, nem…
  • Jogi/etikai megjegyzés (emlékeztető a 27. leckére)
Tudnivalók
  • Olvasási idő: kb. 10 perc (a kódok kipróbálásával több)
  • 9 rész · 28 kódpélda
  • A végén gyakorló feladatok ellenőrzik a tudásodat

Ez a lecke nem egy új témát tanít — hanem az összes korábbi lecke (1–28.) tudását egyetlen, valósághoz közeli projektbe fűzi össze.

Feladat: építsünk egy rendszert, ami mért tulajdonságok (méret, súly, hibaarány) alapján 3 minőségi kategóriába sorol be egy terméket:

  • "A osztály" (jó méret, jó súly, alacsony hibaarány)
  • "B osztály" (elfogadható, de nem tökéletes)
  • "selejt" (túl sok hiba/eltérés)
SzéljegyzetMiért pont ez a példa, miért nem valami konkrétabb (pl. webáruház, ügyfélszolgálat)?

Ez a záróprojekt szándékosan egy olyan, általános területet választ (minőségellenőrzés mért adatok alapján), ami bármilyen iparágra/helyzetre átültethető — lehet szó gyümölcsről, alkatrészről, termékről, vagy bármi másról, amit számokkal le lehet írni és kategóriákba lehet sorolni — a cél, hogy a példa magától értetődő legyen, függetlenül attól, ki olvassa, és milyen területen dolgozik. A lényeg nem a konkrét téma, hanem a folyamat (pipeline), amit bemutat — ez a folyamat ugyanúgy működne bármilyen más osztályozási feladatra.

Végigjárt lépések (mindegyik egy-egy korábbi leckére épül)

  1. Adat előkészítése -> 15, 22. lecke
  2. Jellemzők (feature-ök) kinyerése -> 00b, 22. lecke
  3. Train/val/test felosztás -> 20. lecke
  4. Modell felépítése (osztályozó) -> 14, 21. lecke
  5. Tanítás + túltanulás elleni védekezés -> 14, 20. lecke
  6. Kiértékelés (precision/recall/F1) -> 24. lecke
  7. "Éles" becsomagolás (MLOps-szerűen) -> 25. lecke
  8. Jogi/etikai megjegyzések -> 27. lecke

Fontos: ez egy oktatási, leegyszerűsített példa, kis, mesterségesen létrehozott adathalmazzal — a cél nem az, hogy "éles rendszerként" használd, hanem hogy lásd, hogyan áll össze a teljes folyamat elejétől végéig, egyetlen fájlban.

PYTHON● ● ●
import numpy as np
A záróprojekt teljes folyamata öt lépésben
A záróprojekt az egész kurzus egyben: nyers adattól az előkészítésen, tanításon és értékelésen át a kész, éles rendszerig — pontosan az a folyamat, amit egy igazi AI-projektben végigjársz.

Lépés 1 — Adat előkészítése (emlékeztető a 15, 22. leckére)

Valós projektben itt nyers mérési adatokat (pl. egy érzékelő vagy egy kamera által rögzített értékeket) kellene összegyűjteni és rendszerezni — ez a záróprojekt egyszerűsít: feltesszük, hogy már kinyertünk 3 egyszerű, számszerű "jellemzőt" (feature-t) minden termékből (emlékeztető a 00b lecke vektor fogalmára — minden termék egy vektorrá alakul):

  1. meret_cm: a termék mérete centiméterben
  2. suly_g: a termék súlya grammban
  3. hiba_pontszam: hány apró hibát/eltérést észleltünk rajta (0 = tökéletes, minél magasabb, annál rosszabb)

Ez a fajta "kézi jellemző-kinyerés" egy egyszerűbb, általános megközelítés (mielőtt pl. egy képet embedding-gé alakítottunk volna — 17. lecke) — de oktatási célra tökéletesen mutatja a folyamat lényegét, és bármilyen mérhető termékre/jelenségre átültethető.

Mesterséges példaadat: 30 "termék" jellemzői + a valós kategória (0 = B osztály, 1 = A osztály, 2 = selejt)

PYTHON● ● ●
np.random.seed(42)  # EMLÉKEZTETŐ: EZ BIZTOSÍTJA, hogy MINDIG

Ugyanazt a "véletlen" adatot kapjuk — fontos a reprodukálhatósághoz (25. lecke)!

A osztályú termékek (ideális méret, ideális súly, kevés hiba):

PYTHON● ● ●
a_osztaly = np.column_stack([
    np.random.uniform(8.0, 10.0, 10),   # méret: 8-10 cm
    np.random.uniform(180, 220, 10),    # súly: 180-220 g
    np.random.randint(0, 2, 10),        # hibapontszám: 0-1
])
a_osztaly_cimke = np.ones(10)  # kategória: 1 (A osztály)

B osztályú termékek (elfogadható, de kisebb/nagyobb eltérés, közepes hibaszám):

PYTHON● ● ●
b_osztaly = np.column_stack([
    np.random.uniform(6.5, 11.0, 10),   # méret: kissé szélesebb tartomány
    np.random.uniform(150, 250, 10),    # súly: kissé szélesebb tartomány
    np.random.randint(2, 4, 10),        # hibapontszám: 2-3
])
b_osztaly_cimke = np.zeros(10)  # kategória: 0 (B osztály)

Selejt termékek (nagyon eltérő méret/súly, vagy sok hiba):

PYTHON● ● ●
selejt = np.column_stack([
    np.random.uniform(3.0, 15.0, 10),   # méret: nagyon szélsőséges
    np.random.uniform(80, 320, 10),     # súly: nagyon szélsőséges
    np.random.randint(4, 8, 10),        # hibapontszám: 4-7 (!)
])
selejt_cimke = np.full(10, 2)  # kategória: 2 (selejt)

Összefűzés egy adathalmazzá (emlékeztető a 15. lecke pandas-os megközelítésére — itt NumPy-val egyszerűsítve):

PYTHON● ● ●
X = np.vstack([a_osztaly, b_osztaly, selejt])       # jellemzők (30 x 3 mátrix)
y = np.concatenate([a_osztaly_cimke, b_osztaly_cimke, selejt_cimke])  # címkék (30,)
PYTHON● ● ●
print("LÉPÉS 1 — Adat előkészítve.")
print(f"Adathalmaz alakja: X={X.shape} (30 termék, 3 jellemző), y={y.shape}")
print(f"Egy példa 'A osztály' termék jellemzői: {X[0].round(1)} -> kategória: {int(y[0])}")
print(f"Egy példa 'selejt' termék jellemzői: {X[-1].round(1)} -> kategória: {int(y[-1])}")
print()

Lépés 2 — Train/val/test felosztás (emlékeztető a 20. leckére)

Emlékeztető a 20. lecke fő tanulságára: soha ne értékeld a modellt ugyanazon az adaton, amin tanítottad — ezért három részre osztjuk az adatot.

Először összekeverjük a sorrendet (hogy ne legyen "csoportosítva" a 3 kategória szerint egymás után):

PYTHON● ● ●
indexek = np.random.permutation(len(X))
X_kevert = X[indexek]
y_kevert = y[indexek]

60% tanító, 20% validációs, 20% teszt (Emlékeztető a 20. lecke arányaira):

PYTHON● ● ●
n = len(X_kevert)
n_train = int(n * 0.6)
n_val = int(n * 0.2)
PYTHON● ● ●
X_train, y_train = X_kevert[:n_train], y_kevert[:n_train]
X_val, y_val = X_kevert[n_train:n_train+n_val], y_kevert[n_train:n_train+n_val]
X_test, y_test = X_kevert[n_train+n_val:], y_kevert[n_train+n_val:]
PYTHON● ● ●
print("LÉPÉS 2 — Train/val/test felosztás kész (20. lecke módszerével).")
print(f"Tanító adat mérete: {len(X_train)}")
print(f"Validációs adat mérete: {len(X_val)}")
print(f"Teszt adat mérete: {len(X_test)}")
print()

Lépés 3 — Standardizálás a tanító adat alapján (emlékeztető a 22. leckére)

Emlékeztető: a 3 jellemzőnk nagyon különböző skálán mozog (3-15 cm vs. 80-320 gramm vs. 0-7 hibapont) — ha ezt nem standardizálnánk (22. lecke), a nagyobb skálájú jellemző (súly) indokolatlanul "elnyomná" a kisebb skálájúakat a tanítás során.

SzéljegyzetMiért csak a tanító adatból számoljuk az átlagot és a szórást?

Mert a validációs és a teszt adatnak a tanítás szempontjából „látatlannak" kell maradnia. Ha a teljes adatsor átlagát és szórását használnánk, a teszt adatról is kerülne információ a tanításba (ezt hívják adatszivárgásnak), és a teszteredmény a valósnál kicsit optimistább lenne. Ezért a helyes sorrend: előbb felosztás, aztán a tanító adatból számolt átlaggal és szórással alakítjuk át mindhárom részt — és később az új, éles adatot is (7. lépés).

PYTHON● ● ●
X_atlag = X_train.mean(axis=0)        # CSAK a tanító adatból számoljuk!
X_szoras = X_train.std(axis=0)
X_train = (X_train - X_atlag) / X_szoras
X_val = (X_val - X_atlag) / X_szoras    # ugyanazzal az átlaggal és szórással
X_test = (X_test - X_atlag) / X_szoras
PYTHON● ● ●
print("LÉPÉS 3 — Standardizálás elvégezve (00b + 22. lecke módszerével), a tanító adat alapján.")
print(f"A tanító adat átlaga standardizálás előtt: {X_atlag.round(2)}")
print(f"A tanító adat szórása standardizálás előtt: {X_szoras.round(2)}")
print()

Lépés 4 — Egyszerű osztályozó modell (emlékeztető a 14b lecke k-NN algoritmusára — egyszerűség kedvéért, hogy a teljes pipeline PyTorch nélkül is látható legyen)

SzéljegyzetMiért k-NN-t használunk ebben a záróprojektben, nem PyTorch neurális hálót, mint a 14. leckében?

Ez a záróprojekt szándékosan egy másik, egyszerűbb algoritmust (14b. lecke) mutat be — ezzel bizonyítva, hogy a korábban tanult lépések (adat-előkészítés, felosztás, kiértékelés) nem csak a neurális hálókra érvényesek, hanem bármely ML- algoritmusra — a "pipeline" (folyamat) ugyanaz marad, csak a középső "modell" rész cserélhető.

PYTHON● ● ●
def k_nn_osztalyoz(uj_pont, X_tanito, y_tanito, k=3):
    """Egyszerű k-NN implementáció (EMLÉKEZTETŐ a 14b, 00b LECKÉRE):
    megkeresi a k legközelebbi tanítópontot, és a köztük
    leggyakoribb kategóriát adja vissza."""
    tavolsagok = np.linalg.norm(X_tanito - uj_pont, axis=1)
    legkozelebbi_indexek = np.argsort(tavolsagok)[:k]
    legkozelebbi_cimkek = y_tanito[legkozelebbi_indexek]

A leggyakoribb címke kiválasztása (emlékeztető az argmax-ra, 21. lecke — itt "szavazásként" használva):

PYTHON● ● ●
    ertekek, darabszamok = np.unique(legkozelebbi_cimkek, return_counts=True)
    return ertekek[np.argmax(darabszamok)]
PYTHON● ● ●
def modell_ertekeles(X_adat, y_adat, X_tanito, y_tanito, k=3):
    """Végigfuttatja a k-NN-t egy egész adathalmazon, és
    visszaadja a jóslatokat."""
    joslatok = np.array([
        k_nn_osztalyoz(pont, X_tanito, y_tanito, k)
        for pont in X_adat
    ])
    return joslatok
PYTHON● ● ●
print("LÉPÉS 4 — k-NN osztályozó modell elkészítve (14b. lecke).")
print()

Lépés 5 — Hiperparaméter-választás a validációs adaton (emlékeztető a 20. leckére: miért külön validációs halmaz?)

Kipróbálunk több "k" értéket (hány szomszédot nézzünk), és a validációs adaton nézzük meg, melyik a legjobb — ez pontosan az a folyamat, amit a 20. lecke tanított: a validációs adatot a modell "beállításainak" hangolására használjuk, nem a végső értékelésre.

PYTHON● ● ●
legjobb_k = None
legjobb_pontossag = 0
PYTHON● ● ●
print("LÉPÉS 5 — Hiperparaméter-keresés (k érték) a validációs adaton:")
for k_ertek in [1, 3, 5, 7]:
    joslatok_val = modell_ertekeles(X_val, y_val, X_train, y_train, k=k_ertek)
    pontossag = np.mean(joslatok_val == y_val)
    print(f"  k={k_ertek}: pontosság a validációs adaton = {pontossag*100:.1f}%")
    if pontossag > legjobb_pontossag:
        legjobb_pontossag = pontossag
        legjobb_k = k_ertek
PYTHON● ● ●
print(f"-> Legjobb k érték: {legjobb_k} (validációs pontosság: {legjobb_pontossag*100:.1f}%)")
print()

Lépés 6 — Végső kiértékelés a teszt adaton (emlékeztető a 24. leckére: confusion matrix, precision, recall, F1)

Ez a lépés csak egyszer fut le, a legvégén, a teszt adaton — ez adja a valós, elfogulatlan képet a modell teljesítményéről (emlékeztető: a teszt adatot soha nem használtuk sem tanításra, sem hiperparaméter-választásra — 20. lecke alapelve).

PYTHON● ● ●
joslatok_teszt = modell_ertekeles(X_test, y_test, X_train, y_train, k=legjobb_k)
PYTHON● ● ●
print("LÉPÉS 6 — Végső kiértékelés a teszt adaton:")
print(f"Valós kategóriák:   {y_test.astype(int)}")
print(f"Jósolt kategóriák:  {joslatok_teszt.astype(int)}")
PYTHON● ● ●
vegso_pontossag = np.mean(joslatok_teszt == y_test)
print(f"Teszt pontosság: {vegso_pontossag*100:.1f}%")
print()

Egyszerűsített confusion matrix (emlékeztető a 24. leckére) — 3 kategóriára (0=B osztály, 1=A osztály, 2=selejt):

PYTHON● ● ●
kategoriak = [0, 1, 2]
kategoria_nevek = ["B oszt.", "A oszt.", "selejt"]
print("Confusion matrix (sor = valós, oszlop = jósolt):")
print(f"{'':10}", end="")
for nev in kategoria_nevek:
    print(f"{nev:>10}", end="")
print()
for valos_kat, valos_nev in zip(kategoriak, kategoria_nevek):
    print(f"{valos_nev:10}", end="")
    for jos_kat in kategoriak:
        darab = np.sum((y_test == valos_kat) & (joslatok_teszt == jos_kat))
        print(f"{int(darab):>10}", end="")
    print()
print()

Melyik hiba a legveszélyesebb ebben a forgatókönyvben? Emlékeztető a 24. lecke precision/recall gondolatmenetére: ha egy valós "selejt" terméket a rendszer tévesen "A osztályúnak" jelöl (alacsony recall a "selejt" kategórián), az komoly minőségi problémát okozhat (egy hibás termék eljut a vevőhöz) — ezért egy valós projektben külön figyelmet érdemelne a "selejt" kategória recall értékének maximalizálása, még akkor is, ha ez néhány "A osztályú" terméket tévesen "selejtnek" jelölne (alacsonyabb precision a "selejt" kategórián) — ez egy tudatos, üzleti/szakmai döntés, nem csak technikai kérdés.

Lépés 7 — „Éles" becsomagolás (emlékeztető a 25. lecke MLOps elveire — illusztratív, nem teljes FastAPI-kód)

PYTHON● ● ●
def mino_osztalyozo_szolgaltatas(meret_cm, suly_g, hiba_pontszam):
    """Ez a függvény reprezentálja azt, amit egy VALÓS projektben
    egy API-végpont (25. lecke FastAPI példája) hívna meg —
    bemenetként egy ÚJ termék jellemzőit kapja, kimenetként a
    jósolt kategóriát adja vissza, EMBERI OLVASÁSRA ALKALMAS
    FORMÁBAN."""
    uj_pont_nyers = np.array([meret_cm, suly_g, hiba_pontszam])

Fontos: az új adatot is ugyanazzal az átlaggal/szórással kell standardizálni, amit a tanító adaton számoltunk (lépés 3) — ez egy gyakori hibaforrás éles rendszerekben (emlékeztető a 25. lecke "verziókezelés" elvére: a standardizálási paramétereket is el kell menteni/követni a modellel együtt!):

PYTHON● ● ●
    uj_pont_standardizalt = (uj_pont_nyers - X_atlag) / X_szoras
    joslat = k_nn_osztalyoz(uj_pont_standardizalt, X_train, y_train, k=legjobb_k)
    kategoria_map = {0: "B osztály", 1: "A osztály", 2: "selejt"}
    return kategoria_map[int(joslat)]
PYTHON● ● ●
print("LÉPÉS 7 — 'Éles' szolgáltatás kipróbálása ÚJ, korábban nem")
print("látott termékekkel:")
print()

Teszteljük le 3 új, kitalált termékkel:

PYTHON● ● ●
teszt_termekek = [
    (9.0, 200, 0),    # ideális méret/súly, nincs hiba -> valószínűleg A osztály
    (7.0, 160, 3),    # kissé eltérő, közepes hiba -> valószínűleg B osztály
    (14.0, 300, 6),   # nagyon szélsőséges méret, sok hiba -> valószínűleg selejt
]
for me, su, hi in teszt_termekek:
    eredmeny = mino_osztalyozo_szolgaltatas(me, su, hi)
    print(f"  Termék (méret={me}cm, súly={su}g, hiba={hi}) -> KATEGÓRIA: {eredmeny}")
print()

Lépés 8 — Jogi/etikai megjegyzés (emlékeztető a 27. leckére)

Emlékeztető a 27. lecke rész 3-ra: egy ilyen minőségosztályozó rendszer (ami mért, objektív adatok alapján sorol be termékeket, de nem személyekről dönt) tipikusan a "minimális kockázat" kategóriába esne az EU AI Act szerint — de ha a rendszer eredménye közvetlenül befolyásolna pl. egy munkavállaló teljesítmény-értékelését (ha a "sok selejtet gyártó" gépsort vagy operátort automatikusan "megbüntetné"), az már egy magasabb kockázati szintet jelenthetne — ezért a gyakorlati javaslat (27. lecke rész 5 checklistája alapján): mindig legyen emberi áttekintési lehetőség, különösen határeseti ("B osztály" közeli) besorolásoknál.

8. lépés · Jogi és etikai megjegyzés

A 27. lecke elvei alapján az ilyen rendszert érdemes előszűrésre használni, nem pedig emberi felülvizsgálat nélküli végleges döntésre. Különösen a határeseteknél maradjon lehetőség emberi ellenőrzésre.

Összefoglaló — a teljes pipeline egyben

LépésMit csináltunk?Kapcsolódó lecke
1.Nyers adat → jellemzővektorok00b, 15, 22
2.Train/val/test felosztás20
3.Standardizálás a tanító adat alapján00b, 22
4.Modell választása (k-NN)14b, 00b
5.Hiperparaméter-hangolás a validációs adaton20
6.Végső kiértékelés a teszt adaton (confusion matrix)24
7.„Éles" becsomagolás (szolgáltatás-függvény)25
8.Jogi/etikai kockázat átgondolása27

Mi marad ugyanaz, ha más modellt választasz? A teljes sorozat végső tanulsága: ez a 8 lépés pontosan az a folyamat, amit bármilyen valós osztályozási/minőségellenőrzési projekt végigjárna — legyen szó gyártásról, mezőgazdaságról, logisztikáról, vagy bármi másról, ahol mért adatok alapján kell döntést hozni — csak a középső rész, a modell (lépés 4) változna (k-NN helyett lehetne neurális háló — 14. lecke, vagy bármely más, a 14b. leckében bemutatott algoritmus) — de a keretrendszer (adat előkészítése, felosztás, hangolás, kiértékelés, csomagolás, jogi átgondolás) ugyanaz marad, függetlenül a konkrét algoritmustól vagy alkalmazási területtől. Ez a "gondolkodásmód" az, amit ez a tananyag ténylegesen át akart adni — nem csak egyes technikákat, hanem egy teljes, megbízható, általánosan alkalmazható munkafolyamatot.

Gyakorlás

1. Módosítsd a lépés 1 adatgenerálást: adj hozzá egy negyedik jellemzőt (pl. "szín_eltérés" — mennyire tér el a termék színe az ideálistól) — futtasd újra a teljes pipeline-t, és nézd meg, változik-e a teszt pontosság.

2. Cseréld le a lépés 4 k-NN modellt egy valódi PyTorch neurális hálóra (emlékeztető a 14, 21. leckére — három kimeneti neuron kell a 3 kategóriához, CrossEntropyLoss-szal) — ez a legjobb gyakorlat annak bizonyítására, hogy a többi lépés (1, 2, 3, 5, 6, 7, 8) változatlan maradhat.

3. Gondold végig: válassz egy saját területet (bármit, ami érdekel — lehet gasztronómia, sport, kertészkedés, bármi), és írj le legalább 3 mérhető jellemzőt, amivel egy hasonló osztályozó rendszert építhetnél arra a területre.

4. Új gyakorlat — a teljes sorozat lezárása: nézd végig a 00a. lecke (tartalomjegyzék) teljes listáját, és írj magadnak egy rövid (5-10 mondatos) összefoglalót: mit tanultál a legfontosabbnak ebből a teljes sorozatból, és mi az, amivel a jövőben a legszívesebben folytatnád a tanulást?

A záróprojekt vége

Gratulálunk! Ezzel a tananyag végigért: a Python alapoktól a matematikai háttéren, a neurális hálókon és nyelvi modelleken át a jogi és gazdasági kontextusig. A záróprojektben láthatóvá vált, hogyan áll össze mindez egyetlen gyakorlati folyamatban. Ha szeretnéd lemérni, mennyi maradt meg belőle, próbáld ki a 00e. lecke végén a 60 kérdéses, pontozott záróvizsgát.