Új lapon nyílik meg

Kiegészítő lecke

Hogyan "tanul" valójában egy gépi modell?

6 rész10 kódpélda1 ábra

Mintázatok, extrapoláció, és a megbízhatóság kérdése

Miről szól ez a lecke?

Az előző leckében a modell „megtanult" valamit — de mit jelent ez pontosan? Ez a lecke a színfalak mögé néz: mi az a mintázat, hogyan találja meg a gép a legjobb egyenest a hiba lépésenkénti csökkentésével, miért tűnik egy AI „okosnak", miért hallucinál, és hogyan lehet megbízhatósági ellenőrzést beépíteni. Itt a megértésen van a hangsúly, nem a kódon.

Amit ebben a leckében megtanulsz
  • Mi az a "mintázat"? (nincs benne varázslat)
  • Hogyan találja meg a gép ezt az egyenest?
  • Miért tűnik egy AI mégis "emberinek", "okosnak"?
  • A "stop vonal" hiánya: miért hallucinál az AI?
  • Megoldás: hogyan építhetünk be egy "megbízhatósági indikátort"?
  • A keretezés (framing) problémája: miért nem ellenőrzi az AI a valóságot, csak a…
Tudnivalók
  • Olvasási idő: kb. 10 perc (a kódok kipróbálásával több)
  • 6 rész · 10 kódpélda
  • A végén gyakorló feladatok ellenőrzik a tudásodat

Ez a lecke a 12. lecke (első ML modell) mélyebb megértését adja. Összegyűjti a legfontosabb "miért/hogyan" kérdéseket és a rájuk adott válaszokat, hogy bármikor visszaolvashatók legyenek.

A hiba lépésről lépésre csökken, ahogy a modell tanul
Így „tanul" a gép: minden lépésben méri a hibáját, és addig hangolja magát, amíg a hiba a lehető legkisebb nem lesz. A görbe lefelé tart — ez maga a tanulás.

Rész 1 — Mi az a "mintázat"? (nincs benne varázslat)

Nézzük az autós adatunkat:

km_futottár (ezer Ft)
10 0008500
30 0007200
60 0005800
90 0004500
120 0003200
150 0002100

Ha ránézel, te magad is látod a mintázatot: minél több km, annál alacsonyabb az ár, és ez elég egyenletesen csökken. Ez a "mintázat" — semmi több, mint egy megfigyelhető, ismétlődő összefüggés az adatokban.

A LinearRegression modell dolga: megtalálni egy egyenest, ami erre a mintázatra a legjobban illeszkedik. Az egyenes képlete:

ár = meredekség × km + kezdőpont

A "meredekség" és a "kezdőpont" azok a konkrét számok, amiket a modell magától talál ki a tanítás során.

Rész 2 — Hogyan találja meg a gép ezt az egyenest?

Hasonlat: képzeld el, hogy egy sötét szobában állsz, és meg kell találnod egy tárgyat a padlón — de nem látsz semmit. Az egyetlen segítséged: valaki megmondja, "melegebb" vagy "hidegebb" vagy, amikor lépsz egyet valamerre.

Ez pontosan az, amit a gép csinál — csak nem egy tárgyat, hanem a legjobb egyenest keresi, ugyanezzel a "próbálgatás + visszajelzés" módszerrel.

Konkrét példa, lépésről lépésre (2 autóval, egyszerűsítve):

10 000 km -> 8500 ezer Ft (valós) 150 000 km -> 2100 ezer Ft (valós)

1. Lépés: a gép kitalál egy kezdő egyenest (találomra): ár = -0.01 * km + 9000

2. Lépés: kiszámolja, mit "jósolna" ez, és összeveti a valósággal:

kmvalós áregyenes jóslataeltérés (hiba)
10 00085009000 - 100 = 8900400-zal téved
150 00021009000 - 1500 = 75005400-zal téved!

3. Lépés: az eltéréseket négyzetre emeli és összeadja (hogy a pozitív/negatív eltérések ne "kioltsák" egymást) — ez adja a teljes hibát, egyetlen számban kifejezve.

4. Lépés: megnézi, mi történne, ha kicsit másképp állítaná be az egyenest (pl. a meredekség -0.011 legyen -0.01 helyett). Újraszámolja a hibát. Ha csökkent -> jó irány, megy tovább arra. Ha nőtt -> rossz irány, fordít. (Ez a "melegebb/hidegebb" játék matematikai megfelelője.)

