13.4 Határkezelés és frekvenciaintuíció

13.4.1 Cél, előismeret és induló becslés

A 13.3. Lokális szűrők és tanult reprezentáció egységben a cross-correlation réteget úgy definiáltuk, hogy a kernel egy lokális ablakban mozog a bemeneten. Egy $H$ hosszúságú véges 1D jelre és $K$ hosszúságú kernelre azonban az ablak a széleken kilógna a definíciós tartományból. Ebben az egységben azt vizsgáljuk, hogyan definiáljuk a hiányzó pozíciókat; ez a határfeltétel (boundary condition) megválasztása.

Előismeret: a 13.3. Lokális szűrők és tanult reprezentáció cross-correlation jelölése; a függvény és linearitás fogalma a 4.1.–4.3. egységekből. A frekvenciaintuícióhoz a 13.4. Határkezelés és frekvenciaintuíció alfejezetben bevezetett DFT-t használjuk, de ez a laborban opcionális mélyítés.

Induló kérdés. Egy $H=32$ hosszú jelet $K=3$ hosszú átlagoló kernelrel szűrünk. Hányféle, egymástól lényegesen eltérő módon definiálhatjuk a szélső pozíciókat, és a periodikus jel esetén melyik a „természetes” választás? A becslés: legalább három alapvető mód van — valid, zero padding és körkörös (circular) —, és periodikus jelnél a körkörös kiterjesztés őrzi meg a periodicitást; ezt a 52.3 szakaszban egzakt módon is megvizsgáljuk.

13.4.2 Határfeltételek: definíció, jelölés és alakok

Legyen a bemeneti 1D jel $x\in\mathbb R^H$, a kernel pedig $w\in\mathbb R^K$, ahol $K=2m+1$ páratlan egész, az egyszerűség kedvéért. A 13.3. Lokális szűrők és tanult reprezentáció cross-correlation definíciója szerint a kimenet egy $t$ pozícióban

$$y_t=\sum_{r=0}^{K-1}x^{\mathrm{pad}}_{t+r}\,w_r,$$

ahol $x^{\mathrm{pad}}\in\mathbb R^{H+2p}$ a paddelt (kiegészített) tömb, $p$ a szimmetrikus padding mérete, és a kernel $r$ indexe $0,\dots,K-1$ között fut, megfordítás nélkül. A kernel középpontja a $m=K//2$ pozíció, ezért $p=m$ esetén a kimenet hossza $H$, azonos a bemenettel; ezt same kimenetnek hívjuk. Ha $p=0$, akkor a kernel soha nem lóg ki a jelből, és a kimenet hossza $H-K+1$; ez a valid eset. A padding nélküli definícióban $x^{\mathrm{pad}}$ helyett közvetlenül $x$-et használunk, és a $t$ index $0,\dots,H-K$ között fut.

Két objektumot különböztetünk meg. Az $x^{\mathrm{ext}}:\mathbb Z\to\mathbb R$ virtuális kiterjesztés minden egész indexre értéket ad, és a $0,\dots,H-1$ tartományon egyezik a jellel: $x^{\mathrm{ext}}_i=x_i$. A paddelt tömb ennek egy véges, nullától indexelt kivágata:

$$x^{\mathrm{pad}}_j=x^{\mathrm{ext}}_{j-p},\qquad j=0,\dots,H+2p-1.$$

A $j$ tömbindex és az $i=j-p$ jelindex tehát $p$-vel el van tolva: $x^{\mathrm{pad}}_0=x^{\mathrm{ext}}_{-p}$, $x^{\mathrm{pad}}_p=x_0$. A határfeltétel az $x^{\mathrm{ext}}$ értékét rögzíti a $0,\dots,H-1$ tartományon kívül:

1. Valid (nincs padding). $p=0$, nem definiálunk külső pozíciót; a kernel kizárólag a jel belsejében mozoghat. A kimeneti hossz $H-K+1$.
2. Zero padding. $x^{\mathrm{ext}}_i=0$, ha $i<0$ vagy $i\geq H$. A kimeneti hossz $H$ (same esetben $p=m$), illetve általában $H+2p-K+1$.
3. Körkörös (circular) padding. $x^{\mathrm{ext}}_i=x_{i\bmod H}$, ahol $i\bmod H$ a $0,\dots,H-1$ halmazba eső maradék. Ez azt jelenti, hogy a jelet mintha $H$ periódussal periodikusan ismételnénk, és a kernel az ismételt példányon dolgozik.

