19.3 EfficientNet és architektúraskálázás

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

A 19.2. MobileNet és inverted residual egységben a MobileNetV2 inverted residual blokkját és a width multiplier fogalmát vizsgáltuk. Ott a width multiplier egyetlen beállítás volt; most azt kérdezzük, hogyan skálázzuk együtt egy CNN mélységét, szélességét és bemeneti felbontását. Előismeret: a konvolúciós réteg MAC-számítása 14.3. Paraméterszám, MAC és aktivációmemória, a normrétegek paraméterezése 18.3. Pre-activation, kis batch és alternatív normalizálás, valamint az osztályozási loss-szerződés 7.3. Bináris, multilabel és regressziós cél. Induló becslés: ha egy hálózat minden csatornaszámát kétszerezzük, vajon a paraméterszám és a műveletszám is kétszereződik?

19.3.2 Definíciók és jelölések

Legyen egy baseline CNN $L_0$ darab $k_i\times k_i$ kernelű, stride 1-es, azonos térbeli alakot megőrző paddinges, groups=1 konvolúciós rétege. A bemeneti kép $H_0\times W_0$, az $i$-edik réteg bemeneti és kimeneti csatornaszáma $c_{in,i}$ és $c_{out,i}$. A bemeneti képbatch $X\in\mathbb R^{N\times C_{in}\times H\times W}$ NCHW alakú [D10].

A három skálázási dimenziót szorzókként értelmezzük:

• Width, $w$: minden belső réteg csatornaszámának közös szorzója. A width multiplier 19.2. MobileNet és inverted residual az egész hálózat csatornáira vonatkozik, ellentétben a blokkon belüli expansion faktorral.
• Depth, $d$: a blokkok/rétegszám szorzója; $dL_0$ rétegű változatot készítünk azonos alakú rétegek hozzáadásával.
• Resolution, $r$: a bemeneti felbontás szorzója, azaz $rH_0$ és $rW_0$ bemeneti méret; stride 1 és azonos padding mellett minden feature map mérete $r$-szeres.
• Compute budget, $B$: egy felső korlát a forward cross-correlation szorzás-akkumulálás műveletszámára (MAC), amelyen belül modellváltozatokat hasonlítunk.

A skálázott modell csatornáit $w c_{in,i}$-ként értelmezzük; valós $w$ esetén a tényleges implementáció egészre kerekít, de a költségmodellben valós szorzóval dolgozunk.

19.3.3 A skálázás számítási költsége

Állítás (a rögzített bemeneti csatornaszám hatása). Jelölje $M_{\mathrm{stem}}$ a rögzített bemeneti csatornaszámú első konvolúció, $M_{\mathrm{body}}$ pedig az utána következő, csatornák között skálázott konvolúciók baseline-MAC-ját. Ekkor $M_0=M_{\mathrm{stem}}+M_{\mathrm{body}}$. Tegyük fel, hogy a konvolúciók groups=1 típusúak, a térbeli méret mindkét tengelyen $r$-szeresére nő, és a csatornaszám-kerekítést figyelmen kívül hagyjuk. Ha a belső csatornaszámok $w$-szeresükre nőnek, változatlan mélység mellett a pontos skálázási képlet:

$$M(w,1,r)=r^2\left(w M_{\mathrm{stem}}+w^2 M_{\mathrm{body}}\right).$$

Ha a hálózatot ezenfelül olyan, alakkompatibilis belső blokkok ismétlésével mélyítjük, amelyek egy példányának alap MAC-ja $M_{\mathrm{body}}$, és amelyek között nem kell további illesztőréteg, akkor az erre a külön megadott építési szabályra érvényes képlet:

$$M(w,d,r)=r^2\left(w M_{\mathrm{stem}}+d w^2 M_{\mathrm{body}}\right).$$

Valós architektúrákban a depth skálázása új átmeneti vagy downsampling rétegeket igényelhet, ezért az utóbbi képlet ott közelítés, nem univerzális azonosság.

Indoklás. Egy standard keresztkorrelációs réteg MAC-ja $c_{out}c_{in}k^2 H_{out}W_{out}$. A belső rétegekben mindkét csatornadimenzió $w$-vel, a térbeli dimenziók szorzata $r^2$-tel változik, tehát a költség $w^2r^2$-szeres. Az első réteg bemeneti csatornaszáma viszont rögzített (például RGB-nél 3), így ott a költség $wr^2$-szeres. Alakkompatibilis belső blokk $d$-szeres ismétlése további $d$ tényezőt ad, míg az első réteg egyszer szerepel. A két költséget összeadva kapjuk a formulát.

A széles körben használt $dw^2r^2M_0$ szabály ezért csak közelítés. Ebben az egyszerű modellben a hozzá viszonyított eltérés:

