17.3 VGG és kis kernelek kompozíciója

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

Ez az egység a VGG egyik legismertebb tervezési döntését, a kis 3×33\times3-as kernelek egymás utáni alkalmazását vizsgálja. A cél annak pontos megértése, hogy a mélység növelése hogyan kapcsolódik a recepciós mezőhöz, a paraméterszámhoz és a nemlinearitáshoz. Az előismeret a 17.2. AlexNet és a kísérleti kontextus történeti kontextusa: az AlexNet nagy kerneleket használt, a VGG ezt cserélte kisebbekre. Szükség van a 16.3. Elméleti és effektív recepciós mező recepciósmező-rekurziójára és a 13.3. Lokális szűrők és tanult reprezentáció lineáris/affin megkülönböztetésére. A kísérleti állításokhoz visszaidézzük az 5.3. Mintavételi bizonytalanság és intervallum mintavételi bizonytalanságról tanultakat: egyetlen futtatás eredménye nem általános tétel.

Induló kérdés: ha egy 10×1010\times10-es bemeneten egy 5×55\times5-ös, stride 1, padding nélküli réteg kimenete 6×66\times6, és két egymás utáni 3×33\times3-as réteg kimenete szintén 6×66\times6, akkor a két blokk ugyanazt a bemeneti tartományt látja? És melyik használ kevesebb paramétert, ha a csatornaszám mindenhol CC?

17.3.2 Definíció: kernelkompozíció és recepciós mező

Legyen egy 2D cross-correlation réteg súlya K∈ℝCout×Cin×kh×kwK\in\mathbb R^{C_{\mathrm{out}}\times C_{\mathrm{in}}\times k_h\times k_w}, biasza b∈ℝCoutb\in\mathbb R^{C_{\mathrm{out}}}. A programozói főútban a réteg keresztkorrelációt számol, nem matematikai konvolúciót: a kernel nem fordul meg, az indexezés a 13.2. Konvolúció és cross-correlation konvencióját követi.

Definíció (kernelstack). Két vagy több konvolúciós réteg kompozícióját kernelstacknek nevezzük, ha a rétegek kimenetei között elemenkénti nemlineáris aktiváció, itt ReLU σ(z)=max(0,z)\sigma(z)=\max(0,z) áll. Az ll-edik réteg kimenete Hl=σ(Kl*Hl−1+bl)H_l=\sigma(K_l*H_{l-1}+b_l), ahol ** a cross-correlation, H0=XH_0=X a bemenet.

Definíció (elméleti recepciós mező, RF). A 16.3. Elméleti és effektív recepciós mező rekurziójával: J0=1J_0=1, F0=1F_0=1, és Jl=Jl−1sl,Fl=Fl−1+(kl−1)dlJl−1.J_l=J_{l-1}s_l,\qquad F_l=F_{l-1}+(k_l-1)d_lJ_{l-1}. Itt JlJ_l a kimeneti rácson mért lépésköz (jump), FlF_l a bemeneti rácson mért mező oldalhossza, sls_l a stride, klk_l a kernelméret, dld_l a dilation. A padding nem változtatja sem FlF_l-et, sem a paraméterszámot.

17.3.3 Lemma: két 3×3 stack és egy 5×5 réteg összehasonlítása

Lemma (kis kernelek kompozíciója). Tekintsünk két egymás utáni 3×33\times3-as cross-correlation réteget stride s=1s=1, dilation d=1d=1 és tetszőleges padding mellett; a rétegek közé tegyünk ReLU-t. Legyen mindkét réteg bemeneti és kimeneti csatornaszáma CC. Ekkor

  1. a stack elméleti recepciós mezője 5×55\times5, azonos egyetlen 5×55\times5-ös réteggel;
  2. a stack paraméterszáma bias-szal Pstack=18C2+2CP_{\mathrm{stack}}=18C^2+2C, míg egyetlen 5×55\times5-ös, CC-ből CC-be képező rétegé P5=25C2+CP_{5}=25C^2+C;
  3. P5−Pstack=7C2−C>0P_{5}-P_{\mathrm{stack}}=7C^2-C>0 minden C≥1C\ge1-re.

