37.2 Backward és ellenőrzési lefedettség

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

A 37.1. Operátorspecifikáció és kézi referencia egységben rögzítettük a teljes forward-szerződést: a referenciaoperátor NCHW bemenetre, OIHW súlyra, groups=1-gyel számol térbeli keresztkorrelációt szimmetrikus zero paddinggel, stride-dal és dilationnel. Itt azt kérdezzük, mi a helyes VJP (vektor–Jacobi-szorzat) mindhárom tanuló objektumra, azaz $X$ inputra, $K$ súlyra és $b$ biasra. Induló kérdés: ha $H=3$, $k=2$, $s=1$, $p=0$, akkor a belső $X[1,1]$ pixel vajon egyetlen kimenethez tartozik-e, vagy többhöz is, és ez hogyan látszik a gradiens összegzésében? Becslés: több kimenethez tartozik, tehát a gradiensnak összegeznie kell az átfedő hozzájárulásokat; ezt levezetjük és számpéldán ellenőrizzük.

Előismeret: a forward indexképlete és outputalakja 37.1. Operátorspecifikáció és kézi referencia, a VJP oszlopkonvenciója 4.3. Jacobi-mátrix, láncszabály és VJP, a gradiensellenőrzés alapmérőszámai 10.3. Gradiensellenőrzés és numerikus hibamérce. A $dX/dW/db$ jelölés itt mindig a skalár loss szerinti gradiens, nem egy közvetlen mátrixderivált: $\nabla_X L$, $\nabla_K L$, $\nabla_b L$.

37.2.2 Jelölések, alakok és a forward visszahívása

Legyen $$X\in\mathbb R^{N\times C_{in}\times H\times W},\qquad K\in\mathbb R^{C_{out}\times C_{in}\times k_h\times k_w},\qquad b\in\mathbb R^{C_{out}},$$ a stride $s$, a szimmetrikus padding $p$, a dilation $d$; mind pozitív egész, kivéve $p\ge0$. Az output $$Y\in\mathbb R^{N\times C_{out}\times H_{out}\times W_{out}}$$ alakú, ahol $$H_{out}=\left\lfloor\frac{H+2p-d(k_h-1)-1}{s}\right\rfloor+1,$$ és a szélességre ugyanígy, $k_w$-vel. A forward egyetlen indexképlete a zérussal kiegészített $\bar X$ tenzoron: $\bar X$ alakja $N\times C_{in}\times(H+2p)\times(W+2p)$, és $$\bar X[n,c,a',b'] = X[n,c,a'-p,b'-p],$$ ha $a'\in[p,p+H-1]$ és $b'\in[p,p+W-1]$, egyébként $0$. Ezzel $$Y[n,o,i,j] = b[o]+\sum_{c=0}^{C_{in}-1}\sum_{u=0}^{k_h-1}\sum_{v=0}^{k_w-1} K[o,c,u,v]\,\bar X[n,c,s i+d u,\,s j+d v], \tag{1}$$ ahol $n\in[0,N-1]$, $o\in[0,C_{out}-1]$, $i\in[0,H_{out}-1]$, $j\in[0,W_{out}-1]$.

Definíció (upstream gradiens). Legyen $L:\mathbb R^{N\times C_{out}\times H_{out}\times W_{out}}\to\mathbb R$ differenciálható skalár veszteség, és legyen $$\delta=\nabla_Y L\in\mathbb R^{N\times C_{out}\times H_{out}\times W_{out}},$$ azaz $\delta[n,o,i,j]=\frac{\partial L}{\partial Y[n,o,i,j]}$. A projekt kézi konvenciója $L=\frac12\sum_{n,o,i,j}Y[n,o,i,j]^2$, ekkor $\delta=Y$; ez nem MSE és nem cross-entropy, csak a levezetés ellenőrzését egyszerűsíti.

A VJP alakja mindig megegyezik a megfelelő tanuló objektum alakjával:

37.2.3 Tétel: a forward teljes VJP-je

Tétel (a konvolúciós forward minden VJP-je). Az (1) forwardra, differenciálható skalár $L$ mellett:

