20.4 V. ellenőrző pont: indokolt CNN-választás

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

Ez az V. ellenőrző pont. A hallgató a 20.1.–20.3. egységekben megismerte a feature extractor és az új fej, a finomhangolás, valamint a preprocessing- és licencszerződés fogalmát. A 19.4. ConvNeXt és a recept/architektúra elválasztása a recept és az architektúra szétválasztását adta, a 16.4. IV. ellenőrző pont: a CNN-operátor teljes megértése a CNN-operátor teljes specifikációját, a 8.4. II. ellenőrző pont: korrekt tanulási állítás pedig a korrekt tanulási állítás keretét. Itt nem új réteget vezetünk be: a feladat az, hogy a három döntési dimenzió — architektúracsalád (classic/residual/efficient), tanítási mód (scratch/transfer) és erőforráskeret — együtt egyetlen, lektorálható architektúra-döntési lapba álljon össze.

Értékelés. A közös 0–4 rubrikát, a PASS-szabályt és a hibatípusonkénti visszautakat az 1.4. Tanulási diagnózis és kísérleti napló „Tanulási főút és ellenőrző pontok” szakasza adja meg; itt csak az eltérés: a riport helyett architektúra-döntési lapot adunk le; a súlypont a D5.

Induló kérdés: a GlyphLab adat 360 képet tartalmaz, $24\times24$-es, egycsatornás, három osztállyal. Válasszon a feladatra architektúrát és tanítási módot. Melyik döntés igényel több paramétert: egy VGG-szerű classic háló vagy egy kis saját CNN? Milyen adat- és erőforrásfeltétel zárja ki az előtanított ResNet18-at az alapforgatókönyvből? A becslést a szakasz végén a döntési lappal ellenőrizzük.

20.4.2 2. Döntési dimenziók és jelölések

A választási feladatot három szemponthalmaz feszíti ki.

Architektúracsalád. A classic jelző itt a VGG-stílusú, egymásra rakott konvolúciós blokkokat jelöli: Conv → ReLU → Pooling ismétlése, skip nélkül. A residual család a [P06]-ban bevezetett $y=F(x)+x$ identitás-utat alkalmazza; ennek egyszerű, kétszer $3\times3$-as basic blokkját a 18.1. Reziduális blokk és identitásút már tárgyalta. Az efficient család depthwise separable és inverted residual blokkokat használ; a paraméterszám csökkentésének levezetése a 19.1. Depthwise separable és pointwise réteg alfejezetben szerepelt. A családok nem rangsorolhatók abszolút értelemben: a 19.4. ConvNeXt és a recept/architektúra elválasztása alfejezetben látott matched-recept elv éppen azt mondja ki, hogy a kísérleti összevetés csak akkor értelmes, ha a tanítási receptet azonos szinten tartjuk.

Tanítási mód. A scratch mód véletlen inicializálással indítja az összes súlyt. A feature extractor mód egy előtanított modell konvolúciós részét fagyasztja, és csak az új fejet tanítja. A finomhangolás ezen felül a konvolúciós súlyok egy részét vagy egészét is kis tanulási rátával frissíti. A három mód a 20.1.–20.2. alfejezetben bevezetett fogalom.

Erőforráskeret és protokoll. A döntéshez rögzíteni kell: a paraméterszámot ($P$), a konvolúciós szorzás-összeadás párok számát (MAC), az aktivációmemória nagyságrendjét, a rendelkezésre álló hardvert, az adat splitjét és a modellválasztási szabályt. A protokoll alapszabálya a 8.4. II. ellenőrző pont: korrekt tanulási állítás alfejezetből: a validációs loss választ best checkpointot, a testet pedig csak a választás után, egyszer értékeljük.

A képbatch alakja $X\in\mathbb R^{N\times C_{in}\times H\times W}$, a logité $Z\in\mathbb R^{N\times K}$, a címke $y\in\{0,1,2\}^N$ a GlyphLab három osztályára. A konvolúciós súly alakja $K\in\mathbb R^{C_{out}\times C_{in}\times k_h\times k_w}$, hacsak a groups paraméter mást nem mond.

20.4.3 3. Analitikusan ellenőrzött blokk: a basic residual blokk