$$M_{\mathrm{approx}}-M_{\mathrm{exact}} =r^2(dw^2-w)M_{\mathrm{stem}}.$$

$d=1$, $w\ge1$ esetén a közelítés relatív hibája $w\to\infty$ mellett nem nullához tart, hanem $M_{\mathrm{stem}}/M_{\mathrm{body}}$-hoz. A rögzített bemeneti csatornaszámú első réteg tehát akkor hanyagolható el, ha már a baseline költségéből is kis részt képvisel, nem pusztán attól, hogy a hálót szélesítjük. A bias-műveletek és BatchNorm paraméterei nem szerepelnek a konvolúciós MAC ezen definíciójában. A belső konvolúciók súlyparamétereinek költsége hasonló okból $w^2$-tel változik, de a teljes modell pontos paraméterszámához a stemet, a fejet és a normalizálást külön hozzá kell adni.

19.3.4 Compound scaling: az együttes elv

Az iménti költségállítás csak a műveletszámot írja le; abból nem következik, hogy milyen $w,d,r$ arány adja a legjobb pontosságot adott $B$ mellett. A [P10] absztraktjában ellenőrzött állítás szerint a szerzők azt találták, hogy a mélység, szélesség és felbontás kiegyensúlyozott, együttes skálázása jobb hatékonyságú modelleket adhat, mint egyetlen dimenzió növelése.

A módszer elterjedt paraméterezése az alábbi alakot használja. Egy $\phi$ compound coefficient és három pozitív, a keresés során rögzített arány $(a,b,c)$ mellett

$$d=d_0a^\phi,\qquad w=w_0b^\phi,\qquad r=r_0c^\phi,$$

ahol $d_0=w_0=r_0=1$ a baseline skálát jelöli. A fenti egyszerűsített, belső rétegek dominanciájára építő költségmodell szerint a MAC-szorzó közelítőleg

$$a^\phi (b^\phi)^2 (c^\phi)^2 = (ab^2c^2)^\phi,$$

tehát ha egy lépésben $\phi$ eggyel nő, és az $ab^2c^2\approx2$ feltételt választják, akkor a modell MAC-ja lépésenként körülbelül kétszereződik. Státusz: ez az algebrai szerkezet a fenti költségmodellből származtatható, de az, hogy mely $a,b,c$ értékek optimálisak, empirikus keresési eredmény, nem elméleti optimumtétel. A konkrét $a,b,c$ arányokat itt nem tételezzük fel, mert a választásuk adatokhoz és implementációhoz kötött empirikus keresés tárgya. Az alábbi ábra képletből számolt szemléltetés: a depth-only, width-only és resolution-only stratégia eltérő MAC-görbéje.

19.3.5 Kézi számpélda

Vegyünk egy $8\times8$-as, 3 csatornás bemenetű baseline modellt négy konvolúciós réteggel: $3\to4$, $4\to8$, $8\to16$, $16\to8$, mind $3\times3$ same padding, stride 1. Az egyes rétegek MAC-ja:

$$m_1=4\cdot3\cdot9\cdot64=6912,\quad m_2=8\cdot4\cdot9\cdot64=18432,$$

$$m_3=16\cdot8\cdot9\cdot64=73728,\quad m_4=8\cdot16\cdot9\cdot64=73728,$$

tehát $M_0=172\,800$. Válasszunk $w=2$, $d=1$, $r=2$ skálázást. Az egyszerűsített $dw^2r^2M_0$ becslés $1\cdot4\cdot4\cdot172\,800=2\,764\,800$. A pontos érték, az első réteg $3\to8$ alakjával számolva: $55\,296+294\,912+1\,179\,648+1\,179\,648=2\,709\,504$. A közelítő hiba $55\,296$ MAC, azaz körülbelül $2\%$ a pontos költséghez viszonyítva. Nagyobb $w$ esetén ez az arány nem szükségképpen csökken: $d=r=1$-nél a tényleges költséghez viszonyított relatív hiba határértéke $M_{\mathrm{stem}}/M_{\mathrm{body}}\approx4{,}17\%$.

19.3.6 Minimális kód és labor

A labor két kis modellt hasonlít össze azonos bemeneten: width=1.0 és width=1.4. A mérés CPU-n fut, float32 dtype-tal, rögzített seed mellett. A kód a lab/n075/ munkakönyvtárban futtatható:

# lab/n075/n075_scale_bench.py
import time
import torch
from torch import nn

def make_cnn(width, base=(16, 32, 64, 128), num_classes=10):
    ch = [max(1, int(c * width)) for c in base]
    layers, prev = [], 3
    for c in ch:
        layers += [nn.Conv2d(prev, c, 3, padding=1),
                   nn.BatchNorm2d(c), nn.ReLU()]
        prev = c
    layers += [nn.AdaptiveAvgPool2d(1), nn.Flatten(),
               nn.Linear(prev, num_classes)]
    return nn.Sequential(*layers)

