19.2 MobileNet és inverted residual

19.2.1 Cél, előismeret és induló becslés

A 19.1. Depthwise separable és pointwise réteg egységben szétválasztottuk a térbeli és a csatornakeverő operátort, és levezettük, hogy a depthwise separable kompozíció paraméter/MAC aránya a teljes konvolúcióhoz képest $\frac1{C_{out}}+\frac1{k_h k_w}$. Itt azt vizsgáljuk, hogyan rendezhető el ez a két művelet egy olyan reziduális blokkban, amelynek a bemenete és kimenete vékony, a köztes reprezentációja viszont széles. Ehhez a 18.1. Reziduális blokk és identitásút reziduális gondolatát, a 18.2. Batch normalization train és eval módban BatchNorm-életciklusát és a 15.2. Inputgradiens és átfedő recepciós mezők depthwise gradienst használjuk fel; osztályozási cél esetén a 7.2. Softmax és többosztályos cross-entropy logitos cross-entropy konvencióját.

Induló becslés. Egy 16 csatornás $8\times8$-as feature mapon egy $3\times3$-as teljes konvolúció $16\cdot16\cdot9=2304$ súlyt használ. Ha a 16 csatornát egy $1\times1$-es réteggel 48-ra növeljük, a depthwise szűrő $48\cdot9=432$ súlyt igényel, a visszavetítő $1\times1$ pedig $48\cdot16=768$ súlyt. Az inverted residual tehát nem attól takarékos, hogy a belső réteg széles; a nyereség abból jön, hogy a blokk határán lévő vékony reprezentációk közötti szomszédos blokkok $1\times1$-es csatornakeverései olcsók, a drágább térbeli szűrés pedig csatornánként szétválasztva fut a széles köztes téren.

A MobileNetV2 központi tervezési elvei az inverted residual, a linear bottleneck és az expanzió [P09]. Az eredeti blokk és a labor saját, egyszerűsített blokkja a [P09] alapján (3.2–3.3. szakasz, 2–3. o.; 1. táblázat és 4. fejezet, 4. o.; 2. táblázat és 4(d) ábra, 5. o.):

A saját blokk tehát oktatási egyszerűsítés, nem a közölt hálózat reprodukciója: más expanziós faktort és aktivációt használ, és csak egyetlen blokkot vizsgál, nem a 2. táblázat 19 reziduális bottleneck rétegét.

19.2.2 Definíciók: expanzió, lineáris bottleneck, inverted residual

A következő specifikáció didaktikai szerződés; a [P09] (absztrakt és 3.3. szakasz) szerint a be- és kimeneti reprezentáció thin bottleneck, a köztes expanziós rétegben lightweight depthwise szűrők dolgoznak, a linear bottleneck pedig a kis dimenzióban információt romboló nemlinearitást kerüli.

Definíció (expanziós réteg). Legyen $X\in\mathbb R^{N\times C_{in}\times H\times W}$ és $e\in\mathbb N_+$ az expanziós faktor. Az expanzió $1\times1$-es konvolúció, amelynek súlyalakja $W_e\in\mathbb R^{(eC_{in})\times C_{in}\times1\times1}$; kimenete $X_e\in\mathbb R^{N\times eC_{in}\times H\times W}$. A $W_e$ minden kimeneti csatornája a bemeneti csatornák lineáris kombinációját adja azonos térbeli pozícióban.

Definíció (köztes depthwise szűrő). A $C_t=eC_{in}$ köztes csatornán $k_h\times k_w$ méretű depthwise konvolúció fut, stride $s$, szimmetrikus zero padding $p$, $groups=C_t$. A [D10] szerint ez keresztkorreláció; a súlyalak $W_d\in\mathbb R^{C_t\times1\times k_h\times k_w}$.

Definíció (lineáris bottleneck). A záró $1\times1$-es projekciós réteg $C_t\to C_{out}$ csatornát vetít, $W_p\in\mathbb R^{C_{out}\times C_t\times1\times1}$. A projekció után nem alkalmazunk nemlinearitást; az aktivációs függvény és a normalizálás esetleges további elrendezése a konkrét modell receptjéhez tartozik, a döntő pont az, hogy a csatornacsökkentő $1\times1$ kimenetén a vékony reprezentációt nem törjük meg ReLU-val.