1. Biasgradiens, minden $o\in[0,C_{out}-1]$-re: $$\frac{\partial L}{\partial b[o]}=\sum_{n=0}^{N-1}\sum_{i=0}^{H_{out}-1}\sum_{j=0}^{W_{out}-1}\delta[n,o,i,j]. \tag{2}$$

2. Súlygradiens, minden $o,c,u,v$ indexre: $$\frac{\partial L}{\partial K[o,c,u,v]}=\sum_{n=0}^{N-1}\sum_{i=0}^{H_{out}-1}\sum_{j=0}^{W_{out}-1}\delta[n,o,i,j]\,\bar X[n,c,s i+d u,s j+d v]. \tag{3}$$ Az eredeti $X$-szel ez azon $(n,i,j)$ pozíciókra értendő, ahol $s i-p+d u\in[0,H-1]$ és $s j-p+d v\in[0,W-1]$, és ott az integrandus $X[n,c,s i-p+d u,s j-p+d v]$; a padded írásmód a határon kívüli pozíciókat zérussal kezeli.

3. Inputgradiens a zero-padded tartományon, minden $n,c,a',b'$-re: $$\frac{\partial L}{\partial \bar X[n,c,a',b']}=\sum_{o=0}^{C_{out}-1}\sum_{u=0}^{k_h-1}\sum_{v=0}^{k_w-1}\sum_{\substack{i,j\\a'=s i+d u,\ b'=s j+d v}}\delta[n,o,i,j]\,K[o,c,u,v], \tag{4}$$ ahol az utolsó összeg azon $i\in[0,H_{out}-1]$, $j\in[0,W_{out}-1]$ párokra megy, amelyek a megadott afin egyenletet teljesítik. Végül a padding levágása: $$\frac{\partial L}{\partial X[n,c,a,b]}=\frac{\partial L}{\partial \bar X[n,c,a+p,b+p]},\qquad a\in[0,H-1],\ b\in[0,W-1]. \tag{5}$$

Bizonyítás. A $b[o]$ csak az $Y[n,o,i,j]$ kimenetekben jelenik meg, mindegyikben $1$ együtthatóval, ezért a skalár láncszabály közvetlenül adja (2)-t.

A $K[o,c,u,v]$ szintén csak az $o$ kimeneti csatorna értékeiben szerepel, de ott minden $(n,i,j)$ pozícióban, $\bar X[n,c,s i+d u,s j+d v]$ együtthatóval. Ezért $$\frac{\partial L}{\partial K[o,c,u,v]}=\sum_{n,i,j}\delta[n,o,i,j]\frac{\partial Y[n,o,i,j]}{\partial K[o,c,u,v]},$$ és a parciális derivált éppen a megfelelő $\bar X$-érték, ami (3)-at adja.

Az inputgradiensnél először a padded változóra alkalmazzuk a láncszabályt. Egy rögzített $\bar X[n,c,a',b']$ elem azokban az $Y[n,o,i,j]$ kimenetekben szerepel, amelyekre létezik $u,v$, hogy $a'=s i+d u$ és $b'=s j+d v$; ezekben a parciális derivált $K[o,c,u,v]$. Ez pontosan (4). Minden összeg véges, ezért az összegzések sorrendje szabadon felcserélhető (a Fubini-tétel véges halmazokra vonatkozó triviális esete; a könyv nem hív mértékelméleti állítást). Az (5) vágás abból következik, hogy a padded tenzor belső része az eredeti $X$ eltolt másolata, tehát a megfelelő Jacobi-rész az identitás; a padding tartománybeli gradiens nem tartozik egyetlen $X$-elemhez sem. $\square$

A (4) összeg az „overlap” (átfedés) kvantitatív alakja: ugyanaz az input pozíció több kimeneti pozíciót is érint, és a gradiens a közösen használt $K$-súlyokkal súlyozva összegződik. A (3) pedig azt mondja, hogy a súlygradiens a $\delta$ és az input térbeli keresztkorrelációja, azzal a fontos különbséggel, hogy a kimeneti pozíciók szerint összegzünk, tehát ugyanaz a súly minden pozícióból kap hozzájárulást.

