Processing math: 100%

User Tools

Site Tools


muszaki_informatika:gepi_tanulas

This is an old revision of the document!


Gépi tanulás

Hétköznapi szóhasználatban a tanulás azt jelenti, hogy egy feladat megoldásához szabályokat találunk, vagy fedezünk fel. Például egy kisgyermek megtanulhatja, hogy a madaraknak van szárnyuk, és képesek repülni – anélkül, hogy ezt valaki pontos szabályok formájában elmagyarázná neki. A gyerek megfigyelései alapján felismeri a jellemző mintákat és kapcsolatokat, és ez alapján képes új esetekre is következtetni.

Formálisan tekintve, a gépi tanulás célja olyan függvény megtalálása, amely egy bemeneti adat 𝑥 alapján megbízhatóan becsli a hozzá tartozó kimenetet 𝑦. Például ha a bemenet egy rendszámtáblát ábrázoló kép, a kimenet a rajta olvasható szöveg lesz.

Ahhoz, hogy ez megvalósuljon, először is összegyűjtünk egy tanítóhalmazt, amely bemeneti és kimeneti adatpárokat tartalmaz:

D={(x1,y1),(x2,y2),,(xN,yN)}

Ezután definiálunk egy paraméteres modellt f(x;w), ahol:

  • f egy függvény (pl. neurális hálózat),
  • w a tanulható paraméterek összessége (súlyok),

cél, hogy f(xi;w)yi legyen, azaz tetszőlegesen kiválasztott adatpár bemenetére xi, az yi kimenetet adja.

A tanulás célja

A tanulás célja az optimális w paraméter megtalálása, amely mellett a modell jól teljesít. A modell jóságát (teljesítményét) veszteségfüggvény segítségével mérjük:

L(w)=1NNn=1(yn,f(xn;w))

ahol például lehet a négyzetes hiba, aminek egyik bemenete a tanító halmaz y kimenetének értékéből kivonja, a modell által számolt ˆy kimenetet és ennek a különbségnek veszi a négyezetét:

(y,ˆy)=(yˆy)2

Ilyenkor a veszteségfüggvény értéke a négyzetes hibák átlaga. Behelyettesítve:

L(w)=1NNn=1(ynf(xn;w))2

A tanulás célja, hogy megtaláljuk azt a paraméterbeállítást, amely a lehető legjobban teljesít. Ez azt jelenti, hogy olyan súlyokat (paramétereket) keresünk, amelyek a lehető legkisebb hibát eredményezik a tanítóadatokon.

Másként fogalmazva: a tanulás során azt a súlyvektort szeretnénk megtalálni w, amely minimalizálja a veszteségfüggvényt — vagyis azt, amely mellett a modell becslései a lehető legközelebb esnek a tényleges válaszokhoz az összes tanítópéldára nézve.

w=argminwL(w)

Ez a megközelítés számos alkalmazás alapját képezi: képfelismerés, szövegértés, hangfeldolgozás, játékstratégia stb. A modell nem szabályokat programozva működik, hanem adatokból „tanul meg” viselkedni.

Példa: Egyszerű lineáris modell tanulása

Tegyük fel, hogy a modellünk (becslő függvény) így néz ki:

f(x;w)=wx

és két tanítópéldánk van:

  • (1, 2)
  • (2, 4)

A cél, hogy olyan w súlyt találjunk, amely a következő veszteségfüggvényt minimalizálja:

L(w)=12[(2w1)2+(4w2)2]

Ez a függvény azt méri, hogy adott w esetén mekkora hibát követ el a modell. Az alábbi ábrán látható a veszteségfüggvény alakja, valamint a minimumhely:

  • A minimális veszteség L(w)0.00
  • A hozzá tartozó optimális súly: w=2.01

Példa: Összetettebb modell

Legyen a modell több paraméteres:

f(x;w)=Kk=1wkfk(x)

ahol:

  • fk(x) előre definiált bázisfüggvények (pl. Gauss-görbék, szinuszok, polinomok stb.)

  • Fekete pontok: zajos tanítóadatok (xn,yn)
  • Kék görbék: a 10 darab Gauss-alakú bázisfüggvény fk(x)
  • Piros görbe: a tanult függvény f(x;w)=wkfk(x)

A modell megtanulta, milyen súlyokkal (w-kel) kombinálja a bázisfüggvényeket úgy, hogy a piros görbe minél jobban kövesse a tanítóadatokat, azaz minimalizálja a négyzetes hibát.

A következő Python program hozta létre a fenti ábrát.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error
from scipy.linalg import solve
 
# 1. Tanítóadat generálása (zajos szinuszgörbe)
np.random.seed(42)
N = 30
x_train = np.linspace(0, 1, N)
y_train = np.sin(2 * np.pi * x_train) + 0.1 * np.random.randn(N)
 
# 2. Bázisfüggvények: Gauss-görbék
K = 10  # Bázisfüggvények száma
centers = np.linspace(0, 1, K)
width = 0.1
 
def gaussian_basis(x, c, s):
    return np.exp(-0.5 * ((x - c)/s)**2)
 
# 3. Design mátrix Φ (N x K)
Phi = np.stack([gaussian_basis(x_train, c, width) for c in centers], axis=1)
 