A levezetési kötelezettséghez egy olyan blokkot választunk, amelynek a paraméterszáma és műveletigénye zárt formában ellenőrizhető. A [P06] 3.1–3.2 szakaszának olvasott állapota alapján a basic residual blokk rövidítése $y=F(x)+x$. A jelen alfejezetben a $F$ függvényt két, bias nélküli $k\times k$-s konvolúció és egy közbeékelt ReLU alkotja; a normalizáló réteget a döntési lap kedvéért elhagyjuk, hogy a képlet csak a domináns konvolúciós költséget tartalmazza.

Definíció (egyszerűsített basic block). Legyen $X\in\mathbb R^{N\times C\times H\times W}$. A blokk

$$Y = F(X)+X, \qquad F(X)=\sigma(\operatorname{conv}_{W_2}(\sigma(\operatorname{conv}_{W_1}(X)))),$$

ahol $W_1,W_2\in\mathbb R^{C\times C\times k\times k}$, a két konvolúció stride-ja $1$, paddingje $p=(k-1)/2$, dilationje $1$, groups paramétere $1$, és $k$ páratlan. A $\sigma$ a ReLU. Mivel $p=(k-1)/2$ és $s=1$, a 14.1. Stride, padding, dilation és outputméret alfejezetből ismert kimeneti méretképlet szerint a térbeli méret $H\times W$ marad, tehát az identitás-összeadás $X$-szel alakhelyes.

Állítás (paraméterszám és konvolúciós MAC, saját levezetés). A fenti blokkra

$$P = 2C^2k^2, \qquad M = 2N H W C^2 k^2.$$

Itt $P$ a modellsúlyok száma, $M$ pedig a konvolúciós szorzás-összeadás párok (multiply-accumulate) domináns száma egy bemeneti batchre. Az állítás feltétele: stride=1, padding=(k-1)/2, bias=False, groups=1, dilation=1, és a bemeneti csatornaszám $C$ azonos a kimenetivel. Az identitás-összeadás $N H W C$ elemi összeadást, a ReLU $N H W C$ elemi maximumképzést ad; ezeket külön számoljuk, és a nagy $C,k$ tartományban alacsonyabb rendűek.

Bizonyítás. Az első súlytensor elemeinek száma $C\cdot C\cdot k\cdot k=C^2k^2$; a másodiké ugyanannyi. Bias nincs, ezért $P=2C^2k^2$. Egy konvolúcióban minden kimeneti elemhez $Ck^2$ szorzás és ugyanennyi, az akkumulátorba adódó összeadás tartozik; az első szorzat akkumulációjának hiánya $O(NHWC)$ rendű, ezért a MAC-becslés a domináns tag. A kimeneti elemek száma konvolúciónként $N\cdot C\cdot H\cdot W$, tehát egy konvolúció $NHC\cdot Ck^2=N H W C^2k^2$ szorzás-összeadás párt végez. Két konvolúcióra ez $M=2N H W C^2k^2$. $\square$

20.4.4 4. Kézi számpélda és minimális kontroll

Legyen $N=1$, $C=2$, $k=3$, $H=W=4$. Ekkor

$$P = 2\cdot 2^2\cdot 3^2 = 72, \qquad M = 2\cdot 1\cdot 4\cdot 4\cdot 2^2\cdot 3^2 = 1152.$$

Az első konvolúció kimenete $1\times2\times4\times4$, tehát $2\cdot16=32$ elemet tartalmaz; minden elemhez $Ck^2=2\cdot9=18$ MAC tartozik, ami $32\cdot18=576$ műveletpár. A második konvolúció ugyanennyit ad, így az összeg $1152$. A skip-összeadás további $N H W C=32$ elemi összeadást jelent, amit a domináns MAC-képlet expliciten nem tartalmaz.

A képlet és a PyTorch-implementáció egyezését az alábbi kontroll ellenőrzi. A kód nem futtatott; a paraméterszám a fenti, számított érték.

# lab/n080_residual_check.py
import torch

torch.manual_seed(20261020)

