6.1 Objektív, reguláris tag és gradienslépés

6.1.1 Cél, előismeret és induló kérdés

Ez az egység a tanulás matematikai magját, az empirikus kockázat minimalizálását és annak első numerikus eszközét, a gradienslépést vezeti be. A 4.4. I. ellenőrző pont: matematika és kód megfelelése alfejezetben egy rögzített pontban számoltunk gradienst és ellenőriztük annak helyességét; ott a kérdés a számítás, nem a paraméterfrissítés volt. Az 5.4. Függő képek, seedek és resampling alfejezetben láttuk, hogy a minta statisztikai szerkezete — például a jelenetekbe rendezett képek — befolyásolja, mit jelent egy átlag bizonytalansága. Most ezt a két szálat kapcsoljuk össze: egy batch megfigyeléséből átlagolt veszteséget definiálunk, a modellparaméterekre vett gradiensét levezetjük, majd abból tényleges paraméterfrissítést készítünk.

Egy kérdés a mélytanulási kódok mindennapjából: miért szerepel a legtöbb keretrendszer veszteségében egy $\tfrac12$ szorzó, és miért beszélünk külön adathibáról és regularizáló tagról, holott a kódban a kettő egyszerűen összeadódik? A válaszhoz előbb pontosan definiálnunk kell az objektívfüggvényt, a hozzá tartozó tenzoralakokat, majd a derivált skáláját — ez utóbbi a batchméret és a konstansszorzók kezelésén áll vagy bukik.

6.1.2 Empirikus kockázat, batch-átlag és penalty

Definíció (empirikus kockázat). Legyen $D=\{(x_i,y_i)\}_{i=1}^{N}$ egy véges megfigyelés-sorozat, ahol $x_i\in\mathbb R^d$ a bemeneti vektor és $y_i$ a hozzá tartozó cél, amely jelen egységben regressziós esetben $y_i\in\mathbb R^m$, osztályozásnál később osztályindex. Legyen $f_\theta:\mathbb R^d\to\mathbb R^m$ egy $\theta$ paraméterű modell és $\ell:\mathbb R^m\times\mathbb R^m\to\mathbb R$ egy elemenkénti veszteség. Az empirikus kockázat

$$R_D(\theta)=\frac{1}{N}\sum_{i=1}^{N}\ell(f_\theta(x_i),y_i).$$

A kifejezés azért kockázat, mert a teljes adathalmazra vett átlagot jelenti; a szó empirikus arra utal, hogy a várható értéket a véges mintával helyettesítettük. Folytonos cél esetén a négyzetes veszteség $\ell(f,y)=\tfrac12\lVert f-y\rVert_2^2$; a $\tfrac12$ kizárólag a derivált kényelmét szolgálja, és nincs statisztikai jelentése. Osztályozási logitokhoz ugyanitt a 7.2. Softmax és többosztályos cross-entropy alfejezetben bevezetett cross-entropy kerül, amely a logitot nem kezeli valószínűségként: a softmax abban a veszteségben belül történik.

A gyakorlati tanítás nem a teljes $D$-re, hanem egy $B\subseteq\{1,\ldots,N\}$ minibatchre számol. Legyen $M=|B|$ a batch elemszáma. A batch bemenete $X_B\in\mathbb R^{M\times d}$, ahol minden sor egy megfigyelés; a cél $Y_B\in\mathbb R^{M\times m}$. A batch-átlag veszteség:

$$L_B(\theta)=\frac{1}{M}\sum_{i\in B}\ell(f_\theta(x_i),y_i).$$

Ha $B=\{1,\ldots,N\}$, akkor $L_B=R_D$; általában azonban a batch-átlag csak közelíti az empirikus kockázatot. Az 5.4. Függő képek, seedek és resampling alfejezetből tudjuk, hogy ha a megfigyelések klaszterekbe rendeződnek, a batch-átlag statisztikai értelmezése is finomabb: a képek, nem a jelenetek szerinti átlagolás nem ugyanazt a független egységet becsli.

Definíció (regularizáló penalty). Legyen $W\in\mathbb R^{m\times d}$ a modell lineáris paramétermátrixa, $b\in\mathbb R^{m}$ a biasvektor. Az $L^2$-regularizáló tag