Például $x=(1,2,3)$, $p=1$ mellett a zero paddinges tömb $x^{\mathrm{pad}}=(0,1,2,3,0)$, a circular paddinges $x^{\mathrm{pad}}=(3,1,2,3,1)$.

A PyTorch Conv2d dokumentációja szerint a natív konvolúciós réteg szimmetrikus zero paddinget használ, és a padding_mode paraméter 'zeros', 'reflect', 'replicate' vagy 'circular' értéket vehet fel [D10]. A mi laborunkban a zero és circular módot hasonlítjuk össze kézi implementációval.

2D-ben a jelölés analóg. Legyen $X\in\mathbb R^{H\times W}$, kernel $W\in\mathbb R^{K_h\times K_w}$, padding $(p_h,p_w)$. A virtuális kiterjesztés $X^{\mathrm{ext}}:\mathbb Z^2\to\mathbb R$, a paddelt tömb $X^{\mathrm{pad}}_{a,b}=X^{\mathrm{ext}}_{a-p_h,\,b-p_w}$, $X^{\mathrm{pad}}\in\mathbb R^{(H+2p_h)\times(W+2p_w)}$, és a kimenet

$$Y_{i,j}=\sum_{r=0}^{K_h-1}\sum_{s=0}^{K_w-1}X^{\mathrm{pad}}_{i+r,j+s}W_{r,s},\qquad i=0,\dots,H_{out}-1,\ j=0,\dots,W_{out}-1.$$

A zero padding esetén a tartományon kívüli indexekre $X^{\mathrm{ext}}_{u,v}=0$, a circular esetén $X^{\mathrm{ext}}_{u,v}=X_{u\bmod H,\,v\bmod W}$. Batch és csatornadimenziók esetén a padding csak a térbeli $H,W$ dimenziókat érinti, az NCHW alakban $N$ és $C$ változatlan marad.

Intuíció. A valid mód a legóvatosabb: csak olyan kimenetet ad, ahol minden bemeneti érték valódi. A zero padding a hiányzó értéket nulla intenzitásúnak tekinti, ami a kép fekete szegélyének felel meg. A circular padding a jelet gyűrűként zárja: a bal szélen a jobb szélső értékek jelennek meg. Ez akkor természetes, ha a jel valóban periodikus, például egy körvonal mentén mintavételezett intenzitás; általános képen azonban mesterséges ugrást hoz létre a szemközti szélek között.

13.4.3 Ellenpélda: a határkezelés nem azonos globális operátort ad

A levezetési kötelezettségünk a következő hamis állítás cáfolata: a különböző határkezelések ugyanazt a globális lineáris operátort adják ugyanazon a véges jelen. Az alábbi lemma pontos ellenpéldát mutat.

Lemma (zero és circular padding különböző operátort ad). Legyen $H=3$, $x=(1,2,3)\in\mathbb R^3$, $K=3$, $w=(1,1,1)\in\mathbb R^3$, és $p=1$ mindkét paddingnél. Ekkor a zero paddinges kimenet $y^{\mathrm{zero}}=(3,6,5)$, a circular paddinges kimenet $y^{\mathrm{circ}}=(6,6,6)$, tehát $y^{\mathrm{zero}}\neq y^{\mathrm{circ}}$.

Bizonyítás (ellenpélda). Zero padding esetén $x^{\mathrm{pad}}=(x^{\mathrm{ext}}_{-1},x_0,x_1,x_2,x^{\mathrm{ext}}_{3})=(0,1,2,3,0)$, mert a $-1$ és a $3$ jelindex a tartományon kívül esik. A definíció szerint:

