Informationsteori: entropi och KL-divergens

Information är överraskning. Ett meddelande som säger något du redan visste bär ingen information.

Shannons definition: överraskningen av en händelse med sannolikheten $p$ är $-\log_2 p$ bitar.

Entropi är den genomsnittliga överraskningen — hur oförutsägbar en fördelning är:

$H(p) = -\sum_i p_i \log_2 p_i$

Entropin är också den teoretiska undre gränsen för hur mycket data kan komprimeras: du kan inte packa ihop något till färre bitar än dess entropi.

Tre storheter, byggda på varandra:

Sambandet är exakt:

$H(p, q) = H(p) + D_{KL}(p \| q)$

Detta är hela förklaringen till varför korsentropi är ML:s standardförlust. Vid klassificering är $p$ de sanna etiketterna — fasta, med entropi $H(p)$ som du inte kan påverka. Att minimera korsentropin är därför exakt samma sak som att minimera KL-divergensen mellan modellen och sanningen.

Och eftersom $D_{KL} \geq 0$ med likhet endast när $p = q$, är minimum nått precis när modellen har rätt fördelning. Förlusten är inte vald av bekvämlighet — den mäter avståndet till sanningen.

Tre egenskaper hos KL som förvånar:

1. Den är inte symmetrisk. $D_{KL}(p\|q) \neq D_{KL}(q\|p)$. Därför är den inte ett avstånd i vanlig mening.
2. Riktningen spelar roll. $D_{KL}(p\|q)$ straffar hårt om $q$ ger nära noll där $p$ har massa — modellen får inte utesluta något som faktiskt händer. Omvänd riktning ger i stället modellen tillåtelse att fokusera på en topp och ignorera resten. (Det är skillnaden mellan «mode-covering» och «mode-seeking».)
3. Den blir oändlig om $q_i = 0$ där $p_i > 0$. Därför läggs alltid ett litet tal till i implementationer.

Ömsesidig information $I(X;Y) = H(X) - H(X\mid Y)$ mäter hur mycket kunskap om $Y$ minskar osäkerheten om $X$. Den används för att välja features och för att mäta beroenden som en korrelationskoefficient missar.

import numpy as np

def H(p, bas=2):
    p = np.asarray(p, float)
    p = p[p > 0]
    return float(-(p * np.log(p)).sum() / np.log(bas))

def korsentropi(p, q, bas=2):
    p, q = np.asarray(p, float), np.asarray(q, float) + 1e-12
    return float(-(p * np.log(q)).sum() / np.log(bas))

def kl(p, q, bas=2):
    return korsentropi(p, q, bas) - H(p, bas)

print(round(H([0.5, 0.5]), 3))          # 1.0    mynt
print(round(H([0.9, 0.1]), 3))          # 0.469  viktat mynt
print(round(H([1.0, 0.0]), 3))          # 0.0    ingen osäkerhet
print(round(H([1/6] * 6), 3))           # 2.585  tärning

# Sambandet H(p,q) = H(p) + KL(p||q)
p, q = [0.7, 0.2, 0.1], [0.5, 0.3, 0.2]
print(round(korsentropi(p, q), 4), round(H(p) + kl(p, q), 4))     # 1.2796 1.2796

# KL är INTE symmetrisk
print(round(kl(p, q), 4), round(kl(q, p), 4))                     # 0.1228 0.1328

# Klassificering: p är one-hot, så H(p) = 0 och korsentropi = KL
facit = [0, 1, 0]
for namn, pred in (("säker och rätt", [0.02, 0.96, 0.02]),
                   ("osäker", [0.3, 0.4, 0.3]),
                   ("säker och fel", [0.96, 0.02, 0.02])):
    print(f"  {namn:<16} korsentropi {korsentropi(facit, pred):.3f} bitar")
#   säker och rätt   korsentropi 0.059 bitar
#   osäker           korsentropi 1.322 bitar
#   säker och fel    korsentropi 5.644 bitar   ← straffas hårdast

# Perplexitet: 2^H, «hur många alternativ modellen i praktiken väljer mellan»
for h in (1.0, 2.0, 3.32):
    print(f"  entropi {h} bitar → perplexitet {2 ** h:.1f}")