Bizonyítás. Az (1) ponthoz a rekurziót használjuk. Az első rétegen J0=1J_0=1, F0=1F_0=1, k1=3k_1=3, d1=1d_1=1, így F1=1+(3−1)⋅1⋅1=3,J1=1⋅1=1.F_1=1+(3-1)\cdot1\cdot1=3,\qquad J_1=1\cdot1=1. A második rétegen F2=3+(3−1)⋅1⋅1=5F_2=3+(3-1)\cdot1\cdot1=5, J2=1J_2=1. Egyetlen 5×55\times5-ös rétegen F1=1+(5−1)⋅1⋅1=5F_1=1+(5-1)\cdot1\cdot1=5, tehát a mező megegyezik.

A (2) ponthoz a súlytenzor méretét szorozzuk össze és adjuk hozzá a biaszt. Egy k×kk\times k-s, Cout×CinC_{\mathrm{out}}\times C_{\mathrm{in}} csatornás réteg paraméterszáma Cout(Cink2+1)C_{\mathrm{out}}(C_{\mathrm{in}}k^2+1), mert minden kimeneti csatornához Cink2C_{\mathrm{in}}k^2 súly és egy bias tartozik. A stack első rétege C(C⋅32+1)=9C2+CC(C\cdot3^2+1)=9C^2+C, a második ugyanennyi, így Pstack=2(9C2+C)=18C2+2C.P_{\mathrm{stack}}=2(9C^2+C)=18C^2+2C. Az 5×55\times5-ös rétegre P5=C(25C+1)=25C2+CP_5=C(25C+1)=25C^2+C. A különbség P5−Pstack=(25C2+C)−(18C2+2C)=7C2−C=C(7C−1),P_5-P_{\mathrm{stack}}=(25C^2+C)-(18C^2+2C)=7C^2-C=C(7C-1), ami C≥1C\ge1 esetén pozitív, mert 7C−1≥6>07C-1\ge6>0. ▫\square

A lemma feltétele fontos: az első és második réteg csatornaszáma is CC. Ha a bemenet CinC_{\mathrm{in}}, a középső CmidC_{\mathrm{mid}}, a kimenet CoutC_{\mathrm{out}}, akkor Pstack=CinCmid9+Cmid+CmidCout9+Cout,P5=CinCout25+Cout,P_{\mathrm{stack}}=C_{\mathrm{in}}C_{\mathrm{mid}}9+C_{\mathrm{mid}}+C_{\mathrm{mid}}C_{\mathrm{out}}9+C_{\mathrm{out}},\qquad P_5=C_{\mathrm{in}}C_{\mathrm{out}}25+C_{\mathrm{out}}, és az összehasonlítás már nem független a csatornaválasztástól. A VGG gyakorlatában a csatornaszámok fokozatosan nőnek, ezért a megtakarítás mértéke rétegenként eltérő, de a 3×33\times3-as választás a paraméterszámot az azonos csatornájú részekben csökkenti.

A paraméterkülönbséget szemlélteti a következő ábra:

5×5 mínusz 3×3-stack paraméterszám - Képletből számolt szemléltetés, nem mérés.

17.3.4 Kézi számpélda és ellenőrző kód

Legyen C=4C=4 minden rétegben, stride 1, padding 0, bemenet 11 csatorna helyett 44 csatorna, így a lemma feltétele teljesül. A bemeneti kép 10×1010\times10. A kimeneti méret padding nélkül:

A térbeli kimenet egyezik, a recepciós mező mindkettőnél 5×55\times5. A paraméterszám:

Pstack=18⋅16+2⋅4=288+8=296,P5=25⋅16+4=404.P_{\mathrm{stack}}=18\cdot16+2\cdot4=288+8=296,\qquad P_5=25\cdot16+4=404.