5. Lépés: ezt ismétli, sokszor (akár több ezerszer), apró lépésekkel, amíg a hiba már alig csökken tovább — ekkor mondja a gép: "ez a legjobb egyenes, amit találtam."

A lényeg: nincs benne intelligencia, nincs "megértés" — csak egy nagyon sokszor ismételt, egyszerű számolás: "próbáljunk egy kicsit más beállítást, nézzük meg jobb-e, ha igen, menjünk arra tovább." A model.fit(X, y) sor pontosan ezt csinálja a háttérben, emberi szemmel láthatatlanul gyorsan.

(Ezt a módszert "gradient descent"-nek hívják a szakmában — nem kell megjegyezned a nevet, csak az elvet: szisztematikus próbálgatás + hibacsökkentés alapján való korrekció.)

SzéljegyzetMi az a 'tanulási ráta' (learning rate)?

Azt, hogy egy lépésben mekkorát változtat a gép a beállításon, a "tanulási ráta" (learning rate) szabályozza. Ha túl nagy, a gép túllépi a legjobb megoldást és ide-oda ugrál; ha túl kicsi, nagyon lassan tanul. Ez az egyik legfontosabb beállítás, amit egy valódi modell tanításakor hangolni kell.

Rész 3 — Miért tűnik egy AI mégis "emberinek", "okosnak"?

Ami most történt (6 autó, egy egyenes) ugyanaz az alapelv, mint ami egy ChatGPT vagy Claude mögött is áll — csak több milliárdszor nagyobb léptékben, és nem egyenest, hanem szavak közötti statisztikai mintázatokat keres, ugyanezzel a "próbálgatás + hiba csökkentése" módszerrel.

Nincs benne semmi más, csak ez: rengeteg szöveget "megnézett" betanításkor, és megtanulta, hogy adott szavak után statisztikailag milyen szavak "szoktak" következni — pontosan úgy, ahogy a kis modellünk megtanulta, hogy adott km-hez milyen ár "szokott" tartozni.

Miért tűnik mégis "emberinek"? Mert az emberi nyelv maga annyira gazdag mintázatokkal teli, hogy ha valami elég jól megtanulja ezeket a mintázatokat, a kimenet úgy fest, mintha értené — anélkül, hogy bármit is "értene" a szó emberi értelmében.

Hasonlat: ez egy kicsit olyan, mint egy nagyon jó papagáj, ami nem 10, hanem milliárdnyi mondatmintát hallott, és olyan ügyesen kombinálja őket, hogy a kimenet koherensnek, sőt kreatívnak tűnik — de a "motorháztető alatt" ugyanaz a szám-alapú próbálgatás zajlik, amit az autós példán láttunk.

SzéljegyzetVan hivatalos neve a 'hibának', amit a gép csökkent?

A szakirodalom ezt "veszteségfüggvénynek" (loss function) hívja — ez az a szám, amit a tanítás során a gép lépésről lépésre csökkenteni próbál. A mi autós példánkban ez a jóslat és a valós ár közti, négyzetre emelt eltérések összege volt; nagy nyelvi modelleknél ugyanez az elv, csak sokkal bonyolultabb, szöveg-alapú veszteségfüggvénnyel.

Rész 4 — A "stop vonal" hiánya: miért hallucinál az AI?

A LinearRegression modell szó szerint csak egy dolgot tud: ár = meredekség * km + kezdőpont

Ha behelyettesítesz egy számot, mindig kiszámolja a képlet eredményét, függetlenül attól, hogy az a szám 50 000 vagy 50 000 000. Nincs beépített "óvatosság" vagy "bizonytalanság-érzékelés".

Példa: ha megkérdezed a modellt egy 500 000 km-t futott autóról, a modell vakon folytatja ugyanazt az egyenest, és egy negatív árat adna vissza (ami nyilván képtelenség — egy autóért nem fizethetsz "mínusz pénzt"). A modell ezt nem veszi észre, mert nincs beépítve semmi, ami szólna: "hé, ez a tartomány kívül esik azon, amit valaha láttam!"

Ez nem hiba — ez a rendszer alapvető természete. A modell nem "tudja, hogy nem tudja" — csak azt tudja, amit megtanítottak neki: "ha bemenetet kapsz, adj ki egy számot/szót a mintázat alapján." Az, hogy mennyire megbízható ez a kimenet, egy külön, ráépített réteg kérdése.

Ez az oka a "hallucinációnak" nagy nyelvi modelleknél is: a statisztikai mintázat túl magabiztosan folytatott egy olyan irányba, ahol nincs valós adat mögötte — pont úgy, mintha a mi autós modellünket egy 5 000 000 km-es autóról kérdeznéd.

