18.3 Pre-activation, kis batch és alternatív normalizálás

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

A 18.2. Batch normalization train és eval módban egységben tisztáztuk, hogy a BatchNorm2d train módban batchstatisztikát, eval módban futó buffert használ. Itt azt vizsgáljuk, hogy a normalizáló réteg mely tengelyeken aggregál, és ez hogyan hat a batchfüggésre. Az előismeret a következő: a normalizálás képlete, a train/eval különbség, valamint a 14.3. Paraméterszám, MAC és aktivációmemória alfejezetből ismert tenzoralakok és paraméterszámok, a 17.3. VGG és kis kernelek kompozíciója alfejezetből a mély, kis kernelű blokkok szerkezete, a 6.3. Sztochasztikus és minibatch gradiens alfejezetből pedig a minibatchstatisztika zajossága.

Induló kérdés: egyetlen, $N=1$ méretű batch esetén milyen statisztikát számol a BatchNorm, a LayerNorm és a GroupNorm? A becslésed rögzítése után ellenőrizzük a definíciókból.

18.3.2 A normalizáló réteg közös váza és a három tengelyválasztás

Legyen a bemenet $X\in\mathbb R^{N\times C\times H\times W}$, ahol $N$ a batch, $C$ a csatorna, $H$ és $W$ a térbeli kiterjedés. Egy normalizáló réteg minden megfigyeléshez kiválaszt egy $\mathcal A$ indexhalmazt, és azon számol átlagot és torzított varianciát:

$$\mu_{\mathcal A}=\frac{1}{|\mathcal A|}\sum_{a\in\mathcal A}x_a,\qquad \sigma_{\mathcal A}^2=\frac{1}{|\mathcal A|}\sum_{a\in\mathcal A}(x_a-\mu_{\mathcal A})^2,$$

majd a normalizált értéket $\hat x_a=(x_a-\mu_{\mathcal A})/\sqrt{\sigma_{\mathcal A}^2+\epsilon}$ és az affin kimenetet $y_a=\gamma_{\mathcal C}\,x_a+\beta_{\mathcal C}$ módon számolja. A $\gamma$ és $\beta$ alakja a rétegtípustól függ; az $\epsilon>0$ a nullához közeli variancia elleni numerikus védelem. A PyTorch megvalósítás mindhárom alábbi rétegnél torzított, $1/|\mathcal A|$ nevezőjű varianciát használ, ahogy azt a [D12] dokumentáció is rögzíti a BatchNorm2d esetén.

BatchNorm2d. A normalizálás minden $c$ csatornára külön-külön az $n,h,w$ indexek felett történik, azaz $\mathcal A_c=\{0,\ldots,N-1\}\times\{0,\ldots,H-1\}\times\{0,\ldots,W-1\}$. A tanulható paraméterek alakja $(C,)$. Train módban a batchstatisztika egyben frissíti a futó $\mu_{run},\sigma^2_{run}$ buffert; eval módban ezt használja, így az inference nem függ a batch összetételétől.

LayerNorm normalizált alakkal $[C,H,W]$. Itt minden egyes $n$ mintára a $c,h,w$ indexek felett számolunk, azaz $\mathcal A_n=\{0,\ldots,C-1\}\times\{0,\ldots,H-1\}\times\{0,\ldots,W-1\}$. A normalizált alak egy mintára terjed ki, ezért az $N$ batchdimenzió nem része a statisztikának. A PyTorch LayerNorm(normalized_shape=[C,H,W]) esetén a $\gamma,\beta$ paraméterek alakja szintén $(C,H,W)$; nincs futó állapot. Az inference ezért mindig bemenetfüggő, de mintánként független: az $n$-edik sor kimenetét nem befolyásolja, mi van még a batchben.

GroupNorm. A csatornákat $G$ darab azonos méretű csoportra osztjuk; ehhez $C/G$ egész kell. A $g$-edik csoport csatornahalmaza legyen $C_g$, mérete $|C_g|=C/G$. Egy rögzített $(n,g)$ párra a