A stack tehát 404−296=108404-296=108 paramétert takarít meg, miközben ugyanazt a bemeneti tartományt fedi le, és egy extra ReLU-t is tartalmaz. Ezt a számítást a következő rövid Python-kóddal ellenőrizhetjük:

import torch
import torch.nn as nn

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

X = torch.randn(2, 4, 10, 10, dtype=dtype, device=device)

stack = nn.Sequential(
    nn.Conv2d(4, 4, kernel_size=3, padding=0),
    nn.ReLU(),
    nn.Conv2d(4, 4, kernel_size=3, padding=0),
)
single = nn.Conv2d(4, 4, kernel_size=5, padding=0)

def n_params(m):
    return sum(p.numel() for p in m.parameters() if p.requires_grad)

print("stack params:", n_params(stack))   # várt: 296
print("single params:", n_params(single)) # várt: 404

with torch.no_grad():
    y_stack = stack(X)
    y_single = single(X)
print("stack output shape:", y_stack.shape)   # várt: torch.Size([2, 4, 6, 6])
print("single output shape:", y_single.shape) # várt: torch.Size([2, 4, 6, 6])

A kód kimenete itt nem rögzített futtatásból származik; a kommentben megadott értékek a levezetett paraméterszámok és a konvolúciós alakképlet alapján elvárt ellenőrzések. A kód futtatása után ezeknek az értékeknek kell megjelenniük.

17.3.5 Labor: két blokk azonos inputon

A labor célja a fenti két blokk összehasonlítása azonos bemeneten, dokumentált kapacitással. A főút kis CPU-n fut, nincs GPU, nincs előtanított súly.

Input: saját generálású X∈ℝ1×1×9×9X\in\mathbb R^{1\times1\times9\times9}, float32, értékei a [−1,1][-1,1] intervallumból; a seed 20261020. A 11 csatorna a szürkeárnyalatos GlyphLab sémát idézi, de ez a labor nem használja a GlyphLab fájlokat, és nem tanít modellt.

Blokkok:

A labor tehát nem az azonos csatornás lemma feltételét használja, mert az első réteg a bemeneti 11 csatornát 44-re bővíti. A cél a shape-egyezés, a recepciós mező és a kapacitáskülönbség ellenőrzése, nem a paraméterazonosság.

Kód és futtatási parancs:

# fajl: lab_vgg_stack.py, futtatas: python lab_vgg_stack.py
import torch
import torch.nn as nn

torch.manual_seed(20261020)

X = torch.rand(1, 1, 9, 9, dtype=torch.float32)