Rész 5 — Megoldás: hogyan építhetünk be egy "megbízhatósági indikátort"?

1. Módszer — tartomány-ellenőrzés (a legegyszerűbb, mi magunk is megépíthetjük): Megnézzük, hogy a kérdezett érték a tanító adatok tartományán belül van-e. Ha nem, figyelmeztetünk, hogy a becslés megbízhatatlan lehet (lásd a kód alul).

2. Módszer — konfidencia-intervallum (komolyabb, léteznek rá kész eszközök, pl. Bayesian regression): A modell nem egy számot ad vissza, hanem egy tartományt — pl. "a becsült ár 3200-4100 ezer Ft között van, 90%-os biztonsággal". Minél messzebb vagy az ismert adatoktól, a tartomány egyre szélesebb lesz, jelezve a bizonytalanságot.

3. Módszer — nagy nyelvi modelleknél (bonyolultabb, mert a bemenet szöveg, nem szám):

  • A modell megtanulja jelezni, mikor nincs elég megbízható alapja (ez még mindig tökéletlen, ezért van hallucináció)
  • Több válasz generálása és összevetése — ha egy kérdésre 5-ször kérdezed meg a modellt, és mindig ugyanazt válaszolja, valószínűbb, hogy megbízható
  • Külső ellenőrzés (fact-checking) — a válasz összevetése valós, ellenőrzött forrásokkal

Rész 6 — A keretezés (framing) problémája: miért nem ellenőrzi az AI a valóságot, csak a szöveget követi?

Ez a rész közvetlenül a rész 4-ből (a "stop vonal" hiánya) következik, de egy másik, ugyanolyan fontos oldalát mutatja meg ugyanannak az alapproblémának.

Egy fontos különbségtétel, mielőtt belemegyünk: Amikor egy nyelvi modell (mint a ChatGPT vagy Claude) egy kérdésre válaszol, ő nem egy tényadatbázisból néz vissza egy "igaz/hamis" választ. Ő szöveget generál, szóról szóra, mindig azt választva, ami a tanított mintázatok alapján a legvalószínűbb folytatás — függetlenül attól, hogy a kérdésben leírt állítások ténylegesen igazak-e.

Példa (elvi, nem konkrét recept, csak a mechanizmus megértéséhez): ha valaki egy kérdést úgy fogalmaz meg, hogy a szövegkörnyezetben egy veszélyes cselekvés "jónak", "segítőnek" vagy "mindenki érdekét szolgálónak" tűnjön, a modell — mivel nincs saját, független módja arra, hogy ellenőrizze, ez az állítás igaz-e — hajlamosabb lehet azt a keretezést követni, és a szöveg logikáját "kiszolgálni", ahelyett hogy megkérdőjelezné.

Ez nem azért van, mert a modell "elhiszi" a hazugságot — hanem mert a modellnek nincs olyan beépített képessége, hogy kilépjen a szövegből, és megnézze: "de vajon tényleg igaz-e, amit ez az ember állít?" Ő csak azt látja, ami a szövegben van, és a szövegen belüli logikai/nyelvi mintázatot folytatja.

Ez pontosan ugyanaz a gyökérprobléma, mint a hallucináció (rész 4): nincs "valóság-ellenőrző" réteg a nyers nyelvi modellben — csak mintázatkövetés van, akár egy hiányzó adatról van szó (hallucináció), akár egy manipulatív keretezésről (ez a rész).

Ezért nem elég a modellre bízni a védelmet. A valódi, éles AI-rendszereknél (amiket cégek, pl. Anthropic vagy OpenAI üzemeltetnek) ezért léteznek a nyers modellen kívüli, kemény, szöveggel fel nem ülírható biztonsági szabályok és szűrőrétegek — ha csak a modell "belátására" lenne bízva a döntés, egy elég ügyesen megfogalmazott szöveg elméletileg befolyásolhatná. Ezért a védelem nem egyetlen pontban van (a modell "jó szándékában"), hanem több, egymástól független rétegben:

  • a modell saját tanítása (hogy felismerje a manipulatív mintázatokat)
  • a modellen kívüli, szabályalapú szűrők, amiket nem lehet szöveggel meggyőzni vagy "kibeszélni"
  • emberi felügyelet és folyamatos tesztelés (ezt hívják "red teaming"-nek — erről lásd a Gyakorlás rész végét)