$$\mu_{n,g}=\frac{1}{|C_g|HW}\sum_{c\in C_g}\sum_{h,w}X_{n,c,h,w}$$

átlagot és a hozzá tartozó torzított varianciát számoljuk, majd az $X_{n,c,h,w}$ elemeket ezzel normalizáljuk. A $\gamma,\beta$ paraméterek alakja $(C,)$; nincs futó állapot. A $G=1$ választás egy mintára LayerNorm jellegű normalizálást ad, a $G=C$ választás pedig csatornánkénti, térbeli normalizálást.

A különböző rétegek nem ugyanazt a statisztikát normalizálják, és ezt a tengelyválasztás rögzíti.

Ez a táblázat a levezetési kötelezettség magja: a réteg viselkedése abból következik, hogy a fenti indexhalmazok mely dimenziókat fogják össze. A BatchNorm az $N$ dimenziót használja, ezért train módban a batchfüggés beépül; a LayerNorm és GroupNorm az $N$ dimenziót nem aggregálja, ezért egy minta kimenete más mintáktól független marad.

18.3.3 Pre-activation és post-activation reziduális blokk

A [P06] forrás olvasott 3.1–3.2 szakasza szerint a reziduális blokk rövidített definíciója $y=\mathcal F(x)+x$; az eredeti elrendezésben a főág kimenetéhez adjuk a shortcutot, és az összeg után még egy ReLU áll. Ezt poszt-aktivációs formának nevezzük, mert az utolsó nemlinearitás a shortcut hozzáadása után következik.

A pre-aktivációs elrendezés ezzel szemben a normalizálást és a ReLU-t a konvolúció elé helyezi, és az összegzés után már nincs további ReLU. Egy két konvolúciós, csatornaszám-tartó blokk sematikus definíciója:

$$ y=x+W_2\,\mathrm{ReLU}\Bigl(\mathrm{BN}\bigl(W_1\,\mathrm{ReLU}(\mathrm{BN}(x))\bigr)\Bigr), $$

ahol $W_1,W_2$ a konvolúciós rétegek, és a bias a BatchNorm jelenléte miatt tipikusan elhagyható. A fontos különbség nem pusztán esztétikai: a poszt-aktivációs formában a BatchNorm a konvolúció után, az összegzés előtt normalizál, a pre-aktivációs formában viszont a normalizálás és a nemlinearitás a következő konvolúció bemenetét készíti elő, és az identitás shortcut közvetlenül, normalizálatlanul csatlakozik az összeghez.

Ebből a szerkezetből azonban nem következik automatikus konvergencia- vagy általánosítási garancia. Mind P06, mind a pre-aktivációs változatoknál az elrendezés előnye empirikus architektúraállítás; a matematikailag bizonyítható rész csak az, amit az operátorok definíciójából levezetünk. A [P07] absztraktja az internal covariate shift csökkentését nevezi meg motivációként, a [P08] absztraktja pedig az optimalizálási táj kedvezőbbé válását hangsúlyozza; e két állítás különböző szakirodalmi igény, és egyik sem olvasott teljes bizonyítás ebben az egységben. A jelen alfejezet csak a normalizálási statisztika és a batchfüggés pontos leírására vállalkozik.

18.3.4 Eredeti kézi kis példa

Legyen $X\in\mathbb R^{2\times2\times1\times2}$, azaz két minta, két csatorna, egy sor és két oszlop. A négy csatornamátrix:

$$X_{0,0,:,:}=[1,3],\quad X_{0,1,:,:}=[5,7],\quad X_{1,0,:,:}=[-3,-1],\quad X_{1,1,:,:}=[-7,-5].$$

