Law of Large Numbers and Central Limit Theorem

Siamo nel binario ml-tabellare, dove ogni decisione parte da una tabella di esperimenti. Un esperimento parte bene: nei primi due giorni la variante nuova sembra vincere e il team è tentato di chiudere subito e spedire. Poi arrivano altri utenti, la stima si muove, l’effetto si riduce e il grafico racconta una storia meno spettacolare ma più vera. La legge dei grandi numeri e il teorema del limite centrale servono a dare disciplina a questo momento: un campione piccolo può raccontare una storia rumorosa, mentre un campione più ampio rende la stima più stabile e leggibile.

Che cosa garantiscono i due teoremi

Con campioni abbastanza ampi le medie campionarie si stabilizzano sul valore vero e la loro oscillazione diventa normale e misurabile.

Come si applicano i teoremi ai dati

1. Verifica indipendenza delle osservazioni e varianza finita prima di invocare i teoremi.
2. Stima la media campionaria x̄ₙ e osserva come si stabilizza al crescere di n (legge dei grandi numeri).
3. Standardizza con √n·(x̄ₙ − μ)/σ per ricondurti alla normale standard (teorema del limite centrale).
4. Controlla code pesanti e correlazione temporale che invalidano entrambi i teoremi.
5. Se la media non converge per via degli outlier, passa a mediana o statistiche robuste.
6. Dimensiona il campione in base alla varianza osservata, non a una soglia magica di numerosità.

Legge dei grandi numeri (LLN)

Weak version: per ogni ε > 0, P(|x̄ₙ − μ| > ε) → 0 when n → ∞.

In italiano: la probabilità che la media campionaria sia lontana dalla media vera va a zero all’aumentare del campione. Quello che la legge garantisce è che, con abbastanza dati, la stima diventa accurata. Quello che non garantisce è quanti dati ti servono. La convergenza può essere lentissima. Se la distribuzione ha varianza infinita, per esempio una power law con α sotto 2, la legge non vale nemmeno.

C’è un caso in cui la legge sembra mentire. Se misuri il revenue medio per cliente su 1 milione di clienti e la distribuzione è una power law, la media campionaria può essere dominata da pochi outlier. Aggiungendo più clienti la media non converge a nulla di stabile, perché ogni nuovo grande cliente la sposta drasticamente. La soluzione è usare la mediana o statistiche robuste, non la media.

Teorema del limite centrale (CLT)

Siano X₁, X₂, ..., Xₙ variabili indipendenti e identicamente distribuite con media μ e varianza σ² finita. Allora:

√n·(x̄ₙ − μ)/σ → N(0,1) in distribuzione.

In italiano: la media campionaria standardizzata converge a una normale standard. Le condizioni sono indipendenza e varianza finita. Se manca una delle due, il teorema non si applica.

Le violazioni sono frequenti in analisi dati. La prima è la dipendenza temporale: transazioni consecutive sono correlate e la varianza stimata risulta sbagliata. La seconda è la varianza infinita, tipica delle distribuzioni a coda pesante come revenue e dimensione di un trade, dove il teorema non tiene. La terza è avere campioni troppo piccoli per la distribuzione: per una binomiale con p=0.001 servono molte migliaia di osservazioni prima che l’approssimazione normale sia decente.

Quando il CLT fallisce: il Value at Risk

Il Value at Risk nelle banche assume, via CLT, che i rendimenti siano normalmente distribuiti. Ma i rendimenti finanziari hanno code pesanti. Eventi a 6 sigma accadono molto più spesso di quanto la normale preveda, e quando accadono i modelli basati sul teorema crollano. È successo nel 1998 con LTCM e nel 2008 con la crisi subprime, e può succedere ancora. Prima di usare test basati sulla normale conviene quindi chiedersi se i dati hanno varianza finita e se sono indipendenti. Se la risposta a una delle due è che non lo sai, il teorema potrebbe non salvarti.

