Gauss-Newton-módszer

Sablon:Hunfn Sablon:Label A **Gauss-Newton-módszer** egy iteratív algoritmus, amelyet nemlineáris legkisebb négyzetek problémáinak megoldására használnak. A módszer a Newton-módszer egy leegyszerűsített változata, amely nemlineáris regresszió vagy más optimalizációs problémák során hasznos.

---

Matematikai alapok

Ha egy nemlineáris függvényt $f(x)$ szeretnénk illeszteni az adatokhoz, az optimalizálandó célfüggvény a reziduális négyzetösszeg:

$$S(x)=\sum _{i=1}^m{(r_i(x))}^2,$$

ahol a $r_i(x)=y_i-f(x_i)$ a reziduális függvény.

A Gauss-Newton-módszer iterációval közelíti meg a minimumot:

1. Lineáris közelítést alkalmazunk $r(x)$ környezetében.
2. A Jacobian-mátrixot ($J$) használjuk az irány meghatározásához.
3. Az iterációs szabály a következő:

  $$x_{k+1}=x_k-{\left(J^{T}J\right)}^{-1}{J}^{T}r(x_k),$$
  ahol:
  * $J$ a Jacobian-mátrix, amely tartalmazza az $r(x)$-beli parciális deriváltakat.

---

Python-implementáció

Az alábbi példában bemutatjuk, hogyan használható a Gauss-Newton-módszer nemlineáris illesztéshez.

Példa: Nemlineáris függvényillesztés

import numpy as np

def gauss_newton(f, jacobian, x0, y, max_iter=100, tol=1e-6):
    """
    Gauss-Newton algoritmus a legkisebb négyzetes illesztéshez.
    
    :param f: Nemlineáris függvény
    :param jacobian: Jacobian-mátrix (parciális deriváltak)
    :param x0: Kezdő paraméterek
    :param y: Megfigyelt adatok
    :param max_iter: Iterációk maximális száma
    :param tol: Tolerancia a konvergenciához
    :return: Optimalizált paraméterek
    """
    x = x0
    for i in range(max_iter):
        # Reziduális számítás
        r = y - f(x)
        # Jacobian számítás
        J = jacobian(x)
        # Gauss-Newton lépés
        delta = np.linalg.lstsq(J.T @ J, J.T @ r, rcond=None)[0]
        x_new = x + delta
        # Konvergencia ellenőrzése
        if np.linalg.norm(delta) < tol:
            break
        x = x_new
    return x

# Példa függvény és Jacobian
def f(x):
    """Nemlineáris modell: y = a * e^(b * t)"""
    t = np.linspace(0, 10, len(y_data))
    return x[0] * np.exp(x[1] * t)

def jacobian(x):
    """Jacobian mátrix számítása"""
    t = np.linspace(0, 10, len(y_data))
    J = np.zeros((len(t), len(x)))
    J[:, 0] = np.exp(x[1] * t)       # Parciális derivált x[0] szerint
    J[:, 1] = x[0] * t * np.exp(x[1] * t)  # Parciális derivált x[1] szerint
    return J

# Példa adatok
t_data = np.linspace(0, 10, 15)
y_data = 3 * np.exp(0.5 * t_data) + np.random.normal(0, 0.5, len(t_data))

# Kezdeti becslések
x0 = np.array([1.0, 0.1])

# Optimalizáció
x_opt = gauss_newton(f, jacobian, x0, y_data)
print("Optimalizált paraméterek:", x_opt)

---

Kimenet

Az optimalizált paraméterek $x_0$ és $x_1$ lesznek, amelyek a legjobban illeszkednek az $y=a{e}^{bt}$ modellhez.

---

Fontos jellemzők

1. Gyors konvergencia: A módszer gyorsan konvergál, ha az induló becslés közel van a valódi megoldáshoz.
2. Limitáció: Nem garantált a globális minimum megtalálása, és a Jacobian-invertálás érzékeny lehet a rosszul kondicionált problémákra.
3. Alkalmazási terület: Használják nemlineáris regresszióban, mérnöki problémákban és adatillesztési feladatokban.

• Sablon:En: Sablon:T
• Sablon:De: Sablon:T