A kézzel levezetett idealizált esetben vegyünk $\epsilon=0$, $\gamma=1$, $\beta=0$ értékeket, így a normalizált érték a tiszta standardizálás. A futtatott PyTorch-rétegekhez később pozitív $\epsilon$ értéket adunk: a kézi számolás ezért a numerikus kimenet jó közelítése, de nem bitpontos kódpredikció.

BatchNorm2d. A $c=0$ csatornán a négy érték $1,3,-3,-1$, átlaga $0$, torzított varianciája $(1^2+3^2+(-3)^2+(-1)^2)/4=20/4=5$. A normalizált értékek:

$$[1/\sqrt5,\;3/\sqrt5,\;-3/\sqrt5,\;-1/\sqrt5].$$

A $c=1$ csatornán az értékek $5,7,-7,-5$, átlaga $0$, varianciája $(25+49+49+25)/4=148/4=37$, így a normalizált értékek:

$$[5/\sqrt{37},\;7/\sqrt{37},\;-7/\sqrt{37},\;-5/\sqrt{37}].$$

LayerNorm $[C,H,W]$. A $0$-adik minta négy értéke $1,3,5,7$, átlaga $4$, varianciája $((1-4)^2+(3-4)^2+(5-4)^2+(7-4)^2)/4=20/4=5$. A normalizált minta:

$$[-3/\sqrt5,\;-1/\sqrt5,\;1/\sqrt5,\;3/\sqrt5].$$

Az $1$-es minta értékei $-3,-1,-7,-5$, átlaga $-4$, varianciája szintén $5$, normalizált alakja:

$$[1/\sqrt5,\;3/\sqrt5,\;-3/\sqrt5,\;-1/\sqrt5].$$

A két réteg kimenete már ebből a kis példából láthatóan nem azonos, mert a BatchNorm a batch mentén, a LayerNorm az egyes mintákon belül aggregál.

Szélsőeset. $N=1$ és $H=W=1$ esetén a BatchNorm egy csatornára egyetlen értékkel rendelkezik, így a normalizált érték nulla, és a kimenet $\gamma\cdot0+\beta=\beta$ lesz. Ha viszont $H$ vagy $W$ nagyobb, a BatchNorm $N=1$ esetén is rendelkezik térbeli mintákkal, tehát nem degenerálódik automatikusan.

18.3.5 Minimális kód

Munkakönyvtár: lab/n071. Az alábbi kód a fenti kézi példát ellenőrzi PyTorchban. A gyári $\gamma=1,\beta=0$ inicializálás miatt a normalizált értékeket látjuk.

import torch
import torch.nn as nn

torch.manual_seed(0)

# N=2, C=2, H=1, W=2
x0 = torch.tensor([[[[1.0, 3.0]], [[5.0, 7.0]]]])
x1 = torch.tensor([[[[-3.0, -1.0]], [[-7.0, -5.0]]]])
X = torch.cat([x0, x1], dim=0)

bn = nn.BatchNorm2d(2, eps=1e-5, momentum=0.1)
ln = nn.LayerNorm([2, 1, 2], eps=1e-5)
gn = nn.GroupNorm(1, 2, eps=1e-5)  # G=1: mintánkénti normalizálás

bn.train()
print("BN train:")
print(bn(X))
print("running_mean:", bn.running_mean.tolist())
print("running_var :", bn.running_var.tolist())

ln.eval()
print("LN:")
print(ln(X))

gn.eval()
print("GN, G=1:")
print(gn(X))

# Eval BatchNorm: a running bufferrel normalizál
bn.eval()
print("BN eval, első minta:")
print(bn(X[:1]))

