16.2 Pooling, downsampling és aliasing

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

A 16.1. Eltolási equivariance és invariance egységben az eltolási ekvivarianciát operátoregyenletekkel vizsgáltuk, és láttuk, hogy a stride-os művelet az ekvivarianciát a stride-részcsoportra szűkíti. Most a pooling rétegre mint lokális aggregációra és mint mintavétel-csökkentésre koncentrálunk. A két szerep gyakran egyetlen rétegben jelenik meg, de fogalmilag különválasztható, és a különválasztás dönti el, hogy milyen eltolási tulajdonságokat várhatunk.

Előismeret: a 16.1. Eltolási equivariance és invariance eltolási operátora, a 15.2. Inputgradiens és átfedő recepciós mezők NCHW-alakkezelése és a 4.2. Parciális derivált és gradiens gradiensfogalma. A poolingnak többnyire nincs tanulható paramétere, ezért a gradiens itt csak az inputra vonatkozik; a jelen egységben azonban elsősorban az előremenő leképezés és a rácsszimmetria a tárgy.

Induló kérdés: legyen $X\in\mathbb R^{1\times 1\times 4\times 1}$ a négypixeles vektor $[2,1,4,0]$. Egy $k=2$, $s=2$ maxpooling után mi az eredménye $X$-nek és a $T_1 X=[0,3,1,4]$ eltoltjának? Becsülje meg, tud-e a kimeneti rácson olyan eltolást mondani, amely az első kimenetet a másodikba viszi. A pontos definíciókkal ezt az alábbiakban megválaszoljuk.

16.2.2 Definíciók, tenzoralak és a két szerep szétválasztása

Legyen a bemenet

$$X\in\mathbb R^{N\times C\times H\times W},$$

NCHW elrendezésben. A pooling réteg csatornánként függetlenül dolgozik; a batch és csatorna dimenziók változatlanok. Az ablaktérbeli méret $k_h,k_w$ pozitív egész, a stride $s_h,s_w$ pozitív egész. Paddinget ebben az egységben zérusnak vesszük, és feltesszük, hogy az ablak mindig teljesen a bemeneti rácson belül marad; a kimeneti méret ekkor

$$H_{out}=\left\lfloor \frac{H-k_h}{s_h}\right\rfloor+1,\qquad W_{out}=\left\lfloor \frac{W-k_w}{s_w}\right\rfloor+1.$$

Ez ugyanolyan alakú képlet, mint a konvolúcióé [dilation nélkül: $d=1$ mellett $H+2p-(k-1)-1=H-k$], de itt a kernel súlyok helyett rögzített aggregáló függvény áll.

Max pooling. A $0\le i<H_{out}$, $0\le j<W_{out}$ kimeneti pozícióhoz tartozó bemeneti ablak

$$R_{ij}=\{(i s_h+u,\; j s_w+v)\;:\;0\le u<k_h,\;0\le v<k_w\},$$

és

$$Y[n,c,i,j]=\max_{(p,q)\in R_{ij}} X[n,c,p,q].$$

Average pooling. Ugyanilyen ablakokon

$$Y[n,c,i,j]=\frac{1}{k_h k_w}\sum_{(p,q)\in R_{ij}} X[n,c,p,q].$$

A kimenet mindkét esetben $\mathbb R^{N\times C\times H_{out}\times W_{out}}$. Gyakori választás a $k_h=k_w=2$, $s_h=s_w=2$, amely a térbeli méretet felezi.

1. definíció (lokális aggregáció). Egy térbeli leképezést lokális aggregációnak nevezünk, ha a kimenet minden pontja egy rögzített méretű, a bemeneti rács szerinti lokális környezet elemeinek egyetlen értékké való összegzése, például maximum, összeg vagy átlag, anélkül hogy a bemeneti rács felbontását megváltoztatná. Formálisan $s_h=s_w=1$; ilyenkor $H_{out}=H-k_h+1$, tehát a kimeneti rács sűrűsége megmarad, csak a határ zsugorodik.

