1.4 Tanulási diagnózis és kísérleti napló

1.4.1 Cél és induló kérdés

Ez az egység diagnózis, nem új elméleti fejezet: a hallgató a saját programozói előismeretét méri fel kézi számpéldán és egy kis laboron. Az előfeltétel az 1.3. Adatfelosztás és a megfigyelési egység fogalomkészlete: train/validation/test, scene_id mint megfigyelési egység, csoportos split és adatszivárgás. A cél az, hogy a hallgató az első változatát rögzítse, és a hibák alapján célzott alapozó egységet válasszon a későbbi fejezetekből.

Induló kérdés. Adott a $v=(3,4)^\top$ vektor. Mekkora az euklideszi hossza, és mi a mértékegysége, ha a komponensek pixelben adottak? Előzetes becslés nélkül írja le a válaszát; a diagnózisnak éppen ez a nyers első változat a tárgya.

1.4.2 Fogalmak, jelek és mértékegységek

Vektor. A $d$-dimenziós valós vektor $x=(x_1,\ldots,x_d)^\top\in\mathbb R^d$; oszlopvektorként írjuk az absztrakt képletekben (JELOLESEK.md). Az euklideszi norma

$$\|x\|=\sqrt{\sum_{i=1}^{d}x_i^2}.$$

A norma csak akkor fizikailag értelmes, ha a komponenseknek közös mértékegysége van: ha minden $[x_i]=u$, akkor $[\|x\|]=u$. A GlyphLab intenzitásvektorainál a komponensek dimenzió nélküli $[0,1]$ értékek, tehát a norma is dimenzió nélküli.

Függvény. Az $f:D\to R$ hozzárendelés egy $D\subseteq\mathbb R$ definíciós tartomány minden $u$ eleméhez egy $f(u)\in R$ értéket rendel. A bemenet egységét $[u]$, a kimenetét $[f]$ jelöli; a kettő általában különbözik. Az $f(u)=2u-1$ affin kifejezésnél, ha $[u]=\mathrm{mm}$ és az eredmény pixelben értendő, akkor az eredmény egysége $\mathrm{px}$, a konstans $-1$ egysége is $\mathrm{px}$, a $2$ együttható egysége pedig $\mathrm{px}/\mathrm{mm}$.

Átlag. Az $x=(x_1,\ldots,x_N)$ valós minta átlaga

$$\bar{x}=\frac{1}{N}\sum_{i=1}^{N}x_i,\qquad N\ge1.$$

A reduction explicit: az összegzés mind az $N$ elemet fedi, az osztás $N$-nel történik. Az üres minta ($N=0$) átlaga nem értelmes. A mértékegység azonos a minta egységével: $[\bar{x}]=[x_i]$.

Deriváltintuíció. A differenciahányados

$$D_h f(t)=\frac{f(t+h)-f(t)}{h},\qquad h\ne0,$$

a $t$ és $t+h$ közötti szelő meredeksége. A derivált ennek határértéke $h\to0$ mellett; a formális definíciót és a láncszabályt a 4.1. Függvény, határérték és derivált építi fel. Itt csak az intuíciót mérjük. A szimmetrikus változat

$$S_h f(t)=\frac{f(t+h)-f(t-h)}{2h},\qquad h\ne0,$$

gyakran jobb numerikus közelítés; ezt használjuk majd a gradiensellenőrzésben is. A mértékegység $[S_h f]=[f]/[t]$.

Tensor. A tensor többdimenziós számrendezés; a könyv főútján a képbatch $X\in\mathbb R^{N\times C\times H\times W}$, NCHW sorrendben: batch, csatorna, magasság, szélesség. A dimenziók darabszámok, ezért dimenzió nélküliek. Az elemszám a dimenziók szorzata. Például $X\in\mathbb R^{2\times1\times24\times24}$ elemszáma $2\cdot1\cdot24\cdot24=1152$; a dtype (például float32) a tárolás pontosságát rögzíti.

Seed. A pszeudovéletlen generátor egy $s$ seedből (magból) egy $(u_1,u_2,\ldots)$ sorozatot állít elő. A seed mértékegysége nincs, általában nemnegatív egész. Ugyanaz a seed csak ugyanazon algoritmus, verzió és kiértékelési sorrend mellett ígér azonos sorozatot; a seed önmagában nem hordozhatósági garancia (D02, D09).

Futásazonosító. A futásazonosító ($\rho$, run id) egy konkrét kísérleti végrehajtást címkéző karakterlánc. Nem azonos a seeddel: a seed egy generátor bemenete, a futásazonosító a napló kulcsa, amely a seed, az adatverzió, a kódverzió és az időbélyeg mellé kerül. A kettő felcserélése megnehezíti annak megállapítását, hogy két eltérő eredmény közül melyik tartozik ugyanahhoz a beállításhoz.

1.4.3 Három feladat teljes specifikációja

A levezetési kötelezettség: minden jelre, tartományra és mértékegységre kiterjedő specifikációt adunk három feladatra.

F-A: vektornorma. Jelek: $d=2$, $x=(3,4)^\top\in\mathbb R^2$, $\|x\|\in\mathbb R_{\ge0}$. Tartomány: a komponensek közös egysége $u$; itt $u=\mathrm{px}$, tehát $[\|x\|]=\mathrm{px}$. Számítás: $\|x\|=\sqrt{3^2+4^2}=\sqrt{25}=5\ \mathrm{px}$.

F-B: átlag. Jelek: $N=3$, $x=(1.0,3.0,5.0)$, $\bar{x}\in\mathbb R$. Tartomány: az értékek pixelintenzitások, dimenzió nélküliek. Számítás: $\bar{x}=\frac{1}{3}(1.0+3.0+5.0)=3.0$, dimenzió nélkül.