Megjegyzés (adjoinált, nem inverz). A (4)–(5) művelet a forward lineáris operátor adjungáltja a megadott stride/padding/dilation konvencióval; kapcsolódik a ConvTranspose2d-hez, de nem általános inverz, és a kernel megfordítási konvenciója attól függ, hogy a forwardot korrelációnak vagy matematikai konvolúciónak definiáltuk. A részletes adjungált-tulajdonságot 37.3. Linearitás, adjungált és határfeltétel tárgyalja, a könyvtári háttér a [D05] és [D11] körébe tartozik; ebben az egységben a közvetlen (4)–(5) scatter-add formulát használjuk.

37.2.4 Eredeti kézi kis példa

Legyen $N=2$, $C_{in}=C_{out}=1$, $H=W=3$, $k_h=k_w=2$, $s=1$, $p=0$, $d=1$, tehát $H_{out}=W_{out}=2$. Az inputok: $$X[0]=\begin{pmatrix}1&2&3\\4&5&6\\7&8&9\end{pmatrix},\qquad X[1]=\begin{pmatrix}9&8&7\\6&5&4\\3&2&1\end{pmatrix},$$ $K=((1,0),(0,1))$, $b=[0.5]$. A forward kézzel: $$Y[0]=\begin{pmatrix}6.5&8.5\\12.5&14.5\end{pmatrix},\qquad Y[1]=\begin{pmatrix}14.5&12.5\\8.5&6.5\end{pmatrix}.$$ A kvadratikus loss miatt $\delta=Y$.

A (2) képlet szerint $gb=6.5+8.5+12.5+14.5+14.5+12.5+8.5+6.5=84$, azaz $gb=[84]$.

A (3) képletet a négy kernelpozícióra alkalmazva mind a négy $gK[u,v]$ érték $460$; ennek egyik tagja például a $gK[0,0]$-hoz az $n=0$ képből a $(0,0)$ pozíció hozzájárulása $6.5\cdot 1$, a $(1,1)$ pozícióé $14.5\cdot 5$; a teljes összeg mindkét képen és mind a négy eltolásban e példa szimmetriája miatt $460$. Tehát $$gK=\begin{pmatrix}460&460\\460&460\end{pmatrix}.$$

Az inputgradiens (4)–(5) szerint scatter-add módon: inicializálunk egy $N\times1\times3\times3$ zérus tenzort, és minden $(n,i,j,u,v)$ esetén hozzáadunk $\delta[n,i,j]K[u,v]$-t a $(i+u,j+v)$ cellához. A belső $X[0,1,1]=5$ elemre például két tag esik: $\delta[0,1,1]K[0,0]=14.5$ és $\delta[0,0,0]K[1,1]=6.5$, összegük $21$. A teljes eredmény: $$gX[0]=\begin{pmatrix}6.5&8.5&0\\12.5&21&8.5\\0&12.5&14.5\end{pmatrix},\qquad gX[1]=\begin{pmatrix}14.5&12.5&0\\8.5&21&12.5\\0&8.5&6.5\end{pmatrix}.$$ A jobb alsó, $0$ értékű cellák a $p=0$ határt mutatják: kívülről nem érkezik hozzájárulás, de a padding nélküli forwardban ott nincs is inputon kívüli tag.

37.2.5 Véges differencia és autograd: mit ellenőrizzünk?

Legyen $\theta$ az $X,K,b$ bármely megkötött skalár bejegyzése, és tekintsük a többi változót rögzítettnek. A centrális differencia $$\Delta_\varepsilon L(\theta)=\frac{L(\theta+\varepsilon)-L(\theta-\varepsilon)}{2\varepsilon}.$$ Mivel a forward $\theta$-ban affin, az $L=\frac12\sum Y^2$ veszteség pedig kvadratikus, a centrális differencia valós aritmetikában algebrailag pontos; az eltérés csak a lebegőpontos kerekítésből származik. Ez hasznos kontroll: ha a referencia gradiens és a centrális differencia között a hiba az $\varepsilon$-hoz képest sok nagyságrenddel kisebb, akkor a képletek, nem pedig a differencia approximációs hibája érvényesül. A gyakorlatban float64, $\varepsilon=10^{-5}$ mellett a relatív hiba tipikusan $10^{-11}$ alá esik; ezért elfogadási korlátnak $\mathrm{atol}=10^{-8}$, $\mathrm{rtol}=10^{-6}$ bőven elég. A relatív hibát stabil nevezővel számoljuk: $$e_{rel}=\frac{|g_{ref}-g_{fd}|}{\max(|g_{ref}|,|g_{fd}|,\eta)},\qquad \eta=10^{-12}.$$ A normálás nélküli, nullához közeli gradiensű elemeket az abszolút korlát fogja el.