2. definíció (downsampling, leskálázás). A mintavételi sűrűség csökkentése: a bemeneti rácson kijelölünk egy ritkább rácsobjektumot, és csak ezen adjuk vissza az értékeket. Ebben a pooling-kontextusban $s_h>1$ vagy $s_w>1$. A kimeneti rács ennek megfelelően ritkább, és az aggregálás, ha van, már ezen a ritkább rácson történik.

Fontos, hogy a $k=2$, $s=2$ pooling egyszerre aggregál és leskáláz: az ablakot nem csúsztatjuk egyesével, hanem kettesével, tehát a kimeneti rács sűrűsége fele. Ezzel szemben $k=2$, $s=1$ csak lokális aggregáció, nincs mintavételi sűrűségcsökkenés.

Az eltolási ekvivariancia szempontjából a különbség lényeges: az aggregáció önmagában kompatibilis az eltolással a belső tartományon, a leskálázás viszont áttér egy ritkább rácsra, ahol a bemeneti rács egypixeles eltolásának nincs egyértelmű megfelelője. Emiatt várjuk, hogy a stride-1 pooling equivariáns, a stride-$s$ pooling pedig csak az $s\mathbb Z^2$ eltolásokra.

16.2.3 Levezetési kötelezettség: az egy pixeles eltolás nem őrződik meg

A downsampling és az eltolás viszonyát formálisan egy egydimenziós modellben rögzítjük, mert a lényeg már ott látható.

Legyen a bemeneti rács $X\in\mathbb R^4$, az eltolás $T_\tau$ a belső tartományon legyen definiálva a $T_\tau X[i]=X[i-\tau]$ összefüggéssel, a határra zéró értéket feltételezve, ha $i-\tau<0$. A pooling legyen $k=2$, $s=2$ maxpooling, tehát $P:[X_0,X_1,X_2,X_3]\mapsto[\max(X_0,X_1),\max(X_2,X_3)]$.

Lemma (nincs rögzített kimeneti eltolás az egypixeles shiftre). A $k=2,s=2$ maxpoolingra nem létezik olyan $\rho\in\mathbb Z$, amelyre minden $X\in\mathbb R^4$ mellett

$$P(T_1 X)=T_\rho P(X)$$

teljesülne.

Bizonyítás. Megmutatjuk, hogy két különböző bemenet két különböző $\rho$-t követel.

1. Válasszuk az $X^{(1)}=[1,0,0,0]$ bemenetet. Ekkor $P(X^{(1)})=[\max(1,0),\max(0,0)]=[1,0]$. Az egypixeles eltolt $T_1X^{(1)}=[0,1,0,0]$. Ennek poolingja $P(T_1X^{(1)})=[\max(0,1),\max(0,0)]=[1,0]$. Tehát $P(T_1X^{(1)})=P(X^{(1)})$, ami azt jelentené, hogy $T_\rho P(X^{(1)})=P(X^{(1)})$, vagyis $\rho=0$.

2. Válasszuk az $X^{(2)}=[0,1,0,0]$ bemenetet. Ekkor $P(X^{(2)})=[1,0]$. Az eltolt $T_1X^{(2)}=[0,0,1,0]$, és $P(T_1X^{(2)})=[\max(0,0)=0,\max(1,0)=1]=[0,1]$. Ahhoz, hogy $T_\rho[1,0]=[0,1]$ legyen, $\rho=1$ szükséges.

Nincs olyan közös $\rho$, amely az első esetben $0$, a másodikban $1$ egyszerre, ezért az egyenlet nem teljesülhet minden $X$-re. ∎

Az ellenpélda értelmezése: a $[1,0,0,0]$ bemenetben a maximum az első ablakban van; az egypixeles eltolás a maximumot még mindig az első ablakba viszi, mert a második pozíció az első ablakban marad. A $[0,1,0,0]$ bemenetnél azonban az eltolás a maximumot átviszi a második ablakba. A pooling az ablakon belüli pozíciót eldobja, ezért az első esetben a változás láthatatlan, a másodikban ugrást okoz. A kimeneti rácson a $\tfrac12$ pixeles eltolás nem létezik, ezért nincs olyan konzisztens rögzített eltolás.