F-C: differenciahányados. Jelek: $f(t)=t^2$, $t_0=2$, $h=0.01$, $S_h f(t_0)\in\mathbb R$. Tartomány: $t$ idő ($[t]=\mathrm{s}$), $f$ hossz ($[f]=\mathrm{m}$). Dimenziósan helyesen $f(t)=a\,t^2$ alakban írjuk, ahol $a=1\ \mathrm{m}/\mathrm{s}^2$; így $[a\,t^2]=\mathrm{m}$, és $[S_h f]=\mathrm{m}/\mathrm{s}$. Az $f(t)=t^2$ írásmód ennek rövidítése: $t$ a másodpercben, $f$ a méterben vett numerikus érték. Számítás: a lenti lemma adja $S_h f(t)=2t$ minden $h\ne0$-ra; $t_0=2$-nél az eredmény $4\ \mathrm{m}/\mathrm{s}$.

Lemma (másodfokú eset). Ha $f(t)=t^2$ és $h\ne0$, akkor $S_h f(t)=2t$ minden $t\in\mathbb R$ esetén.

Bizonyítás. A definícióból:

$$S_h f(t) =\frac{(t+h)^2-(t-h)^2}{2h} =\frac{(t^2+2th+h^2)-(t^2-2th+h^2)}{2h} =\frac{4th}{2h} =2t.$$

Az első egyenlőség a definíció, a második a binomiális kifejtés, a harmadik az összevonás, a negyedik a $h\ne0$ feltétel melletti egyszerűsítés. $\square$

Ellenpélda a tétel határára. A lemma nem áll harmadfokú függvényre: ha $g(t)=t^3$, akkor $S_h g(t)=3t^2+h^2$, ami $h\ne0$ esetén nem egyenlő a $3t^2$ deriválttal. A $h\to0$ határátmenet az, amit a későbbi kalkulusfejezet formalizál; a lemma tehát a másodfokú alak következménye, nem általános simasági állítás.

1.4.4 Kézi példa

Az F-A, F-B, F-C feladatokat kézzel ellenőrizzük. F-A: $5\ \mathrm{px}$. F-B: $3.0$. F-C: $S_h f(2)=\frac{2.01^2-1.99^2}{0.02}=\frac{4.0401-3.9601}{0.02}=\frac{0.08}{0.02}=4.0\ \mathrm{m}/\mathrm{s}$. Az alakellenőrzés: a norma és az átlag skalár; a differenciahányados egysége az elvárt $\mathrm{m}/\mathrm{s}$.

A tensorfeladat: $X\in\mathbb R^{2\times1\times24\times24}$ elemszáma $1152$, egész szám, dimenzió nélkül. A seed-feladat nem numerikus, hanem a labor naplójába mentett indoklás.

1.4.5 Labor: első változat és napló

A labor megoldja az öt rövid feladatot, elmenti az első változatot, és rögzíti a választott alapozó egységet. Munkakönyvtár: a kurzusprojekt gyökere; a napló a lab_n004/ könyvtárba kerül. A futás CPU-n, float64 numerikus ellenőrzéssel történik; a labor nem generál véletlent, a GlyphLab generáló seedje ($20261020$) csak a napló szerződésrovatában szerepel.

#!/usr/bin/env python3
"""n004 diagnosztikai labor: elso valtozat mentese es naplo."""
import argparse
import hashlib
import json
import os
import sys
from datetime import datetime, timezone

EXPECTED = {
    "norm": {"value": 5.0, "tol": 1e-6},
    "function": {"value": 5.0, "tol": 1e-6},
    "mean": {"value": 3.0, "tol": 1e-6},
    "derivative": {"value": 4.0, "tol": 1e-5},
    "tensor_elements": {"value": 1152, "exact": True},
}

def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--answers", nargs=5, type=float, required=True,
                    help="sorrend: vektornorma, f(3), atlag, "
                         "szimmetrikus differenciahanyados, tensor-elemszam")
    ap.add_argument("--basis", required=True,
                    help="valasztott celzott alapozo egyseg, pl. n009")
    ap.add_argument("--seed-note", required=True,
                    help="magyarazat: miert nem eleg a seed onmagaban")
    ap.add_argument("--output-dir", default="lab_n004")
    args = ap.parse_args()

    os.makedirs(args.output_dir, exist_ok=True)
    log_path = os.path.join(args.output_dir, "log.json")
    if os.path.exists(log_path):
        print(f"Hiba: {log_path} mar letezik. "
              "A naplo append-only; ne ird felul az elso valtozatot.")
        return 2

    tensor_float = args.answers[4]
    if abs(tensor_float - round(tensor_float)) > 1e-9:
        print("Hiba: a tensor-elemszam egesz szam legyen.")
        return 2
    answers = {
        "norm": args.answers[0],
        "function": args.answers[1],
        "mean": args.answers[2],
        "derivative": args.answers[3],
        "tensor_elements": int(round(tensor_float)),
    }

    results = []
    for key, spec in EXPECTED.items():
        got = answers[key]
        if spec.get("exact"):
            err = abs(got - spec["value"])
            ok = got == spec["value"]
        else:
            err = abs(got - spec["value"])
            ok = err <= spec["tol"]
        results.append({
            "task": key,
            "expected": spec["value"],
            "got": got,
            "error": err,
            "ok": ok,
            "tolerance": spec.get("tol", 0),
        })

    now = datetime.now(timezone.utc).isoformat()
    material = now + json.dumps(answers, sort_keys=True)
    run_id = ("run-" + now.replace(":", "").replace("-", "")[:14]
              + "-" + hashlib.sha256(material.encode()).hexdigest()[:8])

    record = {
        "unit": "n004",
        "run_id": run_id,
        "timestamp": now,
        "device": "cpu",
        "dtype": "float64 numerikus ellenorzes; tensor-elemszam int",
        "glyphlab_seed_note":
            "glyphlab generalo seed 20261020; ez a labor nem general veletlent",
        "diagnosis_not_grading": True,
        "answers": answers,
        "results": results,
        "all_ok": all(r["ok"] for r in results),
        "chosen_basis_unit": args.basis,
        "seed_note": args.seed_note,
        "first_version_kept": True,
    }
    with open(log_path, "w", encoding="utf-8") as fh:
        json.dump(record, fh, ensure_ascii=False, indent=2)

    print("run_id:", run_id)
    print("log:", log_path)
    print("results:")
    for r in results:
        print(f"  {r['task']:>15s}: ok={r['ok']}, error={r['error']:.3g}")
    print("all_ok:", record["all_ok"])
    print("chosen_basis_unit:", args.basis)
    return 0 if record["all_ok"] else 1

