37.1 Operátorspecifikáció és kézi referencia

37.1.1 1. Cél, előismeret és induló kérdés

Ez az egység a Projekt I első állomása: egy saját, kézzel írt konvolúciós reference operátort készítünk, amelynek minden indexét, alakját és érvényességi feltételét pontosan dokumentáljuk. A cél nem egy gyors PyTorch-utánzat, hanem egy olyan specifikáció, amelyhez később a backwardot (37.2. Backward és ellenőrzési lefedettség), az adjungált ellenőrzést (37.3. Linearitás, adjungált és határfeltétel) és a tanuló réteget (37.4. Rétegből kis tanulómodell) kapcsolni lehet. A 16.4. IV. ellenőrző pont: a CNN-operátor teljes megértése IV. ellenőrző pontjából ismert, hogy a numerikus egyezés önmagában nem bizonyíték; ezért itt először a definíciót rögzítjük, és csak utána engedünk kódot mellé.

Szükséges előismeret: a 13.4. Határkezelés és frekvenciaintuíció alfejezetben bevezetett cross-correlation és zero padding, a 14.4. Csoportos és depthwise konvolúció alfejezetben tárgyalt groups paraméter és annak korlátozása, a 15.4. Független gradiensellenőrzési protokoll alfejezetben kidolgozott float64-es gradiensellenőrzési protokoll, valamint a 36.4. IX. ellenőrző pont: lektorálható modellállítás alfejezetben áttekintett lektorálható állításforma. A 36.1. Állításból kísérleti terv kísérlettervezési elvét és a 33.1. Inference-szerződés és modellcsomag inference-szerződését csak érintőlegesen idézzük vissza, mert itt még nincs betanított modell.

Induló kérdés: adott egy $5\times5$-ös bemenet, egy $3\times3$-as kernel, stride 2, padding 1, dilation 1. Hány térbeli pozícióból áll a kimenet, és miért nem elegendő a „majd a könyvtár tudja” válasz egy referencia specifikációhoz?

37.1.2 2. Definíció: a támogatott keresztkorrelációs operátor

Az operátor a PyTorch Conv2d által használt térbeli keresztkorrelációt számolja: a kernel nem fordul meg semelyik tengely mentén. A matematikai konvolúció ettől a kernel $180^\circ$-os megfordításában tér el; ezt a 13.2. Konvolúció és cross-correlation pontosan tárgyalta. A jelen specifikáció kizárólag a következő részhalmazt támogatja:

• bemenet: $X\in\mathbb{R}^{N\times C_{in}\times H\times W}$, NCHW elrendezés;
• súly: $K\in\mathbb{R}^{C_{out}\times C_{in}\times k_h\times k_w}$;
• bias: $b\in\mathbb{R}^{C_{out}}$, opcionális;
• kimenet: $Y\in\mathbb{R}^{N\times C_{out}\times H_{out}\times W_{out}}$;
• groups=1, azaz minden kimeneti csatorna minden bemeneti csatornát lát;
• szimmetrikus zero padding: $p_h,p_w\ge0$ egész, mindkét oldalon ugyanannyi;
• stride: $s_h,s_w\ge1$ egész;
• dilation: $d_h,d_w\ge1$ egész;
• kernelméret: $k_h,k_w\ge1$ egész;
• dtype: a referencia kizárólag float64; a training főút később float32, de a numerikus kontrollhoz itt szándékosan a pontosabb típust használjuk;
• a batch, csatorna- és térbeli méretek mind pozitívak.

A zero padding azt jelenti, hogy a bemeneti kép szélén kívülre eső pozíciók értéke nulla. Formálisan bevezetjük a paddingelt tömböt

$$\tilde X \in \mathbb{R}^{N\times C_{in}\times (H+2p_h)\times (W+2p_w)},$$

ahol

$$\tilde X[n,c,\alpha,\beta] = \begin{cases} X[n,c,\alpha-p_h,\beta-p_w], & \text{ha } p_h\le\alpha<H+p_h \text{ és } p_w\le\beta<W+p_w,\\ 0, & \text{egyébként}. \end{cases}$$

