Osztályozás, keresztentrópia, és hogyan ne csapd be magad

Ugyanaz a gyár, mint az 1. fejezetben, nehezebb kérdéssel. Nem az a kérdés, hogy elfogadjuk vagy elutasítjuk, hanem az, hogy hibás-e ez az alkatrész — a hibák pedig ritkák, ettől lesz ennek a fejezetnek a mérési fele nehéz, a modellezési fele pedig megtévesztően könnyű.

import numpy as np

rng = np.random.default_rng(4)
N = 20_000
width  = rng.normal(22.0, 0.9, N)      # millimetres
weight = rng.normal(57.0, 3.0, N)      # grams

z_true = -5.90 + 1.90 * (width - 22.0) + 0.42 * (weight - 57.0)
y = (rng.random(N) < 1 / (1 + np.exp(-z_true))).astype(float)

perm = rng.permutation(N)
train, val, test = perm[:12_000], perm[12_000:16_000], perm[16_000:]

N = 20000  defects = 337  base rate = 0.0169
defects per split = 203 60 74

Három felosztás, nem kettő. Az ok megérdemel egy saját szakaszt, és kap is egyet lentebb; egyelőre taníts az elsőn, hangolj a másodikon, és ne nézz rá a harmadikra.

A jellemzőket standardizáljuk — kivonjuk az átlagot, elosztjuk a szórással —, kizárólag a tanítókészlet statisztikáit használva, ugyanazért, amit az 1. fejezet a perceptron konvergenciakorlátjával bemutatott: a nem központosított adat ellenséges geometriát teremt. Az, hogy mely sorokból számíthatod ki ezt az átlagot, később ebben a fejezetben élő kérdéssé válik.

A perceptron előjelet adott vissza. Egy előjel nem tudja megkülönböztetni azt, hogy elutasítva, attól, hogy elutasítva, de éppen csak, pedig pontosan erre a különbségre van szüksége a gyárnak ahhoz, hogy eldöntse, mely alkatrészeket nézze meg először újra egy ember.

Kövesd tehát szó szerint a 2. fejezet receptjét. Írd le, mit állítasz arról, hogyan keletkezik egy címke, vedd a likelihoodot, vedd a logaritmusát, fordítsd előjelét, és megvan a veszteség. Egy igen/nem kimenetnél az állítás egy Bernoulli-eloszlás: van egy $p$ valószínűség, hogy az alkatrész hibás, és

ami csak egy tömör módja annak, hogy azt írjuk: „$p$, ha $y = 1$, és $1-p$, ha $y = 0$”. Vedd ennek a logaritmusát és fordítsd előjelét, és az egy példára jutó veszteség:

Ez a bináris keresztentrópia. Nem azért választottuk, mert kényelmes; ez az egyetlen eloszlás negatív log-likelihoodja, amelyet egy pénzfeldobás felvehet. Más nem is állt rendelkezésre.

Még az hiányzik, honnan jön $p$. A modell kiszámít egy súlyozott összeget, $s = \mathbf{w}\cdot\mathbf{x} + b$-t, amely valós szám és a teljes számegyenesen mozog, egy valószínűségnek viszont $(0,1)$ között kell élnie. A kettő között átvivő függvény a logisztikus szigmoid:

logit -4.0  ->  p = 0.0180        loss when y=1 and p=0.9  : 0.1054
logit -1.0  ->  p = 0.2689        loss when y=1 and p=0.5  : 0.6931
logit  0.0  ->  p = 0.5000        loss when y=1 and p=0.01 : 4.6052
logit  4.0  ->  p = 0.9820

A jobb oldali oszlopot olvasd árlistaként. 90 %-os magabiztossággal helyesnek lenni 0,105-be kerül. Nem elköteleződni 0,693-ba — ez $\log 2$, a vállrándítás ára. Magabiztosan tévedni 4,6-ba kerül, negyvennégyszer többe, és az ár korlátlanul nő, ahogy a modell egyre biztosabb lesz egy hibában. A keresztentrópia nem pusztán számolja a hibákat: kiszámlázza az arroganciát.

A 3. fejezet azt mondta: bármit akarsz tanítani, szerezd meg a veszteség deriváltját minden paraméter szerint. Csináld meg egy példára. $s = \mathbf{w}\cdot\mathbf{x} + b$ és $p = \sigma(s)$ mellett:

Tehát a frissítés predikció mínusz igazság, szorozva a bemenettel. Semmi más. Itt a teljes tanító, amely a 3. fejezet descentje egyetlen megváltoztatott sorral:

def sigmoid(z):
    return np.where(z >= 0, 1.0 / (1.0 + np.exp(-z)),
                    np.exp(np.minimum(z, 0)) / (1.0 + np.exp(np.minimum(z, 0))))


def fit_logistic(X, y, lr=0.5, epochs=4000):
    w, b = np.zeros(X.shape[1]), 0.0
    for _ in range(epochs):
        p = sigmoid(X @ w + b)
        g = p - y                        
        w -= lr * (X.T @ g) / len(y)     
        b -= lr * g.sum() / len(y)       
    return w, b

A np.where a sigmoid-ben nem kozmetika. A $1/(1+e^{-s})$ közvetlen kiszámítása túlcsordul nagy negatív $s$ esetén; az elágazás azt az algebrailag azonos alakot választja, amely negatívan tartja az exponenst. Ez a 2. fejezet lebegőpontos doboza, amely behajtja az első tartozását, és két szakasz múlva nagyobbat is behajt.

A keresztentrópia négyzetes hibával szembeni előnyének szokásos magyarázata a fenti likelihood-érv: a négyzetes hiba abból jön, hogy Gauss-zajt feltételezünk, a címkék nem Gauss-eloszlásúak, tehát ne ezt használd. Ez igaz, és senkit nem győz meg, mert ráírhatod a $L = (p - y)^2$-t egy szigmoidra, és tanulni fog.

Az érv, ami célba ér, a gradientről szól. Tegyél négyzetes hibát egy szigmoid tetejére, és a láncszabály ezt adja:

Az extra $p(1-p)$ az, ami az előbb kiesett. Most nem esik ki, és nullához tart, amikor a modell magabiztos — akkor is, amikor a modell magabiztosan téved. Értékeld ki mindkettőt néhány pontszámnál egy olyan példára, amelynek valódi címkéje 1:

$s = -8$-nál a modell annyira téved, amennyire csak lehet, a négyzetes hiba pedig a keresztentrópia gradientjénél 1 491-szer kisebb gradienttel válaszol. Minél rosszabb a hiba, annál kevesebbet tanul belőle a modell. A keresztentrópia gradientje ezzel szemben $-1$-nél telítődik: a maximálisan rossz predikció maximálisan nagy jelet ad, de annál nagyobbat nem.

Futtasd le a versenyt. Kétezer kiegyensúlyozott pont, azonos kezdősúlyok, magabiztosan rosszra választva ($\mathbf{w} = [-6, -6]$), azonos learning rate, csak a veszteség különbözik. Mindkét futást keresztentrópiával pontozzuk, hogy az oszlopok összehasonlíthatók legyenek.

A keresztentrópia az 50. epochra végez. A négyzetes hiba a 100. epochban még mindig 24 %-os accuracy körül jár — és a 10. epochbeli 23 %-ról sem mozdult el — rosszabb, mint a találgatás, mert magabiztosan rosszról indult, és az a gradient, amely kimentené, meg lett szorozva 0,0007-tel. Körülbelül az 500. epoch táján szabadul ki, és ugyanoda érkezik. Az őszinte összefoglaló tehát az, hogy a szigmoid fölötti négyzetes hiba nem helytelen; csak pont ott lassú, ahol a sebesség a legfontosabb. Egy kétparaméteres modellen 450 epochot veszítesz. Egy százrétegű hálón, ahol valahol valamelyik egység mindig magabiztosan téved, elveszíted a tanítási futást.

Három mennyiség, amelyekre rendesen szükség lesz a 8. fejezetben a perplexityhez, és a 11. fejezetben ahhoz a büntetéshez, amely egy fine-tuned policyt a referenciája közelében tart. Könnyebbek, mint a hírük.²

Az entrópia az átlagos bitszám, amelyet egy eloszlásból vett minta kommunikálására el kell költened, ha a lehető legjobb kódot használod hozzá:

A keresztentrópia az, amit akkor költesz, amikor egy $q$-hez épített kódot használsz olyan adatra, amely valójában $p$-ből jön:

A KL-divergencia a többlet — a bitben mért pazarlás, amelyet az okoz, hogy $q$-ben hiszel, amikor az igazság $p$:

Ellenőrizd mindhármat a szalagon:

