Inleiding: Meetinformatie
La informatie theorie, opgericht door Claude Shannon in 1948, geeft ons de tools om de onzekerheid te kwantificeren, de hoeveelheid informatie in een bericht te meten e evalueren hoe goed een model de werkelijkheid benadert. Bij machine learning verschijnen deze concepten overal: de kruis-entropie en de standaardverliesfunctie voor classificatie, de KL-divergentie en in het hart van VAE en kennisdestillatie.
Wat je gaat leren
- Informatie-inhoud: de verrassing als -log(p)
- Entropie: maatstaf voor de onzekerheid van een verdeling
- Cross-entropie: het meest gebruikte verlies voor classificatie
- KL-divergentie: asymmetrische afstand tussen distributies
- Wederzijdse informatie: afhankelijkheid tussen variabelen
- Verbijstering en de verbindingen ervan met taalmodellen
Informatie-inhoud: de verrassing
L'informatie inhoud (of zelfinformatie) van een gebeurtenis met waarschijnlijkheid p meet hoe "verrassend" die gebeurtenis is:
Intuïtie: een zeer waarschijnlijke gebeurtenis (P \\circa 1) bevat weinig informatie (weinig verrassing). Een zeldzame gebeurtenis (P \\circa 0) brengt veel informatie (grote verrassing). De eenheid in basis 2 is de beetje: een beetje en de hoeveelheid informatie van een eerlijke toss.
Entropie: de gemiddelde onzekerheid
L'entropie en de verwachte waarde van de informatie-inhoud, d.w.z. de middelmatige verrassing van een distributie:
Voor continue implementatie:
Fundamentele eigenschappen:
- H(X) \\geq 0 altijd (onzekerheid is nooit negatief)
- H(X) = 0 alleen als X en deterministisch (een enkele gebeurtenis heeft waarschijnlijkheid 1)
- H(X) en maximum voor uniforme verdeling (maximale onzekerheid)
Voorbeeld: voor een eerlijke munt (P(T) = P(C) = 0,5), entropie e H = -0,5\\log_2(0,5) - 0,5\\log_2(0,5) = 1 beetje. Voor een vervalste munt met P(T) = 0,99, de entropie is ongeveer 0,08 bit: vrijwel geen onzekerheid, we weten vrijwel altijd de uitkomst.
import numpy as np
def entropy(probs):
"""Calcola entropia in bit (log base 2)."""
probs = np.array(probs)
probs = probs[probs > 0] # Evita log(0)
return -np.sum(probs * np.log2(probs))
# Moneta equa
print(f"Moneta equa: H = {entropy([0.5, 0.5]):.4f} bit")
# Moneta truccata
print(f"Moneta truccata (0.99): H = {entropy([0.99, 0.01]):.4f} bit")
# Dado a 6 facce (uniforme)
print(f"Dado equo: H = {entropy([1/6]*6):.4f} bit")
# Dado truccato (3 esce il 50%)
probs_loaded = [0.1, 0.1, 0.5, 0.1, 0.1, 0.1]
print(f"Dado truccato: H = {entropy(probs_loaded):.4f} bit")
Cross-entropie: het verlies van classificatie
La kruis-entropie tussen de werkelijke verdeling p en de verdeling voorspeld door het model q meet hoeveel bits er nodig zijn gemiddeld om gegevens van te coderen p met behulp van de optimale code voor q:
In de classificatie, p en de doelverdeling (one-hot) e q en de uitvoer van de softmax. Voor een enkel monster met etiket y (one-hot) en voorspelling \\hoed{y}:
Voor binaire classificatie vereenvoudigt het tot binaire kruis-entropie:
Fundamentele verbinding: het minimaliseren van kruisentropie is gelijk aan maximaliseer de log-waarschijnlijkheid van het model. Dit verklaart waarom kruis-entropie en het natuurlijke verlies voor classificatie: we zoeken naar het model dat het maximum toekent waarschijnlijkheid van de waargenomen gegevens.
import numpy as np
def cross_entropy(p, q):
"""Cross-entropy H(p, q) usando logaritmo naturale."""
q = np.clip(q, 1e-15, 1 - 1e-15) # Evita log(0)
return -np.sum(p * np.log(q))
def binary_cross_entropy(y_true, y_pred):
"""Binary cross-entropy per un singolo campione."""
y_pred = np.clip(y_pred, 1e-15, 1 - 1e-15)
return -(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
# Classificazione a 3 classi
y_true = np.array([0, 0, 1]) # Classe 3
# Predizione buona
y_pred_good = np.array([0.05, 0.05, 0.90])
print(f"Buona predizione: CE = {cross_entropy(y_true, y_pred_good):.4f}")
# Predizione mediocre
y_pred_mid = np.array([0.2, 0.3, 0.5])
print(f"Predizione media: CE = {cross_entropy(y_true, y_pred_mid):.4f}")
# Predizione sbagliata
y_pred_bad = np.array([0.7, 0.2, 0.1])
print(f"Predizione errata: CE = {cross_entropy(y_true, y_pred_bad):.4f}")
# Binary cross-entropy
print(f"\nBCE(y=1, pred=0.9) = {binary_cross_entropy(1, 0.9):.4f}")
print(f"BCE(y=1, pred=0.5) = {binary_cross_entropy(1, 0.5):.4f}")
print(f"BCE(y=1, pred=0.1) = {binary_cross_entropy(1, 0.1):.4f}")
KL Divergentie: afstand tussen distributies
La KL-divergentie (Kullback-Leibler) meet hoeveel een distributie is q verschilt van een referentieverdeling p:
Belangrijke eigenschappen:
- D_{\\text{KL}}(p \\| q) \\geq 0 altijd (Gibbs-ongelijkheid)
- D_{\\text{KL}}(p \\| q) = 0 als en slechts als p = q
- Het is niet symmetrisch: D_{\\text{KL}}(p \\| q) \\neq D_{\\text{KL}}(q \\| p)
De relatie H(p, q) = H(p) + D_{\\text{KL}}(p \\| q) vertelt ons dat kruis-entropie en entropie van p plus de KL-divergentie. Zolang H(p) en constant (hangt niet af van het model), minimaliseer de kruis-entropie is gelijk aan het minimaliseren van KL-divergentie.
KL Divergentie in VAE's
In de Variationele auto-encoders, omvat het verlies een KL-divergentieterm die dwingt de latente verdeling dicht bij een standaard Gaussiaans te liggen:
import numpy as np
def kl_divergence(p, q):
"""KL divergence D_KL(p || q)."""
p = np.array(p, dtype=float)
q = np.array(q, dtype=float)
mask = p > 0
return np.sum(p[mask] * np.log(p[mask] / q[mask]))
# Due distribuzioni su 4 classi
p = np.array([0.25, 0.25, 0.25, 0.25]) # Uniforme
q1 = np.array([0.3, 0.2, 0.3, 0.2]) # Leggermente diversa
q2 = np.array([0.9, 0.03, 0.04, 0.03]) # Molto diversa
print(f"KL(p || q1) = {kl_divergence(p, q1):.6f}")
print(f"KL(p || q2) = {kl_divergence(p, q2):.6f}")
# Asimmetria della KL
print(f"\nKL(p || q1) = {kl_divergence(p, q1):.6f}")
print(f"KL(q1 || p) = {kl_divergence(q1, p):.6f}")
# KL per VAE (Gaussiana vs standard normal)
def kl_gaussian(mu, log_var):
"""KL divergence tra N(mu, sigma^2) e N(0, 1)."""
return -0.5 * np.sum(1 + log_var - mu**2 - np.exp(log_var))
mu = np.array([0.5, -0.3, 0.1])
log_var = np.array([-0.5, 0.2, -0.1])
print(f"\nKL(N(mu,sigma^2) || N(0,1)) = {kl_gaussian(mu, log_var):.4f}")
Wederzijdse informatie
La wederzijdse informatie meet hoeveel informatie een willekeurige variabele heeft biedt op een ander:
Se ik(X; Y) = 0, zijn de variabelen onafhankelijk. In ML, het wederzijdse informatie en gebruikt voor: functie selectie (selecteer de meest informatieve functies), evaluatie van clustering, en als doelstelling inInfoNCE-verlies van contrastief leren.
Verbijstering: taalpatronen evalueren
La verbijstering en een standaardmetriek voor het evalueren van taalmodellen. En gedefinieerd als het exponentiële van de gemiddelde kruis-entropie per token:
Een verbijstering van k betekent dat gemiddeld het model e "verward" alsof hij uniform moest kiezen tussen k opties bij elke stap. Hoe lager de perplexiteit, hoe beter het model.
Samenvatting en verbindingen met ML
Belangrijke punten om te onthouden
- Entropie H(X): meet de onzekerheid, maximaal voor uniforme verdeling
- Cross-entropie H(p,q): het standaardverlies voor classificatie
- KL-divergentie: afstand (asymmetrisch) tussen distributies, gebruikt in VAE
- Minimaliseer kruis-entropie = maximaliseer log-waarschijnlijkheid = minimaliseer KL
- Wederzijdse informatie: afhankelijkheidsmaatstaf, gebruikt bij functieselectie en contrastief leren
- Verbijstering: standaardmetriek voor taalmodellen, hoe lager hoe beter en
In het volgende artikel: We zullen verkennen PCA en dimensionale reductie. We zullen zien hoe de covariantiematrix, eigenvectoren en SVD ons in staat stellen de gegevens te comprimeren het grootste deel van de informatie bewaren.