if __name__ == "__main__":
    sys.exit(main())

Futtatási parancs, ha a hallgató mind az öt feladatot helyesen oldotta meg, és például a vektoros alapozást választja:

python n004_diagnosis.py --answers 5 5 3 4 1152 --basis n009 \
  --seed-note "A seed csak a generator kezdoallapota; ugyanaz a seed \
mas NumPy-verzioban vagy mas algoritmussal eltero sorozatot adhat."

A következő kimenet számított/demonstrációs példa, nem e könyv írása során futtatott mérés:

run_id: run-20261020T120000-4f2b81c3
log: lab_n004/log.json
results:
           norm: ok=True, error=0
       function: ok=True, error=0
           mean: ok=True, error=0
     derivative: ok=True, error=0
 tensor_elements: ok=True, error=0
all_ok: True
chosen_basis_unit: n009

Ha a fájl már létezik, a script exit code 2-vel megáll, és nem írja felül az első változatot. Ez a napló append-only/első-változat elve: a fejlődést csak úgy lehet később mérni, ha a diagnózis nyers állapota rögzítve marad. Az eredményértelmezés a hibás feladatokhoz kötött:

A választás nem büntetés, hanem útvonaltervezés: aki a differenciahányadost eltéveszti, annak érdemes a kalkulusfejezetnél lassabban haladnia, de a diagnózis ettől nem minősíti a kurzusbeli kilátásait.

1.4.6 Feladatok

F1 (fogalmi, nehézség 1). Magyarázza el a seed és a futásazonosító különbségét, és adjon egy konkrét helyzetet, amelyben ugyanaz a seed két környezetben eltérő sorozatot adhat. Átadandó: a két definíció saját szavakkal, egy helyzet és egy mondat arról, hogy a naplóban miért kell mindkettő.

F2 (levezetési, nehézség 1). Számítsa ki az $f(t)=3t^2-2t$ függvény $t=1$ pontjához tartozó szimmetrikus differenciahányadost $h=0.1$ mellett. Adja meg minden lépését, az eredmény mértékegységét és a $3$, illetve $2$ együttható mértékegységét, ha $[t]=\mathrm{s}$ és $[f]=\mathrm{m}$. Átadandó: a teljes levezetés és a mértékegység-ellenőrzés.

F3 (implementációs, nehézség 2). Írjon Python-függvényt, amely egy valós lista euklideszi normáját és átlagát számítja; üres listára a függvény ValueError-t dobjon. Átadandó: teljes kód, három teszteset ($v=(3,4)$, $x=(1,3,5)$, üres lista) és a tolerancia.

F4 (hibakeresési, nehézség 2). Az alábbi függvény hibás:

def mean(x):
    return sum(x) / (len(x) - 1)

Lokalizálja a hibát, adja meg a következményét egy egyelemű és egy kételemű bemeneten, javítsa, és ellenőrizze a javítást teszttel. Átadandó: ok, következmény, javított kód, teszteredmény.

F5 (kísérleti/transzfer, nehézség 3). Tervezze meg egy GlyphLab-osztályozó kísérlet naplójának rovatszerkezetét JSON-ban. A terv tartalmazza a run id-t, seedet, adatverziót, a scene_id szerinti csoportos split ellenőrzését, a választási protokollt (best checkpoint val loss alapján) és a záróteszt helyét. Indokolja, miért nem a test metrika alapján választ modellt. Átadandó: séma, kitöltési szabály és az érvényességi korlát egy bekezdésben.

1.4.7 Megoldások és indoklás

F1. A seed a pszeudovéletlen generátor bemenő kezdőállapota; a futásazonosító a kísérleti napló egy rekordját címkéző egyedi karakterlánc. Helyzet: np.random.seed(42) és np.random.default_rng(42) más algoritmus miatt eltérő sorozatot ad; ugyanígy PyTorch CPU és CUDA kernelváltozata is eltérhet. A naplóban a seed önmagában nem azonosítja a futást, mert a kódverzió vagy az adatverzió változása mellett ugyanaz a seed más eredményhez tartozhat; a run id ezért a teljes beállítás címkéje.

F2. A szimmetrikus hányados:

$$S_h f(1)=\frac{f(1.1)-f(0.9)}{0.2}.$$

Kiszámítva: $f(1.1)=3(1.21)-2.2=3.63-2.2=1.43$, és $f(0.9)=3(0.81)-1.8=2.43-1.8=0.63$. Így

$$S_h f(1)=\frac{1.43-0.63}{0.2}=\frac{0.8}{0.2}=4.0.$$

Alternatív algebra: az $f(t)=3t^2-2t$ alakra a lemma mintájára $S_h f(t)=6t-2$ adódik, mert a másodfokú tag szimmetrikus hányadosa $3\cdot2t=6t$, a lineáris $-2t$ tagé pedig $-2$. $t=1$-nél az eredmény $4.0$. A mértékegység $[S_h f]=[f]/[t]=\mathrm{m}/\mathrm{s}$. Dimenziósan $f(t)=a\,t^2-b\,t$ a pontos alak, ahol $a=3\ \mathrm{m}/\mathrm{s}^2$ és $b=2\ \mathrm{m}/\mathrm{s}$: a két együttható egysége különböző, mert mindkét tagnak méterben kell lennie. Ennek megfelelően $S_h f(t)=2a\,t-b$, ahol mindkét tag egysége $\mathrm{m}/\mathrm{s}$. Az alakellenőrzés: a hányados skalár, az egység a számlálóé osztva a nevezőével.