$$P_\lambda(W)=\frac{\lambda}{2}\lVert W\rVert_F^2=\frac{\lambda}{2}\sum_{a=1}^{m}\sum_{b=1}^{d}W_{ab}^{2},\qquad \lambda\ge 0.$$

A $\lambda$ skálaparaméter a regularizáció erőssége; a $\tfrac12$ itt is a derivált alaktisztaságát szolgálja. A Frobenius-norma a mátrix elemnégyzet-összegének négyzetgyöke, tehát $\lVert W\rVert_F^2$ a mátrixelemek négyzetösszege. A biasra rendszerint nem alkalmazunk $L^2$-tagot, mert a bias eltolást kódol, nem pedig a bemenetre ható erősítést.

Definíció (teljes batch-objektív). A regularizált batch-célfüggvény

$$F_B(W,b)=L_B(W,b)+P_\lambda(W).$$

A fenti $L_B$ argumentumába $W,b$ kerül, mert a konkrét modell ezeket használja. A gradienslépés a gradient descent:

$$W^{(t+1)}=W^{(t)}-\eta\,\nabla_W F_B(W^{(t)},b^{(t)}),\qquad b^{(t+1)}=b^{(t)}-\eta\,\nabla_b F_B(W^{(t)},b^{(t)}),$$

ahol $\eta>0$ a step size (tanulási sebesség). A későbbi sztochasztikus változatnál 6.3. Sztochasztikus és minibatch gradiens a batchgradiens a minibatchből származik; itt egyelőre a frissítés alakjára koncentrálunk.

6.1.3 A gradiens levezetése: fél-MSE és $\lambda/2$ súlynorma

Tétel (a regularizált fél-MSE gradiense). Legyen a modell affin transzformáció: $Z=XW^\top+b$, ahol $X\in\mathbb R^{M\times d}$, $W\in\mathbb R^{m\times d}$, $b\in\mathbb R^{m}$ sorirányú broadcast mellett, és $Z\in\mathbb R^{M\times m}$. Legyen a batch-veszteség

$$L_B=\frac{1}{2M}\lVert Z-Y\rVert_F^2=\frac{1}{2M}\sum_{i=1}^{M}\sum_{k=1}^{m}(Z_{ik}-Y_{ik})^2,$$

és a teljes cél $F_B=L_B+\frac{\lambda}{2}\lVert W\rVert_F^2$. Ekkor

$$\nabla_W F_B=\frac{1}{M}(Z-Y)^\top X+\lambda W,\qquad \nabla_b F_B=\frac{1}{M}(Z-Y)^\top\mathbf 1_M,$$

ahol $\mathbf 1_M\in\mathbb R^{M}$ a csupa egyes vektor, és $\nabla_b F_B\in\mathbb R^{m}$.

A kifejezésben $(Z-Y)^\top X$ egy $m\times d$ mátrix, tehát $\nabla_W F_B$ alakja mindvégig megegyezik $W$ alakjával. A biasgradiens a hibamátrix oszlopösszege osztva $M$-mel, ami $m$-dimenziós vektort ad. A tétel a láncszabály definíció szerinti alkalmazása; a levezetést teljesen elvégezzük, mert a skálatényezők — az $\tfrac1M$ és a $\tfrac12$ — pontosan itt dőlnek el.

Levezetés. Jelölje $R=Z-Y$ a hibamátrixot. A veszteség elemenkénti deriváltja $Z$ szerint:

$$\frac{\partial L_B}{\partial Z_{pq}}=\frac{1}{M}(Z_{pq}-Y_{pq})=\frac{1}{M}R_{pq},$$

mert az $(Z_{pq}-Y_{pq})^2$-nél a láncszabály $2(Z_{pq}-Y_{pq})$ faktort ad, amelyet a $\tfrac12$ kiejt, és az $\tfrac1M$ átlagolás megmarad. Most $Z_{ik}=\sum_{j=1}^{d}X_{ij}W_{kj}+b_k$, tehát

$$\frac{\partial Z_{ik}}{\partial W_{ab}}=\delta_{ka}X_{ib},\qquad \frac{\partial Z_{ik}}{\partial b_a}=\delta_{ka},$$

