29.3 Regularizált latent reprezentáció

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

A 29.2. Denoising és korrupciós modell egységben az autoencodert egy konkrét szerződésként írtuk fel: a bemenet a zajos $x'$, a tanulási cél a tiszta $x$, az encoder–decoder páros pedig a rekonstrukciós hibát csökkenti. Ebben az alfejezetben a rekonstrukció mögötti latent reprezentációt vizsgáljuk. A szükséges előismeret a 25.3. Kis adat és feature-alapú baseline lineáris pixel-baseline gondolata, a 28.3. Retrieval-értékelés és adatfelosztás csoportos kiértékelési fegyelme és a 17.3. VGG és kis kernelek kompozíciója kapacitás/recepciós mező megkülönböztetése.

Induló kérdés: ha egy autoencoder empirikus rekonstrukciós hibája nulla, következik-e ebből, hogy a $z=f(x)$ kód „szemantikailag” használható, például egy lineáris osztályozó fejjel jól leolvasható? A válasz nem: a triviális identitásleképezés tökéletesen rekonstruálhat, miközben semmilyen új, downstream feladat számára kedvező átrendezést nem végez.

29.3.2 Autoencoder, kapacitás és identitásleképezés

A fejezet jelölésében a bemenet $x\in\mathbb R^d$. A GlyphLab-kép $C=1$, $H=W=24$ méretű NCHW-tensor, ezért a vektorizált bemenet dimenziója $d=576$. Egy batch $X\in\mathbb R^{N\times d}$ soronként egy-egy megfigyelést tartalmaz.

D1 (autoencoder és rekonstrukciós loss). Az encoder $f_W:\mathbb R^d\to\mathbb R^b$, a decoder $g_V:\mathbb R^b\to\mathbb R^d$, ahol $W,V$ a tanulandó paraméterek. A latent kód

$$z=f_W(x)\in\mathbb R^b, \qquad \hat x=g_V(z)\in\mathbb R^d .$$

Az empirikus rekonstrukciós veszteség elemenkénti átlagolással:

$$L_{\mathrm{rec}}(f_W,g_V;X) =\frac{1}{Nd}\sum_{n=1}^{N}\sum_{j=1}^{d} \left(x_{n,j}-g_V(f_W(x_n))_j\right)^2 .$$

Az $1/(Nd)$-es normálásnak itt nincs valószínűségi jelentése; pusztán az átlagos négyzetes eltérést adja batch- és pixelméreten.

D2 (bottleneck). Bottlenecknek vagy szűkületnek azt nevezzük, amikor $b<d$. A kód tehát kisebb dimenziójú, mint a bemenet. Ha $b=d$, akkor a modell magában foglalhatja a triviális megoldást:

$$f_W(x)=x,\qquad g_V(z)=z,$$

amelyre minden bemeneten $L_{\mathrm{rec}}=0$. Ez a triviális identitásleképezés. Fontos, hogy a $b<d$ feltétel sem oldja meg automatikusan a tanulási problémát: alacsony dimenziós altéren is létezhet olyan kód, amely a downstream feladat szempontjából rossz, vagy éppen összeomolhat a 29.2. Denoising és korrupciós modell alfejezetben tárgyalt módon.

D3 (latent collapse). Azt mondjuk, hogy a $j$-edik latent koordináta összeomlott egy adott $Z\in\mathbb R^{N\times b}$ mátrixon, ha a koordinátánkénti szórása közel nulla. A $j$-edik koordinátára

$$\operatorname{std}_j(Z) =\sqrt{\frac{1}{N-1}\sum_{n=1}^{N}\left(z_{n,j}-\bar z_j\right)^2}, \qquad \bar z_j=\frac1N\sum_{n=1}^{N}z_{n,j}.$$

Teljes collapse esetén minden koordináta szórása eltűnik, tehát a decoder minden inputhoz lényegében ugyanazt az értéket kapja, és a rekonstrukció csak egy konstans képet tud előállítani. Részleges collapse ennél gyakoribb: egy dead unit nulla vagy konstans, a többi koordináta viszi az információt.

