18.1 Reziduális blokk és identitásút

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

Ez az alfejezet a reziduális blokkot, a mély hálózatok egyik legfontosabb szerkezeti elemét vezeti be. Az előismeret a 11.4. Egy teljes PyTorch tanítási iteráció alfejezetből a teljes tanítási lépés, a 14.4. Csoportos és depthwise konvolúció alfejezetből a csatornák közti kapcsolat korlátozása, a 16.4. IV. ellenőrző pont: a CNN-operátor teljes megértése alfejezetből a CNN-operátor specifikációja, a 17.4. Architektúra összehasonlítása kontrollált keretben alfejezetből pedig a kontrollált architektúra-összehasonlítás fogalma. A korábbi 17.1. LeNet és a lokális megosztott reprezentáció megmutatta, hogy a rétegek egymásra építése önmagában nem feltétlenül hoz jobb eredményt: a mélység növelése új optimalizálási és numerikus nehézségeket teremt. He, Zhang, Ren és Sun P06 3.1–3.2 szakasza a reziduális tanulást olyan blokkal vezeti be, amelyben a háló nem közvetlenül a kívánt leképezést, hanem annak egy eltérését tanulja egy identitásút mellett.

Induló kérdés: ha egy blokk kimenete $y=x+F(x)$, akkor mit tudunk mondani a blokk Jacobi-mátrixáról, és miért nem következik ebből, hogy minden reziduális háló jól kondicionált?

18.1.2 Definíció és intuíció

Legyen a blokk bemenete $x$. A reziduális blokk kimenete

$$y = x + F(x;\theta),$$

ahol $F$ a reziduális leképezés: általában két vagy három konvolúciós réteg, amelyet nemlinearitás és esetleg normalizálás követ, $\theta$ pedig a tanulandó paraméterek összessége. Az $x$-et közvetlenül a kimenethez vezető utat identity shortcutnak vagy identitásútnak nevezzük. Az intuíció az, hogy ha a kívánt blokk kimenet közel van a bemenethez, akkor a hálónak elegendő $F(x)\approx 0$-t tanulnia; a shortcut így egy előre adott, paramétermentes jelölt leképezést biztosít.

A tenzoralakú változatban $x\in\mathbb R^{C_{in}\times H\times W}$, $F(x)\in\mathbb R^{C_{out}\times H_{out}\times W_{out}}$. Az összeadás csak akkor értelmes, ha

$$C_{in}=C_{out},\qquad H=H_{out},\qquad W=W_{out}.$$

Ha a blokk csatornát vált, vagy $s>1$ stride-dal csökkenti a térbeli méretet, akkor a shortcutot is transzformálni kell. A projection shortcut egy $1\times1$-es konvolúcióval,

$$h(x)=W_s x,$$

ahol $W_s\in\mathbb R^{C_{out}\times C_{in}\times 1\times 1}$ és a stride megegyezik a főág stride-jával, így a kimenet

$$y = F(x;\theta) + W_s x.$$

A $W_s$ projekció tehát nem egyszerű dimenziótoldás, hanem tanulható lineáris leképezés, amely a shortcut út és a főág alakját összehangolja a 14.1. Stride, padding, dilation és outputméret alfejezetben levezetett kimeneti méret szerint.

A P06 megkülönbözteti a basic blokkot és a bottleneck blokkot. A basic blokk két $3\times3$-as konvolúcióból áll, változatlan csatornaszámmal. A bottleneck blokk három rétegből épül fel: egy $1\times1$-es konvolúció csökkenti a csatornákat $C$-ről $d$-re, egy $3\times3$-as konvolúció a szűkebb $d$ csatornán dolgozik, majd egy második $1\times1$-es konvolúció visszaállítja a $C$ csatornát. A tipikus $C=256$, $d=64$ választás mellett a paraméterszám bias nélkül:

Összesen $69\,632$ paraméter. Két közvetlen $3\times3$-as konvolúció $256$ csatornán ezzel szemben $2\cdot256\cdot256\cdot9=1\,179\,648$ paramétert igényelne, tehát a bottleneck körülbelül tizenhetedére csökkenti a paraméterszámot, miközben a bemeneti és kimeneti csatornaszám változatlan marad.

18.1.3 A lokális Jacobi-alak levezetése

A központi állítást absztrakt vektoros formában mondjuk ki. Legyen $x\in\mathbb R^d$ a blokk bemenete, $F:\mathbb R^d\to\mathbb R^d$ a reziduális leképezés, és $y=x+F(x)$.

