Begreper & referanser
Alle nøkkelbegrepene, formlene og referansene fra Logistisk regresjon og klassifikasjon, samlet på én side. Bruk denne som oppslag når du leser, øver flashcards eller tar quiz.
Begreper
Sentrale begreper fra kapittelet med korte definisjoner.
En prediksjonsoppgave der hver observasjon skal plasseres i én av to klasser.
Logaritmen til oddsene. I logistisk regresjon er logiten en lineær funksjon av input.
En S-formet funksjon som gjør en reell score om til en verdi strengt mellom 0 og 1.
Samsvar mellom predikert sannsynlighet og observert frekvens, for eksempel at hendelsen skjer omtrent 70 prosent av gangene når modellen sier 0,7.
Grensen som gjør en predikert sannsynlighet om til en bestemt klasse.
Mengden inputpunkter der modellen står akkurat mellom klassene ved den valgte terskelen.
Et klassifikasjonstap som gir stor straff til sikre, feilaktige sannsynlighetsprediksjoner.
Forholdet mellom sannsynligheten for at en hendelse skjer og at den ikke skjer.
Funksjonen som gjør klassescorer om til sannsynligheter: . Største score gir største sannsynlighet, og med to klasser blir softmax sigmoiden av differansen mellom scorene.
Tapet for klassifikasjon med flere klasser: av sannsynligheten modellen gir den sanne klassen. Med fasiten som one-hot-vektor er gradienten med hensyn på scorene .
Formler
Hver formel: hva den heter, hvordan den ser ut, og hva symbolene betyr.
Lineær klassifikasjonsscore
Logistisk regresjon starter med den samme lineære scoren som en lineær modell.
Sigmoidfunksjonen
Sigmoid komprimerer enhver reell score til et tall mellom 0 og 1.
Log-odds
Logistisk regresjon modellerer logaritmen til oddsene som en lineær funksjon av input.
Binary cross-entropy
BCE gir stort tap når modellen er svært sikker på feil klasse.
Beslutningsregel
Sannsynligheten gjøres om til en klasse ved terskelen .
Odds
Odds sammenligner sannsynligheten for positivt utfall med sannsynligheten for negativt utfall.
Gradienten til BCE
Med sigmoid og binary cross-entropy blir den deriverte med hensyn på scoren bare . Vektgradienten er (prediksjon minus fasit) ganger input, samme mønster som for lineær regresjon.
Beslutningsgrense for en terskel
Punktene der . For er høyresiden 0. En annen terskel forskyver grensen parallelt, mens vektene bestemmer retningen.
Softmax
Gjør scorer om til sannsynligheter som summerer til 1. I kode trekkes den største scoren fra før eksponentialen for å unngå overflyt.
Kategorisk kryssentropi
Med one-hot er tapet av sannsynligheten for den sanne klassen.
Kodesnutter
Kodesnutter fra kapittelet, vist literal.
Samme oddsforhold, ulik endring i sannsynlighet
import numpy as np w_feil = 0.9 # @param -1.5..1.5 0.1 for z in [-3.0, -0.7, 1.0, 3.0]: # score før én feil til p0 = 1 / (1 + np.exp(-z)) p1 = 1 / (1 + np.exp(-(z + w_feil))) # én feil til: scoren øker med w odds0, odds1 = p0 / (1 - p0), p1 / (1 - p1) print(f"z = {z:4.1f}: p {p0:.3f} -> {p1:.3f} (endring {p1 - p0:+.3f})," f" oddsforhold {odds1 / odds0:.3f}")print(f"e^w = {np.exp(w_feil):.3f}")Prøv: Dra w_feil, også under null, og se «oddsforhold» være likt på alle linjene, mens «endring» i p er størst nær p = 0,5.
Fra lineær score til klasse
import numpy as npimport matplotlib.pyplot as plt rng = np.random.default_rng(4172)X = rng.normal(size=(6, 2))w = np.array([1.2, -0.8])b = -0.15terskel = 0.60 # @param 0.05..0.95 0.05 score = X @ w + bprob = 1 / (1 + np.exp(-score))klasse = (prob >= terskel).astype(int)for i, (z, p, k) in enumerate(zip(score, prob, klasse)): print(f"obs {i}: z = {z:6.3f} p = {p:5.3f} {'KLASSE 1' if k else 'klasse 0'}")bytter = int(np.sum(klasse != (prob >= 0.5)))print(f"{klasse.sum()} av {len(klasse)} er klasse 1 ved terskel {terskel:.2f}; {bytter} bytter klasse mot terskel 0,50")print(f"grensen i scorerommet: z = {np.log(terskel / (1 - terskel)):.3f}") zz = np.linspace(-5, 5, 200)plt.figure()plt.plot(zz, 1 / (1 + np.exp(-zz)), label="sigmoid")plt.scatter(score, prob, color="C1", zorder=3, label="observasjoner")plt.axhline(terskel, linestyle="--", label=f"terskel {terskel:.2f}")plt.xlabel("Score z")plt.ylabel("Sannsynlighet p")plt.legend()plt.tight_layout()plt.show()Prøv: Dra terskel og se hvilke observasjoner som blir «KLASSE 1», hvor mange som bytter, og hvor «grensen i scorerommet» havner.
Binary cross-entropy fra bunnen
import numpy as np def sigmoid(z): return 1 / (1 + np.exp(-z)) feilsikkerhet = 3.0 # @param 0..8 0.5y = np.array([1, 0, 1, 0, 1])z = np.array([2.0, -1.5, 0.3, 0.8, -feilsikkerhet]) # siste punkt: y = 1, men negativ scorep = np.clip(sigmoid(z), 1e-7, 1 - 1e-7) # klipp bort fra 0 og 1 før logtap = -(y * np.log(p) + (1 - y) * np.log(1 - p)) print(f"siste punkt: z = {z[-1]:.1f}, p = {p[-1]:.4f}, tap = {tap[-1]:.2f}")print(f"BCE = {tap.mean():.3f} MSE = {np.mean((p - y) ** 2):.3f}")# Gradienten med hensyn på scoren z for det siste punktetprint(f"BCE-gradient p - y: {p[-1] - 1:+.4f}")print(f"MSE-gradient 2(p - y)p(1 - p): {2 * (p[-1] - 1) * p[-1] * (1 - p[-1]):+.4f}")Prøv: Dra feilsikkerhet opp og se «BCE-gradient» holde seg nær −1, mens «MSE-gradient» forsvinner mot null.
Logistisk regresjon trent med gradient descent
import numpy as npimport matplotlib.pyplot as plt rng = np.random.default_rng(7)x = np.concatenate([rng.normal(2, 1, 30), rng.normal(5, 1, 30)]) # uskalert featurey = np.concatenate([np.zeros(30), np.ones(30)])eta = 0.5 # @param 0.1..3 0.1standardiser = 0 # @param 0..1if standardiser: x = (x - x.mean()) / x.std() w = b = 0.0bce = []for epoke in range(30): p = 1 / (1 + np.exp(-np.clip(w * x + b, -30, 30))) bce.append(-np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))) w -= eta * np.mean((p - y) * x) # gradienten: (p - y) ganger x b -= eta * np.mean(p - y)print(f"BCE etter {len(bce)} epoker: {bce[-1]:.3f} (w = {w:.2f}, b = {b:.2f})") plt.figure()plt.plot(bce)plt.xlabel("epoke")plt.ylabel("BCE")plt.tight_layout()plt.show()Prøv: Dra eta mot 2 og se «BCE etter 30 epoker» og kurven hoppe; sett standardiser til 1 og se samme eta gi et jevnt fallende tap.
Softmax og kryssentropi i NumPy
import numpy as np def softmax_naiv(z): e = np.exp(z) return e / e.sum() def softmax(z): e = np.exp(z - z.max()) # trekk fra maks: samme svar, ingen overflyt return e / e.sum() forskyvning = 0 # @param 0..1000 50z = np.array([2.0, 1.0, -1.0]) + forskyvning # score for pære, kabel og styringprint(f"naiv: {np.round(softmax_naiv(z), 4)}")print(f"stabil: {np.round(softmax(z), 4)}") y = 1 # indeksen til den sanne klassen (kabel)print(f"kryssentropi = {-np.log(softmax(z)[y]):.3f}")print(f"gradient p - y: {np.round(softmax(z) - np.eye(3)[y], 4)}")Prøv: Dra forskyvning mot 1000 og se ved hvilken verdi «naiv» gir nan, mens «stabil» står stille.
Læringsmål
Hva du skal kunne etter å ha lest kapittelet.
- 01Regn ut score, sannsynlighet og klasse fra vekter, features og terskel
- 02Tolk en vekt som endring i log-odds og som oddsforhold
- 03Finn beslutningsgrensen for en gitt terskel, og forklar hvorfor den er lineær
- 04Regn ut binary cross-entropy, velg riktig implementasjon i NumPy og forklar hvorfor MSE er et dårlig tap her
- 05Regn ut ett gradient descent-steg med gradienten , og forklar hvorfor tapet kan oscillere
- 06Regn ut softmax-sannsynligheter og kryssentropi for flere klasser
- 07Forklar hvorfor modellens sannsynlighet er et estimat som må kalibreres