Új lapon nyílik meg

14. lecke

Egyszerű neurális háló építése PyTorch-csal

6 rész11 kódpélda1 ábra
Miről szól ez a lecke?

Ebben a leckében mindazt, amit eddig tanultál, egy valódi, tanuló neurális hálóvá rakod össze. Megnézzük, milyen problémát nem tudott megoldani a 12. lecke egyenes vonalú modellje, felépítjük a hálót az nn.Module segítségével, megírjuk a tanítási ciklust, amelyben a modell ténylegesen tanul, végül előrejelzést készítünk a betanított hálóval.

Amit ebben a leckében megtanulsz
  • A probléma, amit a 12. lecke modellje nem tudott megoldani
  • A neurális háló felépítése — nn.Module
  • A modell létrehozása és kipróbálása (még tanítás nélkül)
  • Tanító adatok — visszatérünk az autós példához
  • A tanítási ciklus — itt történik a "tanulás"
  • Előrejelzés a betanított modellel
Tudnivalók
  • Olvasási idő: kb. 10 perc (a kódok kipróbálásával több)
  • 6 rész · 11 kódpélda
  • Előfeltétel: pip install torch
  • A végén gyakorló feladatok ellenőrzik a tudásodat

Előfeltétel: pip install torch

Mi ez valójában? Mi az a neurális háló, ha lehántjuk róla a rejtélyt? A neurális háló nem más, mint egymás után kapcsolt lineáris regressziók (emlékezz a 12. leckére!), közéjük ékelt egyszerű, nemlineáris "kapcsolókkal" (aktivációs függvényekkel). Ha a 12. leckében egy egyenest illesztettünk az adatokra, itt több egyenest kapcsolunk össze, rétegenként, hogy összetettebb, görbülő mintázatokat is fel tudjon ismerni a modell — amiket egyetlen egyenes nem tudna leírni.