Szándékosan nem részletezzük itt, hogy konkrétan hogyan lehetne egy ilyen keretezéssel visszaélni — ez ugyanolyan felelőtlenség lenne, mint egy zárszerelési tananyagban lépésről lépésre leírni, hogyan kell feltörni egy konkrét zárat. A cél itt az elv megértése (miért sebezhető a nyers mintaillesztés), nem a kihasználás módszertana.

Ha komolyan érdekel az AI-biztonság (AI safety) szakmaként: ez egy valódi, aktívan kutatott terület. A legális, szakmai útvonal nem az, hogy magánemberként próbálgatod a megkerülési módszereket nyílt fórumokon — hanem hogy megismered a védekezési oldalt: hogyan épülnek fel a biztonsági rétegek, mit jelent a "red teaming" (szerződéses, engedélyezett keretek között dolgozó csapatok, akik szándékosan keresik a gyengeségeket, hogy aztán javíthatók legyenek), és mi a "felelősségteljes közzététel" (responsible disclosure) elve — vagyis ha valaki talál egy sebezhetőséget, nem nyilvánosan osztja meg, hanem bejelenti a gyártónak, hogy kijavíthassák. Ez pontosan úgy működik, mint a hagyományos szoftverbiztonságban (gondolj egy népszerű program biztonsági hibájára: a felelős kutató nem teszi közzé azonnal a kihasználás módját, hanem előbb szól a fejlesztőknek).

PYTHON● ● ●
import pandas as pd
from sklearn.linear_model import LinearRegression
PYTHON● ● ●
adatok = pd.DataFrame({
    "km_futott": [10000, 30000, 60000, 90000, 120000, 150000],
    "ar_ezer_ft": [8500, 7200, 5800, 4500, 3200, 2100]
})
PYTHON● ● ●
X = adatok[["km_futott"]]
y = adatok["ar_ezer_ft"]
PYTHON● ● ●
model = LinearRegression()
model.fit(X, y)
PYTHON● ● ●
def josolj_megbizhatosaggal(uj_km):
    """
    Ez a függvény nem csak megjósolja az árat, hanem meg is
    mondja, mennyire bízhatunk a jóslatban, aszerint, hogy a
    kérdezett km-érték az ismert (tanító) adatok tartományán
    belül van-e, vagy azon kívül (extrapoláció).
    """
    km_min = adatok["km_futott"].min()
    km_max = adatok["km_futott"].max()
PYTHON● ● ●
    uj_auto = pd.DataFrame({"km_futott": [uj_km]})
    joslat = model.predict(uj_auto)[0]
PYTHON● ● ●
    print(f"Kérdezett km: {uj_km}")
    print(f"Becsült ár: {joslat:.0f} ezer Ft")
PYTHON● ● ●
    if uj_km < km_min or uj_km > km_max:
        print(f"FIGYELEM: {uj_km} km KÍVÜL esik az ismert tartományon")
        print(f"({km_min} - {km_max} km). A becslés megbízhatatlan")
        print("lehet — ez extrapoláció, nem interpoláció!")
    else:
        print(f"A {uj_km} km az ismert tartományon ({km_min}-{km_max})")
        print("belül van, a becslés megbízhatóbb.")
PYTHON● ● ●
    print("-" * 50)

Próbáljuk ki mindkét esetet:

KÓDPÉLDA● ● ●
josolj_megbizhatosaggal(75000)     # ismert tartományon belül
josolj_megbizhatosaggal(500000)    # messze kívül esik!
Gyakorlás
  1. Hívd meg a josolj_megbizhatosaggal() függvényt egy olyan km-értékkel, ami épp a tartomány szélén van (pl. 9000) — mit tapasztalsz?
  2. Bővítsd a függvényt: ha a kért érték kívül esik a tartományon, számold ki, hány százalékkal lépi túl azt, és írasd ki ezt is (minél nagyobb a túllépés, annál megbízhatatlanabb a becslés).
  3. Gondolkodj el rajta: milyen hasonló "tartomány-ellenőrzést" lehetne beépíteni egy olyan AI-rendszerbe, ami pl. egy használtautó-kereskedés vagy egy webáruház adataival dolgozna?
  4. Új gyakorlat (rész 6-hoz): keress rá (magyarul vagy angolul) az "AI red teaming" és a "responsible disclosure" fogalmakra. Írd le 2-3 mondatban, mi a különbség a között, hogy valaki egy sebezhetőséget felelősen jelent be egy cégnek, vagy nyilvánosan közzéteszi — és szerinted miért számít ez a különbség ennyire sokat egy biztonsági szakember munkájában.