05 - Cultura del dato

Cultura del dato: tradurre un problema vago in una domanda a cui i dati possono rispondere

Corso Machine Learning Engineer · Modulo 00 · Mindset data-driven · Lezione 5

Obiettivo. Mostrare che "essere data-driven" non significa avere molti grafici, ma saper fare tre cose: formulare domande verificabili, scegliere metriche che non ingannano, e accettare che il dato possa smentire la propria idea. Il lettore impara una procedura di traduzione "problema → domanda → metrica → decisione", e incontra con i numeri due trappole classiche: il paradosso di Simpson e la legge di Goodhart.

Falso mito. "I dati parlano da soli." Non parlano: rispondono alla domanda che hai posto, e se la domanda è mal posta rispondono bene a una domanda sbagliata.

Introduzione

Molte organizzazioni raccolgono dati e decidono per abitudine. Altre decidono per intuizione e usano i dati per giustificare a posteriori. Una cultura del dato vera è diversa: le decisioni importanti partono da una domanda esplicita, con una misura concordata prima, e un modo condiviso per dire "mi sbagliavo".

Roadmap. (1) Che cosa significa essere data-driven e che cosa no. (2) La procedura di traduzione. (3) I tre tipi di metrica. (4) Trappola 1: Simpson. (5) Trappola 2: Goodhart. (6) Come si costruisce la cultura in un gruppo.

Cos'è, perché esiste, quando NON basta

Tre livelli di maturità

Una classificazione diffusa dell'analisi dei dati distingue quattro domande, in ordine di difficoltà:

Il machine learning vive soprattutto nei due livelli alti, ma non si salta il basso: un modello predittivo costruito su metriche descrittive mal definite eredita il pasticcio.

Data-driven non significa dato-obbediente

Una distinzione utile è tra data-driven (la decisione è determinata dal dato) e data-informed (il dato è un input fra altri, insieme a contesto, esperienza, valori). Nelle decisioni ripetitive e misurabili (quale messaggio funziona meglio) vince il primo. Nelle decisioni uniche, con poche osservazioni o dove contano valori non misurabili, il dato informa ma non decide. Quando NON basta il dato: pochi casi; un effetto che la metrica non vede; una decisione etica.

Analogia: il cruscotto dell'auto

Il cruscotto non guida: segnala. Se guardi solo la velocità e ignori la spia dell'olio, "guidi in modo data-driven" e fonderai il motore. Una cultura del dato è scegliere quali strumenti stanno sul cruscotto e quando guardarli, con l'umiltà di ricordare che la strada, fuori dal parabrezza, resta la realtà.

Preparazione

Nessuna installazione: solo Python. Gli esempi usano liste e dizionari, volutamente, perché i moduli 01 insegneranno gli strumenti per tabelle.

Un'altra traduzione, passo per passo

Un secondo caso, in un altro settore, per vedere che la procedura è generale. La frase vaga: «Il supporto clienti è lento, migliorate.»