Ezzel a forward egyetlen indexképlete:

$$\boxed{ 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} \tilde X[n,c,\; i s_h + u d_h,\; j s_w + v d_w]\; K[o,c,u,v], }$$

ahol $0\le i<H_{out}$, $0\le j<W_{out}$, és $b[o]\equiv0$, ha a bias ki van kapcsolva. A stride tehát csak a kimeneti pozíciót lépteti, a dilation pedig a kernel pontjainak bemeneti távolságát növeli: az $u$-adik kernelsor a paddingelt kép $i s_h+u d_h$ sorát olvassa.

Következmény (az output alak). A kimeneti magasság $H_{out}$ a legnagyobb olyan $i$ index plusz egy, amelyre a kernel utolsó, $(k_h-1)$-edik sorának pozíciója még a paddingelt tömbön belül van:

$$i s_h + (k_h-1)d_h \le (H+2p_h) - 1.$$

Átrendezve

$$i \le \frac{H+2p_h-(k_h-1)d_h-1}{s_h}.$$

A legnagyobb ilyen egész a jobb oldal alsó egészrésze, ezért

$$H_{out} = \left\lfloor \frac{H+2p_h-(k_h-1)d_h-1}{s_h} \right\rfloor + 1.$$

A szélességre ugyanígy, $h$ helyett $w$ indexekkel. Ez pontosan a JELOLESEK.md képlete, itt levezetve a paddingelt definícióból. A két térbeli dimenzió független, mert a padding szimmetrikus és a stride/dilation tengelyenként külön adható meg.

Érvényességi feltétel. A kimenet csak akkor értelmes, ha $H_{out}\ge1$ és $W_{out}\ge1$. Ha a számláló negatív, az operátor hibát dob: a kernel effektív kiterjedése $d_h(k_h-1)+1$ nagyobb, mint a paddingelt bemenet. Ez a feltétel az implementáció bemeneti validációjának része, nem a felhasználó felelőssége.

A definícióban a bias dimenziója $C_{out}$, és minden térbeli pozícióhoz ugyanaz a skalár adódik: a bias csatornánként egyetlen paraméter, nem térben változó.

37.1.3 3. A specifikáció mint matematikai állítás

A fenti definícióval a referencia operátor pontosan meghatározott függvény: adott $X,K,b$ és a paraméterek mellett $Y$ egyértelmű. A levezetési kötelezettség teljesült: az output alak a paddingelt ablak illeszkedési feltételéből következik, és a képlet minden indexhatárt megad. A bizonyítás státusza: saját, teljes levezetés; nincs átvett nagy tétel.

A specifikáció nem állítja, hogy ez az operátor minden Conv2d-opciót támogat. Kimarad például az aszimmetrikus padding, a padding_mode='reflect'/'replicate'/'circular', a groups>1, az output_padding, és a transzponált művelet. A 15.3. Transposed convolution mint adjungált alfejezetben tárgyalt ConvTranspose2d adjungált szerepe sem tartozik ide; a D11 forrás ehhez kiinduló URL, tartalma e kézirat írásakor nem ellenőrzött. A referencia célja a tanulási főút pontos alapja, nem a keretrendszer helyettesítése.

37.1.4 4. Eredeti kézi kis példa

Vegyünk egy $3\times3$-as bemenetet, egy nemszimmetrikus $2\times2$-es kernelt, stride 1, padding 0, dilation 1, egyetlen bemeneti és kimeneti csatornát, bias $10$:

$$X=\begin{bmatrix}1&2&3\\4&5&6\\7&8&9\end{bmatrix},\qquad K=\begin{bmatrix}1&2\\3&4\end{bmatrix}.$$

A kernel azért nemszimmetrikus, mert a főátlóra tükrözve $2\ne3$; így a keresztkorreláció és a konvolúció eredménye különbözni fog. A definíció szerint például

$$Y[0,0,0,0] = 1\cdot1+2\cdot2+4\cdot3+5\cdot4+10 = 47.$$