test defect rate                                = 0.0185
entropy of that coin                            = 0.1329 bits
cross-entropy of the constant predictor on test = 0.1330 bits
KL(test coin || fair coin)                      = 0.8671 bits
H + KL                                          = 1.0000 bits
cross-entropy of the p=0.5 predictor on test    = 1.0000 bits

Két dolog látszik ott. Először: egy modell, amely egyszerűen a tanítási alaparányt jelenti, 1,69 %-ot, 0,1330 bites keresztentrópiát ér el, szinte pontosan a tesztcímkék entrópiáját — ahogy muszáj is, hiszen a megfelelő eloszlása megvan, más információja viszont nincs. Az entrópia az a padló, amelyet az egyedekről való tudatlanság megvásárol neked. Másodszor: egy modell, amely vállat von és 0,5-öt mond, pontosan 1 bitet fizet, és a kettő közötti rés, 0,8671 bit, pontosan a KL-divergencia. A $H + D_{\mathrm{KL}} = H(p,q)$ nem bemagolandó azonosság; ez egy számla, amelynek összeadódását végignézheted.

És a kapcsolat vissza a tanításhoz: amikor a címke egyetlen ismert osztály, a „valódi” eloszlás one-hot, az entrópiája nulla, és a keresztentrópia egyenlő a KL-divergenciával. A keresztentrópia minimalizálása és a modell eloszlásának az igazság felé húzása ugyanaz a cselekedet.

A hibás nem egyetlen dolog. Fröccsöntésnél egy alkatrész kijöhet short shotként (nincs elég anyag), flashként (túl sok anyag, kinyomódik a formából), vagy égésként. Négy kimenet, tehát négy logit, és ezekből négy olyan valószínűségnek kell lennie, amelyek összege egy. Ez a softmax:

Van egy tulajdonsága, amely balesetnek tűnik, valójában viszont ez az egész implementáció:

bármely $c$ konstansra, mert $e^{z_i + c} = e^{c} e^{z_i}$ és a $e^c$ fent és lent kiesik. Csak a logit értékek közötti különbségek jelentenek bármit. Az abszolút szint nem információ.

Szerencsére így van, mert az abszolút szint az, ami összetöri a számítógépet:

logits            = [800. 801. 799.]
naive softmax     = [nan nan nan]
shifted by -max   = [0.2447 0.6652 0.09  ]
same softmax after adding 1000 to every logit: True

A $e^{800}$ túlcsordít egy 64 bites lebegőpontos számot, az összeg végtelenné válik, és a végtelen osztva végtelennel nan — nem hiba, nem összeomlás, csak egy csendes lyuk ott, ahol korábban három valószínűség volt. A legnagyobb logit kivonása matematikailag semmit sem változtat, numerikusan viszont mindent, mert a legnagyobb exponens pontosan $e^0 = 1$ lesz. Ez a 2. fejezet logsumexp trükkje munkaruhában, és minden komoly implementáció ezt csinálja:

def softmax(Z):
    Z = Z - Z.max(axis=1, keepdims=True)   
    E = np.exp(Z)
    return E / E.sum(axis=1, keepdims=True)


def fit_softmax(X, Y, lr=1.0, epochs=6000):
    W, b = np.zeros((X.shape[1], Y.shape[1])), np.zeros(Y.shape[1])
    for _ in range(epochs):
        G = (softmax(X @ W + b) - Y) / len(X)   
        W -= lr * (X.T @ G)
        b -= lr * G.sum(0)
    return W, b

A gradient megint predikció mínusz igazság, most $Y$ one-hot mellett. A bináris eset végig csak speciális eset volt.

3 000 alkatrészen tanítva és 1 000-en tesztelve, három-három méréssel (szélesség, súly, olvadék-hőmérséklet), 94,00 % accuracyt ér el. Íme, mit rejt el ez a szám:

A modell a short shotok kevesebb mint felét találja meg. Az accuracy ezt nem látja, mert az alkatrészek 86 %-a rendben van, és ezek helyes eltalálása elég az átlag cipeléséhez. A Macro F1 — az osztályonkénti F1-pontszámok átlaga, amely egy ritka osztályt ugyanúgy súlyoz, mint egy gyakorit — 0,7983, szemben a 0,9400-s micro F1-gyel, amely definíció szerint azonos az accuracyvel. Valahányszor valaki egyetlen F1-számot jelent, kérdezd meg, melyiket.

Ez volt a modellezés vége. A fejezet többi része a számokról szól.

