9.3 Expresszivitás és approximációs állítások

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

A 9.2. MLP és nemlinearitás alfejezetben beláttuk, hogy a ReLU MLP folytonos, szakaszonként affin függvény, és hogy nemlinearitás nélkül több affin réteg egyetlen affin réteggé vonható össze. Most a kifejezőerőt formalizáljuk: mit tud egyetlen rejtett rétegű háló egyenletesen közelíteni? Az induló kérdés: legyen $f(x)=\sin(2\pi x)$ a $[0,1]$ intervallumon. Körülbelül hány ReLU neuron szükséges ahhoz, hogy a háló és $f$ között a maximális eltérés $0{,}05$ alatt maradjon? A fejezet először pontos definíciót ad, majd egy olyan approximációs tételt bizonyítunk, amelyre a fenti kérdésre konkrét korlátot kapunk.

9.3.2 Univerzális approximáció, kompakt tartomány és szélesség

Legyen $K\subset\mathbb R^d$ kompakt tartomány (compact domain), azaz korlátos és zárt halmaz. Az 1D esetben $K=[a,b]$ zárt intervallum. A $C(K)$ tér a $K$-n folytonos valós függvények halmazát jelöli. A két függvény eltérését a szupremumnorma (supremum norm) méri:

$$\|f-g\|_\infty=\sup_{x\in K}|f(x)-g(x)|.$$

Az 1D egy rejtett rétegű MLP alakja a jelen egységben

$$g(x)=W^{(2)}\,\mathrm{ReLU}\!\bigl(W^{(1)}x+b^{(1)}\bigr)+b^{(2)},$$

ahol a bemenet $x\in\mathbb R^{1}$, a rejtett szélesség (width) $m$, tehát $W^{(1)}\in\mathbb R^{m\times1}$, $b^{(1)}\in\mathbb R^{m}$, $W^{(2)}\in\mathbb R^{1\times m}$, $b^{(2)}\in\mathbb R^{1}$. Batchelt jelölésben $X\in\mathbb R^{N\times1}$, és a bias a megfelelő dimenzió mentén sugárzódik.

Definíció (univerzális approximációs tulajdonság). A $\mathcal H$ függvényosztály rendelkezik az univerzális approximációs tulajdonsággal a $K$ tartományon, ha minden $f\in C(K)$ és minden $\varepsilon>0$ esetén létezik $g\in\mathcal H$, amelyre $\|f-g\|_\infty\le\varepsilon$.

Az aktivációs feltétel (activation condition) szerepe a ReLU tulajdonságában látszik: a $\mathrm{ReLU}(x-t)$ függvény a $t$ pontban visz be egyetlen meredekségugrást, a konstans vagy az affin aktiváció viszont nem hoz létre ilyen töréspontot. Ezért a ReLU alkalmas darabonként affin függvények összerakására.

9.3.3 A reprezentációs tétel 1D ReLU-hálózatokra

Először egy teljesen bizonyított, saját lemmát mondunk ki. A szakaszonként affin függvény meredekségét a belső töréspontok kivételével mindenütt az intervallumon belüli derivált adja; a töréspontokban a jobb és bal oldali meredekség különbözik.

Lemma 1 (szakaszonként affin függvény ReLU-előállítása). Legyen $f:[a,b]\to\mathbb R$ folytonos és szakaszonként affin, belső töréspontokkal $a<t_1<\cdots<t_k<b$. Legyen $s_0=\lim_{h\to0+}\frac{f(a+h)-f(a)}{h}$ a kezdő meredekség, és legyen

$$\delta_j=\lim_{h\to0+}\frac{f(t_j+h)-f(t_j)}{h}-\lim_{h\to0-}\frac{f(t_j+h)-f(t_j)}{h}$$

a meredekség ugrása a $t_j$ pontban. Ekkor

$$f(x)=f(a)+s_0(x-a)+\sum_{j=1}^{k}\delta_j\,\mathrm{ReLU}(x-t_j),\qquad x\in[a,b].$$

Bizonyítás. Legyen $h(x)$ a jobb oldal. A $\mathrm{ReLU}$ folytonos, ezért $h$ folytonos, továbbá minden $t_j$-től különböző pontban mindkét oldal affin, azaz $h$ is szakaszonként affin. A $t_j$ pontoktól balra $\mathrm{ReLU}(x-t_j)=0$, jobbra pedig a meredeksége $1$, tehát $h$ meredeksége a $(t_{j-1},t_j)$ intervallumon