$$y_0^{\mathrm{zero}}=x^{\mathrm{pad}}_0+x^{\mathrm{pad}}_1+x^{\mathrm{pad}}_2=0+1+2=3,$$ $$y_1^{\mathrm{zero}}=x^{\mathrm{pad}}_1+x^{\mathrm{pad}}_2+x^{\mathrm{pad}}_3=1+2+3=6,$$ $$y_2^{\mathrm{zero}}=x^{\mathrm{pad}}_2+x^{\mathrm{pad}}_3+x^{\mathrm{pad}}_4=2+3+0=5.$$

Circular padding esetén a modulo szabály szerint $x^{\mathrm{ext}}_{-1}=x_{2}=3$ és $x^{\mathrm{ext}}_{3}=x_0=1$, tehát $x^{\mathrm{pad}}=(3,1,2,3,1)$. Így

$$y_0^{\mathrm{circ}}=3+1+2=6,\quad y_1^{\mathrm{circ}}=1+2+3=6,\quad y_2^{\mathrm{circ}}=2+3+1=6.$$

A két vektor különböző, így a két határkezeléshez tartozó lineáris leképezés nem azonos. $\blacksquare$

Következmény. A valid mód eleve más dimenziójú kimenetet ad ($H-K+1=1$), így az sem lehet azonos a fenti kettővel. A határfeltétel tehát a véges jelű cross-correlation definíciós része, nem pusztán implementációs részlet.

Az ellenpélda egyben azt is mutatja, hogy az átlagoló kernel a circular paddingnél a teljes jelen konstans $6$ értéket ad, mert a gyűrűn minden pozíció ugyanazt a három értéket látja; a zero padding a széleken csökkenti az összeget.

13.4.4 Kézi példa és ellenőrző kód

A fenti kézi példa egyben a numerikus kontroll is. Az alábbi kód ugyanezt a számítást végzi el NumPy-ban, kiegészítve a labor két jelével. A dtype float64, mert a cél a pontos egyezés, nem a tanítási sebesség.

# lab/n052_boundary_check.py
import numpy as np

DTYPE = np.float64
SEED = 0          # nincs véletlen a példában; a jegyzőkönyvhöz rögzítjük
rng = np.random.default_rng(SEED)

def pad_1d(x, p, mode):
    """Szimmetrikus padding 1D jelekre."""
    x = np.asarray(x, dtype=DTYPE)
    if mode == "zeros":
        return np.pad(x, (p, p), mode="constant", constant_values=0.0)
    if mode == "circular":
        return np.pad(x, (p, p), mode="wrap")
    raise ValueError(f"ismeretlen mode: {mode}")

def corr_1d(x, w, boundary):
    """Cross-correlation, K páratlan, same kimenet zero/circular esetén."""
    H = x.shape[0]
    K = w.shape[0]
    assert K % 2 == 1, "csak páratlan kernel támogatott"
    p = K // 2
    if boundary == "valid":
        out = np.empty(H - K + 1, dtype=DTYPE)
        for t in range(out.shape[0]):
            out[t] = np.sum(x[t:t+K] * w)
        return out
    xp = pad_1d(x, p, boundary)
    out = np.empty(H, dtype=DTYPE)
    for t in range(H):
        out[t] = np.sum(xp[t:t+K] * w)
    return out

x_demo = np.array([1.0, 2.0, 3.0])
w_mean = np.array([1.0, 1.0, 1.0])

print("zero   :", corr_1d(x_demo, w_mean, "zeros"))
print("circular:", corr_1d(x_demo, w_mean, "circular"))

Várható kimenet (számított példa, nem futtatott):

zero   : [3. 6. 5.]
circular: [6. 6. 6.]

A tolerancia itt $10^{-12}$, mert a műveletek egész értékű összegek.

13.4.5 Labor: periodikus és szélső jel szűrése

Kérdés. Hogyan befolyásolja a határfeltétel a szűrő kimenetét periodikus és éles szélű jelen?

Input, import és adatút. A labor két determinisztikus 1D jelet generál a lab/n052_lab.py fájlban, külső adatfájl nélkül:

• $x^{\mathrm{per}}_t=\sin(2\pi t/16)$, $t=0,\dots,31$, $H=32$: periodikus jel.
• $x^{\mathrm{edge}}_t=1$, ha $t<16$, különben $0$: éles él.