A teljes kimenet:

$$Y = \begin{bmatrix}47&57\\77&87\end{bmatrix}.$$

Ellenőrzésképp a jobb alsó elem:

$$Y[0,0,1,1] = 5\cdot1+6\cdot2+8\cdot3+9\cdot4+10 = 87.$$

Ugyanez a bemenet matematikai konvolúcióval a megfordított kernel $\begin{bmatrix}4&3\\2&1\end{bmatrix}$ alkalmazását jelentené, ami más mátrixot adna; ez az F1 feladatban tér vissza.

A következő minimális kód a referencia függvényt mutatja be, és ezen a kézi példán ellenőrzi az eredményt. A teljes labor-fájl az 5. pontban található; itt csak a függvény vázát adjuk:

import numpy as np

def conv2d_reference(X, K, b=None, stride=(1,1), padding=(0,0), dilation=(1,1)):
    # X: (N, C_in, H, W) float64
    # K: (C_out, C_in, k_h, k_w) float64
    # b: (C_out,) float64 vagy None
    ...
    return Y

# kézi példa
X = np.array([[[[1,2,3],[4,5,6],[7,8,9]]]], dtype=np.float64)  # (1,1,3,3)
K = np.array([[[[1,2],[3,4]]]], dtype=np.float64)              # (1,1,2,2)
Y = conv2d_reference(X, K, b=np.array([10.0], dtype=np.float64))
print(Y)  # várható [[[[47.,57.],[77.,87.]]]]

A kód np.pad-et használ konstans nulla üzemmódban, majd explicit ciklusokkal számol. A ciklusok lassúak, de a referencia célja a helyesség, nem a sebesség.

37.1.5 5. Labor: kézi kontroll és negatív teszt

A labor két fájlból áll. A reference_conv2d.py a specifikációt valósítja meg; a test_reference.py a kézi példát, az alakellenőrzéseket és a hibás bemenetek negatív tesztjeit futtatja. A labor a lab/n145_reference/ munkakönyvtárban található. A futtatás:

cd lab/n145_reference
python -m pytest test_reference.py -q

A kimenet a kézirat írásakor nem mért, ezért jelölt szemléltetés; a tényleges eredményt a futtatás után a hallgató rögzíti a kísérleti naplóban.

A referencia függvény teljes kódja:

# reference_conv2d.py
import numpy as np

def conv2d_reference(X, K, b=None, stride=(1,1), padding=(0,0), dilation=(1,1)):
    """
    Saját NCHW keresztkorrelációs referencia.
    Támogatott: groups=1, szimmetrikus zero padding, stride, dilation,
                opcionális bias. dtype: float64.
    """
    if not (isinstance(X, np.ndarray) and isinstance(K, np.ndarray)):
        raise TypeError("X és K NumPy tömb legyen")
    if X.dtype != np.float64 or K.dtype != np.float64:
        raise TypeError("X és K dtype-ja float64 legyen")
    if b is not None and (not isinstance(b, np.ndarray) or b.dtype != np.float64):
        raise TypeError("b dtype-ja float64 legyen")

    N, C_in, H, W = X.shape
    C_out, C_in_k, k_h, k_w = K.shape
    if C_in_k != C_in:
        raise ValueError(f"K bemeneti csatornája {C_in_k}, de X-é {C_in}")
    if b is not None and b.shape != (C_out,):
        raise ValueError(f"b alakja {b.shape}, várt ({C_out},)")

    s_h, s_w = stride
    p_h, p_w = padding
    d_h, d_w = dilation
    if s_h < 1 or s_w < 1:
        raise ValueError("stride >= 1")
    if p_h < 0 or p_w < 0:
        raise ValueError("padding >= 0")
    if d_h < 1 or d_w < 1:
        raise ValueError("dilation >= 1")
    if k_h < 1 or k_w < 1:
        raise ValueError("kernel méret >= 1")

    H_out = (H + 2*p_h - (k_h-1)*d_h - 1) // s_h + 1
    W_out = (W + 2*p_w - (k_w-1)*d_w - 1) // s_w + 1
    if H_out < 1 or W_out < 1:
        raise ValueError("A kimeneti méret nem pozitív; ellenőrizze a paramétereket")

    # paddingelt tömb
    X_pad = np.pad(X, ((0,0),(0,0),(p_h,p_h),(p_w,p_w)), mode='constant')
    Y = np.zeros((N, C_out, H_out, W_out), dtype=np.float64)

    for n in range(N):
        for o in range(C_out):
            for i in range(H_out):
                for j in range(W_out):
                    s = 0.0
                    for c in range(C_in):
                        for u in range(k_h):
                            for v in range(k_w):
                                s += X_pad[n, c, i*s_h + u*d_h, j*s_w + v*d_w] * K[o, c, u, v]
                    Y[n, o, i, j] = s
            if b is not None:
                Y[n, o, :, :] += b[o]  # bias csatornánként
    return Y

