Differences

This shows you the differences between two versions of the page.

--- muszaki_informatika:gepi_tanulas [2025/05/22 10:18] – [1.3 Underfitting és overfitting (gyenge és túlzott illeszkedés)] knehez
+++ muszaki_informatika:gepi_tanulas [2025/05/23 06:12] (current) – [Felügyelt és felügyelet nélküli tanulás] knehez
@@ Line 125: / Line 125: @@
 </sxh>
-===== 1.3 Underfitting és overfitting (gyenge és túlzott illeszkedés) =====
+===== Underfitting és overfitting (gyenge és túlzott illeszkedés) =====
 A modell kapacitása és a rendelkezésre álló tanítóadatok mennyiségének viszonya fontos szerepet játszik a tanulás sikerességében.
@@ Line 196: / Line 196: @@
 plt.show()
 </sxh>
+===== A gépi tanulási modellek fő típusai =====
+A gépi tanulási modelleket három nagy csoportba sorolhatjuk a tanulás célja és a kimenet jellege alapján:
+==== Regresszió ====
+A regressziós feladat célja egy **folytonos mennyiség** becslése. Ilyenkor a modell egy bemenethez \( x \in \mathbb{R}^d \) tartozó kimeneti értéket \( y \in \mathbb{R}^k \) próbál megjósolni.
+Példák:
+  * Egy tárgy térbeli pozíciójának becslése egy képből.
+  * Egy hőmérséklet vagy ház árának előrejelzése.
+==== Osztályozás (klasszifikáció) ====
+Osztályozás során a cél az, hogy a modell egy véges számú lehetséges címke (osztály) közül válasszon ki egyet egy adott bemenethez. Azaz:
+$$ y \in \{1, 2, \ldots, C\} $$
+A modell általában nem közvetlenül egy címkét ad vissza, hanem **pontszámokat vagy valószínűségeket** rendel minden lehetséges osztályhoz:
+$$ f(x; w) = \text{softmax}(s_1, s_2, \ldots, s_C) $$
+ahol \( s_i \) a \( i \)-edik osztályhoz tartozó nyers pontszám. A predikció:
+$$ \hat{y} = \arg\max_{i} f_i(x; w) $$
+A tanítóadat itt is \( (x_n, y_n) \) párokból áll, de a \( y_n \) most egy osztályindex.
+==== Sűrűségmodellezés ====
+A harmadik kategória a **sűrűségmodellezés**, amelynek célja nem kimeneti érték előrejelzése, hanem **magának az adatnak a valószínűségi eloszlását** megtanulni:
+$$ p(x) \approx \hat{p}(x; w) $$
+Ilyenkor csak \( x_n \) példák állnak rendelkezésre (nincs hozzájuk tartozó \( y_n \)), és a modell azt próbálja megtanulni, **mennyire jellemzőek** az egyes minták, vagy hogyan lehet **új mintákat generálni** az eloszlásból.
+Jellegzetes célfüggvény itt az eloszlás **log-likelihood maximálása**:
+$$ \mathcal{L}(w) = -\frac{1}{N} \sum_{n=1}^N \log \hat{p}(x_n; w) $$
+==== Felügyelt és felügyelet nélküli tanulás ====
+  * A //regresszió// és //osztályozás// esetén mindig szükség van egy **célértékre** (\( y \)), ezért ezeket **felügyelt tanulásnak** nevezzük.
+  * A //sűrűségmodellezés// során nincs célérték, csak maga az \( x \) szerepel, ezért ez a **felügyelet nélküli tanulás** kategóriájába soroljuk.
+==== Megjegyzés ====
+Ezek a kategóriák **nem zárják ki egymást**. Például:
+  * Osztályozás megvalósítható regressziós formában is (pontszámokat tanulunk).
+  * Sűrűségmodellezésből származtathatunk osztályozót (pl. Bayes-szabály szerint).
+  * Léteznek összetett modellek, amelyek többféle célt is egyszerre tanulnak (pl. képgenerálás és címkézés együtt).
+===== Hatékony számítási módszerek =====
+A modern gépi tanulási modellek gyakorlati megvalósítása és alkalmazása, szorosan összefügg a hatékony számítási megoldásokkal. Ezek a modellek hatalmas adathalmazokon dolgoznak, így a háttérben zajló számításokat olyan eszközökön érdemes végrehajtani, amelyek párhuzamosan képesek nagy mennyiségű művelet elvégzésére.
+==== GPU-k, TPU-k és batch feldolgozás ====
+A legtöbb mélytanulási számítás **grafikus feldolgozóegységek (GPU-k)** segítségével történik. Ezeket eredetileg képfeldolgozásra tervezték, de mivel képesek **több ezer szálon párhuzamos számításokat végezni**, kiválóan alkalmasak a gépi tanulás modelljeinek betanítására és futtatására is.
+A GPU-k saját gyors memóriával rendelkeznek, amelyben az adatokat és a modell súlyait is tárolni lehet. A legnagyobb lassulást (szűk keresztmetszet) általában az okozza, ha az adatokat a CPU memóriájából át kell másolni a GPU-ba. Ezért fontos, hogy a számításokat úgy szervezzük, hogy az adatok a GPU memóriájában maradjanak.
+A hatékony működés érdekében az adatokat gyakran **batch-ekre (kötegekre)** osztjuk, vagyis egyszerre több mintát dolgozunk fel. A GPU szinte ugyanolyan gyorsan képes feldolgozni egy batch-et, mint egyetlen mintát, mivel a szűk keresztmetszet ilyenkor is a GPU-ba történő adatbetöltés marad.
+Egy tipikus GPU elméleti teljesítménye:
+$$ 10^{13} \text{ – } 10^{14} \text{ FLOP/s (floating point művelet másodpercenként)} $$
+A lebegőpontos számokat jellemzően 32 biten (FP32) tároljuk, de sok esetben **16 bites (FP16)** vagy kisebb pontosság is elegendő, ami még tovább gyorsíthatja a számítást. FP16-os tárolással közel kétszeres sebességnövekedés érhető el, az FP32-vel szemben.
+==== Tenzorok használata ====
+A mélytanulási könyvtárak, mint a PyTorch vagy a JAX, a számításokat **tenzorokkal** végzik. Egy tenzor nem más, mint egy tömb, amely elemei (számok) több dimenzió mentén vannak elrendezve. A vektorok és mátrixok a tenzorok speciális esetei:
+$$ \text{Vektor: } \mathbb{R}^n, \quad \text{Mátrix: } \mathbb{R}^{n \times m}, \quad \text{Tenzor: } \mathbb{R}^{N_1 \times N_2 \times \dots \times N_k} $$
+A tenzorokkal reprezentáljuk:
+  * a bemeneti adatokat (pl. képek, hangminták),
+  * a modell paramétereit (súlyok),
+  * a rejtett rétegek aktivációit.
+Példák:
+  * Egy RGB kép (64 pixel × 64 pixel): \( \mathbb{R}^{3 \times 64 \times 64} \)
+  * 32 ilyen kép: \( \mathbb{R}^{32 \times 3 \times 64 \times 64} \)
+A népszerű mélytanulási könyvtárak lehetővé teszik ezek **formátumának gyors átalakítását** (tenzorátalakításokat).
+==== Példák tenzorátalakításokra ====
+=== Dimenziók átrendezése (transpose) ===
+Ha van egy mátrixunk:
+$$
+A = \begin{bmatrix}
+& 2 & 3 \\
+& 5 & 6
+\end{bmatrix}
+\in \mathbb{R}^{2 \times 3}
+$$
+A transzponáltja:
+$$
+A^\top = \begin{bmatrix}
+& 4 \\
+& 5 \\
+& 6
+\end{bmatrix}
+\in \mathbb{R}^{3 \times 2}
+$$
+**PyTorch-ban**:
+<sxh python>
+A = torch.tensor([[1, 2, 3],
+                  [4, 5, 6]])
+A_T = A.T  # vagy A.transpose(0, 1)
+</sxh>
+=== Szeletek kivágása ===
+Tegyük fel, hogy van egy 3x4-es mátrix, és csak az első két oszlopra van szükségünk:
+$$
+B = \begin{bmatrix}
+& 2 & 3 & 4 \\
+& 6 & 7 & 8 \\
+& 10 & 11 & 12
+\end{bmatrix}
+$$
+Kivágva az első két oszlop:
+$$
+B[:, 0:2] = \begin{bmatrix}
+& 2 \\
+& 6 \\
+& 10
+\end{bmatrix}
+$$
+**PyTorch-ban**:
+<sxh python>
+B = torch.arange(1, 13).reshape(3, 4)
+slice = B[:, 0:2]  # minden sor, az első két oszlop
+</sxh>
+=== Sorozatok kibontása (reshape) ===
+Egy hosszú vektor:
+$$
+v = [1, 2, 3, 4, 5, 6] \in \mathbb{R}^6
+$$
+Ezt átalakíthatjuk egy 2 soros, 3 oszlopos mátrixszá:
+$$
+\text{reshape: } \begin{bmatrix}
+& 2 & 3 \\
+& 5 & 6
+\end{bmatrix}
+\in \mathbb{R}^{2 \times 3}
+$$
+**PyTorch-ban**:
+<sxh python>
+v = torch.tensor([1, 2, 3, 4, 5, 6])
+reshaped = v.reshape(2, 3)
+</sxh>
+Ezek a műveletek gyakran **memóriamásolás nélkül** végrehajthatók, ami különösen hatékonnyá teszi őket.
+A modern mélytanulási rendszerek tervezése során a tenzoros reprezentáció fontos követelmén. Ha a számításokat **tenzoros formában** szervezzük meg, akkor ez lehetővé teszi a hatékony párhuzamos végrehajtást. Minden szint – a modell, a programkönyvtár, a hardver – **kompatibilis** kell legyen ezzel a reprezentációval.
+A tenzoros struktúra támogatja a memóriabeli **lokalitást**, vagyis a gyakran használt adatok közel maradnak egymáshoz a memóriában, ezáltal gyorsabb az elérésük.