Kódrészlet magyarázata lépésről lépésre

Ez a kód egy egyszerű polinomiális regressziót valósít meg Pythonban, Numpy segítségével, hogy egy szinuszhullámot közelítsen egy harmadfokú polinommal. Ez még nem PyTorch, hanem "kézzel" írt gépi tanulás, de a logika ugyanaz, mint amit PyTorch-ban is használnál.

1. Adatok előállítása

x = np.linspace(-math.pi, math.pi, 2000)
y = np.sin(x)

x: 2000 darab egyenletesen elosztott pont -π és π között.
y: minden x-hez kiszámolja a szinusz értékét. Ez lesz a "valódi" függvény, amit közelíteni akarunk.

2. Súlyok (együtthatók) véletlenszerű inicializálása

a = np.random.randn()
b = np.random.randn()
c = np.random.randn()
d = np.random.randn()

Ezek a polinom együtthatói: y = a + b x + c x^2 + d x^3
Kezdetben véletlen értékek, a tanulás során ezek fognak "tanulni".

3. Tanulási ráta beállítása

learning_rate = 1e-6

Ez határozza meg, hogy a súlyok mennyit változnak minden lépésben.

4. Tanítási ciklus (iterációk)

for t in range(2000):
    # ...

2000-szer ismétli a tanulási lépéseket.

4.1. Előrehaladás (forward pass)

y_pred = a + b * x + c * x ** 2 + d * x ** 3

A jelenlegi súlyokkal kiszámolja a polinom értékét minden x-re.
Ez a "becsült" függvény, amit a tanulás során javítunk.

4.2. Veszteség (loss) kiszámítása

loss = np.square(y_pred - y).sum()

Megméri, mennyire tér el a becsült érték a valódi szinusz értéktől.
A négyzetes eltérések összegét számolja (ez a Mean Squared Error logikája).
Minden 100. lépésnél kiírja az aktuális veszteséget.

4.3. Visszaterjesztés (backpropagation) – gradiens számítás

grad_y_pred = 2.0 * (y_pred - y)
grad_a = grad_y_pred.sum()
grad_b = (grad_y_pred * x).sum()
grad_c = (grad_y_pred * x ** 2).sum()
grad_d = (grad_y_pred * x ** 3).sum()

Kiszámolja, hogy a veszteség hogyan változik, ha az egyes együtthatókat kicsit módosítjuk (ez a gradiens).
Ez mutatja meg, milyen irányba kell "tolni" az együtthatókat, hogy a veszteség csökkenjen.

4.4. Súlyok frissítése (gradient descent)

a -= learning_rate * grad_a
b -= learning_rate * grad_b
c -= learning_rate * grad_c
d -= learning_rate * grad_d

Minden együtthatót módosít a gradiens irányába, a tanulási ráta mértékével.
Így a polinom egyre jobban fogja közelíteni a szinusz görbét.

5. Eredmény kiírása

print(f'Result: y = {a} + {b} x + {c} x^2 + {d} x^3')

A tanulás végén kiírja a megtanult polinom együtthatóit.
Ezekkel az értékekkel a polinomod a lehető legjobban közelíti a szinusz hullámot a megadott x tartományban.

Mit kellene látnod eredményként?

A veszteség (loss) értéke a tanulás során folyamatosan csökken – ez azt jelenti, hogy a polinom egyre jobban közelíti a szinusz hullámot.
A végén kapsz egy polinomot, aminek az együtthatói (a, b, c, d) már "megtanulták" a szinusz hullám alakját.
Ha ábrázolod a y (szinusz) és y_{pred} (polinom) görbéket, a tanulás végén a két görbe nagyon hasonló lesz.

Lépések összefoglalva

Adatok előállítása: x és y (szinusz értékek)
Súlyok inicializálása: a, b, c, d
Tanulási ciklus:
- Előrehaladás: polinom kiszámítása
- Veszteség: eltérés mérése
- Gradiens: hogyan változtassunk a súlyokon
- Súlyok frissítése: tanulás
Eredmény: megtanult polinom együtthatók

Ha szeretnéd, segítek abban is, hogyan lehet ezt PyTorch-ban automatizálni, vagy hogyan ábrázolhatod a tanulás eredményét grafikonon! ¹²³

⁂

4.1 KiB Raw Blame History Unescape Escape