A kézi levezetésből számított kulcspontok: a BN train kimenete a $c=0$ csatornán $[1/\sqrt5,3/\sqrt5,-3/\sqrt5,-1/\sqrt5]$, a $c=1$ csatornán $[5/\sqrt{37},7/\sqrt{37},-7/\sqrt{37},-5/\sqrt{37}]$. A futó puffer az első train forward után $c=0$ esetén $\mu_{run}=0$ és $\sigma^2_{run}=0.9\cdot1+0.1\cdot(20/3)\approx1.5667$, $c=1$ esetén $\sigma^2_{run}=0.9\cdot1+0.1\cdot(148/3)\approx5.8333$. A PyTorch BatchNorm2d a tanítási forward normalizálásához a torzított varianciát, a running_var frissítéséhez viszont a korrigált mintavarianciát használja; emiatt az 5 és 37 közvetlen beírása a pufferfrissítésbe hibás volna. A kézi normalizálás $\epsilon=0$ ideális határesetet használ, a futtatható kód stabilitásból $\epsilon=10^{-5}$-öt, ezért az értékek kis mértékben eltérnek. A LayerNorm és a $G=1$ GroupNorm mintánként a fenti normalizált értékeket adja. A fenti számok a képletből számított várt értékek; a labor tényleges futtatását a hallgató végzi.

18.3.6 Labor: kis batch és egyedi inference összehasonlítása

A labor kérdése: hogyan változik egy rögzített minta kimenete, ha egyedül vagy egy másik mintával egy batchben dolgozzuk fel, BatchNorm és GroupNorm esetén?

Bemenet: determinisztikus $X\in\mathbb R^{2\times8\times4\times4}$, torch.randn seeddel. Két réteg: BatchNorm2d(8, momentum=0.1) és GroupNorm(2, 8). Módok: train, eval. Négy forward mindkét rétegre: teljes batch, majd csak az első minta. Ellenőrzés torch.allclose és a csatornaátlagok összehasonlítása.

import torch
import torch.nn as nn

torch.manual_seed(123)
X = torch.randn(2, 8, 4, 4, dtype=torch.float32)

bn = nn.BatchNorm2d(8, momentum=0.1)
gn = nn.GroupNorm(2, 8)

bn.train(); gn.train()
Y_bn_batch  = bn(X)
Y_bn_single = bn(X[:1])
Y_gn_batch  = gn(X)
Y_gn_single = gn(X[:1])

print("train, batch==single head?",
      torch.allclose(Y_bn_batch[0], Y_bn_single[0], atol=1e-6),
      torch.allclose(Y_gn_batch[0], Y_gn_single[0], atol=1e-6))

bn.eval(); gn.eval()
Y_bn_ev_batch  = bn(X)
Y_bn_ev_single = bn(X[:1])
Y_gn_ev_batch  = gn(X)
Y_gn_ev_single = gn(X[:1])

print("eval, batch==single head?",
      torch.allclose(Y_bn_ev_batch[0], Y_bn_ev_single[0], atol=1e-6),
      torch.allclose(Y_gn_ev_batch[0], Y_gn_ev_single[0], atol=1e-6))

A várt, a tengelyválasztásból következő eredmény: train módban a BatchNorm első mintája a teljes batchben más statisztikát használ, mint az egyedi feldolgozásnál, ezért a két fej nem egyezik. A GroupNorm kimenete viszont mintánként független, így a fejek közel azonosak. Eval módban a BatchNorm a futó buffert használja, ezért a batch- és egyedi feldolgozás feje közel azonos lesz; a GroupNorm eleve batchfüggetlen. A numerikus egyezés toleranciája atol=1e-6 a determinisztikus CPU-s float32 számításra.

Az átadandó eredmény: a futtatott script, a nyomtatott logikai értékek és egy rövid értelmezés, amely megnevezi, hogy a train módbeli BatchNorm-eltérés oka a $\mu,\sigma^2$ batchstatisztika. Ez az állítás a definícióból levezetett tulajdonság, nem mért benchmark; a konkrét futási idő és bitazonosság a helyi környezettől függ.

18.3.7 Feladatok

Az alábbi feladatok mindegyikéhez add meg a bemenetet, a nehézséget és az elvárt átadandó eredményt.