Vedd a betanított bináris modellt, és készíts két változatot úgy, hogy minden logit értéket megszorzol egy konstanssal: 0,35-tel egy tétova verzióhoz, 4-gyel egy túlmagabiztoshoz. Pozitív számmal szorozni nem változtathat meg egyetlen előjelet sem, tehát mindhárom modell pontosan ugyanazt a címkét prediktálja mind a 4 000 tesztalkatrészre. Az accuracy nem tud különbséget tenni köztük. A keresztentrópiának ez egyáltalán nem gond:

A tétova modell kis adót fizet minden alkatrészre, beleértve azt a több ezret is, amelyet helyesen talál el. A túlmagabiztos modell helyes válasznál szinte ingyen van, tévedésnél katasztrofális — a tesztkészletben egyetlen alkatrész önmagában 27,63 natba kerül neki. A kettő majdnem ugyanahhoz az összesítéshez érkezik ellentétes útvonalon, a tanított modell pedig, amelynek valószínűségei az adatokhoz vannak kalibrálva, mindkettő alatt háromszor jobb helyen ül.

Ez a legélesebb módja annak, hogy kimondjuk a különbséget loss és metric között. A loss az, amit optimalizálsz: differenciálhatónak kell lennie, és mindent lát, amit a modell mondott, azt is, mennyire volt biztos benne. A metric az, ami alapján megítélnek: lehet lépcsőfüggvény, üzleti szabály, elhibázott defektek száma. Nem ugyanaz az objektum, és nem mindig értenek egyet — ezért definiálod mindkettőt, mielőtt elkezded, és soha nem hagyod, hogy a loss helyettesítse a metricet csak azért, mert épp az van a képernyőn.

Bármilyen modell előtt jön a követelmény: mit ér el a lehető leglustább válasz? Ezen a szalagon: mindig mondd, hogy rendben:

always-say-fine baseline: accuracy = 0.9815
confusion (tn, fp, fn, tp) = (3926, 0, 74, 0)

98,15 %. Most a tanított logisztikus modell, az alapértelmezett 0,5-ös küszöbbel:

logistic @0.5: accuracy=0.9830 precision=0.8000 recall=0.1081 F1=0.1905
confusion (tn, fp, fn, tp) = (3924, 2, 66, 8)

98,30 %. 0,15 százalékponttal verte meg a baseline-t, és bármely jelentés, amely az accuracynél megáll, ezt győzelemnek fogja nevezni. A konfúziós mátrix megmondja, mi történt valójában:

Három szám nevezi meg a táblázat három olvasatát:

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. Az általa megjelölt alkatrészek közül hány volt valóban hibás. Ez az elpazarolt ellenőrzések költsége.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. A hibás alkatrészek közül hányat kapott el. Ez annak a költsége, hogy rossz alkatrészt küldesz az ügyfélnek.
• F1 $= 2PR/(P+R) = 0.190$, ezek harmonikus átlaga, amely a kisebbik közelében marad, ezért nem hagyja, hogy az egyik önmagában hízelegjen neki.

Hogy melyik számít, az a gyártól függ, nem a matematikától: egy ellenőrzés néhány másodpercbe kerül, egy kiszállított hiba visszahívási értesítésbe, ezért itt a recall dominál, a 0,108 pedig kudarc.

De nem a modell a probléma. A küszöb az, és a küszöb nem része a modellnek — üzleti döntés, amelyet utólag alkalmazunk egy valószínűségre. Söprögessük végig:

Olvasd lefelé az accuracy oszlopot. Végig esik — 98,30 %-ról 65,93 %-ra —, miközben a modell 8 hiba elkapásától eljut 71 hiba elkapásáig a 74-ből. Minden hasznos dolog, amit ez a modell csinálni tud, rontja az accuracyjét. Egy csapat, amely a főcímszámot optimalizálja, azt a verziót szállítaná, amely semmit sem talál.

Miért három felosztás, és miért nem kettő? Mert abban a pillanatban, amikor egy példakészletet arra használsz, hogy válassz valamit — küszöböt, learning rate-et, azt, hogy hat modell közül melyiket szállítsd —, azt a készletet illesztésre használtad, és a pontszáma többé nem torzítatlan.³ Ezen a szalagon mérve: a küszöb végigsöprése a validációs készleten 0,196-ot választ, és a modell ezután F1 = 0,4122 pontot ér el az érintetlen tesztkészleten. Ha a söprést közvetlenül a tesztkészleten futtattuk volna, ott a legjobb elérhető érték 0,4186 lett volna — egy szám, amelynek jelentésére senki nem jogosult.