ahol $\delta_{ka}=1$, ha $k=a$, egyébként $0$. A $W_{ab}$ szerinti parciális derivált a többváltozós láncszabállyal 4.3. Jacobi-mátrix, láncszabály és VJP:

$$\frac{\partial L_B}{\partial W_{ab}}=\sum_{i=1}^{M}\sum_{k=1}^{m}\frac{\partial L_B}{\partial Z_{ik}}\frac{\partial Z_{ik}}{\partial W_{ab}}=\sum_{i,k}\frac{1}{M}R_{ik}\,\delta_{ka}X_{ib}=\frac{1}{M}\sum_{i=1}^{M}R_{ia}X_{ib}.$$

Az utolsó összeg a $R^\top X$ mátrix $(a,b)$ eleme, mert $(R^\top X)_{ab}=\sum_i (R^\top)_{ai}X_{ib}=\sum_i R_{ia}X_{ib}$. Tehát $\nabla_W L_B=\frac{1}{M}R^\top X$. A biasra hasonlóan

$$\frac{\partial L_B}{\partial b_a}=\sum_{i,k}\frac{1}{M}R_{ik}\delta_{ka}=\frac{1}{M}\sum_{i=1}^{M}R_{ia}.$$

A biasgradiens tehát $\frac1M R^\top\mathbf 1_M$, mert $R^\top$ alakja $m\times M$, és $\mathbf 1_M$-mel szorozva az oszlopösszegeket kapjuk.

A regularizáló gradienséhez $\frac{\partial}{\partial W_{ab}}\frac{\lambda}{2}\sum_{c,d}W_{cd}^2=\frac{\lambda}{2}\cdot 2W_{ab}=\lambda W_{ab}$, tehát $\nabla_W P_\lambda=\lambda W$. Az $F_B=L_B+P_\lambda$ összeg deriváltja tagok összege, amiből a tétel képlete adódik. $\square$

Fontos megkülönböztetés: a fenti $\frac{1}{2M}$ skálázású kvadratikus tag a fél-MSE. A köznyelvi MSE definíciója $\frac1M\lVert Z-Y\rVert_F^2$, amelynek gradiense $\frac{2}{M}R^\top X$. A kettő konstansszorzóban tér el; ugyanazt a minimumot adja, de a regularizációs $\lambda$ hangolásakor a skálát rögzítenünk kell. A gyakorlati kódok ezért expliciten dokumentálják, hogy a $\tfrac12$-es skálázást hol alkalmazzák.

A VJP-olvasat 4.4. I. ellenőrző pont: matematika és kód megfelelése szerint: legyen $g=\nabla_Z F_B=\frac1M R$; a paramétergradiensek az affin réteg backward lépéséből $g^\top X$, illetve a biasra a $g$ oszlopösszege. A fenti tétel pontosan ezt a programozói formát adja.

6.1.4 Kézi egyparaméteres példa és a lépések igazolása

A labor célja a gradienslépés mechanikájának kézi, ellenőrizhető követése. Legyen egyetlen bemeneti és kimeneti dimenzió, $d=m=1$, és egyetlen mintapár: $x=3$, $y=9$. A modell $z=Wx$ (bias nélkül, a példa tisztasága érdekében). A fél-MSE egyetlen megfigyelésre:

$$L(W)=\frac12(3W-9)^2.$$

A regularizáló $\lambda=0.2$ mellett $P(W)=0.1\,W^2$. A teljes cél:

$$F(W)=\frac12(3W-9)^2+0.1W^2.$$

A gradiens: $F'(W)=3(3W-9)+0.2W=9.2W-27$. Analitikus optimum: $F'(W^*)=0$, azaz $W^*=27/9.2=2.934\,\!782\,\!608\ldots$

Induljunk $W_0=0$-ból, $\eta=0.05$ lépésközzel. A számított lépések:

• $t=0$: $F(0)=\frac12(81)=40.5$, $F'(0)=-27$, frissítés $W_1=0-0.05\cdot(-27)=1.35$.
• $t=1$: $F(1.35)\approx 12.25125+0.18225=12.4335$, $F'(1.35)\approx 9.2\cdot1.35-27=-14.58$, frissítés $W_2=1.35-0.05\cdot(-14.58)=2.079$.
• $t=2$: $3W_2-9\approx -2.763$, négyzet $\approx 7.634$, fél $\approx 3.817$; regularizáció $0.1\cdot 4.322=0.4322$; $F(2.079)\approx 4.249$; gradiens $F'(2.079)\approx 19.1268-27=-7.8732$.
• $t=3$: $W_3=2.079+0.39366=2.47266$.