Kernel: $w^{\mathrm{mean}}=(1/3,1/3,1/3)$ (aluláteresztő), és $w^{\mathrm{diff}}=(-1,0,1)$ (élkiemelő, felüláteresztő). Mindkét kernelt zero és circular paddinggel futtatjuk, $p=1$ same kimenettel. A dtype float64, a device CPU, a seed rögzített, bár a jelek determinisztikusak.

# lab/n052_lab.py
import numpy as np
from n052_boundary_check import corr_1d

DTYPE = np.float64
SEED = 0

t = np.arange(32, dtype=DTYPE)
x_per = np.sin(2.0 * np.pi * t / 16.0)
x_edge = np.ones(32, dtype=DTYPE)
x_edge[16:] = 0.0

w_mean = np.ones(3, dtype=DTYPE) / 3.0
w_diff = np.array([-1.0, 0.0, 1.0], dtype=DTYPE)

for name, x in [("periodikus", x_per), ("el", x_edge)]:
    for b in ["zeros", "circular"]:
        y_mean = corr_1d(x, w_mean, b)
        y_diff = corr_1d(x, w_diff, b)
        print(f"{name:10s} {b:9s} mean szél: {y_mean[0]:+.4f} {y_mean[-1]:+.4f} "
              f"diff szél: {y_diff[0]:+.4f} {y_diff[-1]:+.4f}")

Futtatás és ellenőrzés. A parancs a lab/ munkakönyvtárból:

cd lab && python n052_lab.py

Ellenőrzés: a corr_1d függvény az alfejezet demonstrációs példáján a fenti várható értékeket adja; a laborban a periodikus jel átlagoló kernelre a belső pontokban mindkét padding azonos értéket ad, de a széleken a zero padding kis eltérést mutat. Az éljel differenciáló kernelre a circular padding a jel két, egymástól távoli szélét kapcsolja össze, ami az egyik oldalon mesterséges ugrást okoz.

Szemléltető, számított kimenet (nem mérés, a képletekből számolt példa):

A periodikus szinusz 32 mintás ablakába pontosan két periódus fér; ezért a circular padding a jel saját folytatásához illeszkedik, a zero padding viszont a bal szélen módosítja az eredményt. A differenciáló szűrő körkörös módban sem ad zérus szélső értéket: a helyes érték a lokális jelváltozásból következik. Az éljelnél a circular padding a távoli végeket is összekapcsolja, és az utolsó pixel gradiensét megváltoztatja.

Opcionális DFT-mélyítés. A körkörös határfeltételhez tartozó szűrés felírható a diszkrét Fourier-transzformációval. Legyen a DFT

$$\hat x_k=\sum_{n=0}^{H-1}x_n e^{-2\pi i kn/H},\qquad k=0,\dots,H-1.$$

A circular paddinges cross-correlation esetén a kernel megfordítottjának DFT-jével való szorzás adja a kimenet DFT-jét; ez a körkonvolúciós tétel standard alakja. A tétel bizonyítását itt elhagyjuk; a feltételeket és a pontos állítást a [B01] Fourier-transzformációról szóló fejezete tárgyalja (a hivatkozott szakasz részletes bibliográfiai ellenőrzése még szükséges). Ha a DFT-szorzást a zero paddinges lineáris szűrésre akarjuk használni, a jelet és a kernelt nullákkal legalább $H+K-1$ hosszra kell kiegészíteni; különben a körkörös átfolyás a kívánt lineáris konvolúció helyett körkonvolúciós eredményt ad. Mindkét művelet lineáris operátor, a különbség a határkezelésben van.

13.4.6 Feladatok

F1 (fogalmi, nehézség 1). Definiálja szavakban a valid, zero padding és circular padding határfeltételt egy $H$ hosszú 1D jelre. Adjon meg egy $H$ és $K$ értéket, amelyre a valid kimenet hossza nem egyezhet a same kimenet hosszával. Átadandó: a három definíció saját szavakkal, a választott $H,K$ és a kimeneti hosszak képlete.