$$s_0+\sum_{i<j}\delta_i,$$

ami éppen $f$ meredeksége ugyanazon az intervallumon, hiszen a $\delta_i$ ugrások kumulálódnak. Az $a$ pontban $h(a)=f(a)$, és szakaszonként affin folytonos függvényt a kezdőérték és a meredekségfüggvény egyértelműen meghatároz, így $h=f$. ∎

A következő lépés minden folytonos függvényt szakaszonként affin interpolánssal közelít.

Lemma 2 (lineáris interpoláns approximációja). Legyen $f\in C([a,b])$. Minden $\varepsilon>0$-hoz létezik olyan folytonos, szakaszonként affin $p$ függvény, hogy $\|f-p\|_\infty\le\varepsilon$.

Bizonyítás. A kompakt $[a,b]$ intervallumon $f$ egyenletesen folytonos, tehát létezik $\delta>0$, hogy $|x-y|<\delta$ esetén $|f(x)-f(y)|<\varepsilon$. Válasszunk egy $a=x_0<\cdots<x_m=b$ rácsot, ahol a lépésköz kisebb, mint $\delta$. Legyen $p$ az $f$ lineáris interpolánsa a rácspontokban: minden $[x_i,x_{i+1}]$ intervallumon

$$p(x)=\frac{x_{i+1}-x}{x_{i+1}-x_i}f(x_i)+\frac{x-x_i}{x_{i+1}-x_i}f(x_{i+1}).$$

Itt $p(x)$ konvex kombinációja két $f$-értéknek, és $|x-x_i|,|x-x_{i+1}|<\delta$, ezért

$$|p(x)-f(x)|\le\max\{|f(x_i)-f(x)|,|f(x_{i+1})-f(x)|\}<\varepsilon,$$

tehát $\|f-p\|_\infty\le\varepsilon$. ∎

A Lemma 2 csak létezést állít: a lépésközt az egyenletes folytonosság $\delta$-ja adja, amelyről a bizonyítás nem mond számot. Kétszer folytonosan differenciálható célfüggvényre explicit, kvantitatív korlát is levezethető.

Lemma 3 (a lineáris interpoláns hibakorlátja $C^2$ függvényre). Legyen $f\in C^2([a,b])$, $M_2=\max_{[a,b]}|f''|$, és legyen $p$ az $f$ lineáris interpolánsa egy $h$ lépésközű egyenletes rácson. Ekkor

$$\|f-p\|_\infty\le\frac{h^2}{8}\,M_2.$$

Bizonyítás. Rögzítsünk egy $[x_i,x_{i+1}]$ intervallumot és benne egy $x$ pontot, ahol $x\ne x_i,x_{i+1}$ (a végpontokban a hiba nulla). Legyen $e=f-p$, és tekintsük a $\phi(t)=e(t)-\frac{e(x)}{(x-x_i)(x-x_{i+1})}(t-x_i)(t-x_{i+1})$ segédfüggvényt. Ez $C^2$, és három pontban nulla: $x_i$-ben, $x_{i+1}$-ben és $x$-ben. A Rolle-tétel kétszeri alkalmazásával van olyan $\xi\in(x_i,x_{i+1})$, ahol $\phi''(\xi)=0$. Mivel $p''=0$ az intervallum belsejében, $\phi''(\xi)=f''(\xi)-\frac{2e(x)}{(x-x_i)(x-x_{i+1})}$, tehát

$$e(x)=\frac{f''(\xi)}{2}(x-x_i)(x-x_{i+1}).$$

A $|(x-x_i)(x-x_{i+1})|$ szorzat az intervallum közepén maximális, értéke $h^2/4$, ezért $|e(x)|\le\frac{M_2}{2}\cdot\frac{h^2}{4}=\frac{h^2}{8}M_2$. ∎

A szükséges lépésközhöz a felső korlátot kell a célhiba alá szorítani: ha $\frac{h^2}{8}M_2\le\varepsilon$, akkor $\|f-p\|_\infty\le\varepsilon$, vagyis elegendő

$$h\le\sqrt{\frac{8\varepsilon}{M_2}}.$$

A lemma valós aritmetikára szól; float32 megvalósításnál a súlyok és a kiértékelés kerekítése ehhez egy kis, külön kezelendő többletet ad (nagyságrendileg néhány $\varepsilon_{32}\approx1{,}2\cdot10^{-7}$ relatív hiba a súlyok és az aktivációk méretéhez mérve), ezért a mért hibát a korláttal tűréssel vetjük össze.