A tesztfájl a kézi példát és a negatív eseteket tartalmazza:

# test_reference.py
import numpy as np
import pytest
from reference_conv2d import conv2d_reference

def test_manual_nonsymmetric():
    X = np.array([[[[1,2,3],[4,5,6],[7,8,9]]]], dtype=np.float64)
    K = np.array([[[[1,2],[3,4]]]], dtype=np.float64)
    Y = conv2d_reference(X, K, b=np.array([10.0], dtype=np.float64))
    expected = np.array([[[[47.0,57.0],[77.0,87.0]]]], dtype=np.float64)
    assert np.allclose(Y, expected, rtol=0, atol=1e-12)

def test_wrong_dtype():
    X = np.zeros((1,1,3,3), dtype=np.float32)
    K = np.zeros((1,1,2,2), dtype=np.float32)
    with pytest.raises(TypeError):
        conv2d_reference(X, K)

def test_channel_mismatch():
    X = np.zeros((1,2,3,3), dtype=np.float64)
    K = np.zeros((1,3,2,2), dtype=np.float64)
    with pytest.raises(ValueError):
        conv2d_reference(X, K)

def test_zero_output():
    X = np.zeros((1,1,2,2), dtype=np.float64)
    K = np.zeros((1,1,5,5), dtype=np.float64)
    with pytest.raises(ValueError):
        conv2d_reference(X, K)

def test_bad_stride():
    X = np.zeros((1,1,4,4), dtype=np.float64)
    K = np.zeros((1,1,2,2), dtype=np.float64)
    with pytest.raises(ValueError):
        conv2d_reference(X, K, stride=(0,1))

A negatív teszt célja annak ellenőrzése, hogy a függvény hibás bemenetnél nem ad csendes, hamis eredményt. Ez a 14.4. Csoportos és depthwise konvolúció alfejezetben jelzett „csendes elnyelés” ellenpontja.

37.1.6 6. Feladatok

37.1.6.1 F1 (fogalmi, nehézség 1)

Magyarázza el, mi a különbség a keresztkorreláció és a matematikai konvolúció között a jelen specifikációban. Adjon meg egy $2\times2$-es, nemszimmetrikus kernelt, és a 4. pontban szereplő $3\times3$-as bemenettel számítsa ki mindkét művelet kimenetét stride 1, padding 0, dilation 1, bias nélkül. Elvárt átadandó: a két definíció képlete, a konkrét mátrixok.

37.1.6.2 F2 (levezetési, nehézség 2)

Legyen $H=4,W=5$, kernel $3\times3$, stride $(2,2)$, padding $(1,1)$, dilation $(2,2)$. Vezesse le $H_{out}$ és $W_{out}$ értékét az output alakképletből, és sorolja fel azokat a bemeneti $(n,c,\alpha,\beta)$ indexhármasokat, amelyek a $Y[n,o,0,1]$ elemhez tartozó összegben nemzérus súllyal járulhatnak hozzá. Adja meg a pontos indexfeltételt.

37.1.6.3 F3 (implementációs, nehézség 2)