F3.

import math

def vector_norm(v):
    return math.sqrt(sum(x * x for x in v))

def mean(v):
    if len(v) == 0:
        raise ValueError("ures tombnek nincs atlaga")
    return sum(v) / len(v)

# Tesztek
assert abs(vector_norm([3.0, 4.0]) - 5.0) < 1e-12
assert abs(mean([1.0, 3.0, 5.0]) - 3.0) < 1e-12
try:
    mean([])
except ValueError:
    pass
else:
    raise AssertionError("ures tomb nem dobott ValueErrort")

A tolerancia $10^{-12}$, mert ezek a műveletek float64-ben pontosan reprezentálhatók. Az üres lista a szélsőeset: az átlag definíciója $N\ge1$-re érvényes, ezért a hibadobás a specifikáció része.

F4. Hiba: a nevező $N-1$, nem $N$. Következmény: $N=1$ esetén nullával osztás (ZeroDivisionError); $N=2$ esetén az eredmény a helyes átlag kétszerese, mert $\frac{x_1+x_2}{1}$ a $\frac{x_1+x_2}{2}$ kétszerese. Javítás: a nevező legyen len(x). Ellenőrző teszt:

def mean_fixed(x):
    return sum(x) / len(x)

assert mean_fixed([2.0]) == 2.0
assert abs(mean_fixed([1.0, 3.0]) - 2.0) < 1e-12

A javított függvény a $N=1$ szélsőesetet is helyesen kezeli; a hiba a korrigálatlan változatban a definíció szerinti normálási konstans tévesztése volt.

F5. Egy lehetséges séma:

{
  "run_id": "run-20261020T...-abcd1234",
  "question": "GlyphLab orientation baseline",
  "data_version": "1.0, seed 20261020",
  "split_check": "grouped by scene_id; train 240 / val 60 / test 60",
  "seed": 42,
  "model": "kesobbi fejezetben rogzitendo",
  "protocol": "best checkpoint val loss alapjan; final test egyszer",
  "metric": "accuracy",
  "raw_results": "TODO"
}

Indoklás: ha a modellválasztás a test metrika alapján történne, a test halmaz a választási folyamat részévé válna, és a mért pontosság adaptív túlillesztést tartalmazna. A val halmaz a kiválasztásé, a test a rögzített protokoll végén egyszeri értékelésé. A GlyphLab érvényességi korlátja: a generált alakzatokon mért eredmény nem természetes képi benchmark és nem termelési validáció.

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

A diagnózist gyakran hivatalos felvételiként vagy végleges készségminősítésként értelmezik. Ez tévedés. Ha egy hallgató a differenciahányadost például $S_h f(2)=2t+h$ értéknek számolja, az nem azt jelenti, hogy a kurzusból kizárt, hanem azt, hogy a határérték-intuíciót a 4.1. Függvény, határérték és derivált egységnél kell elmélyítenie. Ellenpélda a minősítő értelmezésre: két hallgató azonos hibát követ el, de az egyik korábban még soha nem látott deriváltat, a másik pedig elfelejtette; a hibapontszám nem különbözteti meg őket, a kurzus viszont mindkettőjüknek felépíti a hiányzó lépést. A diagnózis egyetlen érvényes következménye a célzott alapozó egység kiválasztása, nem a hallgató osztályozása.

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

Ellenőrizze: (1) az átlag mértékegysége miért egyezik az adatéval; (2) a $t^2$-es lemma melyik lépése használja a $h\ne0$ feltételt; (3) a run id és a seed közül melyiket írjuk a generátornak szánt bemenetként. Válaszok: (1) mert az összeg mértékegysége az adaté, az $1/N$ osztó dimenzió nélküli; (2) a $\frac{4th}{2h}$ egyszerűsítése; (3) a seedet. Visszahívás az 1.3. Adatfelosztás és a megfigyelési egység alfejezetből: a GlyphLabban a független egység a scene_id, ezért a napló split_check rovata azt igazolja, hogy egy jelenet minden nézete ugyanabba a splitbe került; a képszintű felosztás körülbelül 90 szabálytalan jelenetet okozhatott volna.

1.4.10 Tanulási főút és ellenőrző pontok

Ez a szakasz a könyv egészére érvényes, központi szabályokat adja meg. A tíz ellenőrző pont (4.4. I. ellenőrző pont: matematika és kód megfelelése, 8.4. II. ellenőrző pont: korrekt tanulási állítás, …, 40.4. X. ellenőrző pont: önálló neurális modell és bizonyíték) ezeket nem ismétli, csak a saját eltérését rögzíti.

A főút. A könyv tíz, egyenként négy fejezetből álló blokkra tagolódik; minden blokk a negyedik fejezete utolsó alfejezetében lévő ellenőrző ponttal zárul. A munkaterhelés tervezési becslés, nem mért érték: alfejezetenként 2–4 óra olvasás, feladat és labor, ellenőrző pontonként 6–10 óra.