A PyTorch-autograd egy független második kontroll: a saját forwardot float64 leaf tenzorokkal futtatjuk, L.backward() után X.grad, K.grad, b.grad összevethető a referencia (2)–(5) értékeivel. A ReLU-val vagy más törésponttal ellentétben a konvolúciós forward a vizsgált pontokon sima, tehát a véges differenciának nincs konvenciófüggő törésponti eltérése; a nem sima eset kezelését 10.3. Gradiensellenőrzés és numerikus hibamérce rögzíti.

37.2.6 Konkrét labor: f64 gradiensellenőrzés több kis tensoron

A labor CPU-n, torch.float64 tenzorokkal fut. Bemeneti konfigurációk:

Az A eset az előző kézi példa; B és C a stride, padding és dilation határfeltételeit fedi. Minden esetre a labor kiszámolja a forwardot, a referencia backwardot, a centrális differenciát minden $X,K,b$ bejegyzésre, és a PyTorch-autograd gradienseket; a hibákat CSV-be menti.

A teljes, futtatható szkript:

#!/usr/bin/env python3
"""n146 labor: conv2d backward ellenőrzés. CPU, float64.
Nem állítunk már elvégzett futtatást; a szkriptet a hallgató futtatja:
    python check_backward.py --eps 1e-5 --out error_table.csv
"""
import argparse, csv
import torch

def conv2d_forward(X, K, b, s, p, d):
    N, C, H, W = X.shape
    M, Ck, kh, kw = K.shape
    Ho = (H + 2*p - d*(kh-1) - 1)//s + 1
    Wo = (W + 2*p - d*(kw-1) - 1)//s + 1
    Y = torch.empty(N, M, Ho, Wo, dtype=X.dtype)
    for n in range(N):
        for o in range(M):
            for i in range(Ho):
                for j in range(Wo):
                    acc = b[o] + 0.0
                    for c in range(C):
                        for u in range(kh):
                            for v in range(kw):
                                a = s*i - p + d*u
                                bq = s*j - p + d*v
                                if 0 <= a < H and 0 <= bq < W:
                                    acc = acc + X[n, c, a, bq] * K[o, c, u, v]
                    Y[n, o, i, j] = acc
    return Y

def conv2d_backward(X, K, dY, s, p, d):
    N, C, H, W = X.shape
    M, Ck, kh, kw = K.shape
    _, Mo, Ho, Wo = dY.shape
    gb = dY.sum(dim=(0, 2, 3))
    gK = torch.zeros_like(K)
    for n in range(N):
        for o in range(M):
            for i in range(Ho):
                for j in range(Wo):
                    for u in range(kh):
                        for v in range(kw):
                            a = s*i - p + d*u
                            bq = s*j - p + d*v
                            if 0 <= a < H and 0 <= bq < W:
                                gK[o, :, u, v] += dY[n, o, i, j] * X[n, :, a, bq]
    Hp, Wp = H + 2*p, W + 2*p
    gXp = torch.zeros(N, C, Hp, Wp, dtype=X.dtype)
    for n in range(N):
        for o in range(M):
            for i in range(Ho):
                for j in range(Wo):
                    for u in range(kh):
                        for v in range(kw):
                            a = s*i + d*u
                            bq = s*j + d*v
                            if 0 <= a < Hp and 0 <= bq < Wp:
                                gXp[n, :, a, bq] += dY[n, o, i, j] * K[o, :, u, v]
    if p == 0:
        gX = gXp
    else:
        gX = gXp[:, :, p:p+H, p:p+W]
    return gX, gK, gb

def quad_loss(Y):
    return 0.5 * torch.sum(Y * Y)