Következmény. Stride $s$ pooling után az ekvivariancia-állítás csak az $s\mathbb Z^2$ eltolásokra fogalmazható meg értelmesen. Ez a 16.1. Eltolási equivariance és invariance megfigyelés általánosítása: a stride az eltolási részegységet a ritkább rácshoz rögzíti.

16.2.4 Aliasing intuíció és anti-aliasing szűrés

A leskálázás egy diszkrét jelet ritkább rácson mintavételez. A klasszikus mintavételi elméletben, ha a jel spektruma a ritkább rács Nyquist-határán túlra nyúlik, akkor a magas frekvenciájú komponensek alacsony frekvenciájú hamis mintázatként, alias-ként jelennek meg. A klasszikus mintavételi tétel folytonos idejű, sávkorlátos jelekről szól: ha egy $f(t)$ függvény nem tartalmaz $W$ ciklus/s-nál nagyobb frekvenciát, akkor egyértelműen meghatározzák az $1/(2W)$ másodpercenként vett mintái ([P28], II. szakasz, „The Sampling Theorem”, Theorem 1, 11. o.). A tételt és bizonyítását itt nem reprodukáljuk. A pooling ettől eltérő helyzet: már diszkrét jelet ritkítunk tovább, és a képek általában nem sávkorlátosak, ezért a tétel feltételei itt nem teljesülnek, és rá nem hivatkozhatunk bizonyításként. Amit a laborban szemléltetünk, az a diszkrét ritkítás aliasing-jelensége: ha a ritkább rácson ábrázolható legnagyobb frekvenciánál magasabb komponens van a jelben, az a ritkítás után alacsonyabb frekvenciaként jelenik meg. Ez a szakasz szemléltetés és mérés, nem a folytonos tétel alkalmazása.

Az anti-aliasing gondolata: a leskálázás előtt egy aluláteresztő szűrővel csökkentjük a magas frekvenciákat, gyakran egyszerűen egy kis kernelű átlagolással, például $2\times2$ box-szűrővel. Ha a szűrés megelőzi a ritkítást, akkor a leskálázás kevésbé éles, de kevésbé fázisfüggő mintázatot kap. A pooling-kontextusban a $k=2$, $s=2$ average pooling éppen egy ilyen box-szűrő és a ritkítás egylépéses kombinációja; a max pooling nem lineáris aluláteresztő, ezért az anti-aliasing szerepét nem ugyanúgy tölti be.

A szakirodalmi kapcsolat: Zhang 2019 absztraktja szerint a stride-os konvolúciós hálózatokban a downsampling aliasing-ot okozhat, és blur-szűrős pooling javasolható az eltolási invariancia javítására [P03]. A teljes módszerszakasz olvasása folyamatban van; a részletes állításokhoz a cikk PMLR-kiadásának módszertani részét kell majd idézni. Mi itt csak a szűrés előtti leskálázás elvét vizsgáljuk, nem állítjuk a javasolt architektúra általános fölényét.

16.2.5 Global average pooling és információs veszteség

Számos osztályozó architektúra, különösen a későbbi fejezetekben tárgyalt modern CNN-ek esetében, az utolsó konvolúciós feature-térképeket global average poolinggal (GAP) redukálja. A GAP lényegében egyetlen ablak az egész térbeli dimenzióra:

$$Y[n,c]=\frac{1}{H W}\sum_{p=0}^{H-1}\sum_{q=0}^{W-1} X[n,c,p,q],$$

a kimenet alakja $N\times C$ vagy $N\times C\times1\times1$, attól függően, hogy a könyvtár megőrzi-e a térbeli szingleton dimenziókat. A GAP a teljes térbeli rácsot egyetlen aggregátummá sűríti, ezért explicit térbeli invarianciát ad: minden olyan permutáció, amely az intenzitásokat a képen belül átrendezi, ugyanazt a GAP-kimenetet adja. Ez erősebb, mint az eltolási invariancia, és egyben mutatja, mekkora árat fizetünk: minden térbeli szerkezet elvész.