def count_params(model):
    return sum(p.numel() for p in model.parameters())

def bench_forward(model, x, warmup=5, iters=30):
    model.eval()
    with torch.no_grad():
        for _ in range(warmup):
            model(x)
        t0 = time.perf_counter()
        for _ in range(iters):
            model(x)
        t1 = time.perf_counter()
    return (t1 - t0) / iters

torch.manual_seed(0)
x = torch.randn(4, 3, 24, 24, dtype=torch.float32)
for w in (1.0, 1.4):
    m = make_cnn(w)
    t = bench_forward(m, x)
    print(f"width={w:.1f} params={count_params(m):,} forward={1000*t:.2f} ms")

Jelölt, nem elvégzett kimenet: a fenti kézi arányból várt nagyságrend width=1.0 esetén mintegy 99 210 paraméter, width=1.4 esetén mintegy 190 000 paraméter; a forward idő 24×24-es CPU batch esetén jellemzően 1–20 ms, de ez hardverfüggő, és mérési eredménynek nem tüntethető fel. Az összehasonlítás azonos gépen, azonos folyamaton belül, melegítés és ismétlés mellett értelmes; small batch esetén az időmérés zaját a melegítési és ismétlési szám növelésével kontrolláljuk.

19.3.7 Konkrét labor: két modell méret- és időmérése

Protokoll. Kérdés: hogyan változik a méret és az inference-idő a width növelésekor? Input: egy rögzített 4×3×24×24-es véletlen float32 tensor; modellek: a fenti make_cnn két width értékkel. Eszköz: helyi CPU, device="cpu", torch.no_grad() és model.eval(). Seed: torch.manual_seed(0) csak a bemenet és a súlyok inicializálásához szükséges; a mérési zajt melegítés és 30 ismételt forward átlaga kezeli. Parancs: python n075_scale_bench.py. Ellenőrzés: a paraméterszámok az alábbi táblázatban várható, a futásidő környezetfüggő.

Az átadandó eredmény: a tényleges futás után a nyers mért időpár, a hányados, a PyTorch-verzió és a processzor azonosítója. A fenti táblázat számított, nem futtatott eredmény; a labor akkor vált ellenőrzötté, ha a hallgató saját környezetben rögzíti a nyers kimenetet.

19.3.8 Feladatok

F1 (fogalmi, nehézség 1). Magyarázza el, miért nem azonos a width multiplier $w$ és a MobileNetV2 expansion faktor $t$. Adjon egy ellenpéldát, amelyben az egyik nő, a másik nem.

F2 (levezetési, nehézség 2). A fenti baseline $M_0=172\,800$ MAC-ú modellre $w=1.5$, $d=3$, $r=1$ választást alkalmazunk. Vezesse le az egyszerűsített közelítő MAC-szorzót, majd az elméleti, alakkompatibilis belső blokk ismétlésének feltétele mellett a stem–body képlet szerinti MAC-ot. Adja meg a $w^2d$ belső paraméterszorzót is.

F3 (implementációs, nehézség 2). Írjon függvényt scale_estimate(M0, w, d, r), amely az egyszerűsített költségbecslést adja vissza, majd ellenőrizze a $(M_0,w,d,r)=(172800,2,1,2)$ bemenetre a 2 764 800-as értéket. Tolerancia: relatív $10^{-3}$.

F4 (hibakeresési, nehézség 2). Az alábbi kód a MAC-szorzót lineárisnak számolja: cost = w*d*r*M0. Mi a hiba, mi a következménye egy skálázási döntésben, és hogyan javítjuk? Ellenőrizze az F3 példán.

F5 (kísérleti/transzfer, nehézség 3). Tervezzen GlyphLab-kísérletet adott $B$ compute budget mellett: három változat – depth-növelés, width-növelés, és a kettő kombinációja –, azonos $B$-re beállított MAC-kal. Adjon megfigyelési egységet, splitet, baseline-t, metrikát és következtetési korlátot.

19.3.9 Megoldások és indoklás

F1. Az expansion faktor egy blokk belső expanziós rétegének csatornaszorzója, míg a width multiplier a teljes hálózat minden konvolúciós rétegének csatornáit skálázza. Ellenpélda: egyetlen bottleneck blokkban $t=6$, de $w=1$; hálózatszintű $w=2$ mellett a blokk bemeneti/kimeneti vékony csatornája duplázva van, a belső expanziós arány $t$ változatlan maradhat.

F2. Az egyszerűsített költségszorzó $d w^2 r^2=3\cdot1{,}5^2\cdot1^2=6{,}75$, így a közelített MAC $6{,}75\cdot172\,800=1\,166\,400$. Az alakkompatibilis belső blokk ismétlését feltételező pontos képlet $M_{\mathrm{stem}}=6912$, $M_{\mathrm{body}}=165\,888$ mellett $1{,}5\cdot6912+3\cdot1{,}5^2\cdot165\,888=1\,130\,112$ MAC. A belső súlyparaméterek skálaszorzója $w^2d=6{,}75$; a stem és a fej külön számolandó.