Definíció (inverted residual). A 18.1. Reziduális blokk és identitásút hagyományos reziduális blokk széles be- és kimenettel dolgozik, és középen szűkít. Az inverted residual ezt megfordítja: a be- és kimenet vékony ($C_{in}$ és $C_{out}$), a köztes expanzió széles ($eC_{in}$), a shortcut pedig a vékony reprezentációkat köti össze: $Y=F(X)+X$, ha az alakok ezt megengedik. A [P09] absztraktjában ez az „input and output of the residual block are thin bottleneck layers” megfogalmazás saját szavas összegzése.

A csatornaprofilok egy $C_{in}=C_{out}=4$, $e=3$ példán:

19.2.3 Width multiplier

A width multiplier (szélességi szorzó) $\alpha>0$ olyan globális skálázó tényező, amely a hálózat vékony csatornaszámait szorozza: $C_{in}\mapsto \alpha C_{in}$, $C_{out}\mapsto \alpha C_{out}$, a köztes expanzió pedig $e\alpha C_{in}$ lesz. A téralakok változatlanok; $\alpha$ megváltoztatása tehát nem érinti a skip téralak-feltételét, csak a csatornaszámokat.

A width multipliert ne keverjük az expanziós faktorral: $e$ egy blokkon belüli szélességarány, $\alpha$ a hálózat egészére ható erőforrás-skála. $\alpha=0.5$ és $e=3$ esetén a köztes csatornaszám $0.5\cdot3C_{in}=1.5C_{in}$ a képletekben; a megvalósítás ilyenkor kerekítési konvenciót igényel, ezért a labor egész $\alpha$ értékeket használ, vagy a kerekítést expliciten rögzíti. A [P10] absztraktja a width, depth és resolution együttes, koherens skálázását vizsgálja; a width multiplier ehhez kapcsolódó eszköz, a pontos MobileNetV2-beli értéktáblázat a [P09] teljes szakaszának ellenőrzését igényli.

19.2.4 Lemma: alakok, költség és a skip alkalmazhatósága

Lemma (inverted residual blokk alakja, paraméter- és MAC-költsége, skip-feltétele). Legyen $X\in\mathbb R^{N\times C_{in}\times H\times W}$. Az inverted residual blokk három konvolúcióból áll: $1\times1$ expanzió $C_{in}\to eC_{in}$, majd $k_h\times k_w$ depthwise szűrő $groups=eC_{in}$, stride $s\in\{1,2\}$, szimmetrikus padding $p$, dilation nélkül, végül $1\times1$ projekció $eC_{in}\to C_{out}$. A konvolúciós biast nullának vesszük; BatchNorm esetén annak affin paramétereit külön számoljuk. Ekkor:

1. Az expanzió kimenete $(N,eC_{in},H,W)$.
2. A depthwise kimenete $(N,eC_{in},H_s,W_s)$, ahol

$$H_s=\left\lfloor\frac{H+2p-(k_h-1)-1}{s}\right\rfloor+1,$$

és $W_s$ ugyanígy $W$-ből; a [D10] képlete $d=1$ mellett. 3. A projekció kimenete $Y\in\mathbb R^{N\times C_{out}\times H_s\times W_s}$. 4. A skip pontosan akkor alkalmazható e specifikációban, ha a rövid út $X$ és a főág $Y$ alakja azonos: $C_{in}=C_{out}$, $s=1$, és a padding biztosítja $H_s=H$, $W_s=W$. Ellenkező esetben az összeadás vagy hibát ad, vagy nem értelmezhető az adott specifikációban. 5. A konvolúciós súlyparaméterek száma bias nélkül

$$P=eC_{in}\left(C_{in}+k_h k_w+C_{out}\right),$$

a MAC-szám pedig