Töltse le vagy írja be a reference_conv2d.py fájlt, futtassa a test_reference.py tesztet, és rögzítse a kimenetet. Ezután egészítse ki egy olyan esettel, ahol $N=2,C_{in}=2,C_{out}=3$, batchbeli képek $6\times7$-esek, kernel $2\times2$, stride $(1,2)$, padding $(0,1)$, dilation $(1,2)$, bias bekapcsolva; a bemenetet np.random.default_rng(20261020).random(...) generálja. A teszt csak a shape-t és a dtype-ot ellenőrizze, értéket ne (a random miatt). Elvárt átadandó: a módosított teszt és a futtatás eredménye.

37.1.6.4 F4 (hibakeresési, nehézség 2)

Az alábbi kódrészlet a forwardot számolja, de hibás:

H_out = (H + 2*p_h - k_h*d_h) // s_h + 1
...
Y[n,o,i,j] += X[n,c, i*s_h + u*d_h - p_h, j*s_w + v*d_w - p_w] * K[o,c,u,v]

Keresse meg a hibá(ka)t, magyarázza el a következményt a kimeneti méretre és az indexelésre, javítsa a kódot, és a 4. pont kézi példáján igazolja, hogy a javítás után a várt $47,57,77,87$ értékek adódnak. Elvárt átadandó: a hibás sorok megnevezése, a javított sor, és a rövid verifikáció.

37.1.6.5 F5 (kísérleti/transzfer, nehézség 3)

Tervezzen kísérletet a conv2d_reference és a PyTorch torch.nn.functional.conv2d kimenetének összehasonlítására. A terv tartalmazza: a paraméterrácsot (legalább 6 különböző konfiguráció, beleértve paddinget, stride-ot, dilationt, több csatornát és bias nélküli esetet), a bemeneti adat generálását rögzített seeddel, a numerikus toleranciát, és annak indoklását, miért kell a PyTorch bemenetet is float64-re konvertálni. Elvárt átadandó: a protokoll szöveges leírása, a lehetséges buktatók, és legalább egy konfiguráció kézzel számolt várt kimeneti shape-je.

37.1.7 7. Megoldások és indoklás

37.1.7.1 F1 megoldás

A keresztkorreláció a kernel megfordítása nélkül:

$$Y[i,j]=\sum_{u,v}X[i+u,j+v]K[u,v],$$

a konvolúció pedig a megfordított kernellel:

$$(C*K)[i,j]=\sum_{u,v}X[i+u,j+v]K[k_h-1-u,k_w-1-v].$$

A 4. pont kernelével $K=\begin{bmatrix}1&2\\3&4\end{bmatrix}$ a keresztkorreláció (bias nélkül):

$$Y_{cc}=\begin{bmatrix}37&47\\67&77\end{bmatrix}.$$

A konvolúcióhoz a kernel megfordítottja $\begin{bmatrix}4&3\\2&1\end{bmatrix}$, így

$$Y_{conv}=\begin{bmatrix}1\cdot4+2\cdot3+4\cdot2+5\cdot1 & 2\cdot4+3\cdot3+5\cdot2+6\cdot1\\ 4\cdot4+5\cdot3+7\cdot2+8\cdot1 & 5\cdot4+6\cdot3+8\cdot2+9\cdot1\end{bmatrix} =\begin{bmatrix}23&31\\53&61\end{bmatrix}.$$

A két eredmény különbözik, mert a kernel nem forgásszimmetrikus.

37.1.7.2 F2 megoldás

$H_{out}=\lfloor(4+2-2\cdot2-1)/2\rfloor+1=\lfloor(4+2-4-1)/2\rfloor+1=\lfloor1/2\rfloor+1=0+1=1$. Hasonlóan $W_{out}=\lfloor(5+2-2\cdot2-1)/2\rfloor+1=\lfloor(5+2-4-1)/2\rfloor+1=\lfloor2/2\rfloor+1=1+1=2$. Tehát $Y$ térbeli alakja $1\times2$.