def fd_all(f, theta, eps):
    theta = theta.detach().clone()
    flat = theta.reshape(-1)
    out = torch.empty_like(flat)
    for q in range(flat.numel()):
        plus = theta.clone()
        minus = theta.clone()
        plus.reshape(-1)[q] = flat[q].item() + eps
        minus.reshape(-1)[q] = flat[q].item() - eps
        out[q] = (f(plus) - f(minus)) / (2.0 * eps)
    return out.reshape(theta.shape)

def max_abs_err(a, b):
    return (a - b).abs().max().item()

def max_rel_err(a, b, eta=1e-12):
    d = (a - b).abs()
    den = torch.maximum(a.abs(), b.abs()).clamp_min(eta)
    return (d / den).max().item()

def check_case_A_hand():
    X = torch.tensor([[[[1,2,3],[4,5,6],[7,8,9]]],
                      [[[9,8,7],[6,5,4],[3,2,1]]]], dtype=torch.float64)
    K = torch.tensor([[[[1,0],[0,1]]]], dtype=torch.float64)
    b = torch.tensor([0.5], dtype=torch.float64)
    Y = conv2d_forward(X, K, b, 1, 0, 1)
    gX, gK, gb = conv2d_backward(X, K, Y, 1, 0, 1)
    exp_gX = torch.tensor(
        [[[[6.5,8.5,0.0],[12.5,21.0,8.5],[0.0,12.5,14.5]]],
         [[[14.5,12.5,0.0],[8.5,21.0,12.5],[0.0,8.5,6.5]]]], dtype=torch.float64)
    assert torch.allclose(gX, exp_gX, atol=1e-12)
    assert torch.allclose(gK, torch.tensor([[[[460,460],[460,460]]]], dtype=torch.float64), atol=1e-12)
    assert torch.allclose(gb, torch.tensor([84.0], dtype=torch.float64), atol=1e-12)
    print("A kézi eset rendben.")

CASES = {
    "A": dict(seed=0, shape=(2,1,1,3,3), kernel=(2,2), stride=1, padding=0, dilation=1),
    "B": dict(seed=1, shape=(1,2,3,4,5), kernel=(3,2), stride=2, padding=1, dilation=1),
    "C": dict(seed=2, shape=(3,2,2,6,5), kernel=(3,3), stride=1, padding=1, dilation=2),
}

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--eps", type=float, default=1e-5)
    ap.add_argument("--out", type=str, default="error_table.csv")
    args = ap.parse_args()
    check_case_A_hand()
    rows = []
    for case_id, cfg in CASES.items():
        torch.manual_seed(cfg["seed"])
        N, C, M, H, W = cfg["shape"]
        kh, kw = cfg["kernel"]
        s, p, d = cfg["stride"], cfg["padding"], cfg["dilation"]
        X = torch.rand(N, C, H, W, dtype=torch.float64) * 2 - 1
        K = torch.rand(M, C, kh, kw, dtype=torch.float64) * 0.6 - 0.3
        b = torch.rand(M, dtype=torch.float64) * 0.4 - 0.2
        X.requires_grad_(True); K.requires_grad_(True); b.requires_grad_(True)
        Y = conv2d_forward(X, K, b, s, p, d)
        dY = Y  # L = 0.5 * sum(Y**2)
        gX, gK, gb = conv2d_backward(X, K, dY, s, p, d)
        L = quad_loss(Y)
        L.backward()
        for name, ga, gt in [("X", gX, X.grad), ("K", gK, K.grad), ("b", gb, b.grad)]:
            rows.append([case_id, name, "autograd",
                         max_abs_err(ga, gt), max_rel_err(ga, gt)])
        Xd = X.detach().clone(); Kd = K.detach().clone(); bd = b.detach().clone()
        fX = lambda t: quad_loss(conv2d_forward(t, Kd, bd, s, p, d))
        fK = lambda t: quad_loss(conv2d_forward(Xd, t, bd, s, p, d))
        fb = lambda t: quad_loss(conv2d_forward(Xd, Kd, t, s, p, d))
        for name, ga, gf in [("X", gX, fd_all(fX, Xd, args.eps)),
                             ("K", gK, fd_all(fK, Kd, args.eps)),
                             ("b", gb, fd_all(fb, bd, args.eps))]:
            rows.append([case_id, name, "fd",
                         max_abs_err(ga, gf), max_rel_err(ga, gf)])
    with open(args.out, "w", newline="") as fh:
        w = csv.writer(fh)
        w.writerow(["case", "object", "method", "max_abs_err", "max_rel_err"])
        w.writerows(rows)
    print(f"Tábla: {args.out}; sorok: {len(rows)}")