A két lemma kompozíciója adja a saját approximációs tételt.

Tétel (1D univerzális approximáció ReLU-hálózattal). Legyen $[a,b]\subset\mathbb R$ kompakt intervallum. Ekkor minden $f\in C([a,b])$ és minden $\varepsilon>0$ esetén létezik egyetlen rejtett rétegű ReLU MLP, amelyre $\|f-g\|_\infty\le\varepsilon$. A Lemma 2 konstrukciójában a rejtett szélesség legfeljebb $m=\lceil (b-a)/\delta\rceil+2$, ahol $\delta$ az $f$ egyenletes folytonossági modulusa az $\varepsilon$-hoz.

Bizonyítás. A Lemma 2 ad egy szakaszonként affin $p$ függvényt, amelyre $\|f-p\|_\infty\le\varepsilon$. A Lemma 1 szerint $p$ pontosan előállítható a fenti egy rejtett rétegű alakban: a lineáris taghoz két ReLU egység ($x=\mathrm{ReLU}(x)-\mathrm{ReLU}(-x)$), a belső töréspontokhoz további $k$ egység tartozik, a kimeneti réteg pedig a $s_0$ és $\delta_j$ együtthatókat kombinálja. A szélességkorlát a rács lépésközéből következik. ∎

Átvett szakirodalmi eredmény. Az általános, többdimenziós univerzális approximációs eredmények közül a klasszikus Cybenko-tételt [P24] egyetlen rejtett rétegű hálózatra vonatkozóan tartjuk nyilván. A Cybenko-tétel részletes feltételrendszerét (aktiváció-osztály, topológia, dimenzió) és bizonyítását itt nem tárgyaljuk, ezért annak pontos, általános formuláját sem használjuk fel a későbbi számításokhoz. A fenti 1D ReLU-tétel a könyv saját, teljes bizonyítású eredménye; a Cybenko-tétel részletes megfogalmazása nem része az itt bizonyított állításnak.

9.3.4 Kézi példa

Legyen $[a,b]=[0,1]$, és definiáljuk

$$f(x)=\begin{cases} x,&0\le x<0{,}3,\\ 0{,}3,&0{,}3\le x<0{,}7,\\ 0{,}3+2(x-0{,}7),&0{,}7\le x\le1. \end{cases}$$

A függvény folytonos, belső töréspontjai $t_1=0{,}3$ és $t_2=0{,}7$. A kezdő meredekség $s_0=1$; a meredekség ugrása $0{,}3$-nál $0-1=-1$, $0{,}7$-nél $2-0=2$. A Lemma 1 képlete:

$$f(x)=0+1\cdot x+(-1)\mathrm{ReLU}(x-0{,}3)+2\,\mathrm{ReLU}(x-0{,}7).$$

Ellenőrzés: $x=0{,}2$ esetén $0{,}2$; $x=0{,}5$ esetén $0{,}5-0{,}2=0{,}3$; $x=0{,}9$ esetén $0{,}9-0{,}6+0{,}4=0{,}7$, és a definícióból $0{,}3+2(0{,}9-0{,}7)=0{,}7$.

A hálózat reprezentációja négy rejtett egységgel: a lineáris taghoz $\mathrm{ReLU}(x)$ és $\mathrm{ReLU}(-x)$, a töréspontokhoz $\mathrm{ReLU}(x-0{,}3)$ és $\mathrm{ReLU}(x-0{,}7)$. A súlyok:

$$W^{(1)}=\begin{bmatrix}1\\-1\\1\\1\end{bmatrix},\quad b^{(1)}=[0,\;0,\;-0{,}3,\;-0{,}7],$$

$$W^{(2)}=[1,\;-1,\;-1,\;2],\quad b^{(2)}=[0].$$

9.3.5 Labor: konstrukció, mért hiba és paraméterszám-kontraszt

A labor célja az 1D tétel közvetlen használata, és annak bemutatása, hogy azonos paraméterszámú hálók között a konkrét súlykonfiguráció, nem pedig a paraméterszám önmagában hozza a jó approximációt. A célfüggvény $f(x)=\sin(2\pi x)$ a $[0,1]$-en. A munkakönyvtár lab/, a kód n035_expressivity.py.

import numpy as np

