Simulazione Monte Carlo: Misurare l'Incertezza Invece del Solo Valore Medio
Quasi tutte le stime che circolano in azienda sono numeri singoli: la domanda media, il tempo medio di consegna, il costo medio per ordine. Sono comodi da comunicare e facili da mettere in una slide, ma nascondono proprio l'informazione che serve quando devi decidere: quanto possono variare. Dire «servono 100 pezzi di scorta» non è la stessa cosa che dire «con 100 pezzi la probabilità di restare a secco è intorno al 9%, con 120 scende all'1%».
La simulazione Monte Carlo serve esattamente a questo: prendere un modello che sai già scrivere, sostituire ai valori singoli delle distribuzioni, e ripetere il calcolo su migliaia di scenari generati a caso. Il risultato non è un numero, è una distribuzione: percentuali, percentili, code. Ed è lì che si prendono le decisioni.
L'idea in tre passi
Il metodo ha una struttura talmente semplice che a volte sembra una scorciatoia poco seria. In realtà è solo un modo diverso di fare i conti, reso praticabile dai computer.
- Descrivi l'incertezza. Invece di «il fornitore consegna in 7 giorni», scrivi «il lead time è tra 4 e 10 giorni, con questa forma». Invece di «la domanda è 10 pezzi al giorno», scrivi «la domanda è in media 10, con deviazione standard 4, mai negativa».
- Genera scenari. Estrai migliaia di combinazioni plausibili di tutti gli input incerti. Ogni estrazione è un mondo possibile.
- Calcola e aggrega. Applica a ogni scenario lo stesso calcolo deterministico che faresti a mano, poi guarda la distribuzione dei risultati: media, mediana, percentili, probabilità di superare una soglia.
Il punto chiave: non serve matematica nuova. Serve una funzione che, dati gli input, restituisca l'output che ti interessa — pezzi mancanti, giorni di ritardo, margine. Se sai scrivere quella funzione, sai fare una simulazione Monte Carlo. È questo che la rende applicabile a problemi dove la formula chiusa non esiste o è ingestibile.
Un esempio minimo: due dadi
Il modo più onesto di presentare il metodo è partire da un caso di cui conosciamo la risposta esatta. Lancio due dadi: qual è la probabilità che la somma sia almeno 10? La risposta teorica è 6/36, cioè circa 0,1667.
import numpy as np
rng = np.random.default_rng(42)
n = 100_000
d1 = rng.integers(1, 7, size=n)
d2 = rng.integers(1, 7, size=n)
somma = d1 + d2
print((somma >= 10).mean()) # circa 0,167
print(np.percentile(somma, 95)) # 11
Tre righe di codice, nessun ciclo esplicito: numpy genera centomila lanci in un colpo solo e il risultato è semplicemente la media di un array di valori booleani. Il dado è un esempio noioso, ma utile: sappiamo qual è la risposta giusta, quindi possiamo verificare che il metodo non stia mentendo.
Perché funziona e quanto sbaglia
La giustificazione sta nella legge dei grandi numeri: la media dei risultati simulati converge al valore atteso man mano che il numero di scenari cresce. Il problema pratico è capire quanto velocemente.
Per una proporzione stimata (per esempio una probabilità di stock-out), l'errore standard della stima è:
errore_standard = sqrt( p * (1 - p) / N )
con p la probabilità stimata e N il numero di scenari. L'errore scende con la radice di N, cioè per dimezzare l'errore devi quadruplicare le simulazioni. È la caratteristica più importante da tenere a mente, perché determina il costo computazionale.
Con p intorno a 0,17 (il caso dei dadi), i conti sono questi:
| N scenari | Errore standard | Intervallo di confidenza 95% (±) |
|---|---|---|
| 1.000 | 0,012 | 2,3 punti percentuali |
| 10.000 | 0,0038 | 0,7 punti percentuali |
| 100.000 | 0,0012 | 0,23 punti percentuali |
| 1.000.000 | 0,0004 | 0,07 punti percentuali |
La tabella dice due cose. La prima: diecimila scenari bastano per la maggior parte delle decisioni operative, dove una precisione di mezzo punto percentuale è già più di quanto serva. La seconda: se ti interessa una coda rara — la probabilità di un evento che accade nello 0,5% dei casi — servono molti più scenari, altrimenti stai stimando rumore.
Dal dado al negozio: rischio di stock-out
Qui il metodo diventa utile davvero. Immagina un negozio con un prodotto, una scorta a magazzino e un fornitore che non consegna sempre negli stessi giorni. Vuoi sapere: qual è la probabilità di restare senza merce prima che arrivi il riordino?
Gli ingredienti incerti sono due: la domanda giornaliera e il lead time del fornitore. Mettiamoli insieme in una simulazione.
import numpy as np
rng = np.random.default_rng(7)
n = 50_000
orizzonte = 12 # giorni simulati
# domanda giornaliera: media 10, deviazione standard 4, mai negativa
domanda = rng.normal(10, 4, size=(n, orizzonte)).clip(0)
# lead time del fornitore: tra 4 e 10 giorni
lead_time = rng.integers(4, 11, size=n)
# consumo cumulato e consumo effettivo nel lead time di ogni scenario
cumulato = np.cumsum(domanda, axis=1)
consumo = cumulato[np.arange(n), lead_time - 1]
for scorta in (80, 100, 120, 140):
print(scorta, round((consumo > scorta).mean(), 3))
L'output è una curva, non un numero. Con numeri di esempio inventati solo per mostrare il formato, l'output potrebbe assomigliare a questo:
| Scorta a magazzino | Probabilità di stock-out (esempio) |
|---|---|
| 80 | 0,33 |
| 100 | 0,09 |
| 120 | 0,01 |
| 140 | meno di 0,01 |
Questa tabella è un vero strumento decisionale: puoi confrontarla con il costo di tenere scorta (capitale immobilizzato, spazio, obsolescenza) e con il costo di un buco di stock (vendite perse, cliente insoddisfatto). Non ti dice cosa fare, ti dice quanto costa ogni livello di rischio, che è quello che manca quando ragioni solo sulla media.
Nota una cosa: la simulazione non ha bisogno di formule complicate. Il calcolo dentro ogni scenario è banalissimo — somma i consumi fino al giorno di consegna, confronta con la scorta. È proprio la semplicità del calcolo interno che rende il metodo potente: puoi rendere il modello arbitrariamente realistico senza dover risolvere integrali.
Stime di progetto: dalla data singola al range
Lo stesso schema funziona per le stime di durata. Invece di dire «questa attività richiede 5 giorni», si usa una stima a tre punti: minimo, valore più probabile, massimo. Poi si simula il totale.
import numpy as np
rng = np.random.default_rng(1)
n = 20_000
# (minimo, moda, massimo) in giorni, per cinque attività
stime = [
(3, 5, 12),
(2, 4, 9),
(5, 8, 20),
(1, 2, 6),
(4, 6, 15),
]
durate = np.array([
rng.triangular(lo, mo, hi, size=n) for lo, mo, hi in stime
])
totale = durate.sum(axis=0)
for p in (50, 80, 90):
print(p, round(np.percentile(totale, p), 1))
Il risultato tipico di questo tipo di simulazione è una distribuzione asimmetrica verso destra: il P50 sta parecchio sotto il P90, e la differenza tra i due è la vera informazione utile. Se in un esempio come quello sopra il P50 fosse intorno a 34 giorni e il P90 intorno a 42, la domanda non è «quale dei due è la risposta giusta?» ma «quanto mi costa arrivare a 42 invece che a 34, e quanto mi costa se ci arrivo?». Un impegno preso sul P50 è un impegno che rispetti una volta su due.
Attenzione a un'assunzione nascosta: il codice sopra somma attività indipendenti. Se le attività condividono una causa comune di ritardo — la stessa persona, lo stesso fornitore, la stessa approvazione — la coda si allarga e il P90 reale è più lontano di quanto la simulazione indipendente suggerisca.
Gli errori che rovinano una simulazione
Monte Carlo è facile da scrivere e facile da usare male. I problemi ricorrenti sono sempre gli stessi.
- Distribuzioni sbagliate. Usare una normale dove la coda conta — per esempio per i tempi di consegna o per gli importi degli ordini — sottostima sistematicamente i casi estremi. La forma della coda è spesso più importante della media.
- Ignorare le correlazioni. Simulare variabili indipendenti quando non lo sono comprime la variabilità del totale. Se nei periodi di promo sale sia la domanda sia il lead time, il rischio congiunto è molto più alto di quello che vedi simulandoli separati.
- Confondere l'output con una previsione. La simulazione non predice il futuro: calcola le conseguenze logiche delle tue assunzioni. Se il modello è sbagliato, la simulazione renderà l'errore più convincente, con grafici e percentili.
- Guardare solo la media dell'output. La media di una distribuzione asimmetrica è un punto che nella pratica può non verificarsi quasi mai. Guarda mediana e percentili.
- Poche simulazioni. Con mille scenari, le stime delle code sono rumore. Non fidarti di una probabilità dello 0,3% stimata su mille iterazioni.
- Non rendere riproducibile il tutto. Seed fisso, codice versionato, distribuzioni scritte esplicitamente. Se non riesci a rigenerare lo stesso risultato, non puoi discuterne con nessuno.
- Non validare il modello. Prima di usare la simulazione per decidere, prova a rigirare lo stesso modello sul passato e vedi se le distribuzioni che produce assomigliano a quelle che hai osservato.
Quando Monte Carlo non serve
Non è sempre la scelta giusta. Se il modello è lineare e gli input sono normali e indipendenti, la somma è ancora normale e le formule analitiche esistono: simulare è solo uno spreco di calcolo. Lo stesso vale quando la decisione non cambia al variare della distribuzione — se qualunque scenario ragionevole porta alla stessa scelta, l'analisi dettagliata aggiunge poco.
Monte Carlo diventa prezioso quando nel modello ci sono soglie, massimi e minimi, code, percorsi che dipendono dallo stato precedente, o più input incerti che interagiscono in modo non lineare. Sono esattamente i casi in cui la formula chiusa non c'è e la stima a occhio è pericolosa. Ed è anche il motivo per cui la qualità del risultato dipende quasi tutta dalla qualità del modello e dei dati con cui lo calibri, non dal numero di scenari.
Conclusione
- La simulazione Monte Carlo ripete un calcolo deterministico su molti scenari campionati, e restituisce una distribuzione invece di un numero.
- Serve quando il modello ha soglie, non linearità o più fonti di incertezza che si combinano: lì le formule chiuse non bastano.
- L'errore di stima scende con la radice di N: per dimezzarlo servono quattro volte le simulazioni. Diecimila scenari bastano per la maggior parte delle decisioni operative, non per le code rare.
- La parte difficile non è il codice, sono le distribuzioni di input e le correlazioni. Un modello sbagliato produce output precisi e inutili.
- L'output utile è una curva — probabilità al variare di una scorta, percentili di una durata — perché è quella che si confronta con i costi e con il rischio che sei disposto ad accettare.
- Non è una previsione del futuro: è la conseguenza logica delle tue assunzioni, e vale quanto valgono le assunzioni.