Új lapon nyílik meg

15. lecke

Az első saját projekted: weboldal-látogatottság elemzése és előrejelzése

8 rész22 kódpélda1 ábra

A nullától a betanított modellig

Miről szól ez a lecke?

Itt végigviszel egy teljes, önálló AI-projektet az elejétől a végéig. Egy webáruház napi látogatottsági adataiból megjósolod a várható vásárlások számát: előállítod és megtisztítod az adatokat, PyTorch-tenzorrá alakítod őket, felépíted és betanítod a modellt, majd kiértékeled és megbízhatósági ellenőrzésnek veted alá. Minden lépésnél látod, melyik korábbi leckére épül.

Amit ebben a leckében megtanulsz
  • Az adatok előállítása (itt: magunk generáljuk, de egy valós projektben ez egy…
  • Adattisztítás és ellenőrzés (11. lecke elvei alapján)
  • Az adatok átalakítása PyTorch tenzorrá (10. és 13. lecke elvei alapján)
  • A modell felépítése (14. lecke elvei alapján)
  • A modell tanítása (12b, 13, 14. lecke elvei alapján)
  • Értékelés: mennyire jó a modellünk? (12. lecke .score() elve, de itt kézzel…
  • Megbízhatósági ellenőrzés (12b lecke elve alapján)
Tudnivalók
  • Olvasási idő: kb. 10 perc (a kódok kipróbálásával több)
  • 8 rész · 22 kódpélda
  • A végén gyakorló feladatok ellenőrzik a tudásodat

Ez a lecke összerakja mindazt, amit az 1–14c. leckékben külön-külön tanultál — ez az első alkalom, hogy egy teljes, önálló AI-projektet végigviszel, elejétől a végéig, egyetlen fájlban.

A téma (szándékosan egy hétköznapi üzleti példa): van egy CSV-fájlod egy webáruház napi látogatottsági adataival (ami nagyon hasonló ahhoz, amit egy Google Analytics export adna), és a cél: megjósolni, egy adott napi látogatószám mellett, várhatóan hány vásárlás (konverzió) történik — ez egy valós, hasznos kérdés, amit bármelyik webáruház-tulajdonos feltesz.

SzéljegyzetMiért ez a projekt, miért nem valami 'AI-osabb' téma?

Mert a cél nem az, hogy lenyűgözőbbnek tűnjön, hanem hogy valódi, végigvihető tapasztalatot szerezz a teljes munkafolyamatról (adat -> tisztítás -> modell -> tanítás -> értékelés -> felhasználás) — és ez a fajta "bemenetből várható eredményt jósolni" feladat számtalan hétköznapi üzleti helyzetben előkerülhet: mennyi bevétel várható X marketingköltségnél, mennyi szervizidő várható X típusú hibánál, stb. A módszertan ugyanaz marad, csak az adatok cserélődnek.

PYTHON● ● ●
import pandas as pd
import torch
import torch.nn as nn
Látogatottsági trend és a jövőre vonatkozó előrejelzés
Az első saját projekted: a modell a múltbeli adatból (folytonos vonal) tanul, és megjósolja a jövőt (szaggatott) — pontosan ez a gépi tanulás gyakorlati haszna.

Lépés 1 — Az adatok előállítása (itt: magunk generáljuk, de egy valós projektben ez egy .CSV fájl lenne — lásd 8. és 11. lecke)

Miért nem egy valós CSV-fájlt töltünk be, ha egyszer a 8. és 11. leckében pont ezt tanultuk? Mert neked, a gyakorlás kedvéért, hasznosabb, ha pontosan tudod, honnan jönnek a számok (itt: mi magunk írjuk le őket) — így látható a kapcsolat a bemenet (látogatók) és kimenet (vásárlások) között, és utólag ellenőrizheted, hogy a modell tényleg megtanulta-e ezt a kapcsolatot. Az alján, a gyakorlás részben megtalálod, pontosan hogyan cserélnéd ezt valós, pd.read_csv()-vel betöltött adatra — a kód többi része egy betűt sem változna.

PYTHON● ● ●
adatok = pd.DataFrame({
    "latogatok": [120, 250, 340, 410, 480, 90, 610, 730, 800, 150,
                  270, 390, 550, 640, 720, 200, 310, 460, 590, 680],
    "vasarlasok": [3, 7, 9, 12, 14, 2, 18, 21, 23, 4,
                   8, 11, 16, 19, 21, 5, 9, 13, 17, 20]
})
SzéljegyzetMiért pont ilyen számokat választottunk?

Szándékosan úgy állítottuk össze az adatokat, hogy legyen bennük egy felismerhető, de nem tökéletesen egyenes mintázat (minél több a látogató, annál több a vásárlás — de nem pontosan arányosan, mert a valóságban is van egy kis "zaj", ingadozás), hogy a modellnek legyen mit tanulnia, és hogy lásd: a valós adatok soha nem tökéletesen "szép" egyenesek.

PYTHON● ● ●
print("ELSŐ 5 SOR AZ ADATAINKBÓL:")
print(adatok.head())
print(f"\nÖsszesen {len(adatok)} nap adata áll rendelkezésre.\n")

Lépés 2 — Adattisztítás és ellenőrzés (11. lecke elvei alapján)

Ez itt most 'felesleges', hiszen tudjuk, hogy az adatunk tiszta (mi magunk írtuk le) — miért csináljuk mégis? Mert egy valós projektben ez sosem garantált — és rossz szokás lenne, ha "megúsznád" ezt a lépést csak azért, mert itt éppen nem szükséges. Az AI-fejlesztői fegyelem része, hogy mindig ellenőrzöd az adatot, mielőtt egy percet is a modellezésre fordítanál — emlékezz a 11. lecke NaN-problémájára: egyetlen hiányzó érték észrevétlenül tönkreteheti a teljes tanítást.

PYTHON● ● ●
hianyzo_ertekek = adatok.isnull().sum().sum()
print(f"Hiányzó értékek száma az adatokban: {hianyzo_ertekek}")
PYTHON● ● ●
if hianyzo_ertekek > 0:
    print("FIGYELEM: hiányzó adat található — tisztításra van szükség!")
    adatok = adatok.dropna()
else:
    print("Az adat tiszta, nincs hiányzó érték — mehetünk tovább.\n")

Lépés 3 — Az adatok átalakítása PyTorch tenzorrá (10. és 13. lecke elvei alapján)

Miért kell a Pandas DataFrame-et 'lefordítani' PyTorch tenzorra, miért nem elég a DataFrame önmagában? Emlékezz: a Pandas (11. lecke) a human-barát adatkezelésre való (könnyű szűrni, rendezni, megérteni) — de a PyTorch (13-14. lecke) nem Pandas-szal, hanem tenzorokkal dolgozik, mert azok vannak felkészítve a GPU-gyorsításra és az automatikus deriválásra (autograd). Ez olyan, mint amikor egy Excel-táblát (Pandas) "exportálsz" egy programnak, ami csak egy speciális formátumot (tenzor) ért — a két eszköz más-más lépésben a leghasznosabb.

PYTHON● ● ●
X = torch.tensor(adatok[["latogatok"]].values, dtype=torch.float32)
y = torch.tensor(adatok[["vasarlasok"]].values, dtype=torch.float32)

Mi az a .values, és miért kell a dtype=torch.float32? A .values "kicsomagolja" a Pandas DataFrame-ből a nyers NumPy tömböt (emlékezz a 10. lecke NumPy-Pandas kapcsolatára — a Pandas épp erre a NumPy-ra épül), amit a torch.tensor() már tud fogadni. A dtype=torch.float32 pedig a 13. leckéből ismert "szigorú típusosság" miatt kell: a Pandas alapból egész számokat (int) tárolt, de a PyTorch tanításhoz tizedestört (float) formátum szükséges a pontos deriváláshoz.

PYTHON● ● ●
print(f"X (bemenet) alakja: {X.shape}")
print(f"y (kimenet) alakja: {y.shape}\n")

Lépés 4 — A modell felépítése (14. lecke elvei alapján)

PYTHON● ● ●
class LatogatottsagModell(nn.Module):
    def __init__(self):
        super().__init__()
        self.reteg1 = nn.Linear(1, 16)   # 1 bemenet (látogatók) -> 16 rejtett érték
        self.aktivacio = nn.ReLU()       # nemlineáris "kapcsoló" (14. lecke)
        self.reteg2 = nn.Linear(16, 1)   # 16 rejtett érték -> 1 kimenet (vásárlások)
PYTHON● ● ●
    def forward(self, x):
        x = self.reteg1(x)
        x = self.aktivacio(x)
        x = self.reteg2(x)
        return x

Miért 16-ot választottunk a 14. lecke 8-as számával szemben? Emlékezz a 14. lecke 3. gyakorlófeladatára, ahol arra kérdeztünk rá: "a nagyobb szám mindig jobb modellt eredményez?" — a válasz: nem feltétlenül, de egy kicsit nagyobb "kapacitás" (itt: 16 a 8 helyett) néha segít összetettebb mintázatokat felismerni. Ez a te saját projektedhez tartozó döntés volt — ilyen "csavarok" hangolása (hiperparaméter-hangolás) a mindennapi AI-fejlesztői munka része, nem egyszeri "beállítás és kész" lépés.

SzéljegyzetMi történik, ha egy saját projektben nem tudod, hány rejtett neuron kelljen?

Nincs egyetlen "helyes" szabály erre — a gyakorlatban gyakran egy kis számmal (pl. 8 vagy 16) kezdenek, megnézik, mennyire csökken a hiba, majd szükség szerint növelik vagy csökkentik, és összevetik az eredményt. Ez a fajta kísérletezés (hiperparaméter-keresés) teljesen normális, bevett gyakorlat, nem olyasmi, amit ki kellene találnod fejből.

PYTHON● ● ●
model = LatogatottsagModell()

Lépés 5 — A modell tanítása (12b, 13, 14. lecke elvei alapján)

PYTHON● ● ●
hibafuggveny = nn.MSELoss()
optimalizalo = torch.optim.SGD(model.parameters(), lr=0.00001)
PYTHON● ● ●
print("TANÍTÁS FOLYAMATBAN...")
for korszak in range(2000):
    joslat = model(X)
    hiba = hibafuggveny(joslat, y)
KÓDPÉLDA● ● ●
    optimalizalo.zero_grad()
    hiba.backward()
    optimalizalo.step()
PYTHON● ● ●
    if korszak % 200 == 0:
        print(f"  Korszak {korszak:>4}, hiba: {hiba.item():.4f}")
PYTHON● ● ●
print("TANÍTÁS BEFEJEZVE.\n")

Miért lr=0.00001, miért ilyen apró szám, a 14. lecke lr=0.0001-jéhez képest is? Ez pontosan a 14. lecke gyakorlás 2. pontjában felvetett probléma gyakorlati következménye: a mi adatunkban a bemenet (látogatók: akár 800-ig) és a kimenet (vásárlások: akár 23-ig) közötti skála nagyobb, mint a 14. lecke autós példájában — ha túl nagy tanulási rátát választanánk, a modell "túllövi" a célt (emlékezz a hőszabályzó-hasonlatra). Ez egy valós példa arra, hogy a tanulási ráta nem egyetlen "helyes" szám, hanem az adott adathoz kell igazítani — pontosan ez a "kísérletezéssel megtalálni" elv, amiről a 14. lecke széljegyzete beszélt.

SzéljegyzetVan jobb megoldás, mint a tanulási rátát nagyon kicsire venni?

Igen — a gyakorlatban gyakran nem a tanulási rátát csökkentik emiatt, hanem az adatokat "normalizálják" (pl. 0 és 1 közé skálázzák) betanítás előtt, hogy a bemenet és a kimenet hasonló nagyságrendű legyen. Ez sokszor stabilabb, gyorsabb tanítást eredményez, mint a nagyon apró tanulási ráta.

Lépés 6 — Értékelés: mennyire jó a modellünk? (12. lecke .score() elve, de itt kézzel kiszámolva)

A 12. leckében volt egy kész .score() metódus — itt miért nem használjuk? Mert a PyTorch (szemben a scikit-learn-nel) nem ad ilyen beépített "egy-gombnyomásos" értékelő függvényt — itt neked kell megírnod, pontosan azért, hogy tudd, mi történik a háttérben (a 12. lecke .score()-ja ugyanezt a fajta számítást végezte el, csak "elrejtve" előled).

PYTHON● ● ●
with torch.no_grad():
    vegso_joslatok = model(X)
    atlagos_elteres = torch.mean(torch.abs(vegso_joslatok - y)).item()
PYTHON● ● ●
print(f"A modell átlagosan {atlagos_elteres:.2f} vásárlással téved")
print("(minél KISEBB ez a szám, annál PONTOSABB a modell).\n")

Mi az a torch.no_grad(), amit még nem láttunk? Emlékezz: a 13. leckében a requires_grad=True azt jelentette, hogy a PyTorch "figyeli" a számításokat, hogy később deriválni tudjon. De amikor már csak értékeljük a kész modellt (nem tanítjuk tovább), erre a "figyelésre" nincs szükség — felesleges számítási teherré válna. A "with torch.no_grad():" blokk ideiglenesen kikapcsolja ezt a "figyelést", gyorsabbá és memória-hatékonyabbá téve az értékelést. Ez egy tipikus, a gyakorlatban mindig használt "csomagolás" predikció/értékelés idejére.

SzéljegyzetElég megbízható ez az értékelés, ugyanazon az adaton, amin tanítottunk?

Ebben a gyakorló projektben szándékosan ugyanazon a 20 napon értékeljük a modellt, amin tanítottuk — ez egyszerűsítés. Egy valós projektben az adatokat előre szét szokták választani "tanító" és "teszt" részre, és csak a modell által korábban nem látott teszt-adatokon mérik a pontosságot, mert így derül ki igazán, mennyire általánosít jól a modell új esetekre.

Lépés 7 — Megbízhatósági ellenőrzés (12b lecke elve alapján)

PYTHON● ● ●
def joslas_megbizhatosaggal(uj_latogatoszam):
    """
    Ugyanaz az elv, mint a 12b lecke josolj_megbizhatosaggal()
    függvénye: megjósolja a vásárlások számát, ÉS figyelmeztet,
    ha a kérdezett érték kívül esik az ISMERT tartományon
    (extrapoláció veszélye).
    """
    latogatok_min = adatok["latogatok"].min()
    latogatok_max = adatok["latogatok"].max()
PYTHON● ● ●
    bemenet = torch.tensor([[float(uj_latogatoszam)]])
    with torch.no_grad():
        joslat = model(bemenet).item()
PYTHON● ● ●
    print(f"Kérdezett látogatószám: {uj_latogatoszam}")
    print(f"Becsült vásárlásszám: {joslat:.1f}")
PYTHON● ● ●
    if uj_latogatoszam < latogatok_min or uj_latogatoszam > latogatok_max:
        print(f"FIGYELEM: {uj_latogatoszam} látogató KÍVÜL esik az ismert")
        print(f"tartományon ({latogatok_min}-{latogatok_max}) — a becslés")
        print("megbízhatatlan lehet (extrapoláció)!")
    else:
        print(f"A {uj_latogatoszam} látogató az ismert tartományon")
        print(f"({latogatok_min}-{latogatok_max}) belül van — megbízhatóbb becslés.")
    print("-" * 55)
PYTHON● ● ●
print("PRÓBAKÉRDEZÉSEK A KÉSZ MODELLTŐL:")
joslas_megbizhatosaggal(350)     # ismert tartományon belül
joslas_megbizhatosaggal(5000)    # extrém extrapoláció

Összefoglalás — mit csináltunk, és melyik leckéből jött?

LépésMelyik leckéből tanultad
Adat előállítása/betöltése6. lecke (dict), 8. és 11. lecke (CSV/pandas)
Adattisztítás, ellenőrzés11. lecke (NaN kezelés)
Tenzorrá alakítás10. lecke (NumPy), 13. lecke (tenzor)
Modell felépítése14. lecke (nn.Module, nn.Linear, ReLU)
Tanítás (a ciklus)12b lecke (elv), 13. lecke (autograd), 14c lecke (a matek mögötte), 14. lecke (kód)
Értékelés12. lecke (.score() elve, kézzel megírva)
Megbízhatósági ellenőrzés12b lecke (extrapoláció-védelem)

Ez a táblázat az összes eddig tanult lecke "térképe" — ha érted, miért van itt minden lépés, és hogyan kapcsolódnak egymáshoz, akkor már nem csak "kódot másolsz", hanem érted egy teljes AI-projekt felépítését.

Gyakorlás

1. Futtasd le a teljes kódot, és nézd meg: az átlagos eltérés (lépés 6) hány vásárlás? Ha sokallod, próbáld meg növelni a korszakok számát (range(2000) helyett range(5000)) — javul-e?

2. Cseréld le a lépés 1 adatait a saját, valós CSV-fájlodra (pl. ha van Google Analytics vagy más statisztikai exportod) — ehhez csak ennyit kell módosítanod:

adatok = pd.read_csv("sajat_adataim.csv")

(Fontos: a CSV oszlopneveinek egyezniük kell a "latogatok"/"vasarlasok" nevekkel, vagy írd át a kód megfelelő részét az új oszlopnevekre — emlékezz a 11. leckére, ahol pontosan ezt gyakoroltad!)

3. Új, önálló projekt-ötlet — válassz egyet, és építsd fel ugyanezzel a 7 lépéses váz segítségével: a) Szerviz: bemenet = a hiba típusának "súlyossága" (egy általad kitalált 1-10 skálán), kimenet = várható javítási idő (órában) b) webáruház: bemenet = napi hirdetési költség (ezer Ft), kimenet = aznapi rendelések száma c) saját ötlet — bármi, amihez van (vagy kitalálható) egy "bemenet -> kimenet" számpáros adatsorod. Ez lesz a "saját projekted" — nincs "jó" vagy "rossz" választás, a lényeg, hogy végigvidd a teljes folyamatot.