PYTHON● ● ●
import torch
import torch.nn as nn
Neurális háló: bemeneti, rejtett és kimeneti réteg összekötött neuronokkal
A neurális háló neuronok rétegei, összekötve. A bemenet végigfolyik a rejtett rétegen (ahol az aktiváció „görbít"), és kiadja a kimenetet. Több réteg = mélyebb, okosabb háló.

1. A probléma, amit a 12. lecke modellje nem tudott megoldani

Miért nem elég a 12. lecke lineáris regressziója mindenre? A 12. leckében az autó-ár becslésünk egy egyenes vonalat illesztett — ez tökéletes, ha az adatokban valóban egyenes vonalú (lineáris) az összefüggés. De a valóságban rengeteg összefüggés nem egyenes, hanem görbe, hullámzó, vagy bonyolultabb mintázatú (pl. képfelismerésnél a "macska" és "kutya" közötti különbség nem írható le egyetlen egyenessel). A neurális háló erre a problémára válasz: több egyszerű "egyenes-illesztést" kapcsol össze, közéjük "görbítő" elemekkel, így összetett, görbe mintázatokat is meg tud tanulni.

2. A neurális háló felépítése — nn.Module

PYTHON● ● ●
class EgyszeruHalo(nn.Module):
    def __init__(self):
        super().__init__()
        self.reteg1 = nn.Linear(1, 8)   # 1 bemenet -> 8 "rejtett" érték
        self.aktivacio = nn.ReLU()      # nemlineáris "kapcsoló"
        self.reteg2 = nn.Linear(8, 1)   # 8 rejtett érték -> 1 kimenet
PYTHON● ● ●
    def forward(self, x):
        x = self.reteg1(x)
        x = self.aktivacio(x)
        x = self.reteg2(x)
        return x
SzéljegyzetMi történik itt pontosan — mi az a nn.Module, __init__, forward, miért ilyen bonyolult a szerkezet?

Ez a PyTorch standard "sablonja" egy neurális háló megépítésére — bontsuk szét lépésről lépésre

- "class EgyszeruHalo(nn.Module):" — ez azt mondja: "ez az én modellem, ami a PyTorch beépített nn.Module 'sablonjából' örökli a szükséges alap-képességeket" (emlékezz, ez hasonló ahhoz, amikor a 6-11. leckékben a listák/DataFrame-ek "saját metódusairól" beszéltünk — itt magad hozol létre egy ilyen "saját képességekkel rendelkező" dolgot).

- "__init__" — ez a rész akkor fut le, amikor létrehozod a modellt (EgyszeruHalo()) — itt definiálod, milyen rétegek lesznek a hálóban. Az nn.Linear(1, 8) egy lineáris regressziós réteg (pontosan olyan, mint a 12. leckében!), csak itt nem 1, hanem 8 külön "egyenest" illeszt párhuzamosan, 1 bemenetből 8 "rejtett" kimenetet számolva.

SzéljegyzetMindig jobb egy nagyobb rejtett réteg?

Nem feltétlenül — egy túl nagy háló (túl sok rejtett neuron) kevés tanító adat mellett könnyen "bemagolhatja" a példákat ahelyett, hogy általános mintázatot tanulna; ezt hívják "túltanulásnak" (overfitting). A megfelelő méret megtalálása kísérletezés kérdése, akárcsak a tanulási rátáé.

- "forward(self, x)" — ez a függvény mondja meg, mi történik, amikor egy adatot "átküldesz" a hálón: először átmegy a reteg1-en (8 párhuzamos egyenes), utána az aktivacio-n (a "görbítő" lépés, lásd lentebb), végül a reteg2-n (ami a 8 rejtett értéket vissza-tömöríti 1 végső kimenetté). Ez pontosan az az "adatfolyam", amiről korábban (7. lecke, függvények) tanultunk — csak itt több rétegen keresztül folyik az adat.

Miért kell a 'nemlineáris kapcsoló' (aktiváció), mit csinál pontosan a ReLU? Ez a legfontosabb rész, amiért a neurális háló többet tud, mint a 12. lecke sima lineáris regressziója! Ha csak egyeneseket (nn.Linear) kapcsolnál egymás után, aktiváció nélkül, a matematika úgy alakulna, hogy több egymás utáni egyenes összessége önmaga is csak egy egyenes maradna — tehát hiába raknál 100 réteget egymás után, a végeredmény ugyanolyan "egyenes vonalú" maradna, mint a 12. leckében.

A ReLU (Rectified Linear Unit) egy nagyon egyszerű szabály: "ha az érték pozitív, hagyd változatlanul; ha negatív, cseréld 0-ra." Ez a látszólag apró "törés" az, ami lehetővé teszi, hogy a háló görbe, töréspontokkal teli mintázatokat tanuljon meg — mert minden egyes "kapcsoló" a saját pontján "bekapcsol" vagy "kikapcsol", és a sok apró kapcsoló együttes hatása már egy bonyolult, görbülő függvényt tud közelíteni, még akkor is, ha minden egyes összetevője (az nn.Linear rétegek) csak egyszerű, egyenes vonalú matematikát végez.

SzéljegyzetCsak a ReLU-t használják aktivációként?

Nem — a ReLU a legelterjedtebb, de léteznek más aktivációs függvények is (pl. Sigmoid, Tanh, vagy a nagy nyelvi modelleknél gyakran használt GELU). Mindegyik ugyanazt a célt szolgálja: nemlinearitást visz a hálóba, csak kicsit másképp "görbítenek".

3. A modell létrehozása és kipróbálása (még tanítás nélkül)

PYTHON● ● ●
model = EgyszeruHalo()
PYTHON● ● ●
teszt_bemenet = torch.tensor([[5.0]])
kimenet = model(teszt_bemenet)
print("Kimenet tanítás előtt:", kimenet)
SzéljegyzetMiért 'értelmetlen' most még a kimenet?

Amikor létrehozod a model = EgyszeruHalo()-t, a PyTorch minden egyes réteg "meredekségét és kezdőpontját" (emlékezz a 12b leckére!) véletlenszerű, kezdő értékekkel tölti fel — ez olyan, mintha a 12. lecke autós modellje egy totálisan véletlenszerű egyenessel indulna, mielőtt még egyetlen adatot is "látott" volna. A kimenet ezért jelenleg értelmetlen — a "tanítás" (lásd lentebb) az, ami ezeket a véletlen kezdő értékeket fokozatosan, értelmes értékekké formálja.

4. Tanító adatok — visszatérünk az autós példához

PYTHON● ● ●
X = torch.tensor([[10.0], [30.0], [60.0], [90.0], [120.0], [150.0]])   # km (ezerben)
y = torch.tensor([[8.5], [7.2], [5.8], [4.5], [3.2], [2.1]])           # ár (millióban)

Miért ilyen furcsa alakúak a tenzorok — miért [[10.0], [30.0], ...] és nem csak [10.0, 30.0, ...]? Emlékezz a 10-11. leckében tanult mátrix-fogalomra: a PyTorch (és minden neurális háló könyvtár) elvárja, hogy az adatok "táblázat-szerűen" legyenek megadva — minden sor egy-egy adatpont (itt: egy autó), minden oszlop egy-egy tulajdonság (itt csak 1 oszlop van: a km). Ez a kettős szögletes zárójel ezt a "táblázat" formát adja — 6 sor, 1 oszlop — szemben egy sima, "lapos" listával, ami csak 6 elem lenne, tulajdonság-struktúra nélkül. A modellünk (nn.Linear(1, 8)) kifejezetten ezt a táblázat-formátumot várja bemenetként.

5. A tanítási ciklus — itt történik a "tanulás"

PYTHON● ● ●
hibafuggveny = nn.MSELoss()
optimalizalo = torch.optim.SGD(model.parameters(), lr=0.0001)
PYTHON● ● ●
for korszak in range(1000):
    joslat = model(X)                     # 1. előrejelzés a JELENLEGI tudással
    hiba = hibafuggveny(joslat, y)         # 2. mennyire téved?
KÓDPÉLDA● ● ●
    optimalizalo.zero_grad()               # 3. "nullázzuk" az előző kör számításait
    hiba.backward()                        # 4. kiszámoljuk, MERRE kell módosítani
    optimalizalo.step()                    # 5. TÉNYLEGESEN módosítjuk a paramétereket
PYTHON● ● ●
    if korszak % 100 == 0:
        print(f"Korszak {korszak}, hiba: {hiba.item():.4f}")
SzéljegyzetEz az 5 sor (joslat, hiba, zero_grad, backward, step) a legfontosabb rész az egész leckében — vegyük szét, hogyan kapcsolódik minden, amit eddig tanultunk!

Emlékezz a 12b leckére, ahol az autós modellünk a "hőmérő-hasonlattal" tanult: "próbáljunk egy kicsit más beállítást, nézzük meg jobb-e, ha igen, menjünk arra tovább" — és a 13. leckére, ahol megismerted a requires_grad/.backward() mechanizmust, ami ezt a "próbálgatást" matematikai deriválással automatizálja. Ez az 5 sor pontosan ez a mechanizmus, csak "iparosított", újrahasználható formában:

1. joslat = model(X) — a modell (a jelenlegi, még tökéletlen tudásával) megbecsüli az árakat. Ez megfelel a 12. lecke model.predict()-jének.

2. hiba = hibafuggveny(joslat, y) — összeveti a becslést a valós árakkal, és egyetlen számba sűríti, mennyire téved a modell (az mseloss, "Mean Squared error loss" — átlagos négyzetes hiba — pontosan azt a "négyzetre emelt eltérés" számítást végzi, amit a 12b leckében kézzel is kiszámoltunk).

  1. optimalizalo.zero_grad() — ez egy fontos, könnyen elfelejtett technikai lépés: a PyTorch alapértelmezés szerint "halmozza" a gradienseket (a .grad értékeket a 13. leckéből) minden .backward() hívásnál, ahelyett hogy felülírná őket — ez bizonyos esetekben hasznos, de itt nem azt akarjuk, hogy az előző kör számításai "összeadódjanak" a mostanival. A zero_grad() "törli a táblát", hogy minden körben frissen, tisztán számolhassunk.

4. hiba.backward() — ez a 13. leckéből ismert automatikus deriválás, csak most nem 1-2, hanem a modell összes paraméterére (mindkét réteg minden "meredekségére és kezdőpontjára") egyszerre kiszámolja: "ha ezt a paramétert egy icipicit megváltoztatnám, mennyit nőne vagy csökkenne a hiba?"

5. optimalizalo.step() — ez a lépés az, ami ténylegesen módosítja a paramétereket, a backward() által kiszámolt irányba, egy kicsi lépéssel (ennek mértékét az "lr", learning rate, "tanulási ráta" szabályozza — lásd lentebb). Ez felel meg a 12b lecke "hőmérő- hasonlatának" "menjünk arra tovább" lépésének.

Ezt az 5 lépést ismételjük 1000-szer (a "korszak" ciklus ezt számolja) — minden egyes körben egy icipicit javul a modell, pontosan úgy, ahogy a 12b lecke "sötét szoba, melegebb/hidegebb" hasonlatában leírtuk, csak most ezt a PyTorch végzi el, matematikailag pontosan, emberi szemmel követhetetlen sebességgel.

Mi az az 'lr=0.0001' (learning rate), miért pont ez a szám? A "tanulási ráta" azt szabályozza, mekkora lépéseket tegyen a modell egy-egy körben a "jobb irány" felé. Ez egy kényes egyensúly: ha túl nagy a lépés, a modell "túllövi" a célt, és soha nem stabilizálódik (mint amikor egy hőszabályzó túl agresszíven reagál, és állandóan túlfűt, majd túlhűt); ha túl kicsi, a modell túl lassan tanul, és 1000 kör sem lenne elég. A 0.0001 itt egy tapasztalati érték — a gyakorlatban ez a szám az egyik fontos "csavar", amit egy AI-fejlesztőnek kísérletezve kell megtalálnia az adott feladathoz.

SzéljegyzetVan okosabb módszer az lr megtalálására, mint a próbálgatás?

Igen — a gyakorlatban ritkán használnak csak sima SGD-t fix tanulási rátával. Egy népszerű, "okosabb" optimalizáló például az Adam, ami menet közben, automatikusan hangolja a lépésméretet, így kevesebb kézi próbálgatással is stabilabban tanul a modell.

6. Előrejelzés a betanított modellel

PYTHON● ● ●
uj_auto = torch.tensor([[75.0]])
becsult_ar = model(uj_auto)
print("Becsült ár 75 000 km-nél:", becsult_ar.item())
SzéljegyzetMiért kell a .item(), amit korábban nem láttunk?

A model(uj_auto) eredménye még mindig egy tenzor (emlékezz a 13. leckére), nem egy "sima" Python szám — ez azért van, mert a PyTorch mindig tenzorokkal dolgozik, hogy a GPU-gyorsítás és az automatikus deriválás lehetősége mindvégig megmaradjon. Az .item() metódus "kicsomagolja" a tenzorból az egyetlen, benne lévő számot, "sima" Python float formátumba, hogy kényelmesen ki tudd írni vagy tovább tudd használni "hétköznapi" Python-kódban.

Gyakorlás
  1. Futtasd le a fenti kódot, és figyeld a kiírt hiba értékeket (Korszak 0, 100, 200, ...) — csökken a hiba a korszakok növekedésével? Ha igen, ez azt jelenti, a modell tényleg tanul.
  2. Próbáld meg megváltoztatni a tanulási rátát (lr) egy sokkal nagyobb értékre (pl. lr=0.1) — mi történik a hibával? (Segítség: valószínűleg "felrobban" — a hiba hatalmasra nő, vagy "nan" lesz — ez a "túllövés" jelensége, amiről a széljegyzetben olvastál.)
  3. Új gyakorlat: növeld a rejtett réteg méretét nn.Linear(1, 8)-ról nn.Linear(1, 32)-re (és a második réteget is: nn.Linear(32, 1)-re) — fusson-e le hiba nélkül? Gondolkodj el rajta: ez a "32" szám mit jelent a háló "kapacitása" szempontjából — vajon egy nagyobb szám mindig jobb modellt eredményez?

Források és további olvasnivaló

A lecke témájának hivatalos dokumentációi és alapvető cikkei:
• PyTorch — alapok (hivatalos bevezető) — pytorch.org