A rés itt kicsi, 0,006, mert ez egyetlen hyperparameter volt, egyszer végigsöpörve 4 000 validációs példa ellen. Minden extra döntéssel és a validációs készlet minden zsugorodásával nő. Figyeld meg azt is, hogy az irány egyetlen futásban nem garantált: a választott küszöb 0,3902-t ért el validáción és 0,4122-t teszten, tehát a validáció ezúttal alulbecsülte. A torzítás sok döntésen át szisztematikus, egyetlen döntésben nem látható.⁴

Most a gyakorlat. A szalagnapló egy harmadik oszloppal érkezik, station_seconds: mennyi időt töltött az egyes alkatrész az ellenőrző állomáson. Hozzáadni egysoros változtatás az előfeldolgozásban. Ezt teszi:

A recall 10,8 %-ról 77,0 %-ra ugrik. Az F1 több mint négyszereződik. És vedd észre, mit csinált az accuracy: 98,30 % → 99,20 %, kilenctized pont nyereség, pont az a fajta szám, amelyet egy összefoglaló dián úgy kerekítenek, hogy „így is, úgy is körülbelül 99 %”. Az accuracy korábban nem látta a kudarcot, most pedig nem látja a csalást.

Mielőtt tovább olvasol: a modell csal. Derítsd ki, hogyan.

station = 1.8 + rng.exponential(0.35, N)                     # a part just passing through
audited = rng.random(N) < 0.006                              # random spot checks
station[audited] += rng.uniform(6.0, 26.0, audited.sum())
station[y == 1] = 9.0 + rng.exponential(7.0, (y == 1).sum())  

A kiemelt sor a leak: egy hibás alkatrész tartózkodási ideje más eloszlásból van húzva, mert egy ember levette a szalagról. Ez az alkalmazott gépi tanulás leggyakoribb súlyos hibája, és neve is van: target leakage — olyan információ a tanítási jellemzőkben, amely nem lenne elérhető abban a pillanatban, amikor a predikciót meg kell tenni.⁵ Nem dob kivételt. Jobb számot ad. Egy projekt minden ösztönzője afelé mutat, hogy megtartsd.

A védekezés egyetlen kérdés, minden oszlopra feltéve: abban a pillanatban, amikor erre a predikcióra szükségem van, létezik már ez az érték? Élő szalagon a station_seconds ismeretlen addig, amíg az alkatrészt már meg nem vizsgálták — pedig ezt kellett volna kiváltania a modellnek.

Tegyük fel, hogy egy modellt 20 példán pontozol, és 17-et eltalál. 85 %-ot jelentesz.

17 correct out of 20 -> accuracy 0.8500
  Wilson    95% CI : [0.6396, 0.9476]
  bootstrap 95% CI : [0.7000, 1.0000]
  P(a 65% model scores 17 or more out of 20) = 0.0444
  P(an 85% model scores 17 or more out of 20) = 0.6477

A 17/20 őszinte olvasata: valahol 64 % és 95 % között. Egy valóban 65 %-os modell az esetek 4,4 %-ában produkálja ezt — huszonhárom futásból egyszer —, és ha kipróbáltál egy marék promptot, majd a legjobbat jelentetted, te magad gyártottad le azt a futást. A húszból tizenhét nem tud különbséget tenni egy 85 %-os és egy 65 %-os modell között.

Két mód arra, hogy intervallumot tegyél egy arány köré, és mindkettőnek a szerszámosládádban a helye:

def wilson(k, n, z=1.959963985):
    """95% interval for k successes in n trials. Correct at small n; no simulation."""
    ph, d = k / n, 1 + z * z / n
    centre = (ph + z * z / (2 * n)) / d
    half = z * (ph * (1 - ph) / n + z * z / (4 * n * n)) ** 0.5 / d
    return centre - half, centre + half


def bootstrap_ci(correct, n_resamples=10_000, alpha=0.05, seed=0):
    """95% interval for the mean of any per-example score array. Works on F1 too."""
    rng = np.random.default_rng(seed)
    correct = np.asarray(correct, dtype=float)
    draws = correct[rng.integers(0, len(correct), size=(n_resamples, len(correct)))]
    lo, hi = np.quantile(draws.mean(axis=1), [alpha / 2, 1 - alpha / 2])
    return float(correct.mean()), float(lo), float(hi)