29.3.3 A rekonstrukcióból nem következik szemantikai tudás

Ahhoz, hogy a „szemantikai tudást” matematikailag kezelhessük, nem definiáljuk általános filozófiai fogalomként. Rögzítünk egy downstream feladatot $y$-nal, és egy lineáris leolvasó családot:

$$q(z)=Az+c,\qquad A\in\mathbb R^{K\times b},\;c\in\mathbb R^K,$$

többosztályú logitokkal, vagy bináris esetben $q(z)=a^\top z+c$ előjelfüggvénnyel. A „jobb reprezentáció” ekkor azt jelenti: a rögzített $q$-családdal, azonos adatfelosztás mellett nagyobb downstream pontosság érhető el.

1. állítás (identitásleképezés mint ellenpélda, saját bizonyítás). Legyen a bemenetek halmaza

$$X_0=\{(1,1),(-1,-1),(1,-1),(-1,1)\}\subset\mathbb R^2,$$

minden pont egyenletes valószínűséggel. Legyen a downstream címke

$$y=1[x_1x_2>0],$$

tehát $y(1,1)=y(-1,-1)=1$, a másik két ponté $0$. Tekintsük a $b=d=2$ triviális identitás-autoencodert: $f(x)=x$, $g(z)=z$. Ekkor

$$L_{\mathrm{rec}}=0.$$

Ugyanakkor ezen a reprezentáción egyetlen lineáris osztályozó sem érhet el $4/4$ downstream pontosságot.

Bizonyítás. Legyen a lineáris leolvasó $q(x)=\alpha x_1+\beta x_2+\gamma$, és döntsünk $q>0$ esetén $1$, egyébként $0$ mellett. Ha mindkét pozitív mintát jól osztályoznánk, akkor

$$\alpha+\beta+\gamma>0, \qquad -\alpha-\beta+\gamma>0 .$$

A kettőt összeadva $2\gamma>0$, azaz $\gamma>0$. Ha mindkét negatív mintát is jól osztályoznánk, akkor

$$\alpha-\beta+\gamma\le 0, \qquad -\alpha+\beta+\gamma\le 0 .$$

Ezeket összeadva $2\gamma\le 0$, azaz $\gamma\le 0$. Ez ellentmond $\gamma>0$-nak, tehát a négy pont nem osztályozható tökéletesen. A $3/4$ pontosság éles: az $\alpha=10$, $\beta=10$, $\gamma=-0{,}1$ választással

$$q(1,1)=19{,}9>0,\quad q(-1,-1)=-20{,}1\le 0,\quad q(1,-1)=-0{,}1\le 0,\quad q(-1,1)=-0{,}1\le 0,$$

ami három helyes döntést ad. $\square$

A kontraszt kedvéért vegyük ugyanezen a négy ponton a következő, szintén $b=2$ dimenziós reprezentációt:

$$f_1(x_1,x_2)=(x_1x_2,x_1), \qquad g_1(u,v)=\left(v,\frac{u}{v}\right).$$

A négy ponton $v=x_1\in\{-1,1\}$, ezért az osztás értelmes, és $g_1(f_1(x))=x$ mind a négy esetben. Tehát ennek a modellnek is

$$L_{\mathrm{rec}}=0.$$

A $q_1(u,v)=u$ lineáris leolvasó viszont mind a négy pontot jól osztályozza, mert $x_1x_2>0$ pontosan akkor, ha $u>0$. Az 1. állítás következménye tehát nem az, hogy a kis rekonstrukciós hiba „rossz”, hanem az, hogy önmagában nem bizonyítja a downstream hasznosságot. A két modell azonos kapacitással és azonos rekonstrukciós hibával is eltérő downstream viselkedést adhat.

