Integraler i sannolikhet: väntevärde

För en diskret fördelning är väntevärdet en summa: E[X] = Σ x·P(x). För en kontinuerlig fördelning blir summan en integral:

$\mathbb E[X] = \int_{-\infty}^{\infty} x\,p(x)\,dx$

Samma idé: varje värde vägs med sin sannolikhetstäthet.

Variansen mäter spridningen: $\text{Var}(X) = \mathbb E[(X-\mu)^2] = \mathbb E[X^2] - \mu^2$

Den andra formen är nästan alltid lättare att räkna med.

Likformig på [a, b]: $p(x) = 1/(b-a)$, $\mathbb E[X] = \frac{a+b}{2}$, $\text{Var}(X) = \frac{(b-a)^2}{12}$.

Exponentiell med parameter λ: $p(x) = \lambda e^{-\lambda x}$ för $x\ge 0$, $\mathbb E[X] = 1/\lambda$, $\text{Var}(X) = 1/\lambda^2$.

Normal: $\mathbb E[X] = \mu$, $\text{Var}(X) = \sigma^2$.

Linjäritet — den mest använda egenskapen: $\mathbb E[aX + bY] = a\mathbb E[X] + b\mathbb E[Y]$ gäller alltid, även när X och Y är beroende. Variansen är däremot inte linjär: $\text{Var}(aX) = a^2\text{Var}(X), \qquad \text{Var}(X+Y) = \text{Var}(X)+\text{Var}(Y)+2\,\text{Cov}(X,Y)$ Den sista termen försvinner bara om X och Y är okorrelerade.

Kopplingen till ML: varje loss-funktion är ett väntevärde över datafördelningen, $\mathcal L(\theta) = \mathbb E_{(x,y)\sim D}[\ell(f_\theta(x), y)]$. Vi kan inte beräkna integralen — vi skattar den med ett stickprov, vilket är exakt vad en minibatch är. Att $\mathbb E$ av minibatch-gradienten är den sanna gradienten (obiased) är hela grunden för att SGD fungerar.

import numpy as np
from scipy import integrate

# Exponentiell med lambda = 2: E[X] = 0,5, Var = 0,25
p = lambda x: 2 * np.exp(-2 * x)
E  = integrate.quad(lambda x: x * p(x), 0, np.inf)[0]
E2 = integrate.quad(lambda x: x**2 * p(x), 0, np.inf)[0]
print(round(E, 4), round(E2 - E**2, 4))      # 0.5 0.25

# Monte Carlo — samma svar utan att lösa integralen
rng = np.random.default_rng(0)
x = rng.exponential(scale=0.5, size=200_000)
print(round(x.mean(), 4), round(x.var(), 4))  # 0.4997 0.2494

# Minibatch-gradienten är en obiased skattning av den sanna
def sann_gradient(data, theta):
    return np.mean([grad(d, theta) for d in data], axis=0)
def minibatch_gradient(data, theta, bs, rng):
    return np.mean([grad(d, theta) for d in rng.choice(data, bs, replace=False)], axis=0)
# E[minibatch_gradient] == sann_gradient  → därför konvergerar SGD