# 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
```python
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
```python
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
```python
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)
```python
for t in range(2000):
# ...
```
- 2000-szer ismétli a tanulási lépéseket.
### 4.1. Előrehaladás (forward pass)
```python
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
```python
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
```python
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)
```python
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
```python
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
1. **Adatok előállítása**: x és y (szinusz értékek)
2. **Súlyok inicializálása**: a, b, c, d
3. **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
4. **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!
[^1][^2][^3]
⁂
[^1]: https://www.youtube.com/watch?v=oKNIr-iCb6g
[^2]: https://learn.microsoft.com/hu-hu/training/modules/understand-regression-machine-learning/
[^3]: https://www.youtube.com/watch?v=YAJ5XBwlN4o