F1 (fogalmi, nehézség 1). Adott $X\in\mathbb R^{2\times4\times3\times3}$. Határozd meg szövegesen, milyen indexhalmaz felett számol átlagot és varianciát a BatchNorm2d, a LayerNorm([4,3,3]) és a GroupNorm(2,4). Add meg mindhárom esetben a normalizált statisztika kiszámításának darabszámát is.

F2 (levezetési, nehézség 2). Legyen $X\in\mathbb R^{1\times2\times1\times2}$ a következő: $X_{0,0,1,2}=[1,3]$ és $X_{0,1,1,2}=[5,7]$. Vezesd le a BatchNorm2d és a LayerNorm $[2,1,2]$ kimenetét $\epsilon=0$, $\gamma=1$, $\beta=0$ mellett. Ellenőrizd, hogy a BatchNorm kimenetén minden csatornán nulla az átlag és egységnyi a torzított variancia, a LayerNorm kimenetén pedig a minta négy elemének átlaga nulla, becsült varianciája egy.

F3 (implementációs, nehézség 2). Készíts PyTorch nn.Module osztályt PreActBlock néven, amely $C$ csatornán $3\times3$-as, padding 1, stride 1 konvolúciókat használ a BN–ReLU–conv sorrenddel, bias nélkül. Az osztály kimenete $x+\mathcal F(x)$. Ellenőrizd a kimeneti alakot $N=2$, $C=3$, $H=W=8$ mellett.

F4 (hibakeresési, nehézség 2). A következő hívás hibát okoz: nn.GroupNorm(2, 2) olyan bemenetre, amelynek csatornaszáma 3. Mi a hiba, mi a következménye, és hogyan javítható úgy, hogy a csatornák száma 3 maradjon? Válaszodban térj ki arra, miért nem oldható meg $G=2$-vel az oszthatóság megsértése nélkül.

F5 (kísérleti transzfer, nehézség 3). Tervezz kísérletet a GlyphLab adaton: hasonlítsd össze ugyanazt a kis CNN-t BatchNorm és GroupNorm normalizálással, miközben a batch méretet 32-ről 4-re csökkented. Add meg a protokollt, a megfigyelési egységet, a baseline-t, a metrikát és a következtetés érvényességi határát. Valós futtatást nem várunk el; a tervnek tartalmaznia kell a seed, split és validációs választás rögzítését.

18.3.8 Megoldások és indoklás

F1 megoldás. A BatchNorm2d minden $c$ csatornára az $N\times H\times W=2\cdot3\cdot3=18$ elemből számol statisztikát, tehát csatornánként egy átlag és egy variancia, összesen $4$ pár. A LayerNorm minden $n$ mintára a $C\times H\times W=4\cdot3\cdot3=36$ elemből számol, tehát $2$ pár. A GroupNorm $G=2$ esetén $C/G=2$ csatorna alkot egy csoportot; minden mintára és csoportra $2\cdot3\cdot3=18$ elem felett aggregál, összesen $N\cdot G=4$ pár. A paraméteres affin transzformáció ezután a normalizált értékekre broadcastolódik.

F2 megoldás. A BatchNorm2d $N=1$ esetén a $H\times W=2$ térbeli elemből számol csatornánként. A $c=0$ csatorna értékei $1,3$, átlaga $2$, torzított varianciája $((1-2)^2+(3-2)^2)/2=1$, normalizált értékek $[-1,1]$. A $c=1$ csatorna értékei $5,7$, átlaga $6$, varianciája $1$, normalizált értékek $[-1,1]$. A BN kimenet tehát $[[[-1,1]],[[-1,1]]]$. A LayerNorm a minta mind a négy értékére $1,3,5,7$ számol: átlag $4$, variancia $(( -3)^2+(-1)^2+1^2+3^2)/4=20/4=5$. A normalizált kimenet $[-3/\sqrt5,-1/\sqrt5,1/\sqrt5,3/\sqrt5]$. Ellenőrzés: a BN csatornaátlagai $0$, a csatornavarianciák $(1+1)/2=1$; az LN négy elemén az átlag $0$, a torzított variancia $(( -3)^2\sqrt5^{-2}+(-1)^2\sqrt5^{-2}+1^2\sqrt5^{-2}+3^2\sqrt5^{-2})/4 = (9+1+1+9)/(4\cdot5)=20/20=1$.