F2 (levezetési, nehézség 2). Legyen $H=4$, $x=(2,4,0,1)$, kernel $w=(1,-1,2)$ páratlan hosszúságú, $p=1$. Számítsa ki a zero és circular paddingű same kimenet minden elemét, és ellenőrizze, hogy a kimenet hossza $H$. Átadandó: a paddelt jelek és a számítás lépései.

F3 (implementációs, nehézség 2). Írjon NumPy függvényt corr_2d(X, W, boundary) néven, amely 2D zero és circular paddingű same cross-correlationt valósít meg $X\in\mathbb R^{H\times W}$ és páratlan $W\in\mathbb R^{K_h\times K_w}$ kernelre. Tesztelje az $X=\begin{pmatrix}1&2&3\\4&5&6\\7&8&9\end{pmatrix}$, $W=\begin{pmatrix}0&1&0\\1&0&1\\0&1&0\end{pmatrix}$ példán. Átadandó: a kód, a futtatás és a kimeneti mátrix.

F4 (hibakeresési, nehézség 3). Az alábbi kód a lineáris (zero paddinges) szűrést DFT-szorzással akarja kiszámítani, de az eredmény hibás:

import numpy as np
x = np.array([1.0, 2.0, 0.0, 1.0])
w = np.array([1.0, 1.0, 1.0])
xpad = np.pad(x, (0, 1))              # 5 hossz
wpad = np.pad(w, (0, 2))              # 5 hossz
y_fft = np.fft.ifft(np.fft.fft(xpad) * np.fft.fft(wpad)).real
print(y_fft)  # hibás? hasonlítsa a zero paddinges corr_1d-hez

Lokalizálja a hibát, magyarázza el a körkörös átfolyást, és adja meg a javítást a minimális szükséges beágyazási hosszal. Átadandó: a hiba oka, a helyes beágyazás és az összehasonlító futás.

F5 (kísérleti/transzfer, nehézség 3). Tervezzen kísérletet a GlyphLab 24×24-es képein annak mérésére, hogy a zero padding és a circular padding hogyan változtatja meg egy fix 3×3-as élkiemelő kernel kimeneti statisztikáját a kép szélén. Adja meg a megfigyelési egységet, a splitet, a metrikát és az érvényességi korlátot. Átadandó: a protokoll szöveges terve, a scene_id csoportosítás indoklásával és az összehasonlítás korlátjával.

13.4.7 Megoldások és indoklás

F1. A valid mód nem definiál külső pozíciót, ezért a kernel csak a jel belsejében dolgozhat, és a kimenet hossza $H-K+1$. A zero padding a hiányzó pozíciókat $0$-nak veszi, a circular padding pedig az indexet modulo $H$ tekinti, mintha a jel $H$ periódussal ismétlődne. Például $H=8$, $K=3$ esetén a valid kimenet hossza $8-3+1=6$, a same ($p=1$) kimenet hossza $8$, tehát a kettő nem egyezhet.

F2. $H=4$, $K=3$, $p=1$. Zero padding: $x^{\mathrm{pad}}=(0,2,4,0,1,0)$. $y_0 = 0\cdot1+2\cdot(-1)+4\cdot2 = 0-2+8=6$; $y_1 = 2\cdot1+4\cdot(-1)+0\cdot2 = 2-4+0=-2$; $y_2 = 4\cdot1+0\cdot(-1)+1\cdot2 = 4+0+2=6$; $y_3 = 0\cdot1+1\cdot(-1)+0\cdot2 = -1$. Tehát $y^{\mathrm{zero}}=(6,-2,6,-1)$.

Circular padding: az indexek modulo 4, tehát $x^{\mathrm{pad}}=(1,2,4,0,1,2)$ (a $-1$ jelindex $x^{\mathrm{ext}}_{-1}=x_3=1$, a $4$ jelindex $x^{\mathrm{ext}}_4=x_0=2$). $y_0 = 1\cdot1+2\cdot(-1)+4\cdot2 = 1-2+8=7$; $y_1 = 2\cdot1+4\cdot(-1)+0\cdot2 = -2$; $y_2 = 4\cdot1+0\cdot(-1)+1\cdot2 = 6$; $y_3 = 0\cdot1+1\cdot(-1)+2\cdot2 = 3$. Tehát $y^{\mathrm{circ}}=(7,-2,6,3)$. Mindkét kimenet hossza $4=H$.