F3. Megoldás:

def scale_estimate(M0, w, d, r):
    return d * (w ** 2) * (r ** 2) * M0

out = scale_estimate(172800, 2.0, 1.0, 2.0)
assert abs(out - 2_764_800) / 2_764_800 < 1e-3

A hányados-ellenőrzés a közelítő képlet implementációját ellenőrzi, nem a tényleges modell MAC-jával való egyezést. Az utóbbihoz a stem és a belső blokkok költségét külön kell számolni.

F4. A kód a depth $d$-vel való közelítő lineáris skálázását tartalmazza, de a felbontás két tengelyének együttes $r^2$ hatását és a width belső rétegekre érvényes $w^2$ hatását nem: minden belső rétegben a súly csatorna-csatorna szorzata $w^2$ miatt nő. Következmény: a modell a tényleges MAC-ját alulbecsüli, így adott budgetre túl nagy width-et választ. Javítás: cost = d * w**2 * r**2 * M0. Az F3 példán 2**2 * 1 * 2**2 * 172800 = 2764800, ellentétben a hibás 2*1*2*172800=691200 értékkel.

F5. Lehetséges terv. Input: data/images.npy 360×1×24×24, címke data/labels.npy. Megfigyelési egység: scene_id, mert a két nézet ugyanahhoz a jelenethez tartozik; a train/val/test felosztás jelenetszintű, class-stratified, és a corrput teszt csak a végén használható. Baseline: a 19.2. MobileNet és inverted residual alfejezetbeli kis modell változatlanul. Változó: három változat, MAC-juk a compute budgetre normálva; a felbontás 24×24-en rögzített, ezért a resolution tengelyt kihagyjuk vagy csak kis r=1 marad. Metrika: validálási cross-entropy, választás a legjobb validációs checkpointtal; záróteszt accuracy a clean–corrupt páron. Következtetési korlát: GlyphLab nem természetes képi benchmark, ezért az eredmény csak a toy-domainre érvényes.

19.3.10 Tipikus tévedés és ellenpélda

Gyakori tévedés, hogy a compound scaling képlete minden hardverre optimális szabály. Ellenpélda: memória-sávszélesség-korlátos eszközön a resolution növelése $r^2$-es aktivációmemória-növekedést okoz, míg a depth növelése soros függőséget visz a futásidőbe; ugyanaz a MAC-budget más-más optimumot ad CPU-n és GPU-n. A heurisztika tehát keresési kiindulópont, nem hardverfüggetlen tétel.

19.3.11 Önellenőrzés és visszahívás

Ellenőrizze: a költségmodell feltevései között szerepel a stride 1, a méretmegtartó padding, a groups=1, valamint a csatornaszámok kerekítésének elhagyása; a bias tag alacsonyabb rendű; a compound képlet arányai empirikusak. A width multiplier 19.2. MobileNet és inverted residual fogalmát most hálózatszintű költségskálázásként alkalmaztuk; a BatchNorm paraméterei 18.3. Pre-activation, kis batch és alternatív normalizálás a csatornaszámokkal együtt $w$-vel nőnek, a loss-szerződés 7.3. Bináris, multilabel és regressziós cél viszont független a skálázástól.

19.3.12 Rövid összefoglaló

A depth, width és resolution külön mérhető skálázási tengely. A feltételesen pontos stem–body költségmodellből levezethető a $d\,w^2r^2$ közelítő MAC-szorzó és a belső súlyparaméterek $w^2d$ skálázása; az első réteg külön kezelendő, és relatív költsége csak akkor hanyagolható el, ha a baseline-ban is kicsi. A compound scaling e három tengelyt egy $\phi$ együtthatóval hangolja, de a konkrét arányok empirikus keresésből származnak, nem elméleti optimumból. A labor két width értékű kis modell méretét és CPU-idejét veti össze; a kimenet e kéziratban jelölt szemléltetés. A képlet hardverfüggősége miatt az eredmény helyi, nem általános optimalitási garancia.

19.3.13 Következő alkalmazás

A 19.4. ConvNeXt és a recept/architektúra elválasztása egység ConvNeXt kapcsán a modernizált CNN-recepteket vizsgálja [P11], ahol a skálázást az architektúra-változtatástól elkülönítve értelmezzük.

19.3.14 Források

• [P10] Tan és Le (2019). EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks. https://arxiv.org/abs/1905.11946.
• [D10] PyTorch contributors (2.14). Conv2d. https://docs.pytorch.org/docs/2.14/generated/torch.nn.Conv2d.html.