A $Y[n,o,0,1]$ elemhez tartozó összeg a $j=1$ kimeneti oszlop miatt a paddingelt kép $1\cdot s_w+v d_w=2+v\cdot2$ oszlopait olvassa, $v=0,1,2$ esetén: $2,4,6$. A paddingelt szélesség $5+2=7$, tehát az oszlopindexek érvényesek ($2,4,6$ mind <7). A paddingelt oszlopindexekből az eredeti bemeneti oszlopindexek $\beta-p_w=1,3,5$. A magassági rész: $i=0$, $u=0,1,2$, paddingelt sorok $0\cdot2+u\cdot2=0,2,4$, ebből eredeti sorindexek $-1,1,3$. Az első sorindex $-1$ a padding zónába esik, ezért a hozzájárulás nulla; a ténylegesen használt bemeneti sorok: $1$ és $3$. Összefoglalva: adott $n,c$ mellett a lehetséges nemzérus bemeneti pozíciók $(\alpha,\beta)\in\{(1,1),(1,3),(1,5),(3,1),(3,3),(3,5)\}$, feltéve, hogy a megfelelő $K[o,c,u,v]$ súly nem nulla.

37.1.7.3 F3 megoldás

A módosított teszt:

def test_random_shape_dtype():
    rng = np.random.default_rng(20261020)
    X = rng.random((2,2,6,7), dtype=np.float64)
    K = rng.random((3,2,2,2), dtype=np.float64)
    b = rng.random((3,), dtype=np.float64)
    Y = conv2d_reference(X, K, b=b, stride=(1,2), padding=(0,1), dilation=(1,2))
    assert Y.shape == (2,3,5,3)  # H_out: (6+0-1-1)//1+1=5; W_out: (7+2-3-1)//2+1=3
    assert Y.dtype == np.float64

A pytest futtatás után a teszt sikeres, ha a shape és dtype illeszkedik. A képlet ellenőrzése: $H_{out}=(6+0-1\cdot(2-1)-1)//1+1=5$, $W_{out}=(7+2\cdot1-2\cdot(2-1)-1)//2+1=(7+2-2-1)//2+1=6//2+1=3$.

37.1.7.4 F4 megoldás

Az első hibás sorban a k_h*d_h szerepel a (k_h-1)*d_h helyett: ez eggyel nagyobb effektív kernelméretet feltételez, így $H_{out}$ túl kicsi lehet. A második sorban a - p_h kivonás jó, de hiányzik annak ellenőrzése, hogy a kivonás után az index $[0,H-1]$ tartományban van-e; a paddingelt tömb használata nélkül a negatív vagy $H$-n túli indexek hibás memóriaterületet vagy Python negatív indexelést okoznak. A helyes megoldás a paddingelt tömb bevezetése, ahogy a reference_conv2d.py teszi: X_pad-del számolunk, és a kernel effektív mérete (k_h-1)*d_h+1.

Javított sorok:

H_out = (H + 2*p_h - (k_h-1)*d_h - 1) // s_h + 1
...
s += X_pad[n, c, i*s_h + u*d_h, j*s_w + v*d_w] * K[o, c, u, v]

A kézi példán a javított kód a 4. pontban megadott $[[47,57],[77,87]]$ mátrixot adja, $1e-12$ abszolút tűréssel egyezően.

37.1.7.5 F5 megoldás

Protokollterv:

1. Cél: a referencia és a PyTorch F.conv2d azonossága a támogatott részhalmazon.
2. Adat: minden esethez np.random.default_rng(20261020).random(shape) float64-ben; a PyTorch tenzort torch.from_numpy(...).double()-ként hozzuk létre.
3. Paraméterrács: (a) $H=W=8$, $k=3$, s=1, p=1, d=1; (b) $H=5,W=6$, $k=2$, s=1, p=0, d=2; (c) $H=10,W=7$, $k=3$, s=2, p=1, d=1; (d) $N=2,C_{in}=2,C_{out}=3$, $k=2$, s=2, p=1, d=1; (e) ugyanez bias nélkül; (f) $H=7,W=7$, $k=1$, s=1, p=0, d=1.
4. Bias: a PyTorch F.conv2d bias argumentumát külön adjuk át, vagy None-t, a referenciával összhangban.
5. Tolerancia: mivel mindkét oldal float64, az eltérés zérus legyen; numerikus pontosságból adódóan rtol=1e-12, atol=1e-12 elfogadható.
6. Kiértékelés: minden konfigurációra np.allclose, a maximális abszolút eltérés rögzítése.
7. Buktatók: a PyTorch alapértelmezett float32 numerikus eltérést okoz; a csatornák sorrendje NCHW mindkettőnél; a dilation a PyTorchban ugyanúgy a kernel pontjai közötti lépés, nem a stride; a padding szimmetrikus, ezért a PyTorch padding=(p_h,p_w) formája használandó.
8. Korlát: az egyezés csak a fenti konfigurációkra bizonyított; nem állít általános implementációs ekvivalenciát.

Példa shape az (a) esetre: bemenet $(1,1,8,8)$, kernel $(1,1,3,3)$, s=1, p=1, d=1, így $H_{out}=W_{out}=(8+2-2\cdot1-1)/1+1=8$. A kimenet $(1,1,8,8)$.

37.1.8 8. Tipikus tévedés és ellenpélda

„A referencia implementáció minden Conv2d-opciót támogat.” Ez hamis. A jelen kód például nem támogat groups>1-et, aszimmetrikus paddinget, más padding módokat, output_padding-et vagy a transzponált műveletet. Ellenpélda: ha a felhasználó groups=2-vel hívná meg, a függvény nem is fogad ilyen paramétert, és a specifikáció ezt kifejezetten kizárja. Egy részleges referencia csak a deklarált tartományon érvényes; aki ennél többet állít, az a 13.4. Határkezelés és frekvenciaintuíció alfejezetben tárgyalt „csendes elnyeléshez” hasonló hibát követ el, csak éppen a dokumentáció szintjén.

Önellenőrzés. A hallgató tegye fel magának: (1) a kernel effektív kiterjedését $(k-1)d+1$-ként számolta-e, nem $kd$-ként? (2) A paddingelt tömb indexelésekor a padding hozzáadása után a stride és dilation sorrendje helyes? (3) A bias dimenziója $C_{out}$, és a kimenet minden térbeli pozíciójához hozzáadódik? (4) A dtype mindenütt float64, és a hibás bemenetek kivételt dobnak? (5) A kimeneti méret képlete a floor függvényt használja, és a nullánál kisebb kimenet hibát ad?

Visszahívás. A 13.4. Határkezelés és frekvenciaintuíció alfejezetben a zero padding és a circular padding közötti különbség azt mutatta, hogy a határfeltétel a definíció része; itt a zero paddingot explicitté tettük a $\tilde X$ bevezetésével. A 14.4. Csoportos és depthwise konvolúció alfejezetben a groups=1 azt jelentette, hogy a súly alakja $C_{out}\times C_{in}\times k_h\times k_w$; ezt most a specifikáció rögzíti.

37.1.9 Rövid összefoglaló

A referencia operátor specifikációja az NCHW keresztkorrelációt egyetlen indexképlettel definiálja: a paddingelt bemenetből stride és dilation szerint olvasott kernelablakok lineáris kombinációja, csatornánkénti bias hozzáadásával. A kimeneti méret levezetése a kernel utolsó pozíciójának illeszkedési feltételéből adódik, és a floor-képletben összegződik. A támogatott tartományt pontosan rögzítettük: groups=1, szimmetrikus zero padding, stride, dilation, opcionális bias, float64. A labor egy nemszimmetrikus kernelű kézi kontrollt és hibás alakokra negatív teszteket tartalmaz. A következő egység a backward pontos levezetését kezdi, amelyben ugyanezt a specifikációt használjuk a súly- és bemeneti gradienshez.

37.1.10 Felhasznált források

• [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/.