F3. Példakód:

def corr_2d(X, W, boundary):
    X = np.asarray(X, dtype=np.float64)
    W = np.asarray(W, dtype=np.float64)
    H, Wd = X.shape
    Kh, Kw = W.shape
    assert Kh % 2 == 1 and Kw % 2 == 1
    ph, pw = Kh // 2, Kw // 2
    if boundary == "zeros":
        mode, cval = "constant", 0.0
    elif boundary == "circular":
        mode, cval = "wrap", 0.0
    else:
        raise ValueError(boundary)
    Xp = np.pad(X, ((ph, ph), (pw, pw)), mode=mode, constant_values=cval) \
         if boundary == "zeros" else \
         np.pad(X, ((ph, ph), (pw, pw)), mode=mode)
    Y = np.empty_like(X)
    for i in range(H):
        for j in range(Wd):
            Y[i, j] = np.sum(Xp[i:i+Kh, j:j+Kw] * W)
    return Y

X = np.arange(1, 10, dtype=np.float64).reshape(3, 3)
W = np.array([[0,1,0],[1,0,1],[0,1,0]], dtype=np.float64)
print(corr_2d(X, W, "zeros"))
# [[ 6.  9.  8.]
#  [13. 20. 17.]
#  [12. 21. 14.]]
print(corr_2d(X, W, "circular"))
# [[16. 17. 18.]
#  [19. 20. 21.]
#  [22. 23. 24.]]

Ellenőrzés. A kereszt alakú kernel a középpont és az átlók helyett csak a négy oldalszomszédot adja össze. Például zero padding mellett a bal felső pixel eredménye $Y_{0,0}=0+0+2+4=6$, a belső pixelé $Y_{1,1}=2+4+6+8=20$. Circular padding mellett a bal felső pixel $Y_{0,0}=7+3+2+4=16$. A két, kóddal is ellenőrzött eredménymátrix:

$$Y^{\mathrm{zero}}=\begin{pmatrix}6&9&8\\13&20&17\\12&21&14\end{pmatrix},\qquad Y^{\mathrm{circ}}=\begin{pmatrix}16&17&18\\19&20&21\\22&23&24\end{pmatrix}.$$

Mindkét kimenet alakja $(3,3)$; a belső pixel mindkét határkezelésben azonos, míg a szélpixelek eltérhetnek.

F4. A közvetlen, 5 hosszú FFT-szorzás körkonvolúciót számít, emiatt az utolsó és az első minta összekeveredhet. Két, $H=4$ és $K=3$ hosszú sorozat lineáris konvolúciójához legalább $H+K-1=6$ hosszú beágyazás szükséges. A corr_1d keresztkorrelációt használ, ezért a konvolúciós szorzás előtt a kernelt meg kell fordítani. Az odd-$K=3$ same kimenet a teljes, 6 hosszú konvolúció $p=1$ pozíciójától kezdődő 4 elem:

x = np.array([1.0, 2.0, 0.0, 1.0])
w = np.ones(3, dtype=np.float64)
fft_size = len(x) + len(w) - 1   # 6
u = np.pad(x, (0, fft_size-len(x)))
v = np.pad(w[::-1], (0, fft_size-len(w)))
full = np.fft.ifft(np.fft.fft(u) * np.fft.fft(v)).real
same = full[1:1+len(x)]
np.testing.assert_allclose(same, corr_1d(x, w, "zeros"), atol=1e-12)
print(same)  # [3. 3. 3. 1.]

Az eredeti ötelemes beágyazás nem alkalmas az általános lineáris konvolúció visszaállítására. Ebben a speciális, szimmetrikus kerneles példában az első néhány érték esetleg véletlenül egyezhet, de a helyes összehasonlításnak a megfelelően eltolt same-szeletet kell figyelembe vennie.