def relu(x):
    return np.maximum(x, 0.0)

def mlp_1hidden(x, W1, b1, W2, b2):
    h = relu(x @ W1.T + b1)          # (N,m)
    return h @ W2.T + b2             # (N,1)

def build_interpolating_mlp(f, a=0.0, b=1.0, n_intervals=10, width=12):
    x_nodes = np.linspace(a, b, n_intervals + 1, dtype=np.float32)
    interiors = x_nodes[1:-1]
    y_nodes = f(x_nodes).astype(np.float32)
    h = (b - a) / n_intervals
    slopes = np.diff(y_nodes) / h     # n_intervals meredekség
    s0 = slopes[0]
    deltas = np.diff(slopes)          # ugrás a belső pontokban
    m = width
    W1 = np.zeros((m, 1), dtype=np.float32)
    b1 = np.zeros((m,), dtype=np.float32)
    W1[0, 0] = 1.0                     # ReLU(x)
    W1[1, 0] = -1.0                    # ReLU(-x)
    W1[2:2 + len(interiors), 0] = 1.0
    b1[2:2 + len(interiors)] = -interiors
    W2 = np.zeros((1, m), dtype=np.float32)
    W2[0, 0] = s0
    W2[0, 1] = -s0
    W2[0, 2:2 + len(deltas)] = deltas
    b2 = np.array([f(a) - s0 * a], dtype=np.float32)
    return W1, b1, W2, b2

def mlp_2hidden(x, W1, b1, W2, b2, W3, b3):
    h1 = relu(x @ W1.T + b1)
    h2 = relu(h1 @ W2.T + b2)
    return h2 @ W3.T + b3

def build_random_two_hidden(seed=20261020):
    rng = np.random.default_rng(seed)
    W1 = rng.standard_normal((3, 1), dtype=np.float32) * 0.5
    b1 = rng.standard_normal((3,), dtype=np.float32) * 0.5
    W2 = rng.standard_normal((6, 3), dtype=np.float32) * 0.5
    b2 = rng.standard_normal((6,), dtype=np.float32) * 0.5
    W3 = rng.standard_normal((1, 6), dtype=np.float32) * 0.5
    b3 = rng.standard_normal((1,), dtype=np.float32) * 0.5
    return W1, b1, W2, b2, W3, b3

def main():
    target = lambda x: np.sin(2 * np.pi * x)
    a, b = 0.0, 1.0
    n_intervals = 10
    W1, b1, W2, b2 = build_interpolating_mlp(target, a, b, n_intervals, width=12)
    # A háló paraméterszáma: 12 + 12 + 12 + 1 = 37
    x_test = np.linspace(a, b, 1001, dtype=np.float32).reshape(-1, 1)
    y_true = target(x_test).astype(np.float32)
    y_A = mlp_1hidden(x_test, W1, b1, W2, b2)
    err_A = np.max(np.abs(y_A - y_true))
    # Elméleti garantált szupremumhiba: max|f''| = 4*pi^2, h = 0.1
    h = (b - a) / n_intervals
    bound = (h**2 / 8.0) * (4 * np.pi**2)
    # B kontraszt: 3+6 rejtett, paraméterszám 3+3+18+6+6+1 = 37
    W1b, b1b, W2b, b2b, W3b, b3b = build_random_two_hidden(seed=20261020)
    y_B = mlp_2hidden(x_test, W1b, b1b, W2b, b2b, W3b, b3b)
    err_B = np.max(np.abs(y_B - y_true))
    print(f"A konstrukciós hiba (1001 pontos rácson): {err_A:.6f}")
    print(f"Elméleti garantált szupremumhiba: {bound:.6f}")
    print(f"B véletlen hiba (1001 pontos rácson): {err_B:.6f}")
    assert W1.shape == (12, 1) and W2.shape == (1, 12)

if __name__ == "__main__":
    main()

Futtatás: python lab/n035_expressivity.py. A kód nem igényel PyTorch-ot, csak NumPy-t; dtype float32, device CPU. A lab-profilban (NumPy 2.3.5) mért kimenet: az $A$ konstrukciós hiba az 1001 pontos rácson $0{,}048944$, az elméleti korlát $0{,}049348$, a $B$ véletlen háló hibája $1{,}580991$. Az $A$ hibája tehát a korlát alatt, de ahhoz közel marad, mert a $\sin(2\pi x)$ második deriváltja a szélsőhelyeken eléri $M_2$-t; a $B$ hiba nagy, mert a véletlen súlyok nem a célt reprezentálják.