Ezt az információs veszteséget pontosan ki tudjuk mondani a nem injektivitás nyelvén.

3. definíció (információs veszteség). Egy $F:\mathcal X\to\mathcal Y$ leképezés akkor nem injektív, ha létezik $X_1\ne X_2$ az $\mathcal X$-ből úgy, hogy $F(X_1)=F(X_2)$. Ekkor a kimenet önmagában nem teszi lehetővé $X_1$ és $X_2$ megkülönböztetését; a leképezésnek nincs balinverze.

Lemma (a pooling nem injektív). Legyen $k\ge2$, és tekintsük az egyablakos $P_{\max}:\mathbb R^k\to\mathbb R$, illetve $P_{\text{avg}}:\mathbb R^k\to\mathbb R$ leképezéseket. Mindkettő nem injektív.

Bizonyítás. $P_{\max}$ esetén $P_{\max}(0,1,1,\ldots,1)=1=P_{\max}(1,1,0,1,\ldots,1)$, miközben a bemenetek különböznek, ha $k\ge2$. $P_{\text{avg}}$ esetén ugyanaz az összeg többféleképpen is előállítható: $P_{\text{avg}}(1,0,0,\ldots,0)=\frac1k=P_{\text{avg}}(0,1,0,\ldots,0)$, és $k\ge2$ miatt a két bemenet különböző. ∎

A max pooling egy további, specifikus veszteséget is okoz: az ablakból csak a legnagyobb értéket tartja meg, a maximális pozíciót és az összes többi értéket eldobja. A backpropagation során — lásd a 15.2. Inputgradiens és átfedő recepciós mezők scattering-add fogalmát — a gradiens csak a maximum pozíciójába folyik tovább, az ablak többi eleme zéró gradienst kap. Az átlag pooling ezzel szemben a lokális zajcsökkentést valósítja meg, mert az átlag varianciája kisebb, mint az egyes elemeké, de a kontrasztos finom struktúrát ugyanúgy elmossa.

16.2.6 Kézi számpélda

Vegyük a $(H,W)=(4,4)$ bemenetet, $N=1$, $C=1$:

$$X= \begin{bmatrix} 1&0&2&1\\ 0&3&2&0\\ 0&0&4&0\\ 1&0&0&1 \end{bmatrix}.$$

$k_h=k_w=2$, $s_h=s_w=2$ maxpooling esetén a kimenet $2\times2$:

• bal felső ablak $\{1,0,0,3\}$, maximum $3$;
• jobb felső ablak $\{2,1,2,0\}$, maximum $2$;
• bal alsó ablak $\{0,0,1,0\}$, maximum $1$;
• jobb alsó ablak $\{4,0,0,1\}$, maximum $4$.

Tehát

$$Y=\begin{bmatrix}3&2\\1&4\end{bmatrix}.$$

Ugyanezzel az ablakkal average pooling esetén:

• bal felső átlag $(1+0+0+3)/4=1$;
• jobb felső $(2+1+2+0)/4=1{,}25$;
• bal alsó $(0+0+1+0)/4=0{,}25$;
• jobb alsó $(4+0+0+1)/4=1{,}25$.

$$Y_{\mathrm{avg}}=\begin{bmatrix}1&1{,}25\\0{,}25&1{,}25\end{bmatrix}.$$

Vegyük most az egypixeles vízszintes eltolást a belső tartományon, zéró határral: $T_1X$ negyedik sora $[0,1,0,0]$ lesz, a harmadik $[0,0,0,4]$, és így tovább. A maxpooling kimenete:

• bal felső ablak $\{0,1,0,0\}$ → $1$;
• jobb felső ablak $\{0,2,0,0\}$? A második sor $[0,3,2,0]$ jobbra tolódik $[0,0,3,2]$, tehát a jobb felső ablak $\{0,2,3,2\}$ → $3$;
• bal alsó $\{0,0,0,1\}$ → $1$;
• jobb alsó $\{0,4,0,0\}$? A harmadik sor $[0,0,0,4]$; a jobb alsó ablak $\{0,4,0,0\}$ → $4$.