Due scelte meritano attenzione. La prima è la mediana invece della media: pochi ticket complicatissimi spostano la media ma non rappresentano l'esperienza tipica. La seconda è la segmentazione per fascia oraria, decisa prima di guardare i dati perché c'è un motivo causale (il carico di lavoro cambia nell'arco della giornata): segmentare per qualunque colonna disponibile, solo per vedere che cosa esce, è il modo più rapido per trovare «scoperte» che non esistono.

Primo esempio: la procedura di traduzione

Un capo dice: «Le vendite stanno andando male, fai un'analisi.» È un problema, non una domanda. La procedura trasforma in sei passi:

1. Decisione. Quale scelta dipende dalla risposta? (Se nessuna, fermati.)
2. Domanda. Riformula come domanda con soggetto, misura, periodo, confronto.
3. Metrica. Definisci il numero con formula, unità, fonte, finestra temporale.
4. Confronto. "Rispetto a che cosa?" (mese scorso, stesso mese dell'anno scorso, gruppo di controllo.)
5. Soglia. Che risultato cambierebbe la decisione?
6. Piano d'azione. Cosa farai in ciascuno dei due casi?

I sei passi sono in ordine perché ciascuno dipende dal precedente: la domanda ha senso solo se c'è una decisione, la metrica solo se la domanda è precisa, la soglia solo se la metrica è definita. Il passo che si salta più spesso è il quinto, la soglia, e saltarlo permette di leggere qualunque risultato come una conferma. Applicata all'esempio:

Osserva la frase "a parità di tipo di prodotto". È lì che si nasconde la prima trappola, la prossima sezione.

Tukey (1962) lo ha formulato così: è molto meglio una risposta approssimata alla domanda giusta che una risposta esatta alla domanda sbagliata.

Teoria e codice: due trappole che i numeri nascondono

Trappola 1: il paradosso di Simpson

Analogia. Due ristoranti, A e B. A ha un voto medio più basso di B. Ma in ogni categoria di piatto (pizze, dolci, pesce) A ha voto più alto di B. Come è possibile? Perché A vende soprattutto piatti difficili (pesce), che ricevono voti più bassi in tutti i locali, mentre B vende soprattutto piatti facili (pizze). La media confonde la qualità del locale con la composizione degli ordini.

Dati reali. Il caso storico: confronto di due trattamenti per i calcoli renali (Charig et al., BMJ 1986, riesaminato da Julious e Mullee 1994). Successi su pazienti, divisi per dimensione del calcolo. I quattro conteggi qui sotto coincidono con quelli riportati per questo esempio in letteratura divulgativa (Wikipedia), ma non ho potuto aprire il testo di Charig et al.: li prendo come dati di scuola, non come verifica dell'articolo originale.

dati = {
    "A": {"piccoli": (81, 87), "grandi": (192, 263)},
    "B": {"piccoli": (234, 270), "grandi": (55, 80)},
}

for trattamento, gruppi in dati.items():
    for gruppo, (successi, totale) in gruppi.items():
        print(f"{trattamento} {gruppo:8s}: {successi:3d}/{totale:3d} = {successi/totale:.1%}")
    S = sum(s for s, _ in gruppi.values())
    T = sum(t for _, t in gruppi.values())
    print(f"{trattamento} COMPLESSIVO: {S}/{T} = {S/T:.1%}\n")

# Output (Python 3.14.4, due esecuzioni identiche):
# A piccoli :  81/ 87 = 93.1%
# A grandi  : 192/263 = 73.0%
# A COMPLESSIVO: 273/350 = 78.0%
#
# B piccoli : 234/270 = 86.7%
# B grandi  :  55/ 80 = 68.8%
# B COMPLESSIVO: 289/350 = 82.6%

Come leggere il codice. Il dizionario dati contiene, per ogni trattamento e per ogni gruppo, la coppia (successi, totale). Il doppio ciclo stampa la percentuale di successo di ogni gruppo; dopo il ciclo interno, S e T sommano successi e totali di tutti i gruppi del trattamento, e la percentuale complessiva è S/T. Il punto delicato è che la percentuale complessiva non è la media semplice delle percentuali dei gruppi: è una media pesata con le dimensioni dei gruppi, ed è lì che nasce il paradosso. Il formato :.1% stampa un rapporto come percentuale con una cifra decimale.

Output (calcolo aritmetico esatto): A vince in entrambi i gruppi (93.1% contro 86.7% sui piccoli; 73.0% contro 68.8% sui grandi), ma perde nel complessivo (78.0% contro 82.6%).

Spiegazione, con la formula. La percentuale complessiva è una media pesata delle percentuali dei gruppi:

P_complessiva = Σ_g w_g · P_g, dove w_g = n_g / n è la quota del gruppo g.

A tratta soprattutto casi grandi (263 su 350, cioè il 75% dei suoi pazienti), che sono più difficili per tutti; B tratta soprattutto casi piccoli (270 su 350, il 77%). I pesi w_g differiscono tra i trattamenti, e questo può ribaltare il confronto. Non c'è errore di calcolo: c'è una variabile (la dimensione) che influenza sia quale trattamento viene scelto sia l'esito. Si chiama variabile di confondimento.

Verificarlo con i pesi

Per vedere il meccanismo in numeri, calcoliamo esplicitamente i pesi dei gruppi e poi ricalcoliamo il tasso complessivo con gli stessi pesi per entrambi i trattamenti (si chiama standardizzazione diretta: si risponde alla domanda «che risultato avrebbe ciascun trattamento su una popolazione con la stessa composizione?»).

dati = {
    "A": {"piccoli": (81, 87), "grandi": (192, 263)},
    "B": {"piccoli": (234, 270), "grandi": (55, 80)},
}

pesi_propri = {}
for t, gruppi in dati.items():
    N = sum(tot for _, tot in gruppi.values())
    pesi_propri[t] = {g: tot / N for g, (_, tot) in gruppi.items()}
    complessivo = sum(pesi_propri[t][g] * s / tot for g, (s, tot) in gruppi.items())
    print(f"{t}: pesi propri {({g: round(w, 3) for g, w in pesi_propri[t].items()})} -> tasso complessivo {complessivo:.3f}")

# popolazione di riferimento comune: tutti i 700 pazienti di entrambi i trattamenti
totali = {g: dati["A"][g][1] + dati["B"][g][1] for g in ("piccoli", "grandi")}
N = sum(totali.values())
pesi_comuni = {g: totali[g] / N for g in totali}
print("pesi comuni:", {g: round(w, 3) for g, w in pesi_comuni.items()})
for t, gruppi in dati.items():
    standardizzato = sum(pesi_comuni[g] * s / tot for g, (s, tot) in gruppi.items())
    print(f"{t}: tasso con pesi comuni = {standardizzato:.3f}")

Output ottenuto:

A: pesi propri {'piccoli': 0.249, 'grandi': 0.751} -> tasso complessivo 0.780
B: pesi propri {'piccoli': 0.771, 'grandi': 0.229} -> tasso complessivo 0.826
pesi comuni: {'piccoli': 0.51, 'grandi': 0.49}
A: tasso con pesi comuni = 0.833
B: tasso con pesi comuni = 0.779

Come leggere il codice. Il primo ciclo calcola per ciascun trattamento la quota di pazienti in ogni gruppo (pesi_propri) e ricostruisce il tasso complessivo come somma di peso × tasso del gruppo: i numeri coincidono con quelli di prima (0.780 per A, 0.826 per B), a conferma che la media pesata è la stessa cosa del rapporto S/T. Si vede anche perché A «perde»: ha peso 0.75 sul gruppo difficile (grandi), B ha peso 0.23. Il secondo blocco applica a entrambi gli stessi pesi, calcolati sull'intera popolazione dei 700 pazienti: ora la composizione è uguale e il confronto è onesto. A risulta migliore (circa 0.83 contro 0.78). Questa è la versione quantitativa di «confrontare a parità di dimensione».

Quando segmentare è invece lo sbaglio

Il paradosso di Simpson non autorizza a segmentare sempre. Dipende dal meccanismo causale, e il disegno sotto lo mostra per il caso dei calcoli: la dimensione del calcolo (confondente) influenza sia quale trattamento viene scelto sia l'esito; confrontare a parità di dimensione blocca il percorso passante per il confondente e lascia solo l'effetto del trattamento.

Esiste anche il caso opposto, in cui la variabile con cui si segmenterebbe è una conseguenza del trattamento (un mediatore), non una sua causa. Esempio: un farmaco riduce la durata del ricovero (conseguenza) e la durata del ricovero influenza l'esito. Se confronti i pazienti «a parità di durata del ricovero» elimini proprio l'effetto che volevi misurare. Le due situazioni hanno la stessa aritmetica e conclusioni opposte: nessun calcolo, da solo, dice quale delle due è quella giusta; serve una conoscenza del processo che ha generato i dati. Questo è il motivo per cui la procedura di traduzione comincia da una decisione e da un modello di come funziona il fenomeno, non da una tabella.

Quale numero è quello giusto? Dipende dal meccanismo causale, non dalla matematica. Qui la dimensione del calcolo è una causa comune della scelta del trattamento e del risultato, perciò il confronto a parità di dimensione (i numeri per gruppo) è quello che risponde alla domanda «quale tratta meglio?». In un altro problema, con un diverso meccanismo, potrebbe essere l'aggregato quello corretto. Il ragionamento causale (modulo 02, probabilità) è ciò che decide, non un'ispezione dei numeri.

Trade-off. Segmentare dà risposte più giuste ma con campioni più piccoli e più rumore, e si può segmentare all'infinito fino a trovare qualunque cosa (vedi p-hacking, lezione 06). Regola pratica: segmenta per variabili che hai motivo causale di ritenere rilevanti, scritte prima di guardare i dati.

Trappola 2: la legge di Goodhart

Enunciato (nella forma di Strathern 1997): quando una misura diventa un obiettivo, cessa di essere una buona misura.

Analogia. Un insegnante valutato sul tasso di promozione dei suoi studenti. Se la promozione è una buona misura della qualità dell'insegnamento, l'osservazione ha senso. Se diventa l'obiettivo (premi, carriera), la strada più economica per alzarla è abbassare l'asticella, non insegnare meglio. La misura continua a salire; la qualità, no.

Un modello minimo. Un team ha una unità di sforzo da dividere tra due attività: lavoro vero (che migliora la qualità reale) e "ottimizzazione della metrica" (che migliora il numero ma non la qualità). Supponiamo che l'ottimizzazione renda il doppio per unità di sforzo, perché è la strada più economica. Sia s la quota di sforzo sul lavoro vero (da 0 a 1).

• Qualità reale: Q(s) = s.
• Metrica osservata: M(s) = s + 2·(1 − s).

Le due formule hanno lo stesso termine s, ma la metrica aggiunge un secondo contributo che non produce valore: è il "gioco" sulla misura, che rende il doppio per ogni unità di sforzo. Il resto del modello è l'aritmetica di questa differenza.

La metrica è sempre decrescente in s (perché M(s) = 2 − s): per massimizzare la metrica conviene s = 0, cioè zero lavoro vero.

def qualita(s):          # lavoro vero
    return s

def metrica(s):          # lavoro vero + ottimizzazione della metrica (che rende il doppio)
    return s + 2 * (1 - s)

griglia = [i / 10 for i in range(11)]
migliore_per_metrica = max(griglia, key=metrica)
print("s che massimizza la metrica:", migliore_per_metrica)
print("metrica a quel punto:", metrica(migliore_per_metrica), "| qualità reale:", qualita(migliore_per_metrica))
print("alla scelta s=1:         ", "metrica:", metrica(1.0), "| qualità reale:", qualita(1.0))

Output: s = 0.0, metrica 2.0, qualità 0.0; a s = 1.0: metrica 1.0, qualità 1.0. Chi viene premiato sulla metrica raddoppia il numero e azzera il valore.

Il modello è volutamente rozzo: serve a mostrare il meccanismo, non a stimare un fenomeno reale. Il meccanismo è questo: finché nessuno ottimizza la misura, misura e qualità sono correlate; nel momento in cui qualcuno ottimizza la misura, quella correlazione si rompe.

Come ci si difende.

• Metriche di guardia: una metrica che deve restare stabile mentre l'altra cresce (per esempio, tempo di risposta del supporto e soddisfazione del cliente).
• Più metriche, non una sola: rende il gioco più difficile.
• Revisione qualitativa a campione: leggere davvero 20 casi.
• Cambiare la misura nel tempo, quando si nota che viene aggirata.

Come leggere il codice. qualita(s) è il valore reale prodotto dal lavoro vero (proporzionale a quanto sforzo s gli dedichi, tra 0 e 1). metrica(s) è ciò che viene misurato: lo sforzo vero più il doppio dello sforzo speso a «ottimizzare la metrica». griglia contiene 11 valori di s; max(griglia, key=metrica) trova il valore che massimizza la metrica. Il risultato è l'estremo s = 0: chi segue la misura abbandona il lavoro vero. Poiché M(s) = 2 − s è decrescente, nessun valore intermedio è un compromesso razionale per chi è premiato sul numero.

La metrica di guardia in azione

Un modello è utile solo se ne mostra l'effetto. Aggiungiamo una guardia alla misura: se la qualità reale scende sotto una soglia (misurata a campione da un revisore), la metrica viene azzerata. Qual è ora la scelta migliore per chi è premiato sulla metrica?

def qualita(s):
    return s

def metrica_grezza(s):
    return s + 2 * (1 - s)

def metrica_con_guardia(s, soglia_qualita=0.6, probabilita_di_controllo=1.0):
    """Se il revisore controlla e la qualità è sotto soglia, la metrica vale 0."""
    controllo_scopre = qualita(s) < soglia_qualita
    atteso_penalizzato = probabilita_di_controllo * controllo_scopre
    return (1 - atteso_penalizzato) * metrica_grezza(s)

griglia = [i / 10 for i in range(11)]
for p_controllo in (0.0, 0.3, 1.0):
    scelta = max(griglia, key=lambda s: metrica_con_guardia(s, probabilita_di_controllo=p_controllo))
    print(f"probabilità di controllo {p_controllo:.1f}: scelta migliore per chi è premiato sulla metrica -> s = {scelta:.1f} (qualità reale {qualita(scelta):.1f}, metrica {metrica_con_guardia(scelta, probabilita_di_controllo=p_controllo):.2f})")

Output ottenuto:

probabilità di controllo 0.0: scelta migliore per chi è premiato sulla metrica -> s = 0.0 (qualità reale 0.0, metrica 2.00)
probabilità di controllo 0.3: scelta migliore per chi è premiato sulla metrica -> s = 0.0 (qualità reale 0.0, metrica 1.40)
probabilità di controllo 1.0: scelta migliore per chi è premiato sulla metrica -> s = 0.6 (qualità reale 0.6, metrica 1.40)

Come leggere il codice. metrica_con_guardia moltiplica la metrica grezza per 1 − (probabilità che il controllo scopra il problema). Se nessuno controlla (probabilità 0) si ottiene la scelta di prima: s = 0, qualità zero. Se si controlla sempre, la scelta razionale passa a s = 0.6, cioè al minimo di qualità richiesto dal revisore: la metrica ha smesso di premiare l'azzeramento del lavoro vero, anche se la qualità ottenuta è solo la soglia, non la massima. Se si controlla il 30% delle volte, siamo esattamente al pareggio (metrica attesa 1.40 sia con s = 0 sia con s = 0.6, e il codice sceglie il primo): basta una probabilità di controllo appena più bassa perché ignorare la qualità torni la scelta migliore. Questo mostra due cose: la guardia funziona se è credibile, e non produce l'ottimo ma un comportamento che soddisfa il vincolo. È un buon motivo per usare più guardie e per ruotare i criteri di controllo.

I tre tipi di metrica

Una cultura del dato matura sceglie almeno una di ciascun tipo per ogni decisione importante.

Come si costruisce la cultura in un gruppo

Non si costruisce con una piattaforma. Si costruisce con abitudini piccole e ripetute:

1. Scrivere la domanda e la soglia prima di guardare i dati. Impedisce di adattare la decisione al risultato.
2. Un glossario delle metriche con formula, fonte, finestra, proprietario. Due persone che dicono "cliente attivo" intendendo cose diverse sono la sorgente più comune di discussioni sterili.
3. Condividere anche gli esperimenti falliti. Se solo i successi vengono mostrati, il gruppo impara che sbagliare è pericoloso e smette di sperimentare.
4. Un posto dove tornare: un registro delle decisioni con la domanda, il dato, l'esito.
5. Formare tutti all'alfabetizzazione di base: leggere un grafico, distinguere media e mediana, sapere che un campione piccolo è rumoroso. Il modulo 02 è questo.

Trade-off. Ogni regola costa tempo. Una procedura pesante per ogni micro-decisione blocca l'organizzazione. Calibra: rigore proporzionale al costo dell'errore e alla reversibilità della decisione. Le cinque abitudini sono in ordine di costo crescente: la prima si adotta domani, l'ultima richiede mesi di formazione, e conviene cominciare da quelle che non richiedono strumenti.

Un vocabolario minimo

• Data-driven / data-informed: decisione determinata dal dato / dato come uno degli input.
• Metrica: numero definito con formula, unità, fonte e finestra temporale.
• Confondente: variabile che influenza sia la causa presunta sia l'effetto.
• Mediatore: variabile attraverso cui la causa produce l'effetto.
• Paradosso di Simpson: il confronto aggregato si ribalta rispetto a quello per gruppi.
• Standardizzazione diretta: confronto con pesi di gruppo comuni.
• Legge di Goodhart: una misura che diventa obiettivo smette di misurare bene.
• Metrica di guardia: misura che segnala danni collaterali.

Le otto voci si dividono in tre gruppi: come si decide (data-driven, metrica), come i numeri ingannano (confondente, mediatore, Simpson, Goodhart) e come ci si difende (standardizzazione, guardia). Quando un collega porta un grafico, chiedi quali tra questi termini si applicano al suo caso.

Errori tipici

Best practice

• Una dashboard per ogni decisione, non per ogni fonte di dati.
• Ogni numero mostra come è calcolato (un clic per vedere la formula).
• Confronti sempre con qualcosa (periodo precedente, gruppo di controllo).
• Mostra l'incertezza (intervalli, dimensione del campione), non solo il valore puntuale.
• Rivedi le metriche con cadenza fissa e ritira quelle che non guidano nessuna decisione.

Le cinque regole hanno un solo filo: ogni numero deve poter essere interrogato (come è calcolato, rispetto a che cosa, con quanta incertezza) e deve servire a una decisione. Le ultime due sono le meno praticate; se devi iniziare da una, inizia dal ritiro delle metriche, perché ogni dashboard inutile ha un costo di attenzione.

Mini-progetto

1. Scegli una decisione reale (o verosimile) del tuo ambiente di lavoro o di studio.
2. Compila i sei passi della procedura di traduzione in una tabella.
3. Indica una metrica di esito, una guida, una di guardia, con formula.
4. Elenca due variabili di confondimento possibili per il confronto che vuoi fare e come le controlleresti.
5. Descrivi un modo in cui la tua metrica principale potrebbe essere aggirata (Goodhart) e la contromisura.

I cinque passi seguono la lezione: i primi tre costruiscono la domanda e la metrica, il quarto applica Simpson e il quinto Goodhart. Il quinto è il più utile da fare in coppia con un collega, perché è più facile immaginare come aggirare la metrica di un altro.

Challenge

• Easy. Nei dati dei calcoli renali, calcola i pesi w_g di ciascun trattamento e ricostruisci il complessivo come media pesata, verificando che coincida.
• Medium. Inventa un esempio numerico di Simpson (due gruppi, due trattamenti) con numeri tuoi e verificalo in Python.
• Hard. Dimostra che il paradosso richiede che le quote w_g siano diverse tra i trattamenti: se le quote sono uguali, un trattamento migliore in ogni gruppo è migliore anche nel complessivo. (Suggerimento: usa la formula della media pesata con gli stessi pesi.)
• Expert. Nel modello di Goodhart sostituisci il rendimento 2 con un parametro r > 1 e aggiungi una penalità sulla gaming-activity (se la scoperta ha probabilità q, la metrica viene azzerata). Per quali (r, q) il comportamento onesto diventa razionale?
• Enterprise. Prepara un glossario di 8 metriche della tua organizzazione con formula, proprietario, frequenza di revisione e metrica di guardia associata.

Easy e Medium consolidano il calcolo dei pesi, Hard lo dimostra, Expert esplora la legge di Goodhart con parametri, Enterprise porta il glossario nel tuo lavoro. La sfida Hard è la più formativa: chiarisce che il paradosso nasce solo quando i pesi differiscono.

Recap

Mappa mentale. Problema vago → decisione → domanda verificabile → metrica (esito, guida, guardia) → confronto → soglia → piano. Trappole: Simpson (aggregato che inganna per pesi diversi), Goodhart (misura che diventa obiettivo).

3 concetti: procedura di traduzione; confondimento; metriche di guardia. 3 errori: metrica non definita; media senza segmenti; proxy ottimizzato. 3 best practice: domanda e soglia prima del dato; glossario delle metriche; registro delle decisioni. 1 esercizio: il mini-progetto di questa lezione.

Prossima lezione: «Test and learn»: come si risolve il problema del confondimento facendo un esperimento controllato.

Nella stessa serie trovi anche: 04 - Implementare l'IA in azienda (la lezione precedente), 06 - Test and learn: esperimenti controllati e A/B test (la lezione successiva).