Használd a Wilson-intervallumot⁶ sima sikerarányhoz; bármilyen $n$ mellett jól viselkedik, és nincs szüksége véletlenre. Figyeld meg fent, hogy $n = 20$-nál a bootstrap felső vége 1,0000 — 20 pont újramintavételezése könnyen húzhat 20 helyeset, ezért nem tud a saját granularitásánál szűkebb intervallumot képviselni. Használd a bootstrapet⁷, amikor nincs képlet, ami a legtöbb érdekes eset: F1, makroátlagok, BLEU, pass@1, rubric-alapú judge pontszáma. Ezen a szalagon a hangolt modell 0,4122-es F1-éhez [0,3009, 0,5156] bootstrap-intervallum tartozik — ennek a számnak kellene szerepelnie a jelentésben, mert a pontbecslés önmagában olyan összehasonlítást hív meg, amelyet nem tud alátámasztani.

Még egy mérés, mert megváltoztatja, hogyan érdemes két modellt összehasonlítanod. Két modell ugyanazon az 500 példán pontozva:

model A: 0.8580  95% CI [0.8260, 0.8880]
model B: 0.8120  95% CI [0.7780, 0.8460]
the two intervals overlap: True
paired difference A-B: 0.0460  95% CI [0.0260, 0.0680]
they disagree on 31 of 500 examples (A right 27, B right 4)

Az intervallumaik átfednek, és a népi szabály — az átfedő hibasávok azt jelentik, hogy nincs szignifikáns különbség — az összehasonlítást nem meggyőzőnek nevezné. Nem az. A két modell ugyanazokon a példákon futott, ezért a helyes mennyiség a példánkénti különbség, amelynek intervalluma [0.0260, 0.0680], kényelmesen nulla felett. Csak 31 elemben nem értenek egyet az 500-ból, és A ezekből az eltérésekből 27-et megnyer; a közös példák, könnyűek és nehezek egyaránt, kioltják egymást ahelyett, hogy zajt adnának hozzá. Hasonlítsd a modelleket párosítva, és az adatok töredékéből ugyanarra a következtetésre jutsz.

Most már van egy modelled, amely kalibrált valószínűségeket ad ki, egy veszteséged, amely az adatról tett állításból származik, nem kényelmi választásból, egy gradiented, amely szó szerint predikció mínusz igazság, és — ami fontosabb — megvan a gépezeted annak kiderítésére, hogy ebből bármi működik-e. A fenti tízsoros Wilson-intervallumot szó szerint újrahasználjuk: ez hordozza a prompt variánsokat a 15. fejezetben, a retrieval táblákat a 19. fejezetben, és a golden setet a 29. fejezetben. A bootstraphez nyúlsz, amikor nincs képlet.

De a modell még mindig egyrétegű. Egy vonalat húz, és az 1. fejezet négy XOR-sorral bizonyította, hogy egy vonal nem elég. A javítás a rétegezés: egy első réteg, amely meghajlítja a teret, és egy második, amely vonalat húz a meghajlított térben.

Itt fogy el ennek a fejezetnek a tiszta gradientje. Fent minden azért működött, mert $\partial L/\partial s = p - y$ kézzel felírható volt, egyszer, egy olyan modellhez, amelyben egy réteg van a bemenet és a veszteség között. Tegyél középre egy második réteget, és a kérdés alakot vált: mi a veszteség deriváltja egy olyan súly szerint, amely egyáltalán nem érinti a kimenetet — amelynek hatása csak egy másik rétegen keresztül érkezik, esetleg egyszerre több útvonalon?

Ez a derivált létezik. Kézzel kiszámítani reménytelen bármihez, ami nagyobb egy játéknál, egyenként, paraméterről paraméterre kiszámítani pedig más skálán reménytelen. Olyan eljárás kell, amely a háló minden deriváltját megszerzi egyetlen visszafelé menettel ugyanazon a gráfon, amelyet a forward pass épp bejárt.

Ez az 5. fejezet, és ez az a motor, amelyen a kurzus többi része fut.

E fejezet mellé még érdemes olvasni: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 és §4.3, amely a valószínűséget, döntéselméletet, információelméletet és lineáris osztályozást abban a sorrendben tárgyalja, amelyet ez a fejezet követ; Murphy, Probabilistic Machine Learning: An Introduction, 6. és 10. fejezet; Prince, Understanding Deep Learning §5.4–5.7; valamint Saito és Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015) — arról, miért nem az AUC lehet az egyetlen küszöbfüggetlen szám, amelyet nézel, amikor az alkatrészek 1,7 %-a hibás.