Differences

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

--- muszaki_informatika:gepi_tanulas [2025/05/22 10:30] – [Felügyelt és felügyelet nélküli tanulás] knehez
+++ muszaki_informatika:gepi_tanulas [2025/05/23 06:12] (current) – [Felügyelt és felügyelet nélküli tanulás] knehez
@@ Line 237: / Line 237: @@
 $$ \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 ====
+==== 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 //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.
+  * 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 ====
@@ Line 249: / Line 249: @@
   * 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.