$$M=N\cdot H\cdot W\cdot eC_{in}^2 +N\cdot H_s\cdot W_s\cdot eC_{in}\cdot k_hk_w +N\cdot H_s\cdot W_s\cdot eC_{in}\cdot C_{out}.$$

Ha $C_{out}=C_{in}$ és $s=1$ mérettartó paddinggel, akkor

$$P=eC_{in}\left(2C_{in}+k_h k_w\right),\qquad M=eC_{in}\,N\,H\,W\left(2C_{in}+k_h k_w\right).$$

Bizonyítás. Mindhárom réteg a [D10] közölt keresztkorrelációs specifikációját követi. Az expanzió bemeneti csatornaszáma $C_{in}$, kimeneti $eC_{in}$, kernel $1\times1$; mivel a kernel nem nyúl túl a térbeli pozíción, a kimeneti téralak $(H,W)$. A depthwise $groups=eC_{in}$ beállítás azt jelenti, hogy minden bemeneti csatornához pontosan egy kimeneti csatorna tartozik, ezért a súlyalak $(eC_{in},1,k_h,k_w)$. A kimeneti méret a [D10] képlete $d=1$ esetén. A projekció kernel $1\times1$, így a téralak $(H_s,W_s)$ marad, a csatornaszám $C_{out}$. A (4) állítás az elemenkénti összeadás alakfeltételéből következik: $X+Y$ csak akkor értelmes, ha mind a négy dimenzió megegyezik; mivel itt $H_s,W_s$-et a stride/padding páros határozza meg, $s=1$ és $H_s=H,W_s=W$ szükséges. A paraméterszámok: az expanzió $C_{in}\cdot eC_{in}$, a depthwise $eC_{in}\cdot k_hk_w$, a projekció $eC_{in}\cdot C_{out}$ szorzata; a MAC minden kimeneti elemenként a kernel bemeneti elemszáma, ezért az expanzió $N\cdot H\cdot W\cdot eC_{in}\cdot C_{in}$ szorzás-akkumulációt ad, és így tovább. Ezzel a lemma bizonyított; ez saját levezetés, nem a [P09] tétele.

Következmény. A skip alkalmazhatósága a réteggráfon lokálisan ellenőrizhető: meg kell nézni a blokk be- és kimeneti csatornaszámát, a depthwise stride-ját és a téralak-megőrző paddinget. Stride $2$ esetén a rövid út kihagyandó, mert a főág downsamplinget hajt végre.

19.2.5 Kézi számpélda

Legyen $N=1$, $C_{in}=C_{out}=4$, $H=W=8$, $e=3$, $k_h=k_w=3$, $s=1$, $p=1$. Ekkor az alakok:

1. $X$: $(1,4,8,8)$;
2. expanzió után: $(1,12,8,8)$;
3. depthwise után: $H_s=\lfloor(8+2-2-1)/1\rfloor+1=8$, tehát $(1,12,8,8)$;
4. projekció után: $(1,4,8,8)$.

Skip: alkalmazható, mert $C_{in}=C_{out}=4$, $s=1$, és a $3\times3$, $p=1$ padding téralak-tartó. Paraméterek: $P=3\cdot4(4+9+4)=12\cdot17=204$. MAC: az expanzió $1\cdot64\cdot12\cdot4=3072$; a depthwise $1\cdot64\cdot12\cdot9=6912$; a projekció $1\cdot64\cdot12\cdot4=3072$; összeg $M=13056$.

Stride $2$ esetén ugyanezzel a bemenettel $H_s=\lfloor(8+2-2-1)/2\rfloor+1=4$, a projekció kimenete $(1,4,4,4)$. A skip nem alkalmazható, mert a rövid út $(1,4,8,8)$ alakú, a főág $(1,4,4,4)$; az elemenkénti összeadás shape hibát ad. Ha $C_{in}=4$ de $C_{out}=8$, stride $1$ mellett a téralak egyezne, de a csatornaszám nem; e specifikációban szintén nincs skip, mert vetítő shortcutot nem vezettünk be.

19.2.6 Labor: kis inverted residual blokk PyTorchban