Az eredmény $\begin{bmatrix}1&3\\1&4\end{bmatrix}$, amely nem az eredeti $\begin{bmatrix}3&2\\1&4\end{bmatrix}$ semmilyen kimeneti eltolása. Az egypixeles eltolás tehát nem konzisztens kimeneti eltolásként jelenik meg, hanem az ablakhatárokon átrendezi a maximumokat.

16.2.7 Minimális NumPy kód és jelölt kimenet

A következő kód a kézi példa műveletét adja meg NCHW bemenetre, padding és dilation nélkül, float32 pontossággal. A kimenet itt számított példa; futtatás előtt a laborban ellenőrizze.

# munkakönyvtár: lab/
# fájl: pooling_reference.py
import numpy as np

def max_pool2d(X: np.ndarray, k: tuple[int, int], s: tuple[int, int]) -> np.ndarray:
    """NCHW max pooling, zero padding nélkül, teljes ablakokkal.

    X: float32, alak (N, C, H, W).
    k, s: (kh, kw), (sh, sw) pozitív egészek.
    """
    N, C, H, W = X.shape
    kh, kw = k
    sh, sw = s
    Ho = (H - kh) // sh + 1
    Wo = (W - kw) // sw + 1
    Y = np.empty((N, C, Ho, Wo), dtype=np.float32)
    for i in range(Ho):
        for j in range(Wo):
            patch = X[:, :, i*sh:i*sh+kh, j*sw:j*sw+kw]
            Y[:, :, i, j] = patch.max(axis=(2, 3))
    return Y

# kézi példa
X = np.array([[[
    [1,0,2,1],
    [0,3,2,0],
    [0,0,4,0],
    [1,0,0,1]
]]], dtype=np.float32)
Y = max_pool2d(X, (2,2), (2,2))
# várt: [[[[3,2],[1,4]]]]
print(Y.shape, Y.tolist())
# (1, 1, 2, 2) [[[[3.0, 2.0], [1.0, 4.0]]]]

A stride feltétel ellenőrzése: ha $(H-k)\bmod s\ne0$, a kód az utolsó nem teljes ablakot dobja el, tehát a floor-képlet érvényes. A PyTorch nn.MaxPool2d(kernel_size=2, stride=2) ugyanezt az alakot adja, és a 12.2. Checkpoint és folytathatóság checkpoint-megfontolásokhoz hasonlóan a modell a paramétereit itt nem tárolja, mert nincs tanulható súlya.

16.2.8 Labor: sakktábla- és sávos jel szűrés előtti/utáni leskálázással

A labor célja az aliasing szemléltetése. A megfigyelési egység egyetlen szintetikus kép; az eredmény itt számított várható érték, nem futtatott mérés. Az állítások csak a konkrét bemenetre vonatkoznak.

Bemenet. Két $8\times8$-as jel, $N=1,C=1$, $[0,1]$ tartományban, float32:

1. sakktábla: $C_1[i,j]=(i+j)\bmod2$;
2. sávos jel: $S_1[i,j]=1$, ha $i\bmod4<2$, egyébként $0$ (2 pixel széles vízszintes sávok 4 pixel periódussal).

Protokoll. Három műveletet hasonlítunk össze:

• 1. közvetlen leskálázás $2\times2$ maxpooling, stride 2;
• 2. közvetlen leskálázás $2\times2$ average pooling, stride 2;
• 3. anti-aliasing szűrés: először $2\times2$ box-szűrő stride 1-gyel, majd a felezett $7\times7$ rácsból minden második pixel vétele (stride 2, szűrés utáni leskálázás).

Várt számított kimenetek.