1. 1–4. fejezet: szerződés, Python/NumPy, lineáris algebra, derivált és VJP. Előfeltétel: nincs. Ellenőrző pont: 4.4. I. ellenőrző pont: matematika és kód megfelelése. Becsült munka: 40–60 óra.
2. 5–8. fejezet: valószínűség, optimalizálás, veszteségek, általánosítás. Előfeltétel: az 1. blokk. Ellenőrző pont: 8.4. II. ellenőrző pont: korrekt tanulási állítás. Becsült munka: 40–60 óra.
3. 9–12. fejezet: perceptron, MLP, backprop, PyTorch-tanítás. Előfeltétel: az 1–2. blokk. Ellenőrző pont: 12.4. III. ellenőrző pont: önállóan tanuló kis háló. Becsült munka: 40–60 óra.
4. 13–16. fejezet: kép, konvolúció, gradiensei, equivariance, pooling. Előfeltétel: a 3. blokk. Ellenőrző pont: 16.4. IV. ellenőrző pont: a CNN-operátor teljes megértése. Becsült munka: 40–60 óra.
5. 17–20. fejezet: klasszikus, reziduális, hatékony CNN, transfer. Előfeltétel: a 4. blokk. Ellenőrző pont: 20.4. V. ellenőrző pont: indokolt CNN-választás. Becsült munka: 40–60 óra.
6. 21–24. fejezet: inicializálás, regularizálás, adat, értékelés, diagnózis. Előfeltétel: az 5. blokk. Ellenőrző pont: 24.4. VI. ellenőrző pont: megbízható CNN-training. Becsült munka: 40–60 óra.
7. 25–28. fejezet: osztályozás, detektálás, szegmentálás, embedding. Előfeltétel: a 6. blokk. Ellenőrző pont: 28.4. VII. ellenőrző pont: CNN alkalmazási szerződés. Becsült munka: 40–60 óra.
8. 29–32. fejezet: autoencoder, önfelügyelt, generatív, szekvencia, attention. Előfeltétel: a 7. blokk. Ellenőrző pont: 32.4. VIII. ellenőrző pont: célhoz illő neurális modell. Becsült munka: 40–60 óra.
9. 33–36. fejezet: inference, hatékonyság, magyarázat, kísérlettervezés. Előfeltétel: a 6–7. blokk. Ellenőrző pont: 36.4. IX. ellenőrző pont: lektorálható modellállítás. Becsült munka: 40–60 óra.
10. 37–40. fejezet: saját operátor, Projekt II–III, záróvizsga. Előfeltétel: az 1–9. blokk. Ellenőrző pont: 40.4. X. ellenőrző pont: önálló neurális modell és bizonyíték. Becsült munka: 60–80 óra.

Az előfeltételek a blokkok közti kötelező sorrendet adja: a 9. blokk a 8.-tól függetlenül is elkezdhető, ha a 6. és 7. blokk PASS; minden más blokk az előzőre épül.

Közös rubrika (0–4). Minden ellenőrző pontot öt dimenzióban értékelünk: (D1) matematikai helyesség, (D2) kód és futtathatóság, (D3) adat- és mérési protokoll (split, megfigyelési egység, tesztfegyelem), (D4) bizonyíték és nyomon követhetőség (napló, seed, verzió, hash, forrás), (D5) az állítás és korlátai (az állítás nem lép túl a bizonyítékon). Szintek: 0 hiányzik; 1 hibás; 2 lényegében helyes, de hiányosan ellenőrzött; 3 helyes és ellenőrzött; 4 helyes, ellenőrzött, és új helyzetre is indokoltan alkalmazott. A rubrika belső lektori eszköz, nem hivatalos osztályzat.

PASS-szabály. Továbbléphet, ha (a) az ellenőrző pont laborjának minden assert-je és toleranciaellenőrzése a saját futtatásában átmegy, (b) mind az öt dimenzió legalább 3, és (c) a riport csak ténylegesen lefuttatott kód kimenetét közli. Közös riportszabály: a riport a 36.4. IX. ellenőrző pont: lektorálható modellállítás hat komponensét tartalmazza (bizonyítás, forrásnyom, kód, futási jegyzék, páros eredmény, korlátok); a futási jegyzék a seedet, a csomag- és eszközverziót és a bemeneti fájlok SHA-256 lenyomatát rögzíti.

Visszautak. Ha egy ellenőrzés elbukik, a hibatípushoz tartozó alfejezetet kell újra feldolgozni: a feladatait megoldani, a laborját újrafuttatni, majd az ellenőrző pontot megismételni.

• alakhiba: shape mismatch, váratlan broadcast, rossz Linear bemenet: 2.1. Python, NumPy és tenzoralak tenzoralak, 3.2. Mátrixszorzás és affín réteg mátrixszorzás, 14.1. Stride, padding, dilation és outputméret outputméret, 14.2. Több bemeneti és kimeneti csatorna csatornák.
• gradienshiba: a kézi gradiens eltér az autogradtól vagy a véges differenciától: 4.3. Jacobi-mátrix, láncszabály és VJP VJP, 10.2. Affín réteg és aktiváció backward backward, 10.3. Gradiensellenőrzés és numerikus hibamérce gradiensellenőrzés, 15.1.–15.2. konvolúció gradiense, 15.4. Független gradiensellenőrzési protokoll protokoll.
• numerikus hiba: nan, inf, $\log 0$, túlcsordulás: 2.2. Lebegőpont és stabil elemi számítás lebegőpont, 7.4. Numerikus stabilitás és jelentésmegőrző implementáció stabil veszteség.
• statisztikai teszt vagy intervallum hibás, függő mintákon számolt bizonytalanság: 5.2. Várható érték, variancia és likelihood variancia, 5.3. Mintavételi bizonytalanság és intervallum intervallum, 5.4. Függő képek, seedek és resampling függő képek és resampling, 23.3. Páros összehasonlítás és csoportszintű intervallum páros összehasonlítás, 36.2. Ismétlések és eredménybizonytalanság ismétlések.
• split- vagy szivárgáshiba, jelenet több splitben: 1.3. Adatfelosztás és a megfigyelési egység megfigyelési egység, 11.3. Dataset és DataLoader a split után Dataset a split után, 22.1. Adateredet, címke és csoportos split csoportos split.
• train/eval mód, checkpoint, visszatöltés: 12.1. Tanítás, validáció és kiértékelési mód kiértékelési mód, 12.2. Checkpoint és folytathatóság checkpoint.
• a tanítás nem indul vagy nem konvergál: 12.3. Sanity check és kis mintára túlillesztés sanity check, 21.2. Learning rate és ütemezés tanulási ráta, 24.1. Tanulási görbe és hibadiagnózis tanulási görbe.
• metrika- vagy aggregálási hiba: 23.1. Confusion matrix és aggregálási konvenció aggregálási konvenció, 27.3. Dice, IoU és aggregálás Dice és IoU.