Lemma (lokális Jacobi-alak). Ha $F$ differenciálható az $x$ pontban, akkor a $G(x)=x+F(x)$ leképezés Jacobi-mátrixa ugyanabban a pontban

$$J_G(x) = I_d + J_F(x),$$

ahol $I_d\in\mathbb R^{d\times d}$ az egységmátrix, $J_F(x)\in\mathbb R^{d\times d}$ pedig $F$ Jacobi-mátrixa a könyv 4.3. Jacobi-mátrix, láncszabály és VJP konvenciója szerint: a $J_F$ $i$. sora és $j$. oszlopa $\partial F_i/\partial x_j$.

Bizonyítás. A $G$ leképezés $i$. koordinátája $G_i(x)=x_i+F_i(x)$. A parciális deriváltra minden $i,j\in\{1,\dots,d\}$ esetén

$$\frac{\partial G_i}{\partial x_j} = \frac{\partial x_i}{\partial x_j} + \frac{\partial F_i}{\partial x_j} = \delta_{ij} + \frac{\partial F_i}{\partial x_j},$$

ahol $\delta_{ij}=1$, ha $i=j$, egyébként $0$. A jobb oldal első tagja az $I_d$ egységmátrix $(i,j)$ eleme, a második pedig a $J_F(x)$ mátrix $(i,j)$ eleme. Ezzel a mátrixegyenlőséget koordinátánként beláttuk. ∎

A lemma következménye a visszaterjesztésre: ha a blokk kimenetére érkező upstream gradiens $g=\nabla_y L$, akkor a VJP-szabály szerint

$$\nabla_x L = J_G(x)^\top g = (I_d+J_F(x))^\top g = g + J_F(x)^\top g.$$

Az első tag, $g$, változatlanul átfolyik az identitásúton; a második tag a paraméterezett $F$ ágon keresztül visszaterjesztett gradiens. Ez a felbontás az, amit a szakirodalom gyakran „a gradiens az identitásúton is eljut a korábbi rétegekhez” formában említ.

Miért nem garantál ez minden hálón jó kondicionáltságot? A fenti lemma lokális állítás: egyetlen $x$ pontban írja le a blokk Jacobi-mátrixát. Egy mátrix kondíciószámát 2-es spektrális normában a $\kappa_2(M)=\sigma_{\max}(M)/\sigma_{\min}(M)$ hányados adja. Az $I_d+J_F(x)$ mátrix kondíciószáma tetszőlegesen nagy lehet, mert $J_F(x)$ sajátértékei a tanulás során közel kerülhetnek $-1$-hez. Szélsőséges lineáris ellenpéldaként legyen $F(x)=-x$; ekkor $y=0$, és

$$J_G(x)=I_d+(-I_d)=0.$$

A Jacobi-mátrix szinguláris, a kondíciószám végtelen, annak ellenére, hogy a shortcut jelen van. A lineáris esetben persze $\kappa_2(I_d+A)$ korlátos marad, ha $A$ sajátértékei elkerülik a $-1$-et, de a nemlineáris $F$ Jacobi-mátrixa pontról pontra változik, ezért egyetlen pontban számított kondíciószám nem ad globális korlátot a teljes tanítási pályára.

Mély háló esetén a láncszabály tovább nehezíti a helyzetet. Ha a háló $L$ blokk kompozíciója, $G=G_L\circ\cdots\circ G_1$, ahol $G_k(x_k)=x_k+F_k(x_k)$, akkor

$$J_G(x) = \prod_{k=1}^{L} \left(I_d+J_{F_k}(x_k)\right),$$

ahol $x_k$ a $k$. blokk bemenete. Még ha minden egyes tényező adott pontban jól kondicionált is, a szorzat spektruma elfajulhat. Ha például minden tényező $0{,}5I_d$, akkor a szorzat $2^{-L}I_d$: a kondíciószáma ugyan 1, de a gradiens normája exponenciálisan csillapodik. A skip tehát nem tünteti el a főág okozta csillapítást, csak hozzáad egy plusz utat. A P06 kísérleti javulást mutat, nem pedig kondicionáltsági vagy globális konvergenciatételt; az állítás típusa empirikus eredmény, nem matematikai garancia.

18.1.4 Kézi számpélda

Legyen a bemenet és a reziduális leképezés lineáris:

$$x=\begin{bmatrix}3\\-1\end{bmatrix},\qquad F(x)=Ax+b,\qquad A=\begin{bmatrix}0{,}5 & 0{,}2\\0{,}1 & -0{,}3\end{bmatrix},\qquad b=\begin{bmatrix}0{,}1\\0{,}2\end{bmatrix}.$$