if __name__ == "__main__":
    main()

A labor ellenőrzése: az A eset check_case_A_hand assertje a fenti kézi táblázatot bitközeli pontossággal kéri; a csv minden sorában max_abs_err < 1e-8 és max_rel_err < 1e-6 az elfogadási feltétel. A tábla szerkezete a fenti, a tényleges B és C számértékeket itt nem állítjuk már lefuttatottnak; a hallgató a szkript futtatásával állítja elő őket. Az eredmény értelmezése: a hiba táblázat csak a felsorolt (N,C,M,H,W,k,s,p,d) konfigurációkra ad bizonyítékot, és csak float64 CPU-n; a groups≠1, aszimmetrikus padding és float32 approximáció kívül esik a teszten (36.2. Ismétlések és eredménybizonytalanság gondolata a több teszt és a kimondatlan tartomány viszonyáról).

37.2.7 Feladatok

F1 (fogalmi, nehézség 1). $N=4$, $C_{in}=3$, $C_{out}=5$, $H=W=8$, $k_h=k_w=3$, $s=2$, $p=1$, $d=1$. Add meg $H_{out},W_{out}$ értékét és a $\delta$, $\nabla_X L$, $\nabla_K L$, $\nabla_b L$ pontos alakját. Mely tengelyek mentén összegzi a biasgradiens a $\delta$ értékeit? Átadandó: az alakok és az összegző tengelyek listája.

F2 (levezetési, nehézség 2). Egydimenziós eset: $N=1$, $C_{in}=C_{out}=1$, $H=4$, $k_h=2$, $s=1$, $p=0$, $d=1$; $X=[1,-1,1,0]$, $K=[2,1]$, $b=[0]$, és $L=\frac12\sum Y^2$. Számold ki $Y$-t, majd a levezetett képletekkel $gX$, $gK$, $gb$ értékét. Jelöld meg azokat a cellákat, ahol két átfedő hozzájárulás összegződik. Átadandó: a négy vektor/skalár és a két átfedő tag kifejtése.

F3 (implementációs, nehézség 2). Írj crop_safe(t, padding, h, w) függvényt a projektben a (5) vágásra úgy, hogy padding==0 esetén ne keletkezzen üres szelet; ellenőrizd $p=0$ és $p=2$ mellett egy véletlen float64 tensoron. Átadandó: a függvény kódja, a két hívás shape-je és a torch.equal eredménye.

F4 (hibakeresési, nehézség 2). Az alábbi 1D inputgradiens-kód a F2 feladatot próbálja reprodukálni:

gX = torch.zeros(4)
for i in range(3):
    for u in range(2):
        gX[i + u] = dY[i] * K[u]   # hiba itt

Hol a hiba, mi a numerikus következménye a F2 példában, és hogyan javítod? Átadandó: a hibás és a javított kód, a F2 értékeivel való összevetés.

F5 (kísérleti/transzfer, nehézség 3). Tervezd meg a backward-ellenőrzés konfigurációs mátrixát legalább hat esetre a támogatott operátortartományból: változtasd egyenként a paddinget, stride-ot és dilationt, valamint a csatorna- és batch-méretet; rögzítsd, mely kombinációkat nem teszteled. Add meg a CSV sémáját, az elfogadási korlátokat és a következtetés érvényességi határát. Átadandó: protokoll, hat konfiguráció indoklással és a mentett tábla.

37.2.8 Megoldások és indoklás

F1 megoldás. $$H_{out}=\left\lfloor\frac{8+2-1\cdot 2-1}{2}\right\rfloor+1=\left\lfloor\frac72\right\rfloor+1=3+1=4,$$ tehát $H_{out}=W_{out}=4$. Az alakok: $\delta\in\mathbb R^{4\times5\times4\times4}$, $\nabla_X L\in\mathbb R^{4\times3\times8\times8}$, $\nabla_K L\in\mathbb R^{5\times3\times3\times3}$, $\nabla_b L\in\mathbb R^{5}$. A biasgradiens a $\delta$ $(n,i,j)$, azaz a $0$, $2$, $3$ tengely szerinti összegzéséből áll, a kimeneti csatorna $o$ tengelyt megtartva.