Az állítástípusok elkülönítése a laborban:

• Levezetett állítás: az $A$ háló szupremumhibája valós aritmetikában legfeljebb $\frac{0{,}1^2}{8}\cdot4\pi^2\approx0{,}0493$ a teljes $[0,1]$-en, a Lemma 3 hibakorlátjából ($h=0{,}1$, $M_2=4\pi^2$); a float32 kerekítés ehhez csak elhanyagolható többletet ad.
• Empirikus állítás: a 1001 pontos rácson mért err_A és err_B a tényleges futásból származik; ez a rács a teljes intervallumnak csak diszkrét részhalmaza, ezért a szupremumhibára alsó közelítés.
• Heurisztikus állítás: sem a $B$ rossz eredménye, sem egy jövőbeli SGD-kísérlet nem mond ellent a reprezentációs tételnek, mert a tétel létezést, nem megtalálhatóságot állít.

9.3.6 Feladatok

F1 (fogalmi, nehézség 1). Magyarázza el a különbséget a reprezentációs (létezési) és az optimalizálási (megtalálási) állítás között. Adjon egy konkrét példát, amelyben a létezés igaz, de a megtalálás nem garantált. Elvárt eredmény: saját megfogalmazás, a példában az architektúra, a létező súlyok és a megtalálást gátló körülmény megnevezése.

F2 (levezetési, nehézség 2). Legyen $[a,b]=[0,1]$ és $$g(x)=\begin{cases}0,&0\le x<0{,}2,\\1{,}5(x-0{,}2),&0{,}2\le x<0{,}6,\\0{,}6,&0{,}6\le x\le1.\end{cases}$$ Adja meg a belső töréspontokat, a kezdő meredekséget, a meredekségugrásokat, a Lemma 1 ReLU-képletet és a hálózat súlyait. Ellenőrizze a $x=0;\;0{,}2;\;0{,}5;\;0{,}6;\;1$ pontokban.

F3 (implementációs, nehézség 1). Írjon NumPy függvényt, amely tetszőleges t törésponttömbből, deltas ugrástömbből, s0 kezdő meredekségből és f_a = f(a) kezdőértékből felépíti a Lemma 1 szerinti egy rejtett rétegű súlyokat. Ellenőrizze a F2 $g$ függvényén 17 egyenletes ponton; a max abszolút hiba $10^{-5}$ alatt legyen. Átadandó: futtatható kód, input, output, tolerancia.

F4 (hibakeresési, nehézség 2). Adott a következő hibás érvelés: „A Cybenko-tétel garantálja, hogy a hálózatunk 10 epoch SGD után megtalálja a jó súlyokat.” Lokalizálja a hibát, nevezze meg a következményt, és fogalmazza át az állítást úgy, hogy az az állítástípusoknak megfeleljen. Ellenőrzésként adja meg, mit állít a tétel, és mit nem.

F5 (kísérleti transzfer, nehézség 3). Tervezzen kísérletet annak vizsgálatára, hogy azonos paraméterszám mellett a széles-sekély vagy a keskeny-mély MLP éri el a jobb max abszolút hibát a $f(x)=\sin(5\pi x)$ függvényen. Adja meg a protokollt: cél, hipotézis, baseline, változó tényező, metrika, seed-kezelés, erőforrás és a következtetés érvényességi határa.

9.3.7 Megoldások és indoklás

F1. A reprezentációs tétel egy $\mathcal H$ osztály kapacitásáról szól: minden $\varepsilon$-hoz létezik legalább egy $g\in\mathcal H$, amely $\varepsilon$ közelségben van $f$-hez. Az optimalizálási állítás ezzel szemben azt mondaná, hogy egy adott keresőeljárás egy adott inicializációból kiindulva megtalálja ezt a $g$-t. Konkrét példa: a labor $A$ hálója a tétel konstrukciójából létezik, de ugyanaz az architektúra véletlen súlyokkal ($B$) nem ad jó hibát; a jó súlyok léteznek, ám a véletlen inicializálásból induló gradienskeresés sikerére a tétel semmit sem mond.

F2. A belső töréspontok $t_1=0{,}2$, $t_2=0{,}6$; a kezdő meredekség $s_0=0$; a meredekségugrás $\delta_1=1{,}5-0=1{,}5$, $\delta_2=0-1{,}5=-1{,}5$. A Lemma 1 képlet:

$$g(x)=0+0\cdot x+1{,}5\,\mathrm{ReLU}(x-0{,}2)-1{,}5\,\mathrm{ReLU}(x-0{,}6).$$

A hálózat súlyai négy rejtett egységgel: $W^{(1)}=[1,\,-1,\,1,\,1]^\top$, $b^{(1)}=[0,\,0,\,-0{,}2,\,-0{,}6]$, $W^{(2)}=[0,\,0,\,1{,}5,\,-1{,}5]$, $b^{(2)}=[0]$. A lineáris tag együtthatója nulla, ezért az első két egység nulla kimeneti súllyal szerepel, de formálisan megtartjuk őket. Ellenőrzés: $x=0$: $0$; $x=0{,}2$: $0$; $x=0{,}5$: $1{,}5\cdot0{,}3=0{,}45$; $x=0{,}6$: $1{,}5\cdot0{,}4=0{,}6$; $x=1$: $1{,}5\cdot0{,}8-1{,}5\cdot0{,}4=1{,}2-0{,}6=0{,}6$.

F3. A kód közvetlenül a Lemma 1 konstrukciót valósítja meg. A lineáris taghoz két identitás-egységet használunk, így az $x=\mathrm{ReLU}(x)-\mathrm{ReLU}(-x)$ azonosság általánosan érvényesül a teljes $\mathbb R$-en, nem csak a nemnegatív félegyenesen.

import numpy as np

def relu(x):
    return np.maximum(x, 0.0)

def build_lemma1(t, deltas, s0, f_a, a=0.0, with_identity=True):
    t = np.asarray(t, dtype=np.float32)
    deltas = np.asarray(deltas, dtype=np.float32)
    k = len(t)
    m = k + 2 if with_identity else k
    W1 = np.zeros((m, 1), dtype=np.float32)
    b1 = np.zeros((m,), dtype=np.float32)
    if with_identity:
        W1[0, 0] = 1.0
        W1[1, 0] = -1.0
        offset = 2
    else:
        offset = 0
    W1[offset:offset + k, 0] = 1.0
    b1[offset:offset + k] = -t
    W2 = np.zeros((1, m), dtype=np.float32)
    if with_identity:
        W2[0, 0] = s0
        W2[0, 1] = -s0
    W2[0, offset:offset + k] = deltas
    b2 = np.array([f_a - s0 * a], dtype=np.float32)
    return W1, b1, W2, b2

def forward(x, W1, b1, W2, b2):
    h = relu(x @ W1.T + b1)
    return h @ W2.T + b2

# F2 g függvénye, 17 ponton ellenőrizve
t = np.array([0.2, 0.6], dtype=np.float32)
deltas = np.array([1.5, -1.5], dtype=np.float32)
s0, f_a, a = 0.0, 0.0, 0.0
W1, b1, W2, b2 = build_lemma1(t, deltas, s0, f_a, a)
x = np.linspace(0, 1, 17, dtype=np.float32).reshape(-1, 1)
g_true = np.where(x < 0.2, 0.0,
          np.where(x < 0.6, 1.5 * (x - 0.2), 0.6))
y = forward(x, W1, b1, W2, b2)
print("max abs hiba:", float(np.max(np.abs(y - g_true))))
assert W1.shape == (4, 1) and W2.shape == (1, 4)
assert float(np.max(np.abs(y - g_true))) < 1e-5

A np.where pontonkénti elágazást ad, ami a 17 pontos ellenőrzéshez elegendő; a feltétel a x < 0.2 alakú tömb, ezért a np.where vektorizáltan működik. A tolerance $10^{-5}$ float32 kerekítést is fedez.

F4. A hiba oka: az állítás összemossa a reprezentációs tételt az optimalizálás konvergenciájával. A Cybenko-típusú tétel létezést mond egy architektúra osztályra, nem pedig az SGD 10 epochja utáni konvergenciát. A következmény téves modellválasztási ígéret: a gyakorló dönthet úgy, hogy 10 epoch elég, pedig a tétel nem ad epoch-számot és nem garantál globális optimumot. A javított állítás: „A tétel garantálja, hogy létezik a hálózatosztályban olyan súly, amely a kompakt tartományon $\varepsilon$ pontossággal közelíti a folytonos függvényt; az, hogy egy adott tanítási eljárás ezt megtalálja-e, külön optimalizálási kérdés.” Ellenőrzés: a tételben nincs „epoch”, „SGD”, „inicializáció”; a hipotézisosztályra és a szupremumnormára vonatkozik.