F5. A kísérleti terv: a GlyphLab 360 képéből a train split 240 képe fix 3×3-as élkiemelő kernel (pl. Sobel-x) zero és circular paddinggel. Megfigyelési egység a scene_id, mert a két nézet ugyanahhoz a jelenethez tartozik, és a split is scene-szintű. Metrika: a kép szélső 2 pixelgyűrűjén számított átlagos abszolút kimeneti érték különbsége a két padding között, képenként, majd scene-szintű átlag és bootstrap CI a scene_id-kből. A protokoll rögzíti a kernel pontos értékeit, a padding méretét ($p=1$) és a dtype-ot. Érvényességi korlát: a GlyphLab mesterséges alakzatképein a szélek gyakran nullák, ezért a zero padding hatása kisebb lehet, mint természetes képeken; az eredmény nem általánosítható más adatra. A korrupt teszt nem használható a paddinghatás mérésére, mert az a választott modell értékelésére van fenntartva; ez a kísérlet nem tanít modellt, ezért nem sérti a tesztválasztási szabályt, de a protokollt a naplóban külön kell rögzíteni.

13.4.8 Tipikus tévedés, önellenőrzés és visszahívás

Tipikus tévedés. Az FFT-s körkonvolúció és a véges lineáris művelet csak megfelelő beágyazással felel meg egymásnak. Ha valaki egy $H=4$ hosszú jelet és $K=3$ hosszú kernelt változatlan hosszon FFT-szoroz, a művelet a $H=4$ hosszú körkonvolúciót adja, nem a zero paddinges lineáris eredményt. Ellenpélda: $x=(1,1,1,1)$, $w=(1,1,1)$; a zero paddinges same kimenet $(2,3,3,2)$, a 4 hosszú FFT-szorzás viszont konstans $(3,3,3,3)$-at ad (a körkörös átfolyás miatt az első és utolsó elem is 3). A javítás a legalább $H+K-1$ hosszú nulla beágyazás, ahogy az F4 feladat mutatja.

Önellenőrzés. Ellenőrizze, hogy a same kimenet hossza $H$, a valid kimeneté $H-K+1$, és hogy a paddelt jel hossza $H+2p$. Számolja ki a szélső pozíciót kézzel, majd a kóddal; ha a zero és circular kimenet egyenlő, akkor vagy a jel periodikus a kernel ablakára nézve, vagy a kernel csak a belső tartományt látja (pl. $H$ nagy, $K=1$).

Visszahívás. A 13.3. Lokális szűrők és tanult reprezentáció cross-correlation definícióját használtuk megfordítás nélkül; a kernel indexelése és a padding mérete összhangban van a 14.1. Stride, padding, dilation és outputméret általános kimeneti képletével. A seed és a determinisztikus jegyzőkönyv kezelése a 12.4. III. ellenőrző pont: önállóan tanuló kis háló gyakorlatát követi; a laborban nincs véletlen, de a SEED rögzítése a reprodukálhatósági szokás része.

13.4.9 Rövid összefoglaló

A véges jelen a kernel széleken kilóg a tartományból, ezért a határfeltétel a cross-correlation definíciós része. A valid mód csak teljes ablakot enged, a zero padding nullával, a circular padding modulo indexeléssel pótol. Az ellenpélda megmutatta, hogy a zero és circular padding különböző lineáris operátort ad: periodikus jelnél a circular konzisztens, éles szélnél mesterséges ugrást okoz. A DFT-szorzás körkörös határfeltételt valósít meg; lineáris szűréshez a jelet és a kernelt legalább $H+K-1$ hosszra kell nullázni. A labor két jelen és két kernelnél számszerűsíti a különbséget.

13.4.10 Következő alkalmazás

A 14.1. Stride, padding, dilation és outputméret egység a stride, padding és dilation általános kimeneti méretképletét vezeti le, és ezzel a CNN-réteg alakjainak teljes kontrollját adja meg.

13.4.11 Források

• [B01] Deisenroth, A. A. Faisal és C. S. Ong (2020). Mathematics for Machine Learning. Cambridge University Press. https://mml-book.github.io/.
• [S01] Stanford CS231n kurzus (n.d.). Convolutional Neural Networks. https://cs231n.github.io/convolutional-networks/.
• [D10] PyTorch contributors (2.14). Conv2d. https://docs.pytorch.org/docs/2.14/generated/torch.nn.Conv2d.html.