F2 megoldás. A forward (1) szerint $Y[i]=2X[i]+X[i+1]$, tehát $Y=[2\cdot1+(-1),\,2(-1)+1,\,2\cdot1+0]=[1,-1,2]$. A kvadratikus loss miatt $\delta=Y$. A (2)–(5) egydimenziós változata: $$gb=\sum_i\delta[i]=1-1+2=2,$$ $$gK[u]=\sum_{i=0}^{2}\delta[i]X[i+u],\qquad gK[0]=1\cdot1+(-1)(-1)+2\cdot1=4,\quad gK[1]=1(-1)+(-1)1+2\cdot0=-2,$$ $$gX[a]=\sum_{\substack{i\in[0,2],\,u\in[0,1]\\a=i+u}}\delta[i]K[u],$$ tehát $gX=[2,\,-1,\,3,\,2]$. Az átfedő pozíciók: $gX[1]=1\cdot1+(-1)\cdot2=-1$ (a $\delta_0K_1$ és $\delta_1K_0$ tagok), $gX[2]=(-1)\cdot1+2\cdot2=3$. A $gX[0]=2$ és $gX[3]=2$ egy-egy tagból állnak; ez mutatja, hogy a határnál nincs padding-hozzájárulás.

F3 megoldás.

def crop_safe(t, padding, h, w):
    row = slice(padding, padding + h) if padding else slice(None)
    col = slice(padding, padding + w) if padding else slice(None)
    return t[:, :, row, col]

# ellenőrzés
torch.manual_seed(0)
t0 = torch.rand(2, 3, 6, 6, dtype=torch.float64)
print(crop_safe(t0, 0, 6, 6).shape)   # torch.Size([2, 3, 6, 6])
print(torch.equal(crop_safe(t0, 0, 6, 6), t0))   # True
t2 = torch.rand(2, 3, 10, 10, dtype=torch.float64)
out = crop_safe(t2, 2, 6, 6)
print(out.shape)   # torch.Size([2, 3, 6, 6])
print(torch.equal(out, t2[:, :, 2:8, 2:8]))  # True

A slice(None) ág azért kell, mert Pythonban -0 == 0, ezért a naiv t[:, :, p:-p] a $p=0$ esetben t[:, :, 0:0] üres tenzort adna. A megoldás szélsőeset-kontrollja: $p=0$ shape-azonosság, $p>0$ érték-egyezés.

F4 megoldás. A hiba az = hozzárendelés a += helyett. Az átfedő pozíciókat a ciklus többször látogatja, és a hozzárendelés felülírja a korábbi hozzájárulást, tehát a gradiens nem összegződik. A F2 példában a hiba hatására $gX[1]$ végül a legutolsó $i=1,u=0$ tag, $(-1)\cdot2=-2$ lesz a helyes $-1$ helyett, $gX[2]$ pedig $4$ a helyes $3$ helyett. Javítás:

gX = torch.zeros(4)
for i in range(3):
    for u in range(2):
        gX[i + u] += dY[i] * K[u]   # += : összegzés
# ellenőrzés: gX == [2, -1, 3, 2]

A javított verzió a F2 összes értékét visszaadja, beleértve a kétátfedéses pozíciókat.

F5 megoldásminta. Kérdés: a referencia backward egyezik-e az autograddal és a centrális differenciával a támogatott paramétertartományon? Megfigyelési egység: egy konfiguráció, benne a max_abs_err és max_rel_err mindhárom objektumra, módszerenként. Minimum hat eset:

A csatorna- és batch-méretet a B és C esetekben változtatjuk, hogy az összegző tengelyek ne csak szingletonok legyenek. Elfogadás: float64, $\varepsilon=10^{-5}$, atol=1e-8, rtol=1e-6; minden bejegyzésre véges differencia, nem mintavétel. A csv oszlopai: case, object, method, max_abs_err, max_rel_err. Érvényességi határ: a hat eset nem reprezentatív minta a parametertérből; az állítás pontosan a tesztelt (s,p,d,k) halmazra szól, groups=1-re, négyzetes paddingre, float64 CPU-n. Nem tárgyalt kombinációk (pl. $s=3$, $p=3$, aszimmetrikus kernel) további kutatást igényelnek; ez ugyanaz a korlát, mint a 36.2. Ismétlések és eredménybizonytalanság alfejezetben a seedek és a fix tesztkészlet viszonya.

37.2.9 Tipikus tévedés és ellenpélda

A leggyakoribb hiba a „minden rendben” állítás a tesztelt tartomány pontos megnevezése nélkül. Tegyük fel, hogy valaki csak az $s=1$, $p=0$, $d=1$, $k=2$ esetet futtatja, és a gradiens ott egyezik; ebből nem következik a paddingelt ág helyessége. Konkrét ellenpélda: ha az inputgradiensben a padded koordinátát a kód a = s*i + d*u helyett a = s*i - p + d*u-val számolja a gXp-scatterhez is, akkor $p=0$-nál tökéletesen egyezik, de $p=1$-nél a padding miatt a (a=-1) hozzájárulások kívülre kerülnek, és a vágás után rossz $gX$ adódik. A kijelentés helyes formája: „a backward a felsorolt hat konfiguráción, float64 CPU-n, a megadott toleranciával egyezik az autograddal és a véges differenciával; más tartományra nincs bizonyítékunk”. Ez a 36.2. Ismétlések és eredménybizonytalanság alfejezetben bevezetett, a fix protokoll és a kimondott tartomány közötti különbség közvetlen alkalmazása.

37.2.10 Önellenőrzés és korábbi fogalom visszahívása

Önellenőrzéshez: (i) mindhárom gradiens alakja megegyezik a megfelelő objektum alakjával; (ii) $p=0$ mellett a padded és a vágott tenzor azonos; (iii) a F2 1D példában a $gX$ összege $2-1+3+2=6$, ami a láncszabály szerint $\sum_i\delta_i\sum_u K_u=2\cdot3=6$, tehát a teljes gradiens konzisztens. Visszahívás: a 37.1. Operátorspecifikáció és kézi referencia forward-egyezménye adja a (1) indexhalmazt; a 33.2. Batch és kis szolgáltatás alfejezetben rögzített sémaellenőrzés logikája itt az ellenőrző tábla oszlopainak formális szerződéseként tér vissza; a 25.2. Multilabel és hierarchikus cél megfigyelését, miszerint a loss mindig skalár, úgy használjuk, hogy a forward VJP-je független a veszteség konkrét választásától, csak $\delta$ alakjától függ.

37.2.11 Rövid összefoglaló

A konvolúciós forward (1) lineáris tagokból áll, ezért mindhárom VJP véges összeg. A biasgradiens a $\delta$ batch- és térbeli összege; a súlygradiens a $\delta$ és az input keresztkorrelációja; az inputgradiens a $\delta$-t a $K$-súlyokkal scatter-add módon szétszórja a padded tartományra, majd levágja a paddinget. A centrális differencia a kvadratikus loss miatt valós aritmetikában pontos, így float64 mellett az autograddal együtt két független numerikus kontrollt ad. A lab hat kis konfiguráción, CSV-táblával, 1e-8 abszolút és 1e-6 relatív korláttal ellenőriz; a $p=0$ üres szelet és az átfedések += összegzése a leggyakoribb implementációs hibák. A következő 37.3. Linearitás, adjungált és határfeltétel egység a linearitást, az adjungált tulajdonságot és a határfeltételeket vizsgálja.

37.2.12 Források

• [D05] PyTorch contributors (2.14). Autograd mechanics. Hivatalos URL, https://docs.pytorch.org/docs/2.14/notes/autograd.html.
• [D10] PyTorch contributors (2.14). Conv2d. https://docs.pytorch.org/docs/2.14/generated/torch.nn.Conv2d.html.
• [S01] Stanford CS231n kurzus (n.d.). Convolutional Neural Networks. https://cs231n.github.io/convolutional-networks/.