Először a reziduális ág:

$$F(x)= \begin{bmatrix}0{,}5\cdot 3+0{,}2\cdot(-1)\\0{,}1\cdot 3-0{,}3\cdot(-1)\end{bmatrix} + \begin{bmatrix}0{,}1\\0{,}2\end{bmatrix} = \begin{bmatrix}1{,}3\\0{,}6\end{bmatrix} + \begin{bmatrix}0{,}1\\0{,}2\end{bmatrix} = \begin{bmatrix}1{,}4\\0{,}8\end{bmatrix}.$$

A blokk kimenete

$$y=x+F(x)= \begin{bmatrix}3\\-1\end{bmatrix} + \begin{bmatrix}1{,}4\\0{,}8\end{bmatrix} = \begin{bmatrix}4{,}4\\-0{,}2\end{bmatrix}.$$

A Jacobi-mátrix a lemma szerint

$$J_G(x)=I_2+A= \begin{bmatrix}1 & 0\\0 & 1\end{bmatrix} + \begin{bmatrix}0{,}5 & 0{,}2\\0{,}1 & -0{,}3\end{bmatrix} = \begin{bmatrix}1{,}5 & 0{,}2\\0{,}1 & 0{,}7\end{bmatrix}.$$

Ellenőrzésképpen a $g=(1,2)^\top$ upstream gradienssel a VJP:

$$\nabla_x L = J_G(x)^\top g = \begin{bmatrix}1{,}5 & 0{,}1\\0{,}2 & 0{,}7\end{bmatrix} \begin{bmatrix}1\\2\end{bmatrix} = \begin{bmatrix}1{,}7\\1{,}6\end{bmatrix}.$$

Ugyanez a felbontásból: az identitásút $g=(1,2)^\top$-t ad, a reziduális út pedig

$$A^\top g= \begin{bmatrix}0{,}5 & 0{,}1\\0{,}2 & -0{,}3\end{bmatrix} \begin{bmatrix}1\\2\end{bmatrix} = \begin{bmatrix}0{,}7\\-0{,}4\end{bmatrix},$$

és $(1,2)^\top+(0{,}7,-0{,}4)^\top=(1{,}7,1{,}6)^\top$, egyezésben a direkt számolással.

18.1.5 Labor: kis reziduális blokk

A labor a skip mechanizmust izolálja, ezért a BatchNormot elhagyjuk; a BN bevezetése a 18.2. Batch normalization train és eval módban feladata. Az alábbi lab/residual_block.py két blokkot valósít meg: azonos alakút és csatornát váltót. Az ellenőrzéshez a 16.4. IV. ellenőrző pont: a CNN-operátor teljes megértése alfejezetben megszokott háromszögelvet követjük: a képletezett $y=x+F(x)$ összeadást közvetlenül összehasonlítjuk a blokk kimenetével.

Munkakönyvtár: lab/.

"""lab/residual_block.py"""
import torch
import torch.nn as nn

torch.manual_seed(20261020)
device = torch.device("cpu")
dtype = torch.float32


class BasicResBlock(nn.Module):
    """Azonos csatornaszámú, stride=1 reziduális blokk."""
    def __init__(self, C, kernel=3):
        super().__init__()
        self.conv1 = nn.Conv2d(C, C, kernel, padding=1)
        self.conv2 = nn.Conv2d(C, C, kernel, padding=1)
        self.relu = nn.ReLU()

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