A bizonyításnak van egy gyakorlati geometriai üzenete is: az identitás encoder megtartja a bemenet koordinátarendszerét. A downstream feladatot leíró döntési határ ebben a koordinátarendszerben nem lineáris, ezért a lineáris fej nem tudja leolvasni. Egy alkalmas nemlineáris encoder viszont kiszámíthat egy olyan új koordinátát, amelyben a feladat lineárissá válik. A rekonstrukciós cél ehhez semmilyen külső jelet nem ad; lehet szerencsés, de nem garantált.

29.3.4 Ritka és kontraktív regularizálás áttekintése

Mivel a rekonstrukciós loss nem bünteti automatikusan a triviális vagy kedvezőtlen latent geometriát, a tanítási célhoz pótlólagos regularizáló tagot adhatunk. Két gyakori család:

Sparse regularizálás. Az aktivációk átlagos $\ell_1$-normáját büntetjük:

$$L_{\mathrm{sparse}} =L_{\mathrm{rec}} +\frac{\lambda}{Nb}\sum_{n=1}^{N}\sum_{j=1}^{b}|z_{n,j}| =L_{\mathrm{rec}} +\frac{\lambda}{Nb}\sum_{n=1}^{N}\|z_n\|_1 .$$

A cél nem az, hogy minden kód nulla legyen, hanem hogy egyszerre kevés koordináta legyen aktív. Sztochasztikus gradiens alatt az $\ell_1$-tag általában ritkító irányba tol, de egzakt nullákat nem feltétlenül állít elő; ez heurisztikus hatás, nem tétel. A $\lambda$ értékét a rekonstrukcióval együtt kell ellenőrizni.

Contractive regularizálás. Az encoder Jacobi-mátrixának Frobenius-normáját büntetjük:

$$L_{\mathrm{contractive}} =L_{\mathrm{rec}} +\frac{\lambda}{Nb}\sum_{n=1}^{N}\left\|J_{f_W}(x_n)\right\|_F^2 .$$

Itt $J_{f_W}(x_n)\in\mathbb R^{b\times d}$, mert a sorok a $b$ kimeneti koordinátának, az oszlopok a $d$ bemeneti koordinátának felelnek meg. A tag azt méri, mennyire változik a kód a bemenet kis megváltoztatására. A triviális identitáson $J=I_d$, ezért $\|I_d\|_F^2=d$, tehát ez a regularizáló közvetlenül drágítja az identitásleképezést. Fontos korlát: ez lokális simasági heurisztika, nem általános robusztussági vagy azonosíthatósági tétel.

29.3.5 Latent geometria és downstream kontroll

A latent térben a kódok elhelyezkedése, a latent geometry, nem automatikusan rendezett. Például a 28.3. Retrieval-értékelés és adatfelosztás alfejezetben tárgyalt kontrasztív tanulás explicit normalizálással egységgömbre vetít; egy sima MSE-autoencoder latent terében ilyen kényszer nincs. Ezért a következő kontrollokat érdemes külön kezelni:

1. Rekonstrukciós kontroll: $L_{\mathrm{rec}}$ a tanító- és validációs halmazon.
2. Capacity/collapse kontroll: minden latent koordinátára $\operatorname{std}_j(Z)$, nemcsak a teljes tensor egyetlen szórása.
3. Downstream kontroll: előre rögzített lineáris fej a befagyasztott encoder kódján, ugyanazzal a tanító/validációs felosztással, mint a felügyelt baseline.

A downstream kontroll azért nem bizonyít általános reprezentációminőséget, mert csak egyetlen címkére és egyetlen lineáris családra vonatkozik. Egy másik downstream feladat más rendezést igényelhet.

29.3.6 Labor: két latentméret és előre rögzített downstream kontroll

A labor kérdése az, hogy a GlyphLab orientációfeladatán a $b=4$ és $b=16$ latentméretű autoencoder hogyan viselkedik rekonstrukcióban és befagyasztott lineáris downstream pontosságban. A protokollt a futtatás előtt rögzítjük:

• Adat: lab/data/images.npy, labels.npy, metadata.csv; a splitet a metadata.csv split oszlopa adja, a függetlenségi egység a scene_id, tehát nem keverjük a nézeteket a felosztások között.
• Előfeldolgozás: NCHW-ből $576$ dimenziós float32 vektor.
• Modell: encoder Linear(576,64), ReLU, Linear(64,b); decoder Linear(b,64), ReLU, Linear(64,576). Csak $b$ változik, a hidden szélesség és az inicializálás receptje nem.
• Tanítás: Adam, $\mathrm{lr}=10^{-3}$, batch méret $48$, $15$ epoch, seed 20261020.
• Rekonstrukciós metrika: elemenkénti MSE a validációs halmazon.
• Downstream kontroll: a tanított encoder befagyasztása után a tanító kódokon Linear(b,3) fejet tanítunk cross-entropyval, torch.manual_seed(20261020), Adam, $\mathrm{lr}=10^{-2}$, $30$ epoch, batch méret $48$; validációs pontosságot jelentünk.
• Baseline: ugyanez a downstream fej a nyers $576$ dimenziós pixelvektoron.

A megadott numerikus kimenet szemléltető, tényleges értékét futtatással kell ellenőrizni.

# lab/n115_latent_probe.py
import csv
from pathlib import Path
import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

ROOT = Path("lab/data")
SEED = 20261020
D = 24 * 24
torch.manual_seed(SEED)
np.random.seed(SEED)
dtype, device = torch.float32, torch.device("cpu")

def read_splits():
    idx = {"train": [], "val": [], "test": []}
    with (ROOT / "metadata.csv").open(newline="") as f:
        for row in csv.DictReader(f):
            idx[row["split"]].append(int(row["index"]))
    return idx

idx = read_splits()
X = np.load(ROOT / "images.npy").astype(np.float32).reshape(-1, D)
Y = np.load(ROOT / "labels.npy").astype(np.int64)

class AE(nn.Module):
    def __init__(self, d, b, h=64):
        super().__init__()
        self.enc = nn.Sequential(nn.Linear(d, h), nn.ReLU(), nn.Linear(h, b))
        self.dec = nn.Sequential(nn.Linear(b, h), nn.ReLU(), nn.Linear(h, d))

    def forward(self, x):
        z = self.enc(x)
        return self.dec(z), z

def make_loader(indices):
    tensors = (
        torch.tensor(X[indices], dtype=dtype, device=device),
        torch.tensor(Y[indices], dtype=torch.int64, device=device),
    )
    return DataLoader(TensorDataset(*tensors), batch_size=48, shuffle=True)

def train_ae(b, epochs=15):
    torch.manual_seed(SEED)
    model = AE(D, b).to(device)
    opt = torch.optim.Adam(model.parameters(), lr=1e-3)
    loader = make_loader(idx["train"])
    for _ in range(epochs):
        for xb, _ in loader:
            opt.zero_grad()
            xh, _ = model(xb)
            loss = nn.functional.mse_loss(xh, xb)
            loss.backward()
            opt.step()
    return model

@torch.no_grad()
def embed_batch(model, indices):
    out = []
    for i in indices:
        x = torch.tensor(X[i], dtype=dtype, device=device)[None, :]
        out.append(model.enc(x)[0].cpu().numpy())
    return np.stack(out)

@torch.no_grad()
def val_mse(model, indices):
    x = torch.tensor(X[indices], dtype=dtype, device=device)
    xh, _ = model(x)
    return nn.functional.mse_loss(xh, x).item()

def downstream_acc(features_tr, label_tr, features_val, label_val, out_dim=3, epochs=30):
    torch.manual_seed(SEED)
    head = nn.Linear(features_tr.shape[1], out_dim).to(device)
    opt = torch.optim.Adam(head.parameters(), lr=1e-2)
    ce = nn.CrossEntropyLoss()
    zt = torch.tensor(features_tr, dtype=dtype, device=device)
    yt = torch.tensor(label_tr, dtype=torch.int64, device=device)
    zv = torch.tensor(features_val, dtype=dtype, device=device)
    yv = torch.tensor(label_val, dtype=torch.int64, device=device)
    for _ in range(epochs):
        opt.zero_grad()
        loss = ce(head(zt), yt)
        loss.backward()
        opt.step()
    pred = head(zv).argmax(dim=1)
    return (pred == yv).float().mean().item()