class BasicResidualBlock(torch.nn.Module):
    def __init__(self, C, k):
        super().__init__()
        assert k % 2 == 1
        self.conv1 = torch.nn.Conv2d(C, C, k, stride=1,
                                     padding=(k - 1) // 2, bias=False)
        self.conv2 = torch.nn.Conv2d(C, C, k, stride=1,
                                     padding=(k - 1) // 2, bias=False)

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

model = BasicResidualBlock(C=2, k=3)
n_params = sum(p.numel() for p in model.parameters())
assert n_params == 72, n_params
x = torch.randn(1, 2, 4, 4)
with torch.no_grad():
    y = model(x)
print("params:", n_params, "output shape:", tuple(y.shape))
assert y.shape == (1, 2, 4, 4)

Futtatás: python lab/n080_residual_check.py. A shape-ellenőrzés a paddingfeltételből következik: a kimenet $1\times2\times4\times4$, mert a két konvolúció stride-ja $1$ és paddingje $1$.

20.4.5 5. Labor: architektúra-döntési lap és kis futó kontroll

A labor átadandó eredménye egy kitöltött döntési lap, három elvetett alternatíva indokával, valamint a kiválasztott modell kis futó kontrollja. A döntési lap a GlyphLab adatszerződésre épül: train 240, val 60, test 60 kép, független mintavételi egység a scene_id, bemenet float32 NCHW $[0,1]$, cél int64 osztályindex.

Döntési lap.

• Adat: GlyphLab; train/val/test rögzített, scene-szintű split; az augmentáció címkemegőrző változatai csak a 22.2. Címkemegőrző transzformációk alfejezetben tárgyalt feltételekkel használhatók.
• Bemeneti szerződés: $X\in\mathbb R^{N\times1\times24\times24}$, float32, $[0,1]$.
• Cél: 3-osztályos orientációfelismerés.
• Erőforrás: kis helyi CPU, külső súlyletöltés nélkül; a seed 20261020.
• Választott változat: saját, scratch, 4155 paraméteres kis CNN, TinyGlyphCNN néven: két classic blokk (8,8) és (16,16) csatornával, $3\times3$-as, padding $1$-es bias nélküli konvolúciókkal, ReLU-val, $2\times2$-es maxpoolinggal, majd global average poolinggal és egy Linear(16, 3) fejjel.
• Választási szabály: a best checkpointot a val loss választja; a testet csak a protokoll végén, egyszer értékeljük.

A kiválasztott modell paraméterszáma pontosan:

$$P_{\text{Tiny}} = 1\cdot8\cdot3^2 + 8\cdot8\cdot3^2 + 8\cdot16\cdot3^2 + 16\cdot16\cdot3^2 + (16\cdot3+3) = 72+576+1152+2304+51 = 4155.$$

A három elvetett alternatíva:

1. Nagy classic háló. Négy blokk $[64,64,128,128]$ csatornával, blokkonként két $3\times3$-as, bias nélküli konvolúcióval. A konvolúciós súlyok összege $$1\cdot64\cdot9 + 64\cdot64\cdot9 + 64\cdot128\cdot9 + 128\cdot128\cdot9 = 576 + 36\,864 + 73\,728 + 147\,456 = 258\,624,$$ és a további rétegekkel együtt nagyságrendileg $1{,}1$ millió paraméter. Indok az elvetésre: a $240$ train képhez képest a paraméterszám túl nagy; a finite-H korlát 8.4. II. ellenőrző pont: korrekt tanulási állítás szerint a nagyobb hipotézisosztály szélesebb általánosítási sávot ad, és a kis mintán a túlillesztés kockázata dominál. A $24\times24$ inputon a nagy recepciós mező sem indokolt.
2. Előtanított ResNet18 feature extractor új fejjel. Indok az elvetésre: ez külső súlyletöltést igényel, ami a fejezet főútjában csak külön, dokumentált opció lehet. A [D13] forrásállapota szerint a konkrét TorchVision súlyváltozat, annak preprocessing-szerződése és licencfeltétele további ellenőrzést igényel; az ImageNet-domain és a $224\times224$-es RGB bemenet áthidalása a $24\times24$-es grayscale GlyphLab-ra a 20.3. Preprocessing, domain shift és súlylicenc alfejezetben tárgyalt domain shiftet hozza be. Az alapdöntésben ezért nem választjuk.
3. Nagy efficient blokk. Egy MBConv-szerű, expand=6, $k=5$, magas csatornaszámú blokk a depthwise separable felépítés ellenére is több ezer paramétert és nagy MAC-ot hozna a kis bemenetre. Indok az elvetésre: a 19.1. Depthwise separable és pointwise réteg alfejezetből ismert paramétercsökkentés előnye nagy csatornaszámnál és nagy térbeli méretnél jelentős; a $24\times24$-es, egycsatornás feladaton a megtakarítás nem indokolja a nagyobb kapacitást és a bonyolultabb normalizálási állapotot.

A választott modell futó kontrollja:

# lab/n080_decision_check.py
import torch

torch.manual_seed(20261020)

class TinyGlyphCNN(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.features = torch.nn.Sequential(
            torch.nn.Conv2d(1, 8, 3, padding=1, bias=False),
            torch.nn.ReLU(),
            torch.nn.Conv2d(8, 8, 3, padding=1, bias=False),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2),
            torch.nn.Conv2d(8, 16, 3, padding=1, bias=False),
            torch.nn.ReLU(),
            torch.nn.Conv2d(16, 16, 3, padding=1, bias=False),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2),
        )
        self.gap = torch.nn.AdaptiveAvgPool2d((1, 1))
        self.head = torch.nn.Linear(16, 3, bias=True)

    def forward(self, x):
        z = self.features(x)
        z = self.gap(z).flatten(1)
        return self.head(z)

model = TinyGlyphCNN()
n_params = sum(p.numel() for p in model.parameters())
assert n_params == 4155, n_params
x = torch.rand(2, 1, 24, 24, dtype=torch.float32)
with torch.no_grad():
    logits = model(x)
print("params:", n_params)
print("logits shape:", tuple(logits.shape))
assert logits.shape == (2, 3)

Futtatás: python lab/n080_decision_check.py. Az ellenőrzés kimenete a paraméterszámot és a $2\times3$-as logitalakot adja; az érték a képletből számított, nem mért futás.

20.4.6 6. Empirikusan vizsgált összehasonlítási protokoll

A döntési lapot egy kis empirikus összehasonlítással lehet validálni. A jelen kézirat nem tartalmaz új mért eredményt; az alábbi protokoll a hallgatói futtatás előírása, és a kezdőlabor ellenőrzött jelentésétől független, új futásnak számít.

• Kérdés. A választott $4155$ paraméteres TinyGlyphCNN val loss-ában jobb-e, mint egy nagyobb kapacitású változat?
• Hipotézis. A nagyobb modell nem javítja a val loss-t, mert a train halmaz $240$ kép, és a kapacitás növelése a túlillesztés kockázatát növeli.
• Adat és split. GlyphLab, scene-szintű train/val/test; a val a best checkpoint kiválasztására, a test csak a végső értékelésre szolgál.
• Megfigyelési egység. scene_id; a két nézet ugyanabba a splitbe tartozik.
• Baseline. TinyGlyphCNN, scratch, Adam, lr=1e-3, batch 16, seed 20261020.
• Változó tényező. A második blokk kimeneti csatornaszáma: $16$ (baseline) és $64$ (nagy kapacitású változat). Az összes többi beállítás azonos.
• Metrika. Val loss a checkpointválasztásra; a végső modellre test accuracy és a páros corrupt teszt különbsége.
• Erőforrás. CPU, float32, maximum 30 epoch.
• Érvényességi korlát. A GlyphLab nem természetes képi benchmark; az eredmény csak a rögzített adatra és protokollra vonatkozik.

20.4.7 7. Feladatok

F1 (fogalmi, nehézség 1). Definiálja a scratch, feature extractor és finomhangolás tanítási módot. Adjon egy-egy feltételt, amely mellett a GlyphLab-on a scratch, illetve a feature extractor értelmes választás. Elvárt átadandó eredmény: a három definíció, a frissített súlyok köre, és két indoklás.

F2 (levezetési/bizonyítási, nehézség 2). Adott egy depthwise separable blokk: bemenet $N\times C\times H\times W$, depthwise konvolúció $k\times k$-val, groups=C, bias=False, stride=1, padding=(k-1)/2, majd pointwise $1\times1$-es konvolúció $C$ kimeneti csatornával, bias=False. Vezesse le a $P_{ds}$ paraméterszámot és az $M_{ds}$ konvolúciós MAC-ot. Hasonlítsa össze a 3. szakasz basic blokkjával $C=8$, $k=3$ mellett. Elvárt: képletek, arány, feltételek.

F3 (implementációs, nehézség 2). Írjon count_tiny(c1, c2) függvényt, amely a döntési lap modelljének paraméterszámát adja vissza a két blokk csatornaszámából, és egészítse ki a lab/n080_decision_check.py kontrollt egy független képletalapú assert-tel. Elvárt: futtatható kód, a 4155 eset helyes visszaadása.

F4 (hibakeresési, nehézség 2). Egy döntési napló a legnagyobb modellt választotta, mert annak test accuracyja $0.01$-gyel magasabb volt a baseline-nál. Mi a hiba, mi a következménye, és hogyan kell javítani? Elvárt: az ok megnevezése, a választási torzítás magyarázata és a javított munkafolyamat.

F5 (kísérleti/transzfer, nehézség 3). Tervezzen összehasonlítást a GlyphLab-on a scratch TinyGlyphCNN és egy külső előtanított ResNet18 feature extractor között. A terv tartalmazza a preprocessing-szerződést, a licencellenőrzést, a megfigyelési egységet, a baseline-t, a metrikát és az érvényességi korlátokat. A külső súly itt opcionális; a [D13] állapota miatt a konkrét súlyváltozatot további ellenőrzéshez kösse.

20.4.8 8. Megoldások és indoklás

F1 megoldás. A scratch mód minden súlyt véletlen inicializálásból indít, és a teljes modellt tanítja. A feature extractor az előtanított modell konvolúciós részét fagyasztja; csak az új fej súlyai frissülnek. A finomhangolás a konvolúciós rész egy részét vagy egészét is frissíti, jellemzően kisebb tanulási rátával. A GlyphLab-on a scratch értelmes, mert a feladat kicsi, a bemenet $24\times24$-es grayscale, és nincs szükség külső domain reprezentációjára. A feature extractor akkor lenne értelmes, ha a külső modell bemeneti szerződése és licencfeltétele ellenőrzött, és a forrás-domain reprezentációja a célfeladatra is hasznos; a jelen adaton ez nem teljesül automatikusan.

F2 megoldás. A depthwise konvolúció súlyalakja $C\times1\times k\times k$, groups=C, tehát $P_d = Ck^2$. A pointwise súlyalakja $C\times C\times1\times1$, tehát $P_p = C^2$. Így

$$P_{ds} = Ck^2 + C^2.$$

A depthwise konvolúció minden kimeneti elemhez $k^2$ MAC-ot használ, a kimeneti elemek száma $N C H W$, tehát $M_d = N H W C k^2$. A pointwise konvolúció minden kimeneti elemhez $C$ MAC-ot használ, tehát $M_p = N H W C^2$. Összesen

$$M_{ds} = N H W C(k^2 + C).$$

A basic blokk $P_b=2C^2k^2$ és $M_b=2N H W C^2k^2$. $C=8$, $k=3$ esetén $P_{ds}=8\cdot9+64=136$, $P_b=2\cdot64\cdot9=1152$, az arány $136/1152\approx0.118$, tehát a paraméterszám kb. $88\%$-kal kisebb. A MAC-arány ugyanez, mert a térbeli és batchtényező kiesik.

F3 megoldás.

def count_tiny(c1, c2):
    p1 = 1 * c1 * 9 + c1 * c1 * 9
    p2 = c1 * c2 * 9 + c2 * c2 * 9
    head = c2 * 3 + 3
    return p1 + p2 + head

assert count_tiny(8, 16) == 4155

A függvény a két blokk konvolúciós súlyait és a lineáris fej súlyát, illetve biasát adja össze. A c1=8, c2=16 eset a döntési lap értékét adja vissza.

F4 megoldás. A hiba: a test halmazt használták modellválasztásra. Következmény: a test már nem független; a kiválasztási iteráció a testre illeszti a választást, ezért a mért test accuracy felfelé torzít, és a valós általánosítási hibát nem becsli. Javítás: a választást a val loss vagy val accuracy alapján kell elvégezni; a testet csak a rögzített, végleges modellre szabad egyszer futtatni. Ellenőrzés: a naplóban a választási oszlop val-metrikát tartalmazzon, és a test oszlop a választás előtt üres legyen.

F5 megoldásminta. Kérdés: javítja-e a külső ResNet18 feature extractor a test accuracyt a scratch baseline-hoz képest? Hipotézis: nem, a nagy domain shift és a kis train halmaz miatt. Adat: GlyphLab, scene-szintű split; megfigyelési egység scene_id. Baseline: TinyGlyphCNN scratch. Változó: ResNet18 előtanított konvolúciós része fagyasztva, új Linear fejjel. Preprocessing: a külső modell bemeneti szerződését ténylegesen ellenőrizni kell; a GlyphLab $24\times24$ grayscale képét méretezni, csatornázni és normalizálni kell a forrás szerződése szerint, ami domain shiftet visz be. Licenc: a TorchVision súly letöltési és felhasználási feltételeit külön dokumentálni kell [D13]. Metrika: val loss a választásra, test accuracy a végén. Erőforrás: CPU, float32. Érvényességi korlát: az eredmény nem általánosítható természetes képekre; a külső súly verziója és a preprocessing pontos paramétere rögzítendő; a [D13] modellkatalógus állapota miatt a konkrét súlyváltozat ellenőrzése a kísérlet előfeltétele.

20.4.9 9. Tipikus tévedés, önellenőrzés és visszahívás

Tipikus tévedés. „A legnagyobb elérhető modell nem automatikusan a legjobb feladatmegoldás.” Ennek ellenpéldája egy $1$D-s regressziós szerkesztett eset: legyen a train három pontja $(-1,0),(0,1),(1,2)$, a generáló összefüggés $f(x)=x+1$. A lineáris modell $b=1, w=1$ paraméterekkel tökéletesen illeszkedik a train pontokra. A nagy kapacitású, kilencedfokú polinom $p_9(x)=x+1+100(x+1)x(x-1)(x^2-4)(x^2-9)$ szintén átmegy mindhárom train ponton, mert a szorzótényező ott nulla; azonban a tesztpontban, például $x=0.5$-nél a predikció $1.5$-höz képest $100(1.5)(0.5)(-0.5)(-3.75)(-8.75)$-tel eltolódik, azaz durván téved. A nagyobb modell tehát azonos train illeszkedés mellett rosszabb tesztpredikciót adhat. A CNN-választásnál ugyanezt a jelenséget a finite-H korlát 8.4. II. ellenőrző pont: korrekt tanulási állítás fogalmazza meg: a nagyobb hipotézisosztály szélesebb általánosítási sávot nyit.

Önellenőrzés. A döntési lap akkor teljes, ha (1) a bemeneti szerződés és a normalizálás rögzített; (2) a split scene-szintű, és a testet nem érinti a választás; (3) a paraméterszám és a MAC képlete a megadott bias, groups, stride, padding feltételekkel egyezik; (4) külső súly esetén a verzió, preprocessing és licenc forrása azonosított; (5) a végső következtetés csak a rögzített protokollra vonatkozik.

Visszahívás. A 16.4. IV. ellenőrző pont: a CNN-operátor teljes megértése alfejezetből: a cross-correlation alak- és gradientszabálya a döntési lap minden konvolúciós sorában érvényes; az eltolási equivariance a stride és a határfeltétel függvénye. A 19.4. ConvNeXt és a recept/architektúra elválasztása alfejezetből: az architektúra címkéje nem örök rangsor, hanem adott receptfeltételhez kötött állítás.

20.4.10 10. Rövid összefoglaló

Az architektúra-döntési lap a családot (classic/residual/efficient), a tanítási módot (scratch/transfer) és az erőforráskeretet együtt rögzíti. Az analitikusan ellenőrzött basic residual blokk paraméterszáma $2C^2k^2$, konvolúciós MAC-ja $2N H W C^2k^2$; a depthwise separable blokk ennél $C=8,k=3$ mellett kb. $88\%$-kal kevesebb paramétert használ. A GlyphLab-on a $4155$ paraméteres scratch TinyGlyphCNN a döntési lap választása; a nagy classic, az előtanított ResNet18 és a nagy efficient blokk elvetésének oka rendre a túl nagy kapacitás, a domain shift és a licencellenőrzés, illetve a kis bemeneten elmaradó előny. A legnagyobb modell nem automatikusan a legjobb.

20.4.11 11. Következő alkalmazás és felhasznált források

A következő egység 21.1. Inicializálás és varianciaterjedés az inicializálást és a varianciaterjedést tárgyalja; ott a döntési lapon kiválasztott kis CNN súlyainak induló eloszlása közvetlenül befolyásolja a tanítás stabilitását.

• [D09] PyTorch contributors (2.14). Saving and Loading Models. https://docs.pytorch.org/tutorials/beginner/saving_loading_models.html.
• [D13] PyTorch contributors (online). TorchVision models. https://docs.pytorch.org/vision/stable/models.html.
• [P06] He, Zhang, Ren és Sun (2015). Deep Residual Learning for Image Recognition. https://arxiv.org/abs/1512.03385.