blockA = nn.Conv2d(1, 4, kernel_size=5, padding=2)
blockB = nn.Sequential(
    nn.Conv2d(1, 4, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.Conv2d(4, 4, kernel_size=3, padding=1),
)

def n_params(m):
    return sum(p.numel() for p in m.parameters())

with torch.no_grad():
    yA = blockA(X)
    yB = blockB(X)

print("A params:", n_params(blockA))  # elvart: 104
print("B params:", n_params(blockB))  # elvart: 188
print("A shape:", tuple(yA.shape))    # elvart: (1, 4, 9, 9)
print("B shape:", tuple(yB.shape))    # elvart: (1, 4, 9, 9)
print("abs diff max:", (yA - yB).abs().max().item()) # veletlenszeru, nem 0

Ellenőrzés és eredményértelmezés. A futtatás során a két paraméterszámnak rendre 104104-nek és 188188-nak kell lennie. A shape-ek egyezése azt igazolja, hogy a padding úgy lett beállítva, hogy mindkét blokk ugyanazt a térbeli felbontást adja. Az elméleti RF mindkét blokkra 5×55\times5: a B blokk első rétege 33, a második 55 mezőt lát. A különbség a paraméterekben van, és a B blokk egy extra ReLU-t is tartalmaz. A labor nem végez tanítást, így a kimeneti tenzorok különbsége véletlenszerű; ott nem várunk zérust. A futtatás tényleges elvégzése után az eredmények rögzíthetők, de e kézirat a kimenetet nem állítja mértnek.

17.3.6 VGG: a kis kernelek használatának kontextusa

A [P05] Simonyan–Zisserman-tanulmány absztraktja nagyon mély, 1616–1919 súlyozott rétegű konvolúciós hálózatokat mutat be; a szerzők a hálózat nevében a VGG rövidítést használják. Az architektúra az [S01] kurzusjegyzet szerint kizárólag 3×33\times3-as konvolúciókat és 2×22\times2-es max-poolingot alkalmaz, a csatornaszámot 6464-ről duplázva 512512-ig növeli. A korábbi [P04] AlexNet ezzel szemben 11×1111\times11-es és 5×55\times5-ös kerneleket is használt, tehát a VGG a kernelméret csökkentésével egyszerűsítette a mintázatot.

A VGG-ben a 3×33\times3-as stack előnye nemcsak a paraméterszám. Ugyanazon 5×55\times5-ös mezőn belül két ReLU áll rendelkezésre, azaz a blokk kimenete egy mélyebb, darabonként lineáris függvény. Ez több döntési határt képes reprezentálni, mint egyetlen lineáris szűrő utáni ReLU. A paraméterszám-megtakarítás azonban a leglátványosabb a konvolúciós részekben: a lemma szerint azonos CC mellett a stack olcsóbb.

A VGG másik tanulsága a classifier cost. A hálózat végén a térbeli felbontás 7×77\times7-re csökken, a csatornaszám 512512, így az első teljesen összekötött réteg bemenete 512⋅7⋅7=25088512\cdot7\cdot7=25\,088 elem. Ha az első FC réteg 40964096 neuront tartalmaz, akkor annak súlymátrixa önmagában 25088⋅4096≈102,825\,088\cdot4096\approx102{,}8 millió paramétert ad, ami a hálózat paramétereinek döntő többsége. Ez a költség motiválta a későbbi architektúrákban a globális átlag-poolingot, de ez már a 19.2. MobileNet és inverted residual és későbbi egységek témája. Itt a VGG kapcsán annyit rögzítünk: a konvolúciós rétegekben a kis kernelek csökkentik a paraméterszámot, a teljes paraméterköltség viszont a FC fejben összpontosul.

17.3.7 Gyakori tévedés: „lineárisan ekvivalens”

Gyakran hallani, hogy „két 3×33\times3-as réteg ekvivalens egy 5×55\times5-ös réteggel”. Ez csak a recepciós mezőre igaz. A paraméterszámra sem igaz, ahogy a lemmában láttuk, és főleg az outputra nem igaz, ha a rétegek között ReLU áll.

Ellenpélda. Legyen X∈ℝ1×1×3×3X\in\mathbb R^{1\times1\times3\times3} egy egycsatornás kép, amelynek középső pixelértéke a∈ℝa\in\mathbb R, minden más eleme 00. Az első 3×33\times3-as kernel K1K_1 középső súlya legyen 11, a többi 00, padding 11, bias 00. Ekkor az első réteg kimenetének középső pozíciójában az érték aa, a többi pozíción 00. A ReLU után a középső érték max(a,0)\max(a,0). A második 3×33\times3-as kernel K2K_2 minden súlya 11, padding 11, bias 00. A második kimenet középső pozíciója a bemenő kép középső 3×33\times3-as ablakának összege; ott egyetlen nemnulla érték a max(a,0)\max(a,0), tehát a kimenet F(a)=max(a,0)F(a)=\max(a,0).

Ha létezne olyan 5×55\times5-ös lineáris kernel, amely ezzel a stackkel minden bemenetre megegyezik, akkor a fenti inputcsaládon a kimenet waw a alakú lenne valamilyen w∈ℝw\in\mathbb R-rel. Ekkor a=1a=1-re w=1w=1, a=−1a=-1-re pedig −w=0-w=0 lenne, ami ellentmondás. A stack tehát nem lineáris leképezés, így nem lehet egyetlen lineáris konvolúcióval azonos.

Ha a ReLU-t elhagyjuk, akkor a bias nélküli kompozíció valóban lineáris, és a bemenetre egyetlen effektív kernelként hat; de a VGG-blokk éppen a ReLU beiktatásával válik mély nemlineáris reprezentációvá.

17.3.8 Önellenőrzés és korábbi fogalmak visszahívása

Ellenőrizzük a lemmát C=1C=1-re: a stack paraméterszáma 18+2=2018+2=20, az 5×55\times5-ösé 25+1=2625+1=26, a különbség 66, ami a 7C2−C7C^2-C képletből 7−1=67-1=6. A recepciós mező mindkettőnél 55. A kimeneti méret padding nélkül 10×1010\times10-es bemeneten 6×66\times6 mindkét blokkra. A kernelstack definíciójában a ReLU a 13.3. Lokális szűrők és tanult reprezentáció affin linearitási ellenpéldájához hasonlóan töri meg a homogenitást: ott a biasos művelet tette affinná a leképezést, itt a ReLU teszi darabonként lineárissá. A 16.3. Elméleti és effektív recepciós mező rekurzióban a padding valóban nem szerepel a mezőképletben, csak a stride és a dilation. Végül az 5.3. Mintavételi bizonytalanság és intervallum tanulsága szerint ha a labor két blokkjának kimenetét összehasonlítjuk, az eltérés egyetlen seedből származó véletlen érték, nem statisztikai állítás a két architektúra minőségéről.

17.3.9 Feladatok

F1 (fogalmi, nehézség 1). Magyarázza el, mi a különbség a recepciós mező és a paraméterszám között, és miért nem elegendő a kettő egyezése ahhoz, hogy két blokkot ekvivalensnek nevezzünk. Térjen ki a ReLU szerepére. Elvárt eredmény: rövid, önálló szöveg, amely a két fogalmat definiálja, és az ellenpélda gondolatát saját szavakkal megismétli.

F2 (levezetési, nehézség 1). Adott C=8C=8 csatorna, stride 1, dilation 1, bias minden rétegben. Számítsa ki három egymás utáni 3×33\times3-as stack és egyetlen 7×77\times7-es réteg elméleti recepciós mezőjét és paraméterszámát. Ellenőrizze, hogy a megtakarítás 7C2−C7C^2-C mintájára milyen képlet adódik. Adja meg a kimeneti méretet is egy 12×1212\times12-es bemenetre padding nélkül. Elvárt eredmény: a kapott számok, a rekurzió lépései és az alakellenőrzés.

F3 (implementációs, nehézség 2). Írjon Python-függvényt, amely bemenetként megkapja a kernelek listáját k_list, a stride-ok listáját s_list, a dilation listáját d_list, a csatornaszámot C (minden réteg be- és kimenete), valamint egy bias logikai értéket. A függvény adja vissza az elméleti recepciós mezőt és a teljes paraméterszámot. Tesztelje a k_list=[3,3], s_list=[1,1], d_list=[1,1], C=4, bias=True esetre; az eredmény RF 55, paraméter 296296 legyen. Elvárt eredmény: futtatható kód, a teszt kimenete és a függvény forrásszövege.

F4 (hibakeresési, nehézség 2). Az alábbi modell állítólag a VGG-style 3×33\times3-as stacket valósítja meg:

class Stack(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 1, 3, padding=1)
        self.conv2 = nn.Conv2d(1, 1, 3, padding=1)

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

Lokalizálja a hibát, adja meg a következményt, javítsa a forward metódust, és adjon egy numerikus ellenőrzést, amely két ellentétes előjelű bemeneten mutatja, hogy a javított modell nemlineáris. Elvárt eredmény: a hibás rész megnevezése, a javított kód, és a teszt kimenetének leírása.

F5 (kísérleti tervezés/transzfer, nehézség 3). Tervezzen kísérletet a GlyphLab adaton arra a kérdésre, hogy egy 3×33\times3-as stack jobb-e, mint egyetlen 5×55\times5-ös réteg az orientációklasszifikációban. Adja meg a megfigyelési egységet, a spliteket, a baseline-t, a változó tényezőt, a metrikát, a seed- és checkpoint-kezelést, valamint az érvényességi korlátot. A válasz nem kérhet előre megadott győztest. Elvárt eredmény: protokollterv, a lehetséges alternatív értelmezések felsorolása.

17.3.10 Megoldások és indoklás

F1 megoldás. A recepciós mező az a bemeneti halmaz, amelytől egy kimeneti neuron értéke elvileg függhet; hosszát a 16.3. Elméleti és effektív recepciós mező rekurzió adja. A paraméterszám a modell tanulható skalárjainak száma: Cout(Cink2+1)C_{\mathrm{out}}(C_{\mathrm{in}}k^2+1) rétegenként bias-szal. Az egyező RF azt mondja, hogy ugyanazt a bemeneti tartományt olvassák, de a függvény alakja eltérhet. A ReLU megtöri a homogenitást: F(−x)≠−F(x)F(-x)\neq-F(x) általában, míg egy lineáris leképezésre mindig L(−x)=−L(x)L(-x)=-L(x). A szakasz ellenpéldájában a középső pixel aa értékére a stack F(a)=max(a,0)F(a)=\max(a,0)-t ad, ami nem lineáris; tehát az RF-egyezés nem ekvivalencia.

F2 megoldás. Három 3×33\times3-as rétegre a rekurzió: F1=1+2=3,F2=3+2=5,F3=5+2=7.F_1=1+2=3,\qquad F_2=3+2=5,\qquad F_3=5+2=7. A stride 1 miatt Jl=1J_l=1 minden ll-re, így az RF 7×77\times7. Egyetlen 7×77\times7-es réteg RF-je 1+(7−1)=71+(7-1)=7, tehát egyezik. A paraméterszám: Pstack=3(9C2+C)=27C2+3C,P7=C(49C+1)=49C2+C.P_{\mathrm{stack}}=3(9C^2+C)=27C^2+3C,\qquad P_7=C(49C+1)=49C^2+C. C=8C=8-ra: Pstack=27⋅64+24=1752,P7=49⋅64+8=3144,P_{\mathrm{stack}}=27\cdot64+24=1752,\qquad P_7=49\cdot64+8=3144, a megtakarítás 3144−1752=13923144-1752=1392. A különbség általános képlete 22C2−2C22C^2-2C, ami C≥1C\ge1-re pozitív. A kimeneti méret 12×1212\times12-es bemeneten padding nélkül: három 3×33\times3-as után 12−2−2−2=612-2-2-2=6, azaz 6×66\times6; egyetlen 7×77\times7-es után 12−7+1=612-7+1=6, azaz ugyanaz. Alakellenőrzés: a kernelstack minden közbülső kimenete CC csatornás, így a paraméterképlet konzisztens.

F3 megoldás.

def stack_rf_params(k_list, s_list, d_list, C, bias=True):
    J = 1
    F = 1
    total = 0
    for k, s, d in zip(k_list, s_list, d_list):
        F = F + (k - 1) * d * J
        J = J * s
        total += C * (C * k * k + (1 if bias else 0))
    return F, total

rf, params = stack_rf_params([3, 3], [1, 1], [1, 1], 4, True)
print(rf, params)   # 5 296

Ellenőrzés: F1=1+2=3F_1=1+2=3, F2=3+2=5F_2=3+2=5; paraméter mindkét rétegre 4(4⋅9+1)=1484(4\cdot9+1)=148, összesen 296296. A függvény szélső esete: ha k_list üres, F=1F=1, total=0, ami a bemeneti réteg RF-jét és paraméterszámát adja.

F4 megoldás. A hiba a forward metódusban van: hiányzik a ReLU a két konvolúció között. Következmény: a modell lineáris, tehát két lineáris konvolúció kompozíciójaként egyetlen effektív kernelre redukálható, és nem VGG-style stack. A javítás:

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

Numerikus ellenőrzés: generáljunk két 1×1×3×31\times1\times3\times3-as tenzort, az egyik középső pixel 11, a másik középső pixel −1-1, a többi 00. A javított modell kimenetének középső pozíciójában a bemeneti 11-re pozitív, −1-1-re nulla vagy eltérő érték adódik, míg a lineáris kompozícióra az értékek egymás negatívjai. A teszt futtatásakor a javított modell F(1)F(1) és F(−1)F(-1) értéke nem lesz egymás ellentettje, ami a nemlinearitást igazolja; a régi modellre viszont Flin(−1)=−Flin(1)F_{\mathrm{lin}}(-1)=-F_{\mathrm{lin}}(1) teljesül.

F5 megoldásminta. A protokoll a következő lehet. A megfigyelési egység a scene_id, mert a két nézet ugyanahhoz a jelenethez tartozik; a split a GlyphLab metadata.csv szerinti train/val/test, osztályonkénti jelenetszám 40/10/1040/10/10. A baseline egyetlen 5×55\times5-ös konvolúciós blokk: Conv(1→8, 5×5, padding 2), ReLU, MaxPool(2×2), majd egy FC fej. A változó tényező a konvolúciós blokk szerkezete: a kísérleti modell Conv(1→C, 3×3, padding 1), ReLU, Conv(C→8, 3×3, padding 1), ReLU, MaxPool, azonos FC fejjel. A C értéket úgy választjuk meg, hogy a konvolúciós blokk paraméterszáma a lehető legközelebb legyen a baseline 1⋅8⋅25+8=2081\cdot8\cdot25+8=208-hoz; például C=3C=3 esetén 1⋅3⋅9+3+3⋅8⋅9+8=30+224=2541\cdot3\cdot9+3+3\cdot8\cdot9+8=30+224=254, ami nem azonos, ezért a paraméterkülönbséget a riportban expliciten közöljük. A tanítás CPU-n, float32, Adam vagy SGD kereszt-entrópiával, 5-10 seeddel. A választás a legjobb val loss alapján történik, a tesztet csak a végén értékeljük, a corrupt tesztet külön, párosítva. A metrika a teszt accuracy; a seedek közötti szórást is jelentjük. Érvényességi korlát: a GlyphLab szintetikus, a paraméterszám nem pontosan egyezik, és az egyetlen adathalmazon mért különbség nem általánosítható természetes képekre. Az F5 tehát tervet és nem garantált eredményt ad; negatív eredmény is értékes.

17.3.11 Rövid összefoglaló

A két egymás utáni 3×33\times3-as, stride 1 konvolúció elméleti recepciós mezője 5×55\times5, pontosan akkora, mint egyetlen 5×55\times5-ösé. Azonos CC bemeneti és kimeneti csatornaszám mellett a stack paraméterszáma 18C2+2C18C^2+2C, az 5×55\times5-ösé 25C2+C25C^2+C, tehát a mélyebb változat kevesebb súlyt használ. A megtakarítás azonban nem jelenti a függvények lineáris ekvivalenciáját, mert a közbeiktatott ReLU nemlinearitást visz be; ezt egy egycsatornás ellenpélda igazolja. A VGG ezt az elvet használja, és a paraméterköltség jelentős része a teljesen összekötött fejben összpontosul. A labor két blokk forwardját és dokumentált kapacitását ellenőrzi.

17.3.12 Következő alkalmazás

A 17.4. Architektúra összehasonlítása kontrollált keretben egység architektúrákat hasonlít össze kontrollált keretben: a VGG, AlexNet és LeNet közötti különbségeket nem csupán leíró módon, hanem azonos adaton, azonos kereszt-entrópiával, rögzített seedekkel és dokumentált paraméterszámmal méri. Az itt levezetett paraméter- és RF-számítás ott alapellenőrzésként szolgál.

17.3.13 Felhasznált források