A sakktáblánál: a $2\times2$ ablak mindig két $0$-t és két $1$-et tartalmaz, a maxpooling ezért minden ablakban $1$-et, az average pooling minden ablakban $0{,}5$-öt ad. A (b) művelet kimenete konstans $0{,}5$. A (c) művelet a box-szűrő után a belső $7\times7$ rácson $0{,}5$-öt ad a $\pm1$ koordináták kivételével, és a ritkított mintavétel a fázistól függ: ha a mintavételi rács a páros-páros pixeleket veszi, a kimenet konstans $0{,}5$; ha a páratlan-páratlan fázist, a határmenti $\tfrac14,\tfrac34$ értékek jelennek meg. A két fázis közötti különbség mutatja, hogy a filterezés önmagában nem szünteti meg teljesen a fázisfüggést, de a kontrasztos ugrást tompítja.

A sávos jelnél a maxpooling (a) kimenete az éles $0/1$ mintázatot őrzi, mert minden $2\times2$ ablak tartalmaz sávot; az average pooling (b) szintén $0{,}5$ vagy $1$, a sáv fázisától függően. A (c) lépés a box-szűrés miatt először átmeneti $\tfrac14,\tfrac34$ értékeket ad a sávhatáron, és a leskálázás utáni kimenet simább, kevésbé fázisfüggő átmeneteket mutat.

Értelmezés. A maxpooling nem simít, ezért az éles magas frekvenciájú tartalmakat a leskálázás után is élesen, de a fázistól erősen függő módon őrzi. Az average pooling a lokális átlaggal alulátereszt, de ha a stride $2$-vel vétel történik, a simítás és a mintavétel egyszerre történik; a (c) változatban a simítás a ritkítás előtt önálló lépés. A különbség a sávhatárokon és a sakktábla-fázisokban látszik.

Részlet a laborból futtatható parancsként:

cd lab && python -c "
import numpy as np
C = ((np.indices((8,8)).sum(0))%2).astype('float32')[None,None]
# (c) egyszerű box-szűrő, stride 1, majd minden 2. pixel
sh = (C[:,:, :-1, :-1] + C[:,:,1:, :-1] + C[:,:, :-1,1:] + C[:,:,1:,1:])/4
out = sh[:,:, ::2, ::2]
print(out.shape, out[0,0].tolist())
"

Ügyeljen az np.indices használatára: az np.indices((8,8)).sum(0) a sakktáblát adja. A futtatás seedet nem igényel, mert nincs véletlen szám; a dtype float32, a device CPU. GPU igénybevétele nem szükséges, és kis példánkban a belső memóriavezérlés helyett a célszerű megjelenítés a cél.

16.2.9 Gyakori tévedés: a maxpool mint univerzális robusztussági garancia

Gyakran hallani, hogy a maxpooling „érzéketlenné tesz a kis eltolásokra”. Ez az állítás túl erős, és az előző lemmában szereplő ellenpélda cáfolja. A maxpooling csak lokálisan, az ablakon belül érzéketlen az értékek permutációjára; egyetlen pixeles eltolás esetén egy $k=2$ ablak esetén a maximum pozíciója az ablakon belül is megváltozhat, és a kimenet ugrik. A 16.1. Eltolási equivariance és invariance terminológiájával élve: az invariancia nem következik a max műveletből, legfeljebb részcsoport-szintű equivariance vagy közelítő invariancia. Zhang 2019 absztraktja is felhívja a figyelmet arra, hogy a modern hálózatok downsampling-műveletei nem feltétlenül eltolás-invariánsak [P03]. A teljes módszer ellenőrzése azonban még nyitott.

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

Ellenőrizze, hogy meg tudja-e válaszolni a következőket. (1) Mi a különbség az $s=1$ és $s=2$ pooling között a kimeneti rács sűrűségét tekintve? (2) Miért nem létezik rögzített kimeneti eltolás az egypixeles bemeneti eltolásra a $k=2,s=2$ maxpoolingnál? (3) Mi az anti-aliasing lépés célja a downsampling előtt? (4) Miért nem injektív a maxpooling, és miért releváns ez a reprezentációs veszteségre?

