Introducere: Măsurarea informațiilor
La teoria informaţiei, fondată de Claude Shannon în 1948, ne oferă instrumentele pentru a cuantifica incertitudinea, măsurați cantitatea de informații conținute într-un mesaj e evaluează cât de bine se aproximează un model realitatea. În învățarea automată apar aceste concepte peste tot: cel entropie încrucișată și funcția implicită de pierdere pentru clasificare, cel Divergența KL și în centrul VAE și al distilării cunoștințelor.
Ce vei învăța
- Conținutul informației: surpriza ca -log(p)
- Entropie: măsură a incertitudinii unei distribuții
- Entropia încrucișată: cea mai utilizată pierdere pentru clasificare
- Divergența KL: distanța asimetrică între distribuții
- Informații reciproce: dependență între variabile
- Perplexitatea și conexiunile ei cu modelele de limbaj
Continut informativ: Surpriza
L'continutul informativ (sau autoinformarea) a unui eveniment cu probabilitate p măsoară cât de „surprinzător” este acel eveniment:
Intuiţie: un eveniment foarte probabil (P \\aproximativ 1) conține puține informații (surpriză scăzută). Un eveniment rar (P \\aproximativ 0) aduce multe informații (surpriză mare). Unitatea din baza 2 este pic: un pic și cantitatea de informații a unei aruncări corecte de monede.
Entropia: incertitudinea medie
L'entropie și valoarea așteptată a conținutului informațional, adică surpriză medie a unei distribuții:
Pentru implementare continuă:
Proprietăți fundamentale:
- H(X) \\geq 0 întotdeauna (incertitudinea nu este niciodată negativă)
- H(X) = 0 numai dacă X și determinist (un singur eveniment are probabilitatea 1)
- H(X) și maxim pentru distribuție uniformă (incertitudine maximă)
Exemplu: pentru o monedă corectă (P(T) = P(C) = 0,5), entropia e H = -0,5\\log_2(0,5) - 0,5\\log_2(0,5) = 1 pic. Pentru o monedă trucată cu P(T) = 0,99, entropia este de aproximativ 0,08 biți: aproape fără incertitudine, aproape întotdeauna știm rezultatul.
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: Pierderea clasificării
La entropie încrucișată între distribuţia adevărată p iar cel distribuția prevăzută de model q măsurați câți biți sunt necesari în medie pentru a codifica datele din p folosind cod optim pentru q:
În clasificare, p și distribuția țintă (one-hot) e q și ieșirea softmax-ului. Pentru o singură mostră cu etichetă y (one-fierbinte) și predicție \\hat{y}:
Pentru clasificarea binară, se simplifică la entropie încrucișată binară:
Legătura fundamentală: minimizarea entropiei încrucișate este echivalentă cu maximizează log-probabilitatea a modelului. Aceasta explică de ce entropia încrucișată iar pierderea naturală pentru clasificare: căutăm modelul care atribuie maximul probabilitatea la datele observate.
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 Divergence: Distanța dintre distribuții
La Divergența KL (Kullback-Leibler) măsoară cât de mult o distribuție q diferă de o distribuție de referință p:
Proprietăți importante:
- D_{\\text{KL}}(p \\| q) \\geq 0 întotdeauna (inegalitatea Gibbs)
- D_{\\text{KL}}(p \\| q) = 0 dacă și numai dacă p = q
- Nu este simetric: D_{\\text{KL}}(p \\| q) \\neq D_{\\text{KL}}(q \\| p)
Relația H(p, q) = H(p) + D_{\\text{KL}}(p \\| q) ne spune că entropia încrucișată și entropia de p plus divergenţa KL. Atâta timp cât H(p) și constantă (nu depinde de model), minimizați entropia încrucișată este echivalentă cu minimizarea divergenței KL.
KL Divergență în VAE
În Autoencodere variaționale, pierderea include un termen de divergență KL care forțează distribuția latentă să fie apropiată de un gaussian standard:
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}")
Informații reciproce
La informare reciprocă măsoară câtă informație are o variabilă aleatoare prevede pe altul:
Se I(X; Y) = 0, variabilele sunt independente. În ML, reciprocul informații și utilizate pentru: selectarea caracteristicilor (selectați cele mai informative caracteristici), evaluarea grupării, iar ca obiectiv înPierdere InfoNCE a învăţării contrastive.
Nedumerire: Evaluarea modelelor lingvistice
La nedumerire și o metrică standard pentru evaluarea modelelor de limbaj. Și definit ca exponențialul mediei entropiei încrucișate pe jeton:
O nedumerire a k înseamnă că, în medie, modelul e „confuz” de parcă ar fi trebuit să aleagă uniform între ele k opțiuni la fiecare pas. Cu cât perplexitatea este mai mică, cu atât modelul este mai bun.
Rezumat și conexiuni cu ML
Puncte cheie de reținut
- Entropie H(X): măsoară incertitudinea, maxim pentru distribuție uniformă
- Entropia încrucișată H(p,q): pierderea standard pentru clasificare
- Divergența KL: distanta (asimetrica) intre distributii, folosita in VAE
- Minimizarea entropiei încrucișate = maximizarea log-probabilității = minimizarea KL
- Informații reciproce: măsura dependenței, utilizată în selecția caracteristicilor și în învățarea contrastiva
- Perplexitate: metrica standard pentru modelele de limbă, cu cât mai mică, cu atât mai bine și
În articolul următor: Vom explora PCA și reducerea dimensională. Vom vedea cum matricea de covarianță, vectorii proprii și SVD ne permit să comprimăm datele păstrând majoritatea informațiilor.