Megfigyelés: $F$ monoton csökken az első lépésekben, $F(0)=40.5$, $F(1.35)\approx12.43$, $F(2.079)\approx4.25$. A gradiens abszolút értéke is csökken: $27$, $14.58$, $7.87$; ez a konvergencia numerikus jele, de önmagában nem bizonyítja a végtelenben vett minimumot — a 6.2. Konvexitás és sima optimalizálási határ alfejezetben adunk majd simasági feltételek melletti kvantitatív korlátot.

Elsőrendű Taylor-indoklás: $F(W_{t+1})\approx F(W_t)+F'(W_t)(-\eta F'(W_t))=F(W_t)-\eta|F'(W_t)|^2$, tehát minden nem nulla gradiensű pontban elegendően kis $\eta$ mellett a lineáris közelítés csökkenést jelez. Ez lokális állítás; nagy $\eta$-ra a kvadratikus tag felülírhatja, és a cél nőhet.

6.1.5 Labor: NumPy gradienslépés egyparaméteres célra

Munkakönyvtár: ch06_empirical_risk/. Fájl: n021_gd_demo.py.

A feladat az előző kézi példa teljes megismétlése NumPy-ban, ahol minden lépés kimenetét külön ellenőrizzük. Nincs véletlen komponens, ezért seed nem szükséges; ezt kimondjuk. A dtype mindenütt float64, mert a gradiensellenőrzési fegyelem 4.4. I. ellenőrző pont: matematika és kód megfelelése szerint a magasabb pontosság a numerikus hibák elkülönítését segíti. Az eszköz CPU; PyTorch nem kell hozzá.

# n021_gd_demo.py
# Az író ezt a fájlt nem futtatta a kérésben; az alábbi kimenet kézzel számolt
# szemléltetés, a futás külön ellenőrizendő.
import numpy as np

x = np.array(3.0, dtype=np.float64)       # bemeneti skalár
y = np.array(9.0, dtype=np.float64)       # cél
lam = 0.2                                 # regularizációs erősség
eta = 0.05                                # step size

def objective(w):
    z = w * x
    return 0.5 * (z - y) ** 2 + 0.5 * lam * w ** 2   # fél-MSE + lambda/2 w^2

def gradient(w):
    z = w * x
    return (z - y) * x + lam * w                     # (3w-9)*3 + 0.2w

def step(w):
    return w - eta * gradient(w)

w = np.array(0.0, dtype=np.float64)
for t in range(6):
    g = gradient(w)
    print(f"t={t}  w={w:.8f}  F={objective(w):.8f}  grad={g:.8f}")
    w = step(w)

# Ellenőrzés: az első három frissítés egyezzen a kézi lépésekkel
w_repro = np.array(0.0, dtype=np.float64)
for expected in (1.35, 2.079, 2.47266):
    w_repro = step(w_repro)
    np.testing.assert_allclose(w_repro, expected, rtol=0.0, atol=5e-6)
print("ellenorzes: az elso harom lepes a kezi szamitassal egyezik (atol=5e-6)")

Számított, nem futtatott kimenet (jelölt):

t=0  w=0.00000000  F=40.50000000  grad=-27.00000000
t=1  w=1.35000000  F=12.43350000  grad=-14.58000000
t=2  w=2.07900000  F=4.24912540   grad=-7.87320000
t=3  w=2.47266000  F=1.63274053   grad=-4.25152800
t=4  w=2.68523640  F=0.94156978   grad=-2.29582448
t=5  w=2.80002762  F=0.88775965   grad=-1.23974588

Futtatási parancs: python n021_gd_demo.py.

Eredményértelmezés. Az értékek az analitikus képletekből számítottak; ha a futtatás eltér, előbb a kézzel való számítást, azután a kód szintaktikáját ellenőrizzük. A veszteség a tizedik lépésig várhatóan $F\approx0.8804$ közelébe ér, mert az optimum $F^*$ a fent számított $0.8804$ körüli érték; a konvergencia az $\eta=0.05$ esetén a szokásos lineáris sebességű, mivel $F''(W)=9.2$, így a csillapítási tényező $|1-\eta F''| = |1-0.46|=0.54$ lépésenként közelítőleg.