Verdetto: usa la media quando varianza finita e indipendenza tengono, la mediana quando code pesanti o outlier dominano, e dichiara quale delle due stai usando prima di confrontare periodi.

References:

• Feller, W. (1971). An Introduction to Probability Theory and Its Applications, Vol. 2. Wiley.
• Embrechts, P., Klüppelberg, C. & Mikosch, T. (1997). Modelling Extremal Events. Springer.

SQL example: building a control view

La vista seguente crea una base analitica con metrica, segmento e finestra temporale, così puoi confrontare periodi e gruppi senza riscrivere la logica ogni volta.

WITH base_events AS (
  SELECT
    user_id,
    account_id,
    event_type,
    event_time,
    DATE_TRUNC('week', event_time) AS week,
    source,
    device_type
  FROM events
  WHERE event_time >= CURRENT_DATE - INTERVAL '180 days'
    AND user_id IS NOT NULL
),
weekly_user_metrics AS (
  SELECT
    week,
    user_id,
    COALESCE(source, 'unknown') AS source,
    COALESCE(device_type, 'unknown') AS device_type,
    COUNT(*) AS total_events,
    COUNT(DISTINCT DATE(event_time)) AS active_days,
    COUNT(DISTINCT event_type) AS event_diversity,
    MAX(CASE WHEN event_type IN ('purchase', 'subscribe', 'activation') THEN 1 ELSE 0 END) AS reached_key_outcome
  FROM base_events
  GROUP BY week, user_id, source, device_type
)
SELECT
  week,
  source,
  device_type,
  COUNT(DISTINCT user_id) AS users,
  ROUND(AVG(active_days), 2) AS avg_active_days,
  ROUND(AVG(event_diversity), 2) AS avg_event_diversity,
  ROUND(AVG(reached_key_outcome) * 100, 2) AS key_outcome_rate
FROM weekly_user_metrics
GROUP BY week, source, device_type
ORDER BY week, source, device_type;

Python example: checking stability and anomalies

Il controllo seguente segnala variazioni anomale settimana su settimana senza reagire a ogni oscillazione casuale.

# df contiene: week, segment, users, key_outcome_rate
# key_outcome_rate espresso in percentuale, es. 12.4

df = df.sort_values(['segment', 'week']).copy()
df['previous_rate'] = df.groupby('segment')['key_outcome_rate'].shift(1)
df['wow_change_pp'] = df['key_outcome_rate'] - df['previous_rate']
df['rolling_mean'] = df.groupby('segment')['key_outcome_rate'].transform(
    lambda s: s.rolling(4, min_periods=2).mean()
)
df['rolling_std'] = df.groupby('segment')['key_outcome_rate'].transform(
    lambda s: s.rolling(4, min_periods=2).std()
)
df['z_score'] = (df['key_outcome_rate'] - df['rolling_mean']) / df['rolling_std']

anomalies = df[df['z_score'].abs() >= 2].sort_values('z_score')
print(anomalies[['week', 'segment', 'key_outcome_rate', 'wow_change_pp', 'z_score']])

LTCM: quando il CLT non protegge

Long-Term Capital Management gestiva negli anni novanta un portafoglio costruito su modelli che trattavano i rendimenti come normali e ben descritti dal teorema del limite centrale. Nell’agosto 1998 il default della Russia produsse movimenti di mercato da coda pesante che quei modelli giudicavano quasi impossibili, e il fondo crollò in poche settimane. A settembre 1998 la Federal Reserve organizzò un salvataggio da 3,6 miliardi di dollari da parte delle banche creditrici. La lezione per l’analyst: se i dati hanno code pesanti, il CLT non ti protegge.

Domande per verificare la tua comprensione

1. Quando una media su un milione di righe resta comunque inaffidabile?
2. Cosa invalida il teorema del limite centrale anche con campioni enormi?
3. Come distingui rumore iniziale da segnale reale nei primi giorni di un test?
4. Quale controllo fai prima di usare un test basato sulla normale?