Ha ugyanaz a dimenzió két egymást követő kísérletben is 3 alatt marad, a blokk első fejezetétől kell visszalépni.

1.4.11 Egységjegyzék

A folyószöveg a többi alfejezetre fejezet.alfejezet számmal hivatkozik (például 4.3. Jacobi-mátrix, láncszabály és VJP). Az nNNN azonosító technikai kulcs: ez a forrásfájl neve (chapters/nNNN.md), a hivatkozási horgony és a laborfájlok előtagja. Az alábbi jegyzék mindkettőt megadja. A labor rovat a lab/ alatti, a könyvben teljes egészében közölt laborfájlokat sorolja fel; az adat rovat a kódblokkokban olvasott GlyphLab-fájlokat (I = images.npy, L = labels.npy, M = masks.npy, C = corrupted_test.npy, D = metadata.csv); a kimenet rovat a kódban szó szerint megnevezett kimeneti fájlokat. Változóval megadott kimeneti útvonalat a jegyzék nem sorol fel; ezeket az adott labor szakasza írja le.

• 1.1 n001 Modell, tanulás és felhasználási szerződés
  labor: f3_grid_linear.py
• 1.2 n002 Szakmailag megalapozott modellezési állítások
• 1.3 n003 Adatfelosztás és a megfigyelési egység
• 1.4 n004 Tanulási diagnózis és kísérleti napló
• 2.1 n005 Python, NumPy és tenzoralak
  labor: n005/lab_batch_mean.py
• 2.2 n006 Lebegőpont és stabil elemi számítás
• 2.3 n007 Izolált környezet, notebook és verzió
• 2.4 n008 Kis tudományos szoftverprojekt
  kimenet: input.npy
• 3.1 n009 Vektor, norma és skalárszorzat
• 3.2 n010 Mátrixszorzás és affín réteg
• 3.3 n011 Vetítés, legkisebb négyzetek és kondicionáltság
  labor: n011_lstsq/n011_lstsq.py, n011_lstsq/least_squares.py
• 3.4 n012 Sajátérték, SVD és spektrális határ
• 4.1 n013 Függvény, határérték és derivált
• 4.2 n014 Parciális derivált és gradiens
  labor: n014_grad_demo.py
• 4.3 n015 Jacobi-mátrix, láncszabály és VJP
  labor: n015/vjp_lab.py, n015/f3_solution.py
• 4.4 n016 I. ellenőrző pont: matematika és kód megfelelése
• 5.1 n017 Esemény, feltétel és véletlen változó
• 5.2 n018 Várható érték, variancia és likelihood
  labor: n018_likelihood.py
• 5.3 n019 Mintavételi bizonytalanság és intervallum
• 5.4 n020 Függő képek, seedek és resampling
• 6.1 n021 Objektív, reguláris tag és gradienslépés
• 6.2 n022 Konvexitás és sima optimalizálási határ
• 6.3 n023 Sztochasztikus és minibatch gradiens
• 6.4 n024 Momentum és adaptív optimizálók
  labor: n024/optim_steps.py
• 7.1 n025 Entrópia, cross-entropy és KL
  labor: n025_entropy_lab.py
• 7.2 n026 Softmax és többosztályos cross-entropy
  labor: n026/check_ce_grad.py
• 7.3 n027 Bináris, multilabel és regressziós cél
• 7.4 n028 Numerikus stabilitás és jelentésmegőrző implementáció
• 8.1 n029 Kockázat, mintavétel és baseline
  labor: n029_simulation.py
• 8.2 n030 Véges hipotézisosztály egyenletes korlátja
• 8.3 n031 Kapacitás, regularizálás és modellválasztás
  adat: ILD
• 8.4 n032 II. ellenőrző pont: korrekt tanulási állítás
  kimenet: evidence.json
• 9.1 n033 Neuron és perceptron
  labor: n033_perceptron/perceptron_lab.py
• 9.2 n034 MLP és nemlinearitás
• 9.3 n035 Expresszivitás és approximációs állítások
• 9.4 n036 Aktivációk és gradiensáramlás
  labor: n036/activation_gradients.py, n036/feladat_f3.py
• 10.1 n037 Számítási gráf és lokális derivált
• 10.2 n038 Affín réteg és aktiváció backward
• 10.3 n039 Gradiensellenőrzés és numerikus hibamérce
• 10.4 n040 Tanítási lépés és tanuló MLP
• 11.1 n041 Tensor és autograd-életciklus
  labor: n041/detach_demo.py, n041/accumulation_demo.py, n041/check_autograd.py, n041/split_path.py, n041/lifetime_counterexample.py
• 11.2 n042 nn.Module és paraméterregisztráció
• 11.3 n043 Dataset és DataLoader a split után
  labor: n043_dataset.py, n043_check.py; adat: D
• 11.4 n044 Egy teljes PyTorch tanítási iteráció
  labor: n044_train_step.py
• 12.1 n045 Tanítás, validáció és kiértékelési mód
  adat: ILD
• 12.2 n046 Checkpoint és folytathatóság
• 12.3 n047 Sanity check és kis mintára túlillesztés
  adat: ILD
• 12.4 n048 III. ellenőrző pont: önállóan tanuló kis háló
• 13.1 n049 Kép mint diszkrét többcsatornás jel
  labor: n049_layout/lab_n049.py
  kimenet: mini_images.npz
• 13.2 n050 Konvolúció és cross-correlation
  labor: n050/check_convs.py
• 13.3 n051 Lokális szűrők és tanult reprezentáció
  adat: ILD
• 13.4 n052 Határkezelés és frekvenciaintuíció
  labor: n052_boundary_check.py, n052_lab.py
• 14.1 n053 Stride, padding, dilation és outputméret
• 14.2 n054 Több bemeneti és kimeneti csatorna
• 14.3 n055 Paraméterszám, MAC és aktivációmemória
  labor: n055/param_mac_check.py, n055/feladat_f3.py
