32.3 Vision Transformer és hibrid felhasználás

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

Ez az alfejezet a Vision Transformer (ViT) képfeldolgozási szerződését építi fel: miként lesz egy $N\times C\times H\times W$ képtensorból tokensorozat, milyen induktív feltevéseket épít be a modell, és miben tér el a CNN lokális feltevésétől. Előismeret a 32.2. Scaled dot-product attention attention-definíciója (Q/K/V, softmax, skálázás, multi-head, pozíciókódolás), valamint a 13.2.–16.1. konvolúciós és ekvivariancia-fogalmai rövid visszahívással. Induló becslés: egy $24\times 24$ méretű GlyphLab-kép $8\times 8$ patchekkel hány tokent ad, és hány paramétere van egy $D=32$ dimenziós patch-beágyazásnak? A fejezet végére ennek pontos, alakellenőrzött válaszát és az ekvivalens konvolúciós megvalósítást is megadjuk.

32.3.2 Patch embedding mint tanult tokenizáció

Definíció (patch embedding). Legyen $X\in\mathbb R^{N\times C\times H\times W}$ egy képbatch. Rögzített patch-mérethez $P_h,P_w>0$ tegyük fel, hogy $P_h\mid H$ és $P_w\mid W$. Ekkor a térbeli rács:

$$n_h=\frac{H}{P_h},\qquad n_w=\frac{W}{P_w},\qquad L=n_h n_w.$$

Az $(i,j)$ patchvektor $x_{n,i,j}\in\mathbb R^{C P_h P_w}$ a

$$X[n,c,iP_h+a,jP_w+b],\qquad 0\le a<P_h,\ 0\le b<P_w,\ 0\le c<C$$

elemek rögzített sorrendű felsorolása. A teljes patch-mátrix $X_p\in\mathbb R^{N\times L\times(C P_h P_w)}$. A beágyazás egy $W\in\mathbb R^{D\times(C P_h P_w)}$ súlyú, $b\in\mathbb R^D$ torzítású affin leképezés:

$$Z=X_p W^\top+b,\qquad Z\in\mathbb R^{N\times L\times D},$$

ahol $b$ az $N$ és $L$ dimenziók mentén broadcastolódik. A ViT-ben ehhez a sorozathoz egy tanulható $z_{cls}\in\mathbb R^{1\times 1\times D}$ osztálytokent és egy $E_{pos}\in\mathbb R^{1\times(L+1)\times D}$ pozícióbeágyazást adnak, így a bemenő tokensorozat $Z^0=[z_{cls};\, Z]+E_{pos}\in\mathbb R^{N\times(L+1)\times D}$.

Lemma (a patch embedding mint nem átfedő konvolúció). Legyen $P_h\mid H$, $P_w\mid W$, $C,D$ tetszőleges. A fenti affin patch-beágyazás pontosan ugyanazt a $Z$ kimenetet adja, mint egy Conv2d(C, D, kernel_size=(P_h,P_w), stride=(P_h,P_w), padding=0) réteg, amelynek kimenetét $(N,D,n_h,n_w)$ alakról $(N,D,L)$-re lapítjuk, majd $(N,L,D)$-re permutáljuk — feltéve, hogy a konvolúciós súly $K\in\mathbb R^{D\times C\times P_h\times P_w}$ és a lineáris súly $W$ azonos indexsorrendben tartalmazza ugyanazokat a skalárokat.

Bizonyítás. Írjuk ki a konvolúció kimenetét egy rögzített $(n,o,i,j)$ pozícióra, ahol $o$ a kimeneti csatorna, $(i,j)$ a $3\times3$-as térbeli rács koordinátája. Mivel $k_h=P_h$, $k_w=P_w$, $s_h=P_h$, $s_w=P_w$ és $p=0$, a 14.1. Stride, padding, dilation és outputméret alakképlete szerint a kimeneti rács éppen $n_h\times n_w$, és a bemeneti ablak az $(i,j)$ patch:

$$Y[n,o,i,j]=\sum_{c=0}^{C-1}\sum_{a=0}^{P_h-1}\sum_{b=0}^{P_w-1} K[o,c,a,b]\,X[n,c,iP_h+a,jP_w+b]+b[o].$$

Az összeg ugyanaz a $C P_h P_w$ skalár szorzatösszege, mint a $Z[n,i n_w+j,o]=\sum_{r}W[o,r]X_p[n,in_w+j,r]+b[o]$ kifejezés, ha $W[o,(cP_h+a)P_w+b]=K[o,c,a,b]$. Mivel az ablakok nem fednek át, más patch nem szól bele az adott tokenbe. A két kimenet elemenként egyenlő. $\square$

Költség-összehasonlítás. A lemma két fontos következményt rögzít:

1. Paraméterszám: mindkét oldalon $D(CP_hP_w+1)$.
2. MAC-kép száma: képenként $L\cdot C P_h P_w\cdot D$.

Ha a stride kisebb a kernelnél, a tokenek száma és a recepciós mezők átfedése nő. Nem átfedő, $s=k$ esetén érdekes állandóság lép fel: $L=H W/(P_h P_w)$, ezért a beágyazás teljes MAC-száma $N\cdot H W\cdot C\cdot D$, független a patch-mérettől — csak a tokenek száma és az attention későbbi költsége változik. Átfedő ablaknál ($s<k$ vagy $p>0$) a képnkénti MAC az ablakméret és a tokenszám szorzataként nő.

32.3.3 A ViT architektúra alakjai

A ViT egy tiszta transzformer-encoder képklasszifikációra [P22]. Blokkonként, $z\in\mathbb R^{N\times(L+1)\times D}$ bemenetre a pre-norm reziduális szerkezet:

$$u=z+\operatorname{MHA}\big(\operatorname{LN}(z)\big),\qquad z'=u+\operatorname{MLP}\big(\operatorname{LN}(u)\big).$$

Az $\operatorname{MHA}$ a 32.2. Scaled dot-product attention alfejezetben definiált többfejű scaled dot-product attention: $Q=zW_Q^\top$, $K=zW_K^\top$, $V=zW_V^\top$ mind $(N,L+1,D)$ alakú, a figyelmi mátrix $QK^\top/\sqrt{D_{head}}\in\mathbb R^{N\times(L+1)\times(L+1)}$, a kimenet pedig $V$ konvex kombinációja. Az MLP két lineáris vetítésből és GELU-aktivációból áll, közbülső $D_{ff}>D$ szélességgel; a pontos $D_{ff}$ az eredeti publikáció hiperparamétere. A végső osztályozás a CLS-token $z_{cls}\in\mathbb R^{N\times D}$ kimenetén egy $W_{head}\in\mathbb R^{K\times D}$ fejjel számol logitot: $Z=z_{cls}W_{head}^\top+b_{head}\in\mathbb R^{N\times K}$.

A laborméretű példában $D=32$, $L=9$, $D_{ff}=64$ egyetlen blokk paraméterszáma: QKV-vetítés $3\cdot32\cdot32=3072$, kimeneti vetítés $32\cdot32+32=1056$, MLP $2\cdot(64\cdot32)+64+32=4192$, két LayerNorm $128$; összesen mintegy $8{,}4$ ezer paraméter. Ez csak a blokk; a teljes hálóhoz a beágyazás ($2080$), a CLS- és pozícióbeágyazás ($32+320$) is hozzáadódik.

32.3.4 Inductive bias: lokális és globális feltevés

Az inductive bias a modellcsaládba beépített, adattól független szerkezeti feltevés, amely leszűkíti a reprezentálható függvények halmazát. Két szinten érdemes elkülöníteni:

• CNN: a 16.1. Eltolási equivariance és invariance alfejezetben tárgyalt lokális recepciós mező és súlymegosztás már a háló definíciójában rögzíti az eltolási ekvivarianciát: egy kép eltolása a közbülső jellemzőtérkép eltolását eredményezi. Ez akkor hasznos, ha a feladat valóban lokális mintázatokból áll, és kevés adatból is stabil becslést ad.
• ViT pozíciókód nélkül: a tokenpermutációra ekvivariáns lenne, mert a per-token LayerNorm, az MLP és az attention a tokenek indexét nem használja. A tanulható abszolút $E_{pos}$ ezt a szimmetriát megtöri, de a beépített geometriai tudás így is sokkal gyengébb: az eltolási ekvivarianciát a modellnek az adatból kell megtanulnia.

Ebből következik a szakirodalom absztraktszintű állítása [P22]: a ViT kevesebb kép-specifikus induktív feltevést épít be, ezért nagy előtanító adat és számítás mellett a tanulás jó eredményt érhet el, Kis adaton viszont a CNN beépített lokalitása gyakran előnyösebb. Fontos: ez a szerzők absztraktjában megfogalmazott empirikus állítás, nem a jelen könyvben bizonyított tétel, és konkrét benchmarkszámot itt nem idézünk.

32.3.5 Adat- és számításigény

A két család számítási profilja eltérően skálázódik. Egy hagyományos konvolúciós réteg költsége a pixelek számában lineáris marad: $O(HW\cdot k_h k_w\cdot C_{in}C_{out})$. A ViT attention-része tokenpárokat számol, tehát $O\big((L+1)^2D\big)$ művelet blokkonként, ami a patch-méret csökkenésével négyzetesen nő. A $24\times24$-es példán:

• $P=8$ esetén $L=9$, attention-párok száma a CLS-sel együtt $10^2=100$;
• $P=3$ esetén $L=64$, a párok száma már $65^2=4225$;
• $P=1$ (pixelenkénti token) mellett $L=576$ és a párok száma $577^2\approx333$ ezer.

Az így számított skálázást szemlélteti az alábbi diagram (képletből számolt értékek, nem mért futás):

Vegyük észre a fenti lemma következményét: a beágyazás teljes költsége $s=k$ mellett független a patch-mérettől, tehát a patch-méret csökkentése elsősorban az attention-költséget növeli, nem a tokenizációt. A patch-méret ezért számítási döntés, nem pusztán felbontási kérdés.

32.3.6 CNN-hybrid felhasználás

A hibrid modell a két induktív feltevés kompozíciója: egy CNN gerinc először lokális jellemzőtérképet állít elő, majd ennek térbeli cellái lesznek a transzformer tokenjei. Formálisan $F=\operatorname{CNN}(X)\in\mathbb R^{N\times C_f\times H_f\times W_f}$, a tokenek $L'=H_f W_f$ darab $C_f$ dimenziós vektor, amelyeket egy $W_{proj}\in\mathbb R^{D\times C_f}$ vetítés képez $D$ dimenzióba:

$$Z_{hyb}=F_{flat}W_{proj}^\top+b_{proj}\in\mathbb R^{N\times L'\times D}.$$

A GlyphLab-példán: egy $3\times3$-as, stride 2, padding 1 konvolúció $1\to16$ csatornával $12\times12$-es térképet ad; egy második $16\to32$ csatornával $6\times6$-ot; ez $L'=36$ token, szemben a nyers kép $P=8$ patchelésének $9$ tokenjével. A hibrid tehát sűrűbb, már feldolgozott tokeneket ad, és a kezdeti lokális szűrők megtartják a CNN kedvező kisadatos viselkedésének egy részét. A globális kontextus másik útját a 31.3. Diffúziós zajmodell és CNN-denoiser U-Net-mély encoderében láttuk; az attention itt ezt a globális keverést minden blokkban közvetlenül elvégzi.

32.3.7 Foundation-use szerződés

Nagy előtanított ViT-ek felhasználása a 20.3. Preprocessing, domain shift és súlylicenc alfejezetben rögzített szerződést örökli: a súlycsomag enumja azonosítja a pontos változatot, a licenc a felhasználási feltételt, a preprocessing-szerződés pedig a bemeneti elvárást. Egy külső ViT általában rögzített felbontásra, RGB-csatornaszámra és normalizálásra van előtanítva; a $24\times24$ egycsatornás GlyphLab-kép közvetlen betáplálása domain shiftet jelent, és a teljesítményre semmilyen garancia nem vonatkozik automatikusan. A 28.3. Retrieval-értékelés és adatfelosztás alfejezetből ismert globális embedding-használathoz hasonlóan a CLS-token kimenete egy globális képdeszkriptor, de ennek minősége az előtanítási eloszláshoz kötött. Ebben a laborban külső súlyt nem töltünk be; a foundation-use csak szerződésszintű előkészítés.

32.3.8 Labor: CNN/ViT döntési lap azonos inputon

A labor célja nem modellverseny, hanem egy alak- és költségalapú döntési lap: ugyanarra a determinisztikus, $[0,1]$-beli $24\times24$ float32 NCHW képre felépítjük a konvolúciós és a lineáris patch-beágyazást, ellenőrizzük az ekvivalenciát, majd kiszámítjuk a token-, paraméter- és attention-alakokat. A kimenet itt kézzel számított várt referencia, nem rögzített mért futás — a kódot a hallgató futtatja le, és a max |diff| értéket neki kell ellenőriznie.

# munkakönyvtár: lab/n127_decision/
import torch

torch.manual_seed(20261020)          # véletlen súlyok reprodukálhatóságához
dtype = torch.float32
device = torch.device("cpu")

N, C, H, W, D, P = 1, 1, 24, 24, 32, 8
x = torch.arange(H * W, dtype=dtype, device=device).view(N, C, H, W) / (H * W - 1)

# 1) konvolúciós beágyazás: k=P, s=P, p=0
conv = torch.nn.Conv2d(C, D, kernel_size=P, stride=P, padding=0,
                       bias=True, device=device, dtype=dtype)

# 2) ekvivalens lineáris patch-beágyazás: a konvolúciós súly átrendezésével
lin = torch.nn.Linear(C * P * P, D, bias=True, device=device, dtype=dtype)
with torch.no_grad():
    lin.weight.copy_(conv.weight.reshape(D, C * P * P))
    lin.bias.copy_(conv.bias)

patches = x.unfold(2, P, P).unfold(3, P, P)      # (N, C, 3, 3, P, P)
patches = patches.permute(0, 2, 3, 1, 4, 5).reshape(N, -1, C * P * P)  # (N,9,64)

z_conv = conv(x).flatten(2).transpose(1, 2)       # (N,9,D)
z_lin = lin(patches)                               # (N,9,D)
diff = (z_conv - z_lin).abs().max().item()

print("konv súly:", tuple(conv.weight.shape), "bias:", tuple(conv.bias.shape))
print("linear súly:", tuple(lin.weight.shape), "bias:", tuple(lin.bias.shape))
print("tokenek:", z_conv.shape[-2], "D:", z_conv.shape[-1])
print("paraméterek konv/linear:",
      sum(p.numel() for p in conv.parameters()),
      "/", sum(p.numel() for p in lin.parameters()))
print("max |z_conv - z_lin|:", diff)

cls = torch.zeros((N, 1, D), dtype=dtype, device=device)
z = torch.cat([cls, z_lin], dim=1)                 # (N, 10, D)
qkv = torch.nn.Linear(D, 3 * D, bias=False, device=device, dtype=dtype)
q, k, v = qkv(z).chunk(3, dim=-1)                  # (N,10,D) mind
attn = (q @ k.transpose(1, 2)) * (D ** -0.5)       # (N,10,10)
print("attention-párok:", attn.shape[-1] * attn.shape[-2],
      "alak:", tuple(attn.shape))

Várt, képletekből számolt kimenet: konvolúciós súly $(32,1,8,8)$, lineáris súly $(32,64)$; tokenek száma $9$, $D=32$; paraméterszám mindkét oldalon $2080$; a lemma szerint max |z_conv - z_lin| konstrukcióból $0$ várható, float32 kerekítés miatt $10^{-6}$ alatt fogadjuk el. Az attention-párok száma $100$, alak $(1,10,10)$. A futtatás parancsa a lab/n127_decision/ könyvtárból: python decision_patch_conv.py.

A döntési lap tényrögzítő táblája:

A táblázat szándékosan nem tartalmaz minőségi rangsort: ilyen állításhoz adat, modellméret, tréningrecept és kiértékelési protokoll kell, amelyet itt nem tételezünk fel.

32.3.9 Feladatok

F1 — fogalmi (nehézség 1, előfeltétel: 32.2. Scaled dot-product attention, 16.1. Eltolási equivariance és invariance). Definiálja az inductive bias fogalmát, adjon egy-egy konkrét példát a CNN-re és a ViT-re, és magyarázza el, miért mondjuk, hogy a ViT kevesebb kép-specifikus induktív feltevést épít be. Átadandó: 200–400 szavas saját magyarázat, benne az eltolási ekvivariancia és a tokenpermutáció-szimmetria megkülönböztetése, valamint egy mondatban az adatmennyiségtől való várható függés.

F2 — levezetési (nehézség 2, előfeltétel: 14.1. Stride, padding, dilation és outputméret, 14.3. Paraméterszám, MAC és aktivációmemória). Egy $32\times32$-es, egycsatornás képre ($N=1$, $C=1$) számolja ki (a) a $P=8$, $D=48$ patch-beágyazás és (b) a $k=8$, $s=4$, $p=0$, $C_{out}=48$ konvolúciós beágyazás tokenszámát, paraméterszámát és képenkénti MAC-számát. Mutassa meg, melyik paraméterválasztás mellett lenne a konvolúció pontosan ekvivalens a patch-beágyazással, és indokolja a lemma feltételeiből. Átadandó: minden közbülső számítás, a 14.1. Stride, padding, dilation és outputméret alakképletének explicit alkalmazása és alakellenőrzés.

F3 — implementációs (nehézség 2, előfeltétel: 11.1.–11.2.). Írjon teljes, futtatható PyTorch-szkriptet, amely egy $1\times1\times16\times16$ méretű, determinisztikus arange-alapú float32 bemeneten ellenőrzi a lemma állítását $P=8$, $D=16$ mellett: a Conv2d(kernel_size=8, stride=8, padding=0) és az ekvivalens Linear kimenetének maximális abszolút eltérését $10^{-5}$ toleranciával kontrollálja. A súlyátvitelt a laborban látott módon végezze. Átadandó: teljes kód, seed, dtype, device, a szélsőeset ($P=H$) token- és alakeseménye, valamint a tolerancia indoklása.

F4 — hibakeresési (nehézség 2, előfeltétel: 13.1. Kép mint diszkrét többcsatornás jel, 32.3. Vision Transformer és hibrid felhasználás). Az alábbi töredék RGB-képen akar patch-tokeneket létrehozni, de a kimenet alakja $(1,27,64)$ lett a várt $(1,9,192)$ helyett. Lokalizálja a hibát, írja le a következményét az attention-bemenetre, javítsa a kódot, és adja meg a javítás utáni ellenőrző alakot:

x = torch.randn(1, 3, 24, 24)          # NCHW
pat = x.unfold(2, 8, 8).unfold(3, 8, 8) # (1,3,3,3,8,8)
tok = pat.reshape(1, -1, 8 * 8)         # (1,27,64) -- hibás

Átadandó: az ok, a szemantikai következmény (csatornák külön tokenként), a javított kód és a javítás utáni alak.

F5 — kísérleti/transzfer (nehézség 3, előfeltétel: 1.3. Adatfelosztás és a megfigyelési egység, 22.4. Augmentációs kísérlet és domainváltozás, 23.3. Páros összehasonlítás és csoportszintű intervallum). Tervezzen kis CPU-s kísérletet a GlyphLab adathalmazon egy rögzített kis CNN és egy azonos paraméterkeretű hibrid CNN–ViT összehasonlítására. A terv kötelező elemei: megfigyelési egység (scene_id), splitbetartás, baseline, egyetlen változó tényező, azonos tréningrecept, val-alapú checkpoint-választás, pontosság és jelenet-alapú bootstrap-CI, valamint a korrupt teszt csak a modellválasztás utáni használata. Tüntesse fel, mit nem állítunk a kísérletből. Átadandó: 1–2 oldalas protokollterv, keresési és erőforráskerettel, előre megjelölt nyertes nélkül.

32.3.10 Megoldások és indoklás

F1. Az inductive bias a tanuló modellcsalád szerkezetébe épített feltételezés, amely adat nélkül is leszűkíti a reprezentálható függvények körét. A CNN példája: a súlymegosztott kis kernel miatt a háló már definíció szerint eltolási-ekvivariáns, tehát egy $3\times3$-as minta felismerését nem kell minden pozícióban külön megtanulni. A ViT példája: pozíciókód nélkül a tokenek sorrendjére nézve ekvivariáns, tehát a térbeli viszonyok ismerete nincs beépítve; abszolút pozíciókóddal a modellnek ezt adatból kell megtanulnia. Kevés adaton a CNN erős feltevése csökkenti a varianciát, míg a ViT gyengébb feltevése több adatot igényelhet, cserébe rugalmasabban tanulhat globális összefüggéseket.

F2. (a) A $32\times32$, $P=8$ kép $n_h=n_w=4$ patchre bomlik, $L=16$ token. A beágyazási bemenet $d_{in}=C P_h P_w=64$, a kimenet $D=48$; paraméterszám $48\cdot64+48=3120$; MAC $L\cdot d_{in}\cdot D=16\cdot64\cdot48=49152$ képenként. (b) A 14.1. Stride, padding, dilation és outputméret képletével $H_{out}=\lfloor(32+2\cdot0-8)/4\rfloor+1=\lfloor24/4\rfloor+1=7$, tehát $L=49$ token. Paraméterszám $D(Ck_hk_w+1)=48\cdot65=3120$, azonos (a)-val, mert az ablakméretek is $64$ skalárt fednek. MAC képenként $L\cdot Ck_hk_w\cdot D=49\cdot64\cdot48=150528$, ami $49/16\approx3{,}06$-szorosa (a)-nak az átfedő ablakok miatt. A lemma feltétele szerint $k=P$ és $s=P$, $p=0$ mellett lenne ekvivalens a két beágyazás, tehát (b) csak $k=8,s=8,p=0$ választással egyezne meg (a)-val.

F3. A szkript vázlata a laborkód $16\times16$-ra módosított változata; a kimeneti kontroll: tokenek $4$ ($n_h=n_w=2$), a lineáris súly $(16,64)$, a konvolúciós súly $(16,1,8,8)$, paraméterszám $16\cdot64+16=1040$ mindkét oldalon. Szélsőeset $P=H=16$: $L=1$, tehát egyetlen token az egész kép, és az attention-párok száma CLS-sel $4$. A $10^{-5}$ tolerancia bőven a float32 kerekítési hibája fölött van, de kiszűri a hibás indexsorrendet; a konstrukcióból adódó eltérés $0$ vagy $10^{-7}$ nagyságrendű.

F4. A hiba a reshape előtti permute hiánya. Az unfold kimenete $(N,C,L_h,L_w,P,P)$ sorrendű, ezért a közvetlen reshape(N,-1,P*P) a csatornákat külön tokenként kezeli: $3\cdot3\cdot3=27$ token jön létre $64$ dimenzióval, és egy-egy patch csatornái szétválnak. Következmény: az attention háromszor annyi, csatornafosztott tokenen fut, a per-token recepciós mező egycsatornás $8\times8$ lesz, és a modell nem látja a színes patch teljes $192$ skalárját együtt. Javítás: tok = pat.permute(0, 2, 3, 1, 4, 5).reshape(1, 9, 192). Az ellenőrző alak $(1,9,192)$.

F5. A terv gerince: adat = GlyphLab images.npy/metadata.csv, train/val/test a jelenetalapú split szerint, a validáció és a CI egysége mindenütt scene_id. A vizsgált tényező kizárólag a modellcsalád: (A) kis CNN (például két konvolúciós blokk, azonos beágyazási paraméterszámmal), (B) hibrid CNN–ViT (a CNN utolsó térképe $P=6$ tokenre lapítva, egy attention-blokk). Rögzített tényezők: seedek, batch, epoch, optimizáló, augmentáció, célmetrika (pontosság), $24\times24$ input, CPU. A modellválasztás val-veszteség szerint történik, a teszt és a korrupt teszt csak utána kerül kiértékelésre; a bizonytalanságot jelenet-alapú bootstrap-CI-vel adjuk meg. Nem állítjuk: természetes képi általánosítást, a modellcsaládok általános fölényét, GPU- vagy nagyadatos viselkedést; ez egy kontrollált, kis méretű adaptációs megfigyelés.

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

A leggyakoribb hiba azt állítani, hogy „a ViT jobb a CNN-nél” vagy fordítva. Az állítás helyes formája mindig feltételes: melyik adat-, méret- és receptosztályon, milyen metrikával. Ellenpélda-pár a modellcsalád-fölény ellen: (i) ha a valódi címkefüggvény tisztán lokális, például a label csak a kép $3\times3$-as középső sávjának átlagától függ, egy kis CNN már a beépített lokalitással ezt meg tudja tanulni, míg a ViT-nek ugyanehhez előbb ki kell tanulnia, hogy a távoli tokenpárok irrelevánsak; (ii) ha a label két távoli pixel szorzatától függ, egyetlen attention-réteg közvetlenül képes a két pozíciót összekötni, míg egy sekély, kis kernelű CNN recepciós mezője ezt nem fedi. Ez a két konstrukció heurisztikus ellenpélda, nem formális lehetetlenségi tétel: elég mély CNN vagy elegendő adat mindkét esetben változtathat a képen. A tanulság: a fölény adat-, méret- és receptfüggő, és csak rögzített protokollú méréssel állítható — mint [P22] absztraktjában is, nagy előtanítás feltételéhez kötve.

32.3.12 Önellenőrzés

• A lemma feltételeiben szerepel-e minden oszthatósági és stride-konvenció? A jelölések követik-e a JELOLESEK-beli NCHW és Linear-súlyalakot?
• A paraméter- és MAC-számításoknál a bias és a batch dimenzió explicit?
• A laborban szerepel-e seed, dtype, device, futtatási parancs, és a kimenet jelölt számítás/szemléltetés, nem mérés?
• A F4 hibája után a permutált patch-sorrend valóban $(C,P_h,P_w)$ vektort ad tokenenként?
• Az összehasonlító állítások mellé megadtuk-e az adatot, a modellméretet, a tanítási protokollt és a mért metrikát? A források összefoglalóiból nem következtethetünk nem közölt architekturális részletekre vagy benchmarkértékekre.

32.3.13 Rövid összefoglaló

A patch embedding az $N\times C\times H\times W$ képet $N\times L\times D$ tokensorozatra vetíti; osztható méretnél ez pontosan egy $k=P$, $s=P$, $p=0$ konvolúcióval azonos lineáris leképezés, azonos paraméter- és MAC-számmal. A ViT ehhez CLS-tokent és tanulható pozíciókódot ad, majd pre-norm attention-blokkokat alkalmaz, amelyek globális tokenpár-interakciót számolnak. A CNN lokális, eltolás-ekvivariáns feltevést épít be; a ViT kevesebb kép-specifikus feltevéssel, adatból tanulja a geometriát. Hogy melyik család vezet, az adattól, mérettől és tréningrecepttől függ; a labor ezért csak alakeseményeket és költségeket rögzítő döntési lapot ad. A hibrid CNN–ViT a két feltevést kompozícióként egyesíti.

32.3.14 Következő alkalmazás és források

A következő egység, 32.4. VIII. ellenőrző pont: célhoz illő neurális modell, a VIII. ellenőrző pont: a CNN, a hibrid ViT és más modellcsaládok közötti választást a feladathoz, adathoz, mérethez és szerződéshez kell kötni; a jelen alfejezet alak-, költség- és induktívfeltevés-lapja ehhez ad döntési nyelvet.

Felhasznált források:

• [P21] Vaswani, A. et al. (2017). Attention Is All You Need. arXiv:1706.03762. https://arxiv.org/abs/1706.03762.
• [P22] Dosovitskiy, A. et al. (2020). An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale. arXiv:2010.11929. https://arxiv.org/abs/2010.11929.
• [B01] Deisenroth, M. P., Faisal, A. A., Ong, C. S. (2020). Mathematics for Machine Learning. Cambridge University Press. https://mml-book.github.io/.