Logaritmer

Logaritmen svarar på frågan: «upphöjt till vad?»

$\log_2 8 = 3 \quad \text{eftersom} \quad 2^3 = 8$

Den är alltså exponentialfunktionens motsats — precis som subtraktion är motsatsen till addition.

Logaritmens superkraft: den gör multiplikation till addition.

$\log(ab) = \log a + \log b$

Det låter som en kuriositet men är avgörande i praktiken: multiplicerar du 500 sannolikheter (var och en mindre än 1) får du ett tal så litet att datorn avrundar det till noll. Adderar du deras logaritmer får du ett hanterbart negativt tal.

Därför räknar all maskininlärning i log-rummet.

Lagarna — alla följer av potenslagarna:

Lösa exponentialekvationer. Logaritmera båda sidor:

$3 \cdot 2^x = 96 \;\Rightarrow\; 2^x = 32 \;\Rightarrow\; x\ln 2 = \ln 32 \;\Rightarrow\; x = \frac{\ln 32}{\ln 2} = 5$

Varför ML räknar i log-rummet — tre skäl:

1. Numerisk stabilitet. $0{,}1^{400}$ är noll i flyttal. $400 \cdot \ln 0{,}1 = -921$ är det inte.
2. Produkter blir summor. Sannolikheten för en hel sekvens är en produkt över tokens; log-sannolikheten är en summa, som dessutom går att derivera term för term.
3. Log-loss är den naturliga förlusten. Att maximera log-sannolikheten för rätt svar är samma sak som att minimera korsentropin:

$\mathcal{L} = -\sum_i y_i \log \hat{p}_i$

För en säker och rätt gissning ($\hat{p} \to 1$) går $-\log \hat{p} \to 0$. För en säker och fel gissning ($\hat{p} \to 0$) går den mot oändligheten. Log-loss straffar alltså självsäker dumhet oändligt hårt — vilket är precis vad man vill.

Perplexitet är samma sak i en mer läsbar förpackning: $\mathrm{PPL} = e^{\mathcal{L}}$, tolkad som «hur många alternativ modellen i praktiken väljer mellan». Går log-lossen från 2,3 till 2,0 låter det litet — men perplexiteten går från 10,0 till 7,4, vilket är en fjärdedels minskning av modellens effektiva osäkerhet.

import math

print(math.log2(8), math.log10(1000), round(math.log(math.e), 4))   # 3.0 3.0 1.0

# Lösa 3 · 2^x = 96
print(math.log(96 / 3) / math.log(2))          # 5.0

# Varför log-rummet behövs: 400 sannolikheter multiplicerade
p = [0.1] * 400
print(math.prod(p))                             # 0.0  ← all information borta
print(sum(math.log(x) for x in p))              # -921.03  ← fortfarande exakt

# Log-loss straffar självsäkra fel
for p_ratt in (0.99, 0.9, 0.5, 0.1, 0.01, 1e-8):
    print(f"  p={p_ratt:<8} log-loss={-math.log(p_ratt):.3f}")
#   p=0.99     log-loss=0.010
#   p=0.5      log-loss=0.693
#   p=0.01     log-loss=4.605
#   p=1e-08    log-loss=18.421   ← självsäkert fel kostar enormt

# Perplexitet gör log-loss läsbar
for loss in (2.3, 2.0, 1.6):
    print(f"  loss={loss}  perplexitet={math.exp(loss):.1f}")
#   loss=2.3  perplexitet=10.0
#   loss=2.0  perplexitet=7.4
#   loss=1.6  perplexitet=5.0

# log1p är exaktare än log(1+x) för små x
x = 1e-15
print(math.log(1 + x), math.log1p(x))           # 1.110223e-15  1.0e-15  ← log1p är exakt