• 14.4 n056 Csoportos és depthwise konvolúció
• 15.1 n057 Súly- és biasgradiens
  labor: n057/weight_grad_check.py
• 15.2 n058 Inputgradiens és átfedő recepciós mezők
  labor: n058_dx_check.py, n058_f3_1d.py
• 15.3 n059 Transposed convolution mint adjungált
• 15.4 n060 Független gradiensellenőrzési protokoll
  kimenet: gradcheck_protocol.json
• 16.1 n061 Eltolási equivariance és invariance
• 16.2 n062 Pooling, downsampling és aliasing
• 16.3 n063 Elméleti és effektív recepciós mező
• 16.4 n064 IV. ellenőrző pont: a CNN-operátor teljes megértése
  labor: n064_checkpoint.py
• 17.1 n065 LeNet és a lokális megosztott reprezentáció
  labor: tiny_lenet_check.py; adat: I
• 17.2 n066 AlexNet és a kísérleti kontextus
• 17.3 n067 VGG és kis kernelek kompozíciója
• 17.4 n068 Architektúra összehasonlítása kontrollált keretben
  labor: n068/train_compare.py
• 18.1 n069 Reziduális blokk és identitásút
• 18.2 n070 Batch normalization train és eval módban
• 18.3 n071 Pre-activation, kis batch és alternatív normalizálás
• 18.4 n072 Reziduális blokk ablatív vizsgálata
  labor: n072_resablation.py
• 19.1 n073 Depthwise separable és pointwise réteg
  labor: n073_lab.py, n073_f3.py
• 19.2 n074 MobileNet és inverted residual
  labor: n074/inverted_residual_demo.py
• 19.3 n075 EfficientNet és architektúraskálázás
  labor: n075/n075_scale_bench.py
• 19.4 n076 ConvNeXt és a recept/architektúra elválasztása
• 20.1 n077 Feature extractor és új fej
  labor: n077/manual_check.py, n077/head_swap_lab.py; adat: ILD
• 20.2 n078 Finomhangolás és tanulási ráta
  adat: ILD
• 20.3 n079 Preprocessing, domain shift és súlylicenc
  labor: preprocess_check.py, check_preprocessing.py, preprocess_normalize.py; adat: I
  kimenet: images_norm.npy
• 20.4 n080 V. ellenőrző pont: indokolt CNN-választás
  labor: n080_residual_check.py, n080_decision_check.py
• 21.1 n081 Inicializálás és varianciaterjedés
  labor: n081_mini_scale.py, n081_init_scale.py
• 21.2 n082 Learning rate és ütemezés
  labor: n082_schedule_compare.py; adat: ILD
• 21.3 n083 Dropout, súlyregularizálás és augmentáció
  adat: ILD
• 21.4 n084 Osztályarány, súlyozás és céleloszlás
  labor: f3_weighted_ce.py; adat: ILD
• 22.1 n085 Adateredet, címke és csoportos split
• 22.2 n086 Címkemegőrző transzformációk
• 22.3 n087 Zajos és hiányos címke
  adat: ILD
• 22.4 n088 Augmentációs kísérlet és domainváltozás
  labor: augment_experiment.py
• 23.1 n089 Confusion matrix és aggregálási konvenció
  adat: L
  kimenet: eval_preds.npz
• 23.2 n090 Kalibráció és döntési küszöb
  adat: ILD
• 23.3 n091 Páros összehasonlítás és csoportszintű intervallum
  labor: scene_interval.py; adat: D
  kimenet: test_preds.npy
• 23.4 n092 Hibaszeletek és alkalmazási határ
• 24.1 n093 Tanulási görbe és hibadiagnózis
  labor: n093_diagnose.py; adat: ILD
• 24.2 n094 CPU/GPU profiling és helyes időmérés
  adat: ILD
  kimenet: measure_report.json
• 24.3 n095 Mixed precision és nagyobb batch
• 24.4 n096 VI. ellenőrző pont: megbízható CNN-training
  labor: n096_checkpoint.py, check_best.py; adat: ILCD
  kimenet: runlog.json
• 25.1 n097 Teljes képosztályozó adatfolyam
  labor: model_def.py, train_classifier.py, infer.py; adat: ILD
• 25.2 n098 Multilabel és hierarchikus cél
• 25.3 n099 Kis adat és feature-alapú baseline
• 25.4 n100 Nyílt halmaz és ismeretlen input
  labor: rejection_rule.py
• 26.1 n101 Dobozkoordináta, IoU és lokalizációs loss
  labor: n101_lab.py; adat: MD
• 26.2 n102 Egy- és kétlépcsős detektor
• 26.3 n103 NMS, confidence és AP
  labor: n103_nms_lab.py, n103_map.py
• 26.4 n104 Detektálási pipeline és hibaelemzés
• 27.1 n105 Pixelszintű klasszifikáció és FCN
  adat: ILMD
• 27.2 n106 U-Net, encoder–decoder és skip
• 27.3 n107 Dice, IoU és aggregálás
• 27.4 n108 Instance mask és összetett feladat
• 28.1 n109 Embedding, távolság és normalizálás
  labor: embedding_exact.py, extract_embeddings.py
• 28.2 n110 Sziámi és triplet cél
  labor: n110_triplet_lab.py
• 28.3 n111 Retrieval-értékelés és adatfelosztás
  labor: retrieval_report.py
• 28.4 n112 VII. ellenőrző pont: CNN alkalmazási szerződés
  labor: n112_dotpair/retrieval_eval.py
• 29.1 n113 Lineáris és nemlineáris autoencoder
• 29.2 n114 Denoising és korrupciós modell
  adat: ID
• 29.3 n115 Regularizált latent reprezentáció
  labor: n115_latent_probe.py
• 29.4 n116 Anomáliapontszám rekonstrukcióból
  labor: score_hand_check.py, anomaly_lab.py
  kimenet: anomaly_report.json