Visszahívás a 15.2. Inputgradiens és átfedő recepciós mezők egységből: a konvolúciós inputgradiensben az átfedő patch-ek hozzájárulásait scatter-add formában kellett összegezni. A maxpooling backward ezzel szemben nem szór vissza minden ablakpixelbe, csak a maximum pozíciójába, ezért az átfedés esetén más gradienssűrűséget kapunk. A 4.2. Parciális derivált és gradiens egység gradiensfogalma itt akkor válik majd fontossá, amikor a tanítható hálózatban a pooling rétegen keresztül visszavezetjük a veszteséget.

16.2.11 Rövid összefoglaló

A pooling réteg két funkciót ötvöz: lokális aggregációt és stride-os mintavétel-csökkentést. Az aggregáció $s=1$ esetén megőrzi a bemeneti rács sűrűségét; a stride $s>1$ esetén ritkább kimeneti rácsra térünk át. A bizonyított ellenpélda szerint a $k=2,s=2$ maxpoolingra nincs rögzített kimeneti eltolás, amely az egypixeles bemeneti eltolást konzisztensen reprezentálná, mert az ablakon belüli pozíció elvész. A downsampling ezért aliasing-fázisfüggőséget okozhat; az aluláteresztő szűrés a ritkítás előtt csökkenti ezt. A global average pooling teljes térbeli invarianciát ad, de nem injektív, tehát a finom szerkezetet eltünteti.

16.2.12 Következő alkalmazás

A 16.3. Elméleti és effektív recepciós mező egységben a recepciós mezőt általánosítjuk: a pooling ablakai és stride-jai a konvolúciós rétegek recepciós mezőjét nyújtják meg, ezért az itt tárgyalt rácssűrűség-csökkenést a többrétegű architektúrákban is el kell tudni számolni.

16.2.13 Feladatok

F1 (fogalmi, nehézség 1). Magyarázza el, miért nem nevezhető a $k=2$, $s=1$ average pooling downsamplingnak, és miért nevezhető annak a $k=2$, $s=2$ average pooling. Adja meg mindkettő kimeneti alakját egy $6\times6$-os bemenetre.

F2 (levezetési, nehézség 2). Bizonyítsa be a maxpooling nem injektivitásáról szóló lemmát $k=2$-re úgy, hogy két konkrét vektort ad meg, amelyek képe azonos. Adjon hasonló bizonyítást az average poolingra is.

F3 (implementációs, nehézség 2). Írjon NumPy függvényt NCHW average poolingra, kernel és stride támogatással, teljes ablakokkal; ellenőrizze a $2\times2$, stride 2 műveletet a fejezet kézi példáján, és egy $H=W=5$, $k=2$, $s=1$ esetet. Tegye lehetővé a global average pooling is a teljes térbeli méret megadásával.

F4 (hibakeresési, nehézség 2). A következő sor hibás: Y[...] = patch.sum(axis=(2,3)) / (kh + kw) átlagpooling kiszámításához. Mi a hiba oka, mi a következménye, és hogyan javítja ki? Ellenőrizze a kézi példán, hogy a $k_h=k_w=2$ eset valóban $\tfrac12$-szeres értéket ad.

F5 (kísérleti/transzfer, nehézség 3). Tervezzen GlyphLab-alapú kísérletet, amely összehasonlítja a max- és average pooling hatását egy kicsi CNN osztályozási pontosságára a clean és corrupt teszten. Ne feltételezze, hogy az egyik győz; adja meg a megfigyelési egységet, a splitet, a baseline-t, a változó tényezőt, a metrikát és egy érvényességi korlátot.

16.2.14 Megoldások és indoklás

F1. A $k=2,s=1$ average pooling esetén a kimeneti rács $6-2+1=5$, tehát a térbeli felbontás majdnem megmarad, a kimenet $5\times5$. A leképezés csak lokális aggregációt végez, nincs ritkítás. A $k=2,s=2$ average pooling kimeneti mérete $\lfloor(6-2)/2\rfloor+1=3$, a rács feleződik, ezért downsampling. Mindkettő kimeneti alakja $N\times C\times H_{out}\times W_{out}$.

F2. A maxpoolingra $k=2$: $P_{\max}(0,1)=1$ és $P_{\max}(1,0)=1$, de $(0,1)\ne(1,0)$, tehát nem injektív. Average poolingra: $P_{\text{avg}}(1,0)=\tfrac12=P_{\text{avg}}(0,1)$, a bemenetek különböznek, a kép azonos. A lemma érvényes.

F3. Egy megoldás:

def avg_pool2d(X, k, s):
    N,C,H,W = X.shape; kh,kw = k; sh,sw = s
    Ho = (H - kh)//sh + 1; Wo = (W - kw)//sw + 1
    Y = np.empty((N,C,Ho,Wo), dtype=X.dtype)
    for i in range(Ho):
        for j in range(Wo):
            patch = X[:, :, i*sh:i*sh+kh, j*sw:j*sw+kw]
            Y[:, :, i, j] = patch.mean(axis=(2,3))
    return Y

A kézi példán a várt mátrix $\begin{bmatrix}1&1.25\\0.25&1.25\end{bmatrix}$, a tolerancia float32 esetén $\le 10^{-6}$ abszolút. A $5\times5$, $k=2,s=1$ esetben a kimenet $4\times4$ lesz, és a GAP-hoz $k=(H,W), s=(1,1)$ használandó.

F4. A hiba oka a nevező: az átlag az ablak elemszámának $k_h k_w$, nem $k_h+k_w$ osztóval történik. A $2\times2$ ablakban a nevező $2+2=4$ valójában egybeesne $2\cdot2=4$-gyel, ezért csak $k_h\ne k_w$, például $k_h=3,k_w=2$ esetben okoz torzítást: a helyes nevező 6, a hibás 5. Következmény: az átlag érték tévesen nagyobb lesz, a kimenet eltolódik. Javítás: / (kh * kw). Ellenőrzés a fejezet számpéldáján: a bal felső ablak összege 4, a helyes átlag 1, a hibás kód $\tfrac4{4}=1$ itt nem mutatja a hibát; válasszon $k_h=3,k_w=2$ ablakot, ahol az összeg 5, a helyes átlag $\tfrac56\approx0.833$, a hibás $\tfrac55=1$.

F5. Egy lehetséges terv. Kérdés: változik-e a clean és corrupt teszten mért accuracy, ha a fix konvolúciós törzs utáni pooling max vagy average? Megfigyelési egység: GlyphLab scene_id; a train/val/test a szerződés szerinti jelenetes split. Baseline: ugyanaz a kétkonvolúciós kis CNN, ReLU aktiváció, egyetlen pooling stratégia, záró global average és lineáris fej. Változó tényező: max- vagy average pooling $2\times2$, stride 2. Protokoll: rögzített seed 20261020, float32 CPU, a legjobb checkpoint kiválasztása val loss alapján, a test és corrupt test páros scene_id szerinti kiértékelése. Metrika: per-image accuracy és a clean–corrupt páros csökkenés. Érvényességi korlát: az adat szintetikus, az eredmény nem általánosítható természetes képekre; egy seed nem elegendő a szóráshoz. Előre rögzített győztest nem állítunk; a negatív eredmény is rögzítendő.

16.2.15 Források

• [P28] C. E. Shannon (1949). Communication in the Presence of Noise. Proceedings of the I.R.E., 37(1), 10–21. doi:10.1109/JRPROC.1949.232969. A mintavételi tétel: II. szakasz, Theorem 1, 11. o. (a szakaszt a forrás szkennelt példányán ellenőriztük).
• [S01] Stanford CS231n (n.d.). Convolutional Neural Networks. https://cs231n.github.io/convolutional-networks/.
• [P03] R. Zhang (2019). Making Convolutional Networks Shift-Invariant Again. PMLR 97:7324–7334. https://proceedings.mlr.press/v97/zhang19a.html.