# 4. Optimális súlyok kiszámítása (normálegyenlet)
#  Φ w = y  => w = (ΦᵗΦ)⁻¹ Φᵗ y
w_star = solve(Phi.T @ Phi, Phi.T @ y_train)
 
# 5. Kiértékelés új pontokon
x_test = np.linspace(0, 1, 200)
Phi_test = np.stack([gaussian_basis(x_test, c, width) for c in centers], axis=1)
y_pred = Phi_test @ w_star
 
# 6. Eredmény kirajzolása
plt.figure(figsize=(10, 6))
for k in range(K):
    plt.plot(x_test, Phi_test[:, k], '--', color='blue', alpha=0.3# bázisfüggvények
 
plt.plot(x_test, y_pred, color='red', label='Lineáris kombináció (becslés)')
plt.scatter(x_train, y_train, color='black', label='Tanítóadatok')
plt.title("Basis function regression Gaussian bázisfüggvényekkel")
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

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.

Ha a modell túl egyszerű (kevés paramétert vagy kevés bázisfüggvényt használ), akkor nem lesz elég rugalmas ahhoz, hogy megtanulja az adatok mögötti összefüggéseket. Ez az eset az underfitting (gyenge illeszkedés): a modell nem tud alkalmazkodni még a tanítóadatokhoz sem, és mind a tanító-, mind a tesztpéldákon nagy hibát vét.

Ezzel szemben, ha a modell túl bonyolult (pl. túl sok paraméterrel dolgozik), akkor hajlamos arra, hogy a tanítóadatokra túlzottan “ráilleszkedjen”. Ez az overfitting (túlzott illeszkedés), amely során a modell tökéletesen teljesít a tanítóhalmazon, de új, ismeretlen adatokra gyengén általánosít. Megtanulja a tanító halmazban lévő “zajt”, pl. az esetleges hibás vagy kiugró értékeket is.

Az alábbi ábra ezt a jelenséget szemlélteti:

  • A fekete vonal a valódi (ismeretlen) függvény, amely szerint az adatok keletkeztek.
  • A fekete pontok a tanítópéldák.
  • A kék szaggatott görbe egy túl egyszerű modell (underfitting): nem tudja követni a mintát.
  • A piros szaggatott görbe egy túltanult modell (overfitting): jól illeszkedik a pontokra, de a valódi görbétől eltér.

Olyan modellt érdemes tervezni, amely épp elég rugalmas ahhoz, hogy meg tudja tanulni az adatok szerkezetét, de nem annyira rugalmas, hogy a véletlen zajokat is megtanulja.

A következő program hozza létre a fenti ábrát:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import numpy as np
import matplotlib.pyplot as plt
 
# Valódi (rejtett) függvény
def true_function(x):
    return np.sin(2 * np.pi * x)
 
# Tanítóadat
np.random.seed(1)
x_train = np.linspace(0, 1, 7)
y_train = true_function(x_train) + 0.1 * np.random.randn(len(x_train))
 
# Teszteléshez sűrű intervallum
x_test = np.linspace(0, 1, 300)
y_true = true_function(x_test)
 
# Gauss bázisfüggvények
def gaussian_basis(x, c, s):
    return np.exp(-0.5 * ((x - c)/s)**2)
 
def design_matrix(x, centers, width):
    return np.stack([gaussian_basis(x, c, width) for c in centers], axis=1)
 
# Underfitting (kevés bázis)
centers_under = np.linspace(0, 1, 3)
Phi_under = design_matrix(x_train, centers_under, 0.3)
Phi_under_test = design_matrix(x_test, centers_under, 0.3)
w_under = np.linalg.lstsq(Phi_under, y_train, rcond=None)[0]
y_under_pred = Phi_under_test @ w_under
 
# Overfitting (sok bázis)
centers_over = np.linspace(0, 1, 15)
Phi_over = design_matrix(x_train, centers_over, 0.05)
Phi_over_test = design_matrix(x_test, centers_over, 0.05)
w_over = np.linalg.lstsq(Phi_over, y_train, rcond=None)[0]
y_over_pred = Phi_over_test @ w_over
 
# Ábra
plt.figure(figsize=(10, 6))
plt.plot(x_test, y_true, color='black', linewidth=2, label='Valódi függvény')
plt.plot(x_test, y_under_pred, color='blue', linestyle='--', label='Underfitting (kevés bázis)')
plt.plot(x_test, y_over_pred, color='red', linestyle='--', label='Overfitting (sok bázis)')
plt.scatter(x_train, y_train, color='black', label='Tanítóadatok')
plt.title("Underfitting és overfitting példája")
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

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 xRd tartozó kimeneti értéket yRk 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{1,2,,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)=softmax(s1,s2,,sC)

ahol si a i-edik osztályhoz tartozó nyers pontszám. A predikció:

ˆy=argmaxifi(x;w)

A tanítóadat itt is (xn,yn) párokból áll, de a yn 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)ˆp(x;w)

Ilyenkor csak xn példák állnak rendelkezésre (nincs hozzájuk tartozó yn), é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:

L(w)=1NNn=1logˆp(xn;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).
muszaki_informatika/gepi_tanulas.1747909869.txt.gz · Last modified: 2025/05/22 10:31 by knehez