6.1.6 Feladatok

F1 (fogalmi, nehézség 1). Fogalmazd meg saját szavakkal a különbséget az empirikus kockázat, a batch-átlag és a regularizáló penalty között. Adj egy példát, amelyben a batch-átlag nem egyenlő az empirikus kockázattal. Átadandó: rövid definíciók és az ellenpélda konkrét $N$-nel, batchmérettel.

F2 (levezetési, nehézség 2). Legyen $M=2$, $d=2$, $m=1$, $X=\begin{pmatrix}1&2\\3&4\end{pmatrix}$, $Y=\begin{pmatrix}5\\7\end{pmatrix}$, modell $Z=XW^\top$ (bias nélkül), $W=(W_{11},W_{12})$, és cél $F=\frac{1}{2M}\lVert Z-Y\rVert_F^2+\frac{\lambda}{2}\lVert W\rVert_F^2$. Vezesd le $\nabla_W F$ értékét a $W=(0,0)$ pontban, $\lambda=0.1$ esetén. Átadandó: teljes levezetés, az alakellenőrzés és a konkrét numerikus gradiensvektor.

F3 (implementációs, nehézség 2). Implementáld a fenti laborlépést általános $x,y$ skalár, $\lambda,\eta$ bemenettel egy f3_gd.py függvényben úgy, hogy a futás a $W_1,W_2,W_3$ értékeket adja vissza. Tedd ellenőrizhetővé: az $x=3,y=9,\lambda=0.2,\eta=0.05$ bemenetre az első három frissítés $1.35$, $2.079$, $2.47266$. Átadandó: a fájl teljes szövege, inputok, tolerancia és futtatási parancs.

F4 (hibakeresési, nehézség 2). A következő függvény a paramétergradienst számítja:

def buggy_grad(W, X, Y):
    Z = X @ W          # (M, m)
    R = Z - Y          # (M, m)
    return R.T @ X     # (m, d), de hiányzik a batchnormálás

Magyarázd meg, milyen hibát követ el, mi a következménye a gradienslépésre, és hogyan javítanád. Átadandó: a hiba oka, hatása és a javított függvény, valamint egy numerikus kontroll, amelyben $M=2$ és a javítás utáni gradiens éppen a felét adja a hibásnak.

F5 (kísérleti transzfer, nehézség 3). Tervezz kísérletet annak mérésére, hogy a $\lambda$ regularizáció hogyan hat egy kis, procedurálisan generált lineáris regressziós feladat tanítási és validációs hibájára. A tervnek tartalmaznia kell: adatgenerálási recept, megfigyelési egység, split, baseline, a változó $\lambda$-értékek, a kiértékelendő metrika, a számítási erőforrás és a következtetési határ. Átadandó: a protokoll és legalább két lehetséges eredményértelmezés a korlátokkal.

6.1.7 Megoldások és indoklás

F1 megoldás. Az empirikus kockázat a teljes $D$ mintára vett átlag $\frac1N\sum_{i=1}^N\ell_i$; a batch-átlag egy $B\subseteq\{1,\ldots,N\}$ részhalmazra vett $\frac1M\sum_{i\in B}\ell_i$; a penalty a modellparaméterektől függő, adattól független büntetőtag, például $\frac\lambda2\lVert W\rVert_F^2$. Ha $N=6$, $B=\{1,2\}$, akkor $L_B=\frac12(\ell_1+\ell_2)$, míg $R_D=\frac16(\ell_1+\cdots+\ell_6)$; a kettő általában nem egyenlő, kivéve ha a batch éppen a teljes halmaz. A penalty akkor sem válik empirikus kockázattá, ha a batch az egész adat: az adatfüggő és paraméterbüntető tag más forrásból származik.

F2 megoldás. A tétel képletéből $\nabla_W F=\frac1M R^\top X+\lambda W$. Kezdőpontban $W=(0,0)$, tehát $\lambda W=0$. Ekkor $Z=XW^\top=(0,0)^\top$, $R=Z-Y=(-5,-7)^\top$. A szorzat:

$$R^\top X=(-5,-7)\begin{pmatrix}1&2\\3&4\end{pmatrix}=(-5-21,\,-10-28)=(-26,-38).$$

Így $\frac1M R^\top X=\frac12(-26,-38)=(-13,-19)$. A regularizáló zérus, tehát $\nabla_W F=(-13,-19)$. Alakellenőrzés: $W\in\mathbb R^{1\times2}$, a gradiens is $1\times2$, helyes. A $W_{11}$ szerinti komponens $-13$: ha $W_{11}$-et kis $\varepsilon$-nal növeljük, mindkét minta predikciója nő, a hibák negatívak, tehát a veszteség csökken, ezért a gradiens negatív.

F3 megoldás. A teljes fájl:

# f3_gd.py
import numpy as np

def gd_first_three(x=3.0, y=9.0, lam=0.2, eta=0.05):

    def F(w):
        z = w * x
        return 0.5 * (z - y) ** 2 + 0.5 * lam * w ** 2

    def grad(w):
        return (w * x - y) * x + lam * w

    w = 0.0
    out = []
    for _ in range(3):
        w = w - eta * grad(w)
        out.append(w)
    return np.array(out, dtype=np.float64)

if __name__ == "__main__":
    res = gd_first_three()
    print(res)
    np.testing.assert_allclose(res, [1.35, 2.079, 2.47266],
                               rtol=0.0, atol=5e-6)
    print("ok")

Futtatás: python f3_gd.py. Tolerancia: abszolút $5\cdot10^{-6}$, mert a harmadik lépés értékét öt tizedesre kerekítettük; a tiszta analitikus képletből további tizedesek is számíthatók, ezért a tolerancia a kerekítést hidalja át.

F4 megoldás. A buggy_grad a batch-összeget számítja, nem a batch-átlagot: $R^\top X$ értéke $M$-szerese az $\frac1M R^\top X$ átlaggradiensnek. Következmény: ha a lépésközt a normalizált gradiensre hangoltuk, a hibás gradiens ötszörös, tízszeres, százszoros lépést adhat, ami a célfüggvény növekedéséhez és divergenciához vezet. Javítás: osszunk a batch méretével, vagy használjunk np.mean-alapú szorzást:

def fixed_grad(W, X, Y):
    M = X.shape[0]
    Z = X @ W
    R = Z - Y
    return (R.T @ X) / M      # (m, d), batch-átlag

Numerikus kontroll: $W=0$, $X=\begin{pmatrix}1&0\\0&1\end{pmatrix}$, $Y=\begin{pmatrix}2\\4\end{pmatrix}$. Ekkor $R=(-2,-4)^\top$, $R^\top X=(-2,-4)$; a hibás grad $(-2,-4)$, a javított $\frac12(-2,-4)=(-1,-2)$.

F5 megoldásminta. Adat: $N=300$, $d=5$ független standard normális $x_i$, cél $y_i=2x_{i1}-x_{i2}+0.3x_{i3}+\varepsilon_i$, $\varepsilon_i\sim\mathcal N(0,0.5^2)$. Megfigyelési egység: egy mintapont; itt nincs klaszterezés, ezért az egyszerű split elfogadható. Split: $60/20/20$ train/validation/test rétegezve a célkvantilisek szerint. Baseline: $\lambda=0$ lineáris regresszió. Változó: $\lambda\in\{0,0.001,0.01,0.1,1\}$, mindegyiknél rögzített $100$ gradienslépés, $\eta$ előzetes sanity checkkel. Metrika: validációs MSE; a döntés után a teszt MSE-t csak egyszer számítjuk. Erőforrás: CPU, NumPy, seed rögzítve az adatgeneráláshoz. Értelmezés: ha a validációs görbe U alakú, a kicsi $\lambda$ alul-, a nagy $\lambda$ túlregularizál; mivel az adat szintetikus és alacsony dimenziós, az eredmény nem vihető át nagy képmodellre. Lehetséges negatív eredmény: ha a zaj kicsi, a $\lambda=0$ is jó, és a regularizálás nem javít; ez is érvényes, dokumentálandó eredmény.

6.1.8 Tipikus tévedés és önellenőrzés