A labor egyetlen fájl, lab/n074/inverted_residual_demo.py. Cél: a blokk implementálása, a stride $1$ és $2$ shape-ellenőrzése, valamint a konvolúciós paraméterszám összevetése a kézi 204 értékkel. A BatchNorm a 18.2. Batch normalization train és eval módban szerint train módban batchstatisztikát számol; a shape-re nincs hatása, ezért a labor shape-kontrollja a BN állapotától független, de a modell kiértékeléséhez később eval() mód kell.

# lab/n074/inverted_residual_demo.py
import torch
import torch.nn as nn

class InvertedResidual(nn.Module):
    """Didaktikai inverted residual, lineáris bottleneck-tel.

    F(X) = Project(Act(BN(DW(Act(BN(Expand(X)))))))
    Y    = F(X) + X, ha stride == 1 es cin == cout.
    """

    def __init__(self, cin, cout, expand=3, stride=1, activation=nn.ReLU):
        super().__init__()
        self.use_skip = (stride == 1) and (cin == cout)
        hidden = expand * cin
        self.conv = nn.Sequential(
            nn.Conv2d(cin, hidden, 1, bias=False),   # expanzió
            nn.BatchNorm2d(hidden),
            activation(),
            nn.Conv2d(hidden, hidden, 3, stride=stride,
                      padding=1, groups=hidden, bias=False),  # depthwise
            nn.BatchNorm2d(hidden),
            activation(),
            nn.Conv2d(hidden, cout, 1, bias=False),  # projekció, utána NINCS aktiváció
            nn.BatchNorm2d(cout),
        )

    def forward(self, x):
        y = self.conv(x)
        if self.use_skip:
            return y + x
        return y


def conv_params(module):
    """Csak a Conv2d súlyparaméterek száma, a BatchNorm affin paraméterei nélkül."""
    total = 0
    for m in module.modules():
        if isinstance(m, nn.Conv2d):
            total += sum(p.numel() for p in m.parameters())
    return total


def main():
    torch.manual_seed(20261020)
    x1 = torch.randn(1, 4, 8, 8, dtype=torch.float32)
    x2 = torch.randn(1, 4, 8, 8, dtype=torch.float32)

    m1 = InvertedResidual(4, 4, expand=3, stride=1)
    m2 = InvertedResidual(4, 4, expand=3, stride=2)

    y1, y2 = m1(x1), m2(x2)
    # A lemmából számított alakok; a futás assert-tel ellenőrzi.
    assert y1.shape == torch.Size([1, 4, 8, 8])
    assert y2.shape == torch.Size([1, 4, 4, 4])
    assert m1.use_skip is True
    assert m2.use_skip is False
    # Konvolúciós súlyok: 3*4*(4+9+4)=204; teljes modell ennél több a BN miatt.
    assert conv_params(m1) == 204
    print("y1 shape:", tuple(y1.shape))
    print("y2 shape:", tuple(y2.shape))
    print("conv params m1:", conv_params(m1))
    print("total params m1:", sum(p.numel() for p in m1.parameters()))

if __name__ == "__main__":
    main()

Futtatás a lab könyvtárból:

cd lab/n074
python inverted_residual_demo.py

A lab-profilban (PyTorch 2.14.1+cpu) mért kimenet: y1 shape: (1, 4, 8, 8), y2 shape: (1, 4, 4, 4), conv params m1: 204, total params m1: 260; minden assert teljesült. A teljes paraméterszámban a három BatchNorm affin paraméterei is benne vannak: a két rejtett ($eC_{in}=12$ csatornás) BatchNorm $2\cdot2\cdot12=48$, a kimeneti ($C_{out}=4$) $2\cdot4=8$, így $204+48+8=260$. A labor a konvolúciós 204 értéket ellenőrzi, hogy a lemmával összevethető legyen.

19.2.7 Feladatok

F1 (fogalmi, nehézség 1). Magyarázza el saját szavakkal, mit jelent az expanzió, a lineáris bottleneck és az inverted residual. Adja meg a csatornaprofilt $C_{in}=6$, $e=4$ esetén. Mitől „fordított” ez a 18.1. Reziduális blokk és identitásút hagyományos reziduális blokkjához képest? Egy ellenpéldával mutassa meg, hogy a 19.1. Depthwise separable és pointwise réteg depthwise separable sorozat önmagában még nem inverted residual. Átadandó: legfeljebb fél oldal, a három definíció, a profil $6\to24\to6$ és az ellenpélda.

F2 (levezetési, nehézség 2). Adott $N=2$, $C_{in}=C_{out}=8$, $H=W=16$, $e=2$, $k_h=k_w=3$, $s=2$, $p=1$, bias nélkül. Számolja ki az összes köztes tenzoralakot, $H_s$ értékét, a konvolúciós paraméterszámot és a MAC-et. Döntse el a skip alkalmazhatóságát, és írja fel az általános skip-feltételt. Átadandó: lépésenkénti levezetés alakellenőrzéssel és a skip indoklásával.

F3 (implementációs, nehézség 2). Módosítsa a laborblokkot úgy, hogy a main() függvény a fenti $N=2$, $C_{in}=8$, $e=2$, stride $2$ esetre is lefusson, és assert-ekkel ellenőrizze a kimeneti alakot, a use_skip értékét és a konvolúciós paraméterszámot. Átadandó: teljes futtatható kód, parancs, a várt értékek.

F4 (hibakeresési, nehézség 2). Az alábbi két hiba közül válasszon egyet, lokalizálja, írja le az okát és következményét, javítsa, és adja meg a visszaellenőrzés lépését.

# A) hibás skip: a stride-ot figyelmen kívül hagyja
self.use_skip = True
# B) hibás bottleneck: a projekció után is aktiváció fut
nn.ReLU(),
nn.Conv2d(hidden, cout, 1, bias=False),
nn.ReLU(),

Átadandó: diagnózis, javított kódrészlet, ellenőrző futtatás várt eredménye.

F5 (kísérleti/transzfer, nehézség 3). Tervezzen GlyphLab-kísérletet a width multiplier hatására: $\alpha=1.0$ baseline és $\alpha=0.5$ változat, minden más rögzített. Használja a 7.2. Softmax és többosztályos cross-entropy logitos cross-entropy konvencióját és a GlyphLab scene-szintű splitjét. Átadandó: kérdés, hipotézis, adat/split, baseline, változó tényező, metrika, best-checkpoint szabály, CPU erőforrás becslés és konkrét érvényességi korlát.

19.2.8 Megoldások és indoklás

F1. Az expanzió $1\times1$-es csatornanövelés $C_{in}\to eC_{in}$; a lineáris bottleneck a projekciós $1\times1$ utáni nemlinearitás elhagyása, hogy a vékony reprezentációt ne törje meg aktiváció; az inverted residual vékony be/kimenettel és széles köztes réteggel dolgozik, a shortcut a vékony reprezentációkat köti össze. $C_{in}=6$, $e=4$ profil: $6\to24\to6$. A 18.1. Reziduális blokk és identitásút hagyományos blokkja ezzel szemben széles határral és szűk középpel dolgozik; a „fordított” jelző erre a megcserélt profilra utal. A 19.1. Depthwise separable és pointwise réteg depthwise separable sorozat például $8\to8\to4$ csatornamenetet adhat, de nincs vékony–széles–vékony profil és nincs reziduális összeadás; tehát nem inverted residual.

F2. Bemenet $(2,8,16,16)$. Expanzió: $eC_{in}=16$, kimenet $(2,16,16,16)$. Depthwise $3\times3$, $s=2$, $p=1$:

$$H_s=\left\lfloor\frac{16+2-2-1}{2}\right\rfloor+1 =\left\lfloor\frac{15}{2}\right\rfloor+1=7+1=8,$$

kimenet $(2,16,8,8)$. Projekció: $(2,8,8,8)$. Skip nem alkalmazható, mert a rövid út $(2,8,16,16)$, a főág $(2,8,8,8)$; az általános feltétel az alakazonosság: $C_{in}=C_{out}$, $s=1$ és téralak-tartó padding mellett $H_s=H,W_s=W$. Paraméterek: $P=2\cdot8(8+9+8)=16\cdot25=400$. MAC: expanzió $N\cdot H\cdot W\cdot eC_{in}\cdot C_{in}=2\cdot256\cdot16\cdot8=65536$; depthwise $2\cdot64\cdot16\cdot9=18432$; projekció $2\cdot64\cdot16\cdot8=16384$; összeg $M=100352$. A kimeneti téralak $8\times8$ páros bemenetre pontos; páratlan $H$ esetén a floor-képlet adná a helyes értéket.

F3. A megoldás kiegészített main-részlete:

def main_extended():
    torch.manual_seed(20261020)
    x = torch.randn(2, 8, 16, 16, dtype=torch.float32)
    model = InvertedResidual(8, 8, expand=2, stride=2)
    y = model(x)
    assert y.shape == torch.Size([2, 8, 8, 8])
    assert model.use_skip is False
    assert conv_params(model) == 400
    print("F3 OK:", tuple(y.shape), conv_params(model))

A teljes fájl úgy futtatható, hogy ezt a függvényt is meghívjuk a main() után. A várt paraméterszám 400 az F2-ből; a shape pedig $(2,8,8,8)$.

F4. Az A) hiba oka: a use_skip engedélyezése stride $2$ mellett is; következménye a forwardban y + x kísérlet, ahol a főág $(N,C,4,4)$, a rövid út $(N,C,8,8)$; a PyTorch ilyenkor shape-mismatch hibát ad (a batch mérettől függetlenül), vagy véletlen broadcast esetén szemantikailag hibás eredményt. Javítás: self.use_skip = (stride == 1) and (cin == cout). Visszaellenőrzés: stride $2$ modellre forward hívás shape-asserttel, stride $1$ modellre a skip aktív. A B) hiba: a projekció után ReLU megtöri a lineáris bottleneck definíciót; a kis csatornaszámú kimenet további nemlinearitása pont azt a kockázatot hozza be, amelyet a [P09] absztraktja szerint a terv elkerül. Javítás: az utolsó ReLU törlése; visszaellenőrzés a blokk modullistájának vizsgálatával, hogy az utolsó konvolúció után csak BatchNorm áll.

F5. Minta terv. Kérdés: csökkenti-e $\alpha=0.5$ a GlyphLab top-1 pontosságát, és hogyan változik a korrupt teszt páros romlása? Hipotézis: a width csökkentése rontja a kapacitást, de kis adaton a regularizáló hatás részben ellensúlyozhat. Adat: GlyphLab data/images.npy, a rögzített scene-split; a modell kiválasztása csak a train/val spliten, a végső teszten egyszer. Változó tényező: $\alpha$; baseline az $\alpha=1.0$ azonos architektúra. Metrika: top-1 accuracy; a korrupt tesztet párosítva a clean testtel. Best checkpoint: legalacsonyabb val loss; a 7.2. Softmax és többosztályos cross-entropy szerint logitos CrossEntropyLoss, int64 target. Erőforrás: CPU, kis batch, például 32, a GlyphLab 24×24-es mérete miatt néhány ezer lépés. Korlát: a GlyphLab nem természetes képi benchmark; egy seed nem általánosítható, a width hatása a kis szélességek mellett kerekítésfüggő lehet; a korrupt teszt csak a befagyasztott modellen értékelhető.

19.2.9 Gyakori tévedés ellenpéldával

A MobileNet-család verzióit nem szabad részletezés nélkül összemosni. A MobileNetV1 szellemiségéhez a 19.1. Depthwise separable és pointwise réteg depthwise separable oszlopa áll közel; a MobileNetV2 a [P09] 3.2–3.3. szakasza szerint az inverted residual és linear bottleneck fogalmát vezeti be. Ha valaki azt mondja, hogy „a MobileNetV2 csak depthwise separable konvolúciók egymásutánja”, az ellenpélda a shortcut: a vékony–széles–vékony profil reziduális összeadása nem következik a separable kompozíció puszta definíciójából. Hasonló hiba a width multiplier és az expanziós faktor felcserélése: $\alpha=0.5$ az egész hálózat vékony csatornaszámait skálázza, $e=3$ pedig egy blokk belső szélességét; a kettő szorzata $\alpha eC_{in}$, nem pedig az $e$ „felezése” önmagában. A MobileNet további változatairól (V1, V3) e kézirat nem ad részletes blokkreceptet; a fenti táblázat csak a [P09]-ben ellenőrzött V2-blokkra vonatkozik.

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

Ellenőrizze, hogy (1) $e=1$ esetén a blokk profilja $C_{in}\to C_{in}\to C_{in}$; a depthwise továbbra is csatornánként szűr, és a shortcut feltétele a szokásos stride/padding szabály. (2) $C_{in}=4$, $C_{out}=8$, $s=1$, $p=1$ esetén a skip nem alkalmazható a csatornaeltérés miatt; az x + y shape hibát adna. (3) Stride $2$ mellett a depthwise downsamplingje után a projekció $1\times1$ már nem változtatja a téralakot, ezért a stride-ot a középső rétegben kell keresni. Visszahívás a 18.2. Batch normalization train és eval módban egységből: a BatchNorm train módban batchstatisztikát és futó buffert frissít, eval módban a running statisztikát használja; a blokk shape-lemmája ettől független, de egy tényleges tanítási kísérletben a módváltást a checkpoint-protokollal együtt kell rögzíteni. A 15.2. Inputgradiens és átfedő recepciós mezők egységből: a depthwise visszafelé menetben csatornánként scatter-add zajlik, az $1\times1$-es rétegek pedig csatornakeverő gradienst szállítanak. A 7.2. Softmax és többosztályos cross-entropy egységből: osztályozási fej logitsot adjon, cél int64, softmaxot ne tegyünk a loss elé.

19.2.11 Rövid összefoglaló

Az inverted residual blokk vékony be- és kimeneti reprezentációk közé széles, depthwise szűrővel feldolgozott expanziót illeszt; a projektáló $1\times1$ utáni nemlinearitás elhagyása a lineáris bottleneck. A lemmában levezettük az összes köztes alakot, a paraméter- és MAC-képleteket, valamint a skip alakfeltételét: $C_{in}=C_{out}$, stride $1$ és téralak-tartó padding. A $4\to12\to4$, $8\times8$-as példán a konvolúciós paraméterszám $204$, a MAC $13056$; stride $2$ esetén a skip nem alkalmazható. A width multiplier a vékony csatornákat globálisan skálázza, és nem azonos az expanziós faktorral. A labor PyTorchban ellenőrzi a shape-eket és a 204 súlyt; a futás e kéziratban nem elvégzett, a kimenet számított.

19.2.12 Következő alkalmazás

A 19.3. EfficientNet és architektúraskálázás egység az EfficientNet [P10] megközelítését tárgyalja: ott a width, depth és resolution együttes, koherens skálázását vizsgáljuk, ami a width multiplier itteni fogalmát hálózatszintű keresési problémává bővíti. A 19.4. ConvNeXt és a recept/architektúra elválasztása ConvNeXt-egység pedig a modernizált CNN-recepteket választja el az architektúra nevének puszta említésétől [P11].

19.2.13 Felhasznált források

• [P09] Sandler et al. (2018). MobileNetV2: Inverted Residuals and Linear Bottlenecks. arXiv:1801.04381 (v4). A hivatkozott helyek: 3.2–3.3. szakasz, 1–2. táblázat, 4. ábra, az arXiv-PDF-en ellenőrizve. https://arxiv.org/abs/1801.04381.
• [P10] Tan, M. és Le, Q. V. (2019). EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks. arXiv:1905.11946. https://arxiv.org/abs/1905.11946.
• [D10] PyTorch contributors (2.14). Conv2d. https://docs.pytorch.org/docs/2.14/generated/torch.nn.Conv2d.html.