• 30.1 n117 Pretext és downstream feladat
  adat: ID
• 30.2 n118 Kontrasztív cél és temperature
  labor: n118/nt_xent_pairs.py
• 30.3 n119 Negatív nélküli módszerek és collapse
• 30.4 n120 Önfelügyelt kísérlet korrekt összevetése
• 31.1 n121 VAE és variációs alsó korlát
• 31.2 n122 GAN mint minimax probléma
• 31.3 n123 Diffúziós zajmodell és CNN-denoiser
• 31.4 n124 Generatív felhasználás és értékelés
• 32.1 n125 Szekvenciamodell és változó hossz
• 32.2 n126 Scaled dot-product attention
  labor: n126/n126_attention.py
• 32.3 n127 Vision Transformer és hibrid felhasználás
• 32.4 n128 VIII. ellenőrző pont: célhoz illő neurális modell
  adat: ILD
• 33.1 n129 Inference-szerződés és modellcsomag
  adat: I
  kimenet: control_input.npy, manifest.json, reference_logits.npy
• 33.2 n130 Batch és kis szolgáltatás
• 33.3 n131 torch.export és ONNX
• 33.4 n132 Üzemeltetés, drift és késő címke
  labor: n132/monitor_demo.py, n132/rollback_policy.py, n132/test_schema.py, n132/test_join.py
• 34.1 n133 Mért késleltetés, throughput és memória
  kimenet: latency_results.json
• 34.2 n134 Kvantálás és hibatovábbterjedés
• 34.3 n135 Pruning és struktúra
  labor: n135_prune_lab.py
• 34.4 n136 Teacher–student desztilláció
  labor: n136_distill/soft_target_example.py, n136_distill/train_distill.py, n136_distill/manual_kd.py; adat: IL
• 35.1 n137 Saliency és Grad-CAM
  labor: n137_gradcam.py
• 35.2 n138 Magyarázat sanity check
  labor: n138_sanity_check.py
• 35.3 n139 Perturbáció és adversarial példa
  labor: n139/manual_fgsm.py, n139/fgsm_demo.py
• 35.4 n140 Korlátok, eredet és döntési felelősség
• 36.1 n141 Állításból kísérleti terv
• 36.2 n142 Ismétlések és eredménybizonytalanság
  adat: ILD
• 36.3 n143 Szakirodalmi reprodukció és attribúció
• 36.4 n144 IX. ellenőrző pont: lektorálható modellállítás
• 37.1 n145 Operátorspecifikáció és kézi referencia
• 37.2 n146 Backward és ellenőrzési lefedettség
• 37.3 n147 Linearitás, adjungált és határfeltétel
  labor: n147_operator_report.py
• 37.4 n148 Rétegből kis tanulómodell
• 38.1 n149 Adat, split és előzetes protokoll
  labor: protocol_check.py; adat: ILMCD
  kimenet: protocol_n149.json
• 38.2 n150 Modell, training és best checkpoint
  labor: glyph_models.py, train_small_cnn.py, run_project2.py
• 38.3 n151 Végső teszt és páros korrupció
  labor: eval_test.py; adat: ILCD
  kimenet: n151_logits_clean.npy, n151_pred_clean.npy, n151_pred_corrupt.npy, n151_report.json, n151_test_index.npy
• 38.4 n152 Mentett modellből független inference
  labor: package_project2.py, PROJECTII/models.py, PROJECTII/inference.py
  kimenet: model_card.json, test_indices.npy, test_reference.npz
• 39.1 n153 Feladat- és annotációs döntés
  labor: project3/annotation_spec.py
• 39.2 n154 Encoder–decoder vagy lokalizációs fej
  labor: project3/segmentation_head.py, project3/train_seg.py; adat: IMD
  kimenet: seg_train_log.json
• 39.3 n155 Geometriai kontroll és metrika
  labor: project3/n155_geom_control.py; adat: MD
  kimenet: control_pred.npy, control_target.npy, n155_control_report.json
• 39.4 n156 Alkalmazási riport és átadás
  labor: project3/export_delivery.py, project3/report_audit.py; adat: ICD
  kimenet: manifest.json, model_card.json
• 40.1 n157 Összetett levezetési vizsga
• 40.2 n158 Kísérleti és hibakeresési vizsga
  adat: ILCD
• 40.3 n159 Tudományos kézirat és forrásaudit
  adat: D
• 40.4 n160 X. ellenőrző pont: önálló neurális modell és bizonyíték
  labor: n160_thickness.py; adat: ID
  kimenet: inference_contract.json, test_predictions.npz

1.4.12 Rövid összefoglaló

Az 1.4. Tanulási diagnózis és kísérleti napló diagnózis nem osztályozó vizsga, hanem az alapozó útvonal kiválasztását segítő első mérés. A vektor normája csak közös komponens-egység mellett értelmes; az átlag egysége az adaté; a differenciahányados egysége $[f]/[t]$. A másodfokú $t^2$ szimmetrikus hányadosa pontosan $2t$, amit algebrailag igazoltunk; harmadfokú esetre a lemma nem áll, és a határértéket a 4.1. Függvény, határérték és derivált formalizálja. A tensor alakja dimenzió nélküli, dtype-ja a tárolást rögzíti. A seed a generátor kezdőállapota, a futásazonosító a napló kulcsa; a kettő nem felcserélhető. A labor az első változatot append-only JSON-ba menti, és a hibák alapján célzott alapozó egységet választ.

Következő alkalmazás. A 2.1. Python, NumPy és tenzoralak egység a tenzoralak és a NumPy-műveletek pontos kezelését vezeti be; ha a diagnózis a mean vagy tensor_elements feladatban hibát mutatott, ez az első célzott alapozó.

Források

• [B01] Deisenroth, A. A. Faisal és C. S. Ong (2020). Mathematics for Machine Learning. https://mml-book.github.io/.