Tévedés: a sum-reduction és a mean-reduction gradientse csak egy konstansban tér el, ezért a tanulási ráta átállításával mindegy, melyiket használjuk. A konstans valóban egy batch $M$-szeres skálája, de a gyakorlati következmény éles: legyen $M=2$, $x_1=3,y_1=9$, $x_2=1,y_2=3$, modell $z_i=w x_i$. A fél-MSE mean-veszteség $L_m=\frac14[(3w-9)^2+(w-3)^2]$, gradiense $w=0$-nál $\frac12[3(-9)+(-3)]=-15$. A sum-változat gradiense $-30$. Ha a lépésközt $\eta=0.05$ a mean-hez hangoltuk, a sum használata effektív $\eta=0.10$-es lépést ad, ami a fenti példa stabilitási tartományát is elhagyhatja. A tanulság: a reduction nem hibátlan átskálázás, hanem a célfüggvény definíciójának része; a $\lambda$ hangolása csak azonos skálázás mellett összehasonlítható [P02].

Önellenőrzési lista.

1. A gradiens alakja egyezik-e $W$ alakjával ($m\times d$)?
2. Az $\frac1M$ tényező minden adatgradiensben megjelenik-e, és a regularizáló tagban nem jelenik-e meg véletlenül?
3. A $\tfrac12$ szorzó a fél-MSE-ben és a $\frac\lambda2$ tagban azonos konvencióból származik-e?
4. Az AdamW decoupled weight decay [P02] vajon azonos-e a fenti lossba tett $L^2$-taggal? Itt nem bizonyítottuk az azonosságot; a 6.4. Momentum és adaptív optimizálók fogja a kettő gradiensútvonalát megkülönböztetni.
5. A Taylor-érvelés lokális; fogalmaztunk-e úgy, mintha globális konvergenciát bizonyítottunk volna? A nem-sima optimum vagy a nagy $\eta$ ellenpélda a 6.2. Konvexitás és sima optimalizálási határ alfejezetben kerül elő.

A fenti tétel levezetése a 2.1. Python, NumPy és tenzoralak alfejezetben bevezetett tenzoralak és broadcasting, valamint a 4.4. I. ellenőrző pont: matematika és kód megfelelése alfejezetben bemutatott elemenkénti láncszabály közvetlen következménye; a biasgradiens a broadcast backward szabálya szerint oszlopösszegből áll.

6.1.9 Rövid összefoglaló

Az empirikus kockázat a teljes minta átlaga, a batch-átlag annak minibatch-közelítése, a regularizáló penalty pedig adatfüggetlen paraméterbüntetés. A fél-MSE $\frac1{2M}\lVert XW^\top+b-Y\rVert_F^2$ gradiense $\frac1M (Z-Y)^\top X$, a biasgradiens $\frac1M (Z-Y)^\top\mathbf 1_M$; az $L^2$-tag $\frac\lambda2\lVert W\rVert_F^2$ gradiense $\lambda W$. A gradienslépés $W^{(t+1)}=W^{(t)}-\eta\nabla_W F$. A Taylor-sor szerint elegendően kis lépésköz csökkentést jelez, de ez lokális állítás, nem globális konvergenciabizonyíték. A sum és mean reduction a gradiens skáláját batchméretezővel változtatja; ez nem közömbös konvenció.

6.1.10 Következő alkalmazás

A 6.2. Konvexitás és sima optimalizálási határ alfejezetben a konvexitás és a simaság fogalmát vezetjük be, hogy a gradienslépés csökkenésére ne csak lokális Taylor-érvünk legyen, hanem megadott Lipschitz-feltétel melletti kvantitatív korlát. A 6.3. Sztochasztikus és minibatch gradiens alfejezetben a minibatch-mintavétel varianciáját elemezzük, ahol az itt levezetett skálák döntik el a lépésköz és a batchméret együttes hangolását.

6.1.11 Források

• [B01] Deisenroth, Faisal és Ong (2020). Mathematics for Machine Learning. Cambridge University Press. https://mml-book.github.io/.
• [P02] Loshchilov és Hutter (2017). Decoupled Weight Decay Regularization. https://arxiv.org/abs/1711.05101.
• [D06] PyTorch contributors (2.14). torch.optim. https://docs.pytorch.org/docs/2.14/optim.html.