class ProjectionResBlock(nn.Module):
    """Csatornát váltó blokk 1x1 projekciós shortcuttal."""
    def __init__(self, C_in, C_out, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(C_in, C_out, 3, stride=stride, padding=1)
        self.conv2 = nn.Conv2d(C_out, C_out, 3, padding=1)
        self.shortcut = nn.Conv2d(C_in, C_out, 1, stride=stride)
        self.relu = nn.ReLU()

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


def main():
    N, C, H, W = 2, 3, 24, 24
    x = torch.randn(N, C, H, W, device=device, dtype=dtype)

    # Azonos alakú blokk: a kimenetnek x + F(x)-szel kell egyeznie.
    block_same = BasicResBlock(C).to(device, dtype)
    block_same.eval()
    with torch.no_grad():
        y = block_same(x)
        F_ref = block_same.conv2(block_same.relu(block_same.conv1(x)))
        err_same = (y - (F_ref + x)).abs().max().item()
    print("azonos alak max hiba:", err_same)

    # Csatornát váltó blokk: a shortcut 1x1 konvolúcióval projektál.
    block_proj = ProjectionResBlock(C, 6).to(device, dtype)
    block_proj.eval()
    with torch.no_grad():
        y2 = block_proj(x)
    print("projekcios kimenet alakja:", tuple(y2.shape))
    print("elvart alak: (2, 6, 24, 24)")


if __name__ == "__main__":
    main()

Futtatás a projekt gyökeréből:

python lab/residual_block.py

A várt kimenet szemléltetés, nem mért futás:

azonos alak max hiba: 0.0
projekcios kimenet alakja: (2, 6, 24, 24)
elvart alak: (2, 6, 24, 24)

Az első sor azt ellenőrzi, hogy a BasicResBlock valóban az $y=x+F(x)$ összeadást számolja: a hiba float32 kerekítés mellett $0$, a tűrés $10^{-6}$. A második sor a csatornaváltó blokk kimeneti alakját ellenőrzi: $C_{in}=3$-ból $C_{out}=6$ lett, a térbeli méret $24\times24$ maradt, mert stride $s=1$ és a $3\times3$-as kernel $p=1$ paddingje megőrzi a méretet, összhangban a 14.1. Stride, padding, dilation és outputméret formulájával:

$$H_{out}=\left\lfloor\frac{24+2\cdot1-3-1}{1}\right\rfloor+1=24.$$

A projekciós shortcut itt $1\times1$-es konvolúció, amely a $3$ csatornát $6$-ra képezi le, így a főág és a shortcut alakja összeadhatóvá válik.

18.1.6 Feladatok

F1 (fogalmi, nehézség 1). Definiálja az identitás shortcutot és a projection shortcutot. Adjon egy konkrét bemeneti alakot, amelynél $F$ kimenete csatornát vált, és mondja meg, miért nem értelmes az $x+F(x)$ összeadás projekció nélkül.

F2 (levezetési, nehézség 2). Legyen $F(x)=Ax+b$ lineáris leképezés, $A\in\mathbb R^{2\times2}$. Bizonyítsa be a lemma alapján, hogy $J_G(x)=I_2+A$, és adjon olyan konkrét $A$ mátrixot, amelyre $\kappa_2(I_2+A)\ge100$. Számolja ki a sajátértékeket vagy a szinguláris értékeket.

F3 (implementációs, nehézség 2). Implementáljon ProjectionResBlock stílusú blokkot $C_{in}=1$, $C_{out}=4$, $5\times5$-ös kernel, $p=2$, stride $s=2$ mellett. Ellenőrizze a kimeneti alakot egy $(2,1,24,24)$ bemeneten, és a shortcut nélküli főággal való összehasonlítással a max hibát. Adja meg a futtatható kódot, a várt shape-et és a tűrést.

F4 (hibakeresési, nehézség 2). Az alábbi kód hibás:

class BrokenBlock(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(2, 4, 3, padding=1)
        self.conv2 = nn.Conv2d(4, 4, 3, padding=1)
        self.relu = nn.ReLU()

    def forward(self, x):
        return self.conv2(self.relu(self.conv1(x))) + x

Lokalizálja a hibát, magyarázza el a következményét, javítsa ki projekciós shortcuttal, és ellenőrizze a javítást egy $(2,2,24,24)$ bemeneten. Adja meg a hiba okát, a javított kódot és az ellenőrző futtatás eredményét.

F5 (kísérlettervezési, nehézség 3). Tervezzen kontrollált ablatív kísérletet a GlyphLab adaton, amely a skip út hatását méri az orientációosztályozási feladatra. Rögzítse a kérdést, a baseline-t, a spliteket, a paraméterkeretet, a választási szabályt, a metrikát, a seed-kezelést és az érvényességi korlátokat. Nincs előre megadott győztes; a 17.4. Architektúra összehasonlítása kontrollált keretben fair comparison keretét kövesse.

18.1.7 Megoldások és indoklás

F1 megoldása. Az identitás shortcut a $y=x+F(x)$ képletben az $x$ közvetlen átvezetése a kimenethez, paraméter nélkül. Ez akkor megengedett, ha $x$ és $F(x)$ alakja megegyezik. A projection shortcut $h(x)=W_sx$ tanulható lineáris transzformáció, amely a shortcut utat a főág alakjára hozza. Példa: $x\in\mathbb R^{2\times3\times24\times24}$, $F$ kimenete $\mathbb R^{2\times6\times24\times24}$. Ekkor $x+F(x)$ nem értelmezhető, mert a csatornadimenzió $3\neq6$; a PyTorch add művelet shape-mismatch hibát adna. A projection $1\times1$-es konvolúcióval $3\to6$ csatornát képez, így mindkét tag $(2,6,24,24)$ lesz.

F2 megoldása. A lemmából $J_G(x)=I_2+J_F(x)$. Lineáris $F$ esetén $J_F(x)=A$ minden $x$-re, tehát $J_G(x)=I_2+A$. Válasszuk a diagonális mátrixot

$$A=\begin{bmatrix}-0{,}99 & 0\\0 & 99\end{bmatrix}.$$

Ekkor

$$I_2+A=\begin{bmatrix}0{,}01 & 0\\0 & 100\end{bmatrix}.$$

A szinguláris értékek diagonális mátrixnál a főátló elemeinek abszolút értékei: $\sigma_1=100$, $\sigma_2=0{,}01$, tehát

$$\kappa_2(I_2+A)=\frac{100}{0{,}01}=10^4\ge100.$$

Az ellenőrzés mutatja, hogy a shortcut jelenléte ellenére a Jacobi-mátrix tetszőlegesen rosszul kondicionált lehet, ha $F$ spektruma $-1$ közelébe kerül.

F3 megoldása. A kód:

"""lab/residual_stride.py"""
import torch
import torch.nn as nn

torch.manual_seed(20261020)
device = torch.device("cpu")
dtype = torch.float32


class StrideResBlock(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 4, 5, stride=2, padding=2)
        self.conv2 = nn.Conv2d(4, 4, 5, padding=2)
        self.shortcut = nn.Conv2d(1, 4, 1, stride=2)
        self.relu = nn.ReLU()

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


def main():
    x = torch.randn(2, 1, 24, 24, device=device, dtype=dtype)
    block = StrideResBlock().to(device, dtype)
    block.eval()
    with torch.no_grad():
        y = block(x)
        F_ref = block.conv2(block.relu(block.conv1(x)))
        err = (y - (F_ref + block.shortcut(x))).abs().max().item()
    print("kimeneti alak:", tuple(y.shape))
    print("max hiba:", err)


if __name__ == "__main__":
    main()

A kimeneti méret a 14.1. Stride, padding, dilation és outputméret formulával: $H_{out}=\lfloor(24+2\cdot2-5-1)/2\rfloor+1=12$, tehát a várt alak $(2,4,12,12)$. A shortcut $1\times1$-es konvolúció stride $s=2$-vel, így annak kimenete is $(2,4,12,12)$. A max hiba tűrése $10^{-6}$; a várt érték $0$.

F4 megoldása. A hiba oka: a BrokenBlock.forward az $x$ bemenetet közvetlenül adja hozzá a főág kimenetéhez, de $x$ csatornaszáma $2$, a főág kimenetéé pedig $4$. A + művelet PyTorchban shape-mismatch RuntimeError-t eredményez. A következmény az, hogy a blokk egyetlen forwardja sem fut le. Javítás: adjunk a konstruktorhoz egy $1\times1$-es projekciós konvolúciót, és a forwardban azt használjuk:

class FixedBlock(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(2, 4, 3, padding=1)
        self.conv2 = nn.Conv2d(4, 4, 3, padding=1)
        self.shortcut = nn.Conv2d(2, 4, 1)
        self.relu = nn.ReLU()

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

Ellenőrzés $(2,2,24,24)$ bemeneten: a kimenet alakja $(2,4,24,24)$, és a (F + shortcut(x)) kifejezés közvetlen kiértékelésével a max hiba $0$ a $10^{-6}$ tűrés mellett.

F5 megoldása. Egy lehetséges protokoll:

• Kérdés: javítja-e az identity shortcut a validációs pontosságot a GlyphLab orientációfeladatán, ha minden más tényező rögzített?
• Baseline: ugyanaz a három blokkból álló CNN shortcut nélkül; a skip változat ugyanazt a főágat használja, kiegészítve identity shortcuttal. Mivel a blokkok csatornaszáma nem változik, a paraméterszám a két modellben azonos; a fair comparison szerint nincs rejtett kapacitáskülönbség.
• Split: a GlyphLab train/val/test felosztása, a scene_id mint független megfigyelési egység. A validáció csak modellválasztásra szolgál; a tesztet a legjobb valós checkpoint kiválasztása után egyszer értékeljük.
• Recept: Adam, tanulási ráta $10^{-3}$, batch méret $32$, 20 epocha; 5 különböző seed. A seed a modell inicializálását és a lépések sorrendjét rögzíti; a GlyphLab splitet nem változtatjuk.
• Metrika: osztályokra aggregált validációs accuracy, a kiválasztás a legmagasabb valós accuracy szerint; a végső tesztmetrika mellett a páros korrupt teszt is rögzíthető.
• Érvényességi korlát: a GlyphLab szintetikus, kis méretű adat, ezért az eredmény nem általánosítható természetes képekre. Az 5 seed nem teljes bizonytalansági lefedés; a seed-szórás a reprodukálhatósági bizonytalanság alsó becslése. A konklúzió csak „ezen az adaton, ezzel a recepttel” típusú lehet.

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

A leggyakoribb tévedés az, hogy a skip út jelenlétét globális konvergenciabizonyításnak tekintik. A fenti lemma csak lokális Jacobi-azonosság, és a $J_F$ tetszőleges értéke miatt nem zárja ki a rossz kondicionáltságot. Konkrét ellenpélda: legyen $F(x)=-x$. Ekkor a blokk kimenete $y=x+F(x)=0$ minden $x$-re. A shortcut jelen van, a Jacobi mégis $I_d+(-I_d)=0$, tehát a blokk a bemenet minden információját eltünteti. Egy ilyen blokkokból álló háló bármely mélységben konstans nullát ad, így semmilyen értelmes feladatot nem tanul meg. A skip tehát csak egy lehetséges gradiensutat biztosít; a tényleges tanulási dinamika és a konvergencia továbbra is a nemlineáris optimalizálás tulajdonságaitól függ. A P06 empirikus javulást közöl, nem tételként bizonyított globális garanciát.

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

Önellenőrző kérdések: (1) Mikor értelmes az $x+F(x)$ összeadás tenzoralakban? (2) Mi a projection shortcut szerepe csatornaváltásnál? (3) Igaz-e, hogy ha minden blokk Jacobija $J_G=I_d+J_F$, akkor a teljes háló Jacobija $I_d$? (4) Mit ellenőriz a laborban a err_same érték? (5) Milyen állítástípus a P06 javulásra vonatkozó megállapítása?

Korábbi fogalmak visszahívása: a 6.1. Objektív, reguláris tag és gradienslépés alfejezetből a gradienslépés és a loss-átlag skálázása; a 11.4. Egy teljes PyTorch tanítási iteráció alfejezetből a zero_grad–forward–backward–step sorrend; a 14.1. Stride, padding, dilation és outputméret alfejezetből a kimeneti méret formulája; a 14.4. Csoportos és depthwise konvolúció alfejezetből a csoportos konvolúció csatornakorlátozása, amely a bottleneck $1\times1$-es rétegeinél pontszerű, teljes csatornakapcsolatot jelent; a 16.4. IV. ellenőrző pont: a CNN-operátor teljes megértése alfejezetből az operátor-specifikáció háromszöge; a 17.4. Architektúra összehasonlítása kontrollált keretben alfejezetből pedig a fair comparison kerete. A BatchNorm, amely a teljes P06 blokkban a konvolúciók után áll, a következő egység témája.

18.1.10 Rövid összefoglaló

A reziduális blokk $y=x+F(x)$ alakú, ahol a shortcut identitás vagy $1\times1$-es projekció, ha az alak nem egyezik. A blokk Jacobi-mátrixa differenciálható $F$ esetén $I_d+J_F(x)$, így a VJP-ben a gradiens az identitásúton és a reziduális ágon is terjed. Ez az azonosság lokális, és nem garantál globálisan jó kondicionáltságot: $J_F$ sajátértékei közel kerülhetnek $-1$-hez, a mély szorzat spektruma pedig akkor is elfajulhat, ha az egyes tényezők jól kondicionáltak. A labor két kis blokkot épít és ellenőriz. A BatchNorm-mechanizmus a következő egységben következik.

18.1.11 Következő alkalmazás

A 18.2. Batch normalization train és eval módban a BatchNorm tanítási és kiértékelési módját vezeti be a P07, P08 és D12 források alapján, és visszatér az itteni reziduális blokkra, amikor a normalizálást a főágba illeszti.

18.1.12 Források

• [P06] He, K., Zhang, X., Ren, S. és Sun, J. (2015). Deep Residual Learning for Image Recognition. arXiv:1512.03385, első preprint. https://arxiv.org/abs/1512.03385.