F5. Egy lehetséges terv. Cél: azonos paraméterszám mellett szélesség vagy mélység hatásának mérése a szintetikus $f(x)=\sin(5\pi x)$ függvényen. Hipotézis: az 1D tétel szerint a széles-sekély háló is elég, ezért a sekély háló ismert konstrukciója ad baseline-t. Változó: A) szélesség 12 egy rejtett réteg, 37 paraméter; B) keskeny-mély, 3+6 rejtett, 37 paraméter. Baseline: a Lemma 1–2 konstrukció A-n, mint levezetett garantált hiba. Metrika: max abszolút hiba 1001 pontos rácson, valamint a szupremumhiba becslése 10000 pontos rácson. A B-t véletlen súlyokkal, 10 seed-del mérjük, és a seedek közötti átlagot, minimumot közöljük. Erőforrás: CPU, NumPy, float32; futásidő másodpercek. Érvényességi határ: az eredmény egyetlen függvényre, egyetlen dimenzióra érvényes; nem általánosítható többdimenziós vagy természetes képadatokra, és a B véletlen súlyos mérése nem training-összehasonlítás.

9.3.8 Tipikus tévedés és ellenpélda

Az approximáció létezése nem garantálja az SGD sikerét vagy a jó mintakomplexitást. Ellenpélda: legyen $f_n(x)=\sin(2\pi n x)$ a $[0,1]$-en. A tétel szerint minden rögzített $n$-re és $\varepsilon$-ra létezik megfelelő háló, de a második derivált maximuma $M_2=4\pi^2n^2$; a Lemma 3 hibakorlátja $\varepsilon$ alá szorítva, $(h^2/8)\,4\pi^2n^2\le\varepsilon$, elegendő feltételt ad: $h\le\sqrt{2\varepsilon}/(\pi n)$. A szükséges töréspontszám tehát $n$-nel arányosan nő, a width rögzített értéke mellett nem érhető el tetszőlegesen jó approximáció. A tétel létezést, nem hatékony reprezentációt és nem megtalálást állít.

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

Ellenőrizze, hogy a Lemma 1 képletében a meredekségugrás $\delta_j$ a jobb meredekség mínusz bal meredekség, nem fordítva. A töréspontok száma a rejtett szélességben a lineáris tag két egységével együtt jelenik meg. A kompakt feltétel lényeges: nem korlátos tartományon a szupremumnorma végtelen lehet. A 9.2. MLP és nemlinearitás szakaszonként affin jellemzése itt megfordul: minden szakaszonként affin függvény előáll ReLU-hálóval. A 8.3. Kapacitás, regularizálás és modellválasztás kapacitásfogalma szerint az approximációs tétel a hipotézisosztály kifejezőképességét növeli, de a validáció és a tanítási variancia külön kérdés marad. Az 5.3. Mintavételi bizonytalanság és intervallum statisztikai bizonytalansága a labor ismételt seedjeire is vonatkozik.

9.3.10 Rövid összefoglaló

Az univerzális approximációs tulajdonság azt jelenti, hogy egy hipotézisosztály tetszőleges folytonos függvényt tetszőleges $\varepsilon>0$ pontossággal közelít kompakt tartományon, szupremumnormában. A fejezet teljes bizonyítással igazolja az 1D esetet: a lineáris interpoláns egyenletesen közelít, majd a szakaszonként affin függvény ReLU-töréspontok és meredekségugrások összegeként áll elő. A rejtett szélesség a töréspontok számától függ. A klasszikus Cybenko-tétel pontos feltételeit ellenőrizetlen forrásállapot miatt nem idézzük; bizonyítása elhagyott. A labor azt mutatja, hogy azonos paraméterszám mellett a konkrét súlykonfiguráció határozza meg a hibát, és a tétel nem ígér tanítási konvergenciát.

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

A 9.4. Aktivációk és gradiensáramlás egység az aktivációk gradiensáramlásra gyakorolt hatását vizsgálja: a ReLU töréspontjának konvencionális deriváltját, a telítődő szigmoid kis gradiensét és a mély hálók taníthatóságát.

• [P24] George Cybenko (1989). Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals and Systems 2:303–314. https://doi.org/10.1007/BF02551274.