def report(latent_b):
    model = train_ae(latent_b)
    z_tr = embed_batch(model, idx["train"])
    z_val = embed_batch(model, idx["val"])
    acc = downstream_acc(z_tr, Y[idx["train"]], z_val, Y[idx["val"]])
    mse = val_mse(model, idx["val"])
    print(f"b={latent_b:2d}  val_MSE={mse:.4f}  val_acc={acc:.3f}")

report(4)
report(16)
# Baseline: nyers pixel + ugyanaz a downstream fej.
acc_raw = downstream_acc(
    X[idx["train"]], Y[idx["train"]],
    X[idx["val"]], Y[idx["val"]],
)
print(f"raw pixel baseline  val_acc={acc_raw:.3f}")

A futtatás a projektgyökérből:

python lab/n115_latent_probe.py

Jelölt, nem mért szemléltető kimenet:

A táblázat számai nem futásból származnak, csak a lehetséges kimenet formáját mutatják. A tényleges futásban sem a kisebb, sem a nagyobb latentméret győzelmét nem ígérjük előre. Az értelmezéshez nemcsak az átlagpontosság kell: a $b=16$ modell kisebb rekonstrukciós hibája nem jelenti automatikusan a jobb downstream reprezentációt, éppen az 1. állítás tanulsága szerint. Emellett a koordinátánkénti $\operatorname{std}_j(Z)$-t is meg kell vizsgálni; ha például $b=16$ mellett több dead unit van, akkor a tényleges effektív dimenzió kisebb lehet a névlegesnél.

29.3.7 Gyakori tévedés és ellenpélda

A gyakori tévedés: „ha a rekonstrukciós hiba kicsi, akkor a latent reprezentáció szükségképpen jó szemantikai reprezentáció.” Az 1. állítás konstrukciója cáfolja: az identitásleképezés $L_{\mathrm{rec}}=0$ értékű, de a XOR-feladaton a lineáris downstream fej legfeljebb $3/4$ pontosságot ér el. Egy másik, ugyancsak nulla rekonstrukciós hibájú nemlineáris reprezentáció viszont $4/4$-et ér. A hiba forrása, hogy a rekonstrukciós cél nem tartalmazza a downstream címkét, a bemenet koordinátarendszerének megtartása pedig önmagában nem hoz létre lineárisan leolvasható jellemzőt.

Önellenőrzés. (1) Megkülönböztettem-e a névleges $b$ dimenziót az effektív, nem összeomlott koordináták számától? (2) A downstream pontosságot befagyasztott encoderen mértem-e, nem közös finomhangolás után? (3) A validációs split megőrizte-e a scene_id függetlenséget a 28.3. Retrieval-értékelés és adatfelosztás szerződése alapján? (4) A lineáris pixel-baseline-t ugyanarra a splitre és ugyanarra a fejre futtattam-e, mint a 25.3. Kis adat és feature-alapú baseline alfejezetben? (5) Nem állítottam-e általános reprezentációminőséget egyetlen downstream feladatból?

29.3.8 F1–F5 feladatok

F1. feladat (fogalmi, nehézség 1). Magyarázza el saját szavaival a bottleneck, a triviális identitásleképezés és a latent collapse közötti különbséget a $d=576$, $b=32$ GlyphLab-példán. Adja meg mindhárom fogalom formális feltételét is.

F2. feladat (levezetési/bizonyítási, nehézség 2). Bizonyítsa be az 1. állításban használt $3/4$-es felső korlátot: a négy XOR-ponton az identitás-reprezentációhoz tartozó lineáris osztályozó nem érhet el négy helyes döntést. Írja le azt is, miért lehet három helyes döntés éles.