F3 megoldás.

import torch
import torch.nn as nn
import torch.nn.functional as F

class PreActBlock(nn.Module):
    def __init__(self, C):
        super().__init__()
        self.bn1 = nn.BatchNorm2d(C)
        self.conv1 = nn.Conv2d(C, C, 3, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(C)
        self.conv2 = nn.Conv2d(C, C, 3, padding=1, bias=False)

    def forward(self, x):
        out = self.conv1(F.relu(self.bn1(x)))
        out = self.conv2(F.relu(self.bn2(out)))
        return x + out

torch.manual_seed(7)
block = PreActBlock(3)
x = torch.randn(2, 3, 8, 8, dtype=torch.float32)
y = block(x)
print(y.shape)  # Várt: torch.Size([2, 3, 8, 8])

Alakellenőrzés: a BN nem változtat alakot, a ReLU sem, a conv padding 1 és stride 1 mellett megőrzi a $8\times8$ térbeli méretet. Az összegzés csak azonos alakú tenszorokra értelmes, ezért az $x$ és $F(x)$ alakjának egyeznie kell.

F4 megoldás. A GroupNorm(num_groups, num_channels) második argumentuma a várt csatornaszám. Ha a bemenet $C=3$, de a konstruktorban $2$ szerepel, a PyTorch a bemeneti és várt csatornaszám eltérése miatt hibát ad, mert a réteg 2 csatornát feltételez. A num_channels értéket 3-ra kell állítani. A $G=2$ csoportosítás ekkor azért hibás, mert $3/2$ nem egész; a csoportok méretének egyenlőnek kell lennie. A lehetséges javítás: nn.GroupNorm(1, 3) vagy nn.GroupNorm(3, 3). Ellenőrzésképpen egy $X\in\mathbb R^{1\times3\times4\times4}$ forwardnak hiba nélkül kell lefutnia, és a kimenet alakjának meg kell egyeznie a bemenetével.

F5 megoldásminta. Kérdés: a batch méret csökkenése melyik normalizálást érinti jobban? Megfigyelési egység a scene_id, mert a két nézet ugyanahhoz a jelenethez tartozik. A split rögzített: train 240, val 60, test 60 kép. Baseline: kis, azonos mélységű CNN, ugyanaz a random seed, BatchNorm rétegekkel, batch méret 32. Változó tényező: a normalizálás típusa (BN vagy GroupNorm), valamint a batch méret (32 és 4). Metrika: validációs pontosság és a veszteség utolsó 10 epochra vett átlaga. A modellválasztás csak a validációs veszteség alapján történik, a tesztet egyszer, a végleges kiválasztás után értékeljük. Erőforrás: CPU, float32. A következtetés korlátja: a GlyphLab szintetikus, 24×24-es, egycsatornás adat, ezért az eredmény nem általánosítható természetes képekre; továbbá a batch méret és a normalizálás hatása összefonódhat a tanulási ráta érzékenységével, ezért az egyes konfigurációkhoz érdemes rövid tanulásiráta-keresést is rögzíteni.

18.3.9 Tipikus tévedés ellenpéldával

Gyakori tévedés, hogy a BatchNorm, LayerNorm és GroupNorm „ugyanazt a standardizálást végzi, csak más néven”. A fenti $N=2,C=2,H=1,W=2$ példa ezt cáfolja. A BatchNorm a $c=0$ csatornához a batch összes mintáját használja, ezért a $[1,3,-3,-1]$ értékekre normalizál; a LayerNorm a $0$-adik minta $[1,3,5,7]$ értékeire. A kimenetek már a nulladik mintán is különböznek: a BN első eleme $1/\sqrt5$, az LN első eleme $-3/\sqrt5$. A hiba következménye lehet, hogy a felhasználó eval módban a LayerNormtól batchfüggetlen futó statisztikát vár, vagy a BatchNormot egyetlen mintán úgy értelmezi, mint az összes csatorna normalizálását; mindkettő téves tengelyválasztásból fakad.

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

Ellenőrizd, hogy a normalizálási képletben az $\epsilon$ a varianciához adódik, nem a szóráshoz; a variancia torzított; a BN train egyszerre frissíti a futó buffert és használja a batchstatisztikát. A 18.2. Batch normalization train és eval módban alfejezetből visszaidézve a futó buffer momentumos rekursiója $r_{new}=(1-\alpha)r_{old}+\alpha\,\hat r$. A 6.3. Sztochasztikus és minibatch gradiens alfejezetből tudjuk, hogy a minibatchstatisztika a teljes adathoz képest zajos becslő, és ez a normalizáló réteg statisztikájára is vonatkozik. A 14.3. Paraméterszám, MAC és aktivációmemória paraméter- és MAC-számítását finomítja, hogy a BN/GN elemenkénti műveletei nem súly-MAC-ok, de a statisztikaredukció és a normalizálás szintén számítási költséggel jár. A 17.3. VGG és kis kernelek kompozíciója alfejezetben tárgyalt kis kernelű mély stackekben a normalizálás elhelyezése éppen a pre-aktivációs blokk kapcsán válik tervezési döntéssé.

18.3.11 Rövid összefoglaló

A normalizáló rétegek közös vázat használnak, de eltérő tengelyeken aggregálnak. A BatchNorm2d csatornánként a batch és a térbeli pozíciók felett normalizál, tanulható $(C,)$ paraméterekkel és futó bufferekkel; eval módban a buffert használja. A LayerNorm mintánként az összes csatorna és térbeli elem felett normalizál, paramétereinek alakja $(C,H,W)$, nincs futó állapota. A GroupNorm csatornacsoportonként aggregál, $(C,)$ paraméterekkel. A pre-aktivációs blokk a BN–ReLU–conv sorrendet használja, és a shortcutra nem kerül normalizálás; az előnyök azonban empirikus architektúraállítások, nem bizonyított konvergenciagaranciák. A feladatmegoldások és a labor a batchfüggést a tengelyválasztásból vezetik le.

18.3.12 Következő alkalmazás

A 18.4. Reziduális blokk ablatív vizsgálata egységben reziduális blokkok ablatív vizsgálatát végezzük el: ugyanazon a kis GlyphLab-feladaton, rögzített seedekkel mérjük össze a poszt-aktivációs és pre-aktivációs elrendezést, valamint a normalizálás elhagyásának hatását. Ott az itt definiált PreActBlock lesz az egyik változat, és a mérési állításokat kísérleti naplóval, nyers epochonkénti metrikákkal kell alátámasztani.

18.3.13 Felhasznált források

• [P06] He, K., Zhang, X., Ren, S. és Sun, J. (2015, első preprint). Deep Residual Learning for Image Recognition. arXiv:1512.03385. https://arxiv.org/abs/1512.03385.
• [P07] Ioffe, S. és Szegedy, C. (2015). Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. PMLR 37:448–456. https://proceedings.mlr.press/v37/ioffe15.html.
• [P08] Santurkar, S. és mtsai (2018). How Does Batch Normalization Help Optimization? arXiv:1805.11604. https://arxiv.org/abs/1805.11604.
• [D12] PyTorch contributors (2.14). BatchNorm2d. https://docs.pytorch.org/docs/2.14/generated/torch.nn.BatchNorm2d.html.