F3. feladat (implementációs, nehézség 1). Írjon Python-függvényt xor_readout_acc(alpha, beta, gamma) néven, amely a négy XOR-pontra kiszámítja a $q(x)=\alpha x_1+\beta x_2+\gamma$ osztályozó pontosságát. Ellenőrizze, hogy az $\alpha=10,\beta=10,\gamma=-0{,}1$ eset $0{,}75$-ös pontosságot ad, és adja meg azt a nemlineáris reprezentációt, amelyen a lineáris leolvasó $1{,}0$-t ér el.

F4. feladat (hibakeresési, nehézség 2). Egy hallgató a következő kóddal ellenőrzi a collapse-ot:

z = encoder(x_batch)          # alak: (N, b)
print("collapse?", float(z.std().item()) < 1e-4)

Mi a hiba? Írja le az okot, a lehetséges következményt, a javítást és a javítás utáni shape-ellenőrzést.

F5. feladat (kísérleti/transzfer, nehézség 3). Tervezze meg a GlyphLabon a $b=4$ és $b=16$ autoencoder összehasonlítását úgy, hogy a következtetés a befagyasztott lineáris downstream pontosságra és a rekonstrukcióra is korrekt korlátot adjon. Adja meg a megfigyelési egységet, a splitet, a baseline-t, a rögzített metrikákat és a legfőbb érvényességi korlátot. Győztest nem kell előre mondani.

29.3.9 Megoldások és indoklás

F1 megoldás. A bottleneck a $b<d$ feltétel, tehát az encoder kimenete kisebb dimenziós, mint a bemenet. A $b=32$ esetben $32\ll 576$; az identitásleképezés ekkor nem rendelkezik a szükséges $(576,576)$-os súlyú lineáris identitásmátrixszal, pontosabban a leképzés nem viheti át általánosan mind a $576$ bemeneti koordinátát $32$ kódkoordinátán. A triviális identitás ehhez képest a $b=d$ esetben $f(x)=x$, $g(z)=z$. A collapse nem dimenziófeltétel, hanem aktivációeloszlás-feltétel; a $Z\in\mathbb R^{N\times b}$ kódmátrix valamely oszlopának szórása közel nulla. Ha $b=32$, de egyetlen koordináta szórása sem nulla, még lehet rossz downstream pontosság; a $b$ csak kapacitás, nem minőség.

F2 megoldás. Tegyük fel, hogy a lineáris osztályozó mind a négy pontot jól osztályozza. A pozitív pontokra $(1,1)$ és $(-1,-1)$ előírt $q>0$ feltételekből

$$\alpha+\beta+\gamma>0,\qquad -\alpha-\beta+\gamma>0,$$

ezért $\gamma>0$. A negatív pontokra $(1,-1)$ és $(-1,1)$ előírt $q\le 0$ feltételekből

$$\alpha-\beta+\gamma\le 0,\qquad -\alpha+\beta+\gamma\le 0,$$

amelyek összege $2\gamma\le 0$. Ez ellentmond $\gamma>0$-nak, tehát a négyes pontosság lehetetlen. A $3/4$ éles, mert az $\alpha=10,\beta=10,\gamma=-0{,}1$ választás három helyes döntést ad, ahogy az 1. állításban kiszámoltuk. A bizonyítás fontos előfeltétele, hogy a döntési szabály $q>0$, nem pedig $q\ge 0$; a szigorú egyenlőtlenség a nulla küszöbnél elkerüli a degenerált esetet.

F3 megoldás.

import numpy as np

P = np.array([[1, 1], [-1, -1], [1, -1], [-1, 1]], dtype=np.float64)
Y = np.array([1, 1, 0, 0], dtype=np.int64)

def xor_readout_acc(alpha, beta, gamma):
    q = alpha * P[:, 0] + beta * P[:, 1] + gamma
    pred = (q > 0).astype(np.int64)
    return float((pred == Y).mean())

print(xor_readout_acc(10.0, 10.0, -0.1))  # 0.75
# Nemlineáris reprezentáció: z=(x1*x2, x1), leolvasó q=z1.
Z = np.column_stack([P[:, 0] * P[:, 1], P[:, 0]])
pred_z = (Z[:, 0] > 0).astype(np.int64)
print((pred_z == Y).mean())                # 1.0

A függvény kimenete a várt $0{,}75$ és $1{,}0$; a bemenő pontokra nincs szükség numerikus toleranciára, mert a döntés csak előjel-egyenlőtlenségeket használ.

F4 megoldás. A hiba oka: a z.std() hívás a teljes (N,b) tensor minden elemére számít egyetlen skalár szórást. Ez a skalár magas lehet akkor is, ha a tensor $b$ oszlopából $b-1$ teljesen nulla vagy konstans. A következmény: a részleges vagy teljes collapse észrevétlen marad. Javítás:

unit_std = z.std(dim=0)          # alak: (b,)
collapsed = unit_std < 1e-4
print("koordinátánként:", unit_std)
print("collapsed:", collapsed.sum().item(), "/", collapsed.numel())

Ellenőrzés: $z$ alakja (N, b), ezért z.std(dim=0) alakja (b,); a küszöb alá eső koordinátákat egyesével jelentjük. Numerikusan a teljes tensor-szórás és az oszloponkénti szórás nem összekeverhető reduction-konvenció.

F5 megoldás (lehetséges terv). Megfigyelési egység: egy kép, de a split függetlenségi egysége a scene_id, tehát egyetlen jelenet mindkét view-ja azonos részbe kerül. Protokoll: a tanító spliten tanítunk két MSE-autoencodert $b=4$ és $b=16$ mellett, azonos hidden szélességgel, seeddel és epochszámmal. Utána mindkét encoder súlyát befagyasztjuk; a tanító kódokon lineáris fejet tanítunk orientációra, a fejet a validációs spliten értékeljük. Baseline: ugyanaz a lineáris fej a nyers $576$ dimenziós pixelveken. Metrikák: validációs MSE, validációs downstream pontosság, a latent koordinátánkénti szórása és a collapsed koordináták száma. A teszt splitet csak a protokoll lezárása után használjuk. Érvényességi korlát: a GlyphLab három, geometriailag szintetikus osztályt tartalmaz, így a következtetés nem vihető át természetes képfelismerésre; a downstream eredmény egyetlen lineáris fejre vonatkozik, tehát nem általános reprezentációminőség. A rekonstrukciós és downstream rangsor akár el is válhat, ahogy az 1. állítás mutatja.

29.3.10 Rövid összefoglaló

Az autoencoder rekonstrukciós célja nem rögzíti a latent tér downstairs hasznosságát. A $b=d$ triviális identitásleképezés nulla hibát ad, miközben egy XOR-szerű downstream címkén a lineáris fej legfeljebb $3/4$ pontosságot ér el; egy alkalmas nemlineáris encoder ugyanakkora dimenzióval és ugyancsak nulla rekonstrukciós hibával teljes pontosságot adhat. Ezért a nullához közeli MSE önmagában nem bizonyít szemantikai tudást. A bottleneck, ritka aktiváció és kontraktív büntetőtag heurisztikus irányt ad, de a tényleges ellenőrzéshez külön kell mérni a rekonstrukciót, a koordinátánkénti collapse-ot és egy előre rögzített downstream kontrollt.

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

A következő 29.4. Anomáliapontszám rekonstrukcióból egység az anomáliapontszám rekonstrukcióból való származtatását vizsgálja; az itteni azonosság és kapacitás-megkülönböztetés ott annak korlátjaként tér vissza, hogy a kis rekonstrukciós hiba nem automatikusan jelent ismert mintát.

Felhasznált források:

• [B01] Deisenroth, M. P., Faisal, A. A., Ong, C. S. (2020). Mathematics for Machine Learning. Cambridge University Press. https://mml-book.github.io/.