Entity Resolution: Unificare Clienti e Prodotti tra Sistemi Diversi
Prendi un cliente che compra sia in negozio sia online. Nel gestionale della cassa si chiama MARIO ROSSI, sull'e-commerce ha scritto Mario Rossi, nel form del programma fedeltà ha inserito Rossi Mario con una seconda email, e in assistenza esiste una quarta scheda creata al telefono. Sono quattro righe in quattro tabelle diverse. È una persona sola.
Finché i sistemi restano separati il problema non si vede. Appena li metti in un unico data warehouse — o anche solo in un'unica dashboard — scopri che quel cliente vale quattro volte il suo valore reale, che ha ricevuto quattro email promozionali identiche e che la sua assistenza è frammentata in quattro conversazioni. Lo stesso vale per i prodotti: lo stesso articolo con tre codici fornitore diversi, due descrizioni e un'unità di misura sbagliata.
Entity resolution (o record linkage, o deduplicazione, a seconda della sfumatura) è l'insieme delle tecniche che assegnano un identificativo stabile alla stessa entità reale, anche quando arriva da fonti diverse e scritta male. Non è un problema di database: è un problema di probabilità e di compromessi.
Falsi positivi e falsi negativi non costano uguale
Prima di scrivere una riga di codice conviene fissare il criterio di errore. Ci sono due modi di sbagliare:
- Falso positivo: unisco due entità che sono in realtà diverse (due Mario Rossi distinti diventano uno).
- Falso negativo: non unisco due record della stessa entità (restano due schede).
Il falso negativo è visibile e recuperabile: te ne accorgi, lo correggi, il danno è un report leggermente sottostimato. Il falso positivo è silenzioso: i dati aggregati sono sbagliati, l'email va alla persona sbagliata e — se stai trattando dati personali — stai potenzialmente incrociando informazioni che non dovrebbero stare insieme. Per questo, in genere, si preferisce una soglia prudente con una zona di revisione manuale, invece di massimizzare le fusioni.
Le quattro fasi
Un pipeline di entity resolution si scompone quasi sempre negli stessi passi:
- Standardizzazione: normalizzare i valori senza distruggere l'informazione.
- Blocking: ridurre il numero di coppie da confrontare.
- Confronto e scoring: dare un punteggio di similarità a ogni coppia candidata.
- Clustering e decisione: trasformare i punteggi in gruppi e in un identificativo canonico.
1. Standardizzazione
Le regole sono noiose e preziose: maiuscole uniformi, accenti rimossi o mantenuti coerentemente, punteggiatura eliminata, spazi multipli collassati, prefissi telefonici normalizzati, abbreviazioni espanse ("v. Roma" → "via roma"), titoli rimossi ("dott.", "sig.").
La regola d'oro: conserva sempre il valore originale in una colonna separata. Se normalizzi in place e poi scopri che una regola era sbagliata, hai perso il dato di partenza.
import re
import unicodedata
def normalizza(testo: str) -> str:
if not testo:
return ""
t = unicodedata.normalize("NFKD", testo)
t = "".join(c for c in t if not unicodedata.combining(c))
t = t.lower()
t = re.sub(r"[^a-z0-9 ]", " ", t)
t = re.sub(r"\s+", " ", t).strip()
return t
Attenzione all'eccesso di zelo: rimuovere tutte le cifre da un indirizzo cancella il civico, che è esattamente ciò che distingue due persone nella stessa via.
2. Blocking
Confrontare ogni record con ogni altro è O(n²). Con centomila clienti sono circa cinque miliardi di coppie: non si fa.
Il blocking costruisce una chiave grossolana e confronta solo i record che la condividono. Esempi classici:
- prime tre lettere del cognome normalizzato + CAP;
- codice fonetico (Soundex, Metaphone) del cognome;
- dominio email, quando il dominio è aziendale;
- un token raro e affidabile (la partita IVA, l'email esatta).
Il trade-off è netto: blocchi grandi significano più confronti, blocchi stretti significano match persi. Il rischio tipico è che un errore di battitura finisca proprio nel campo usato come chiave, e allora i due record non si incontrano mai.
La soluzione pratica è il blocking multiplo: più passate con chiavi diverse, unendo i candidati trovati. Ogni record partecipa a più blocchi e basta che una passata lo avvicini al gemello.
def chiavi_di_blocking(rec: dict) -> list[str]:
cognome = normalizza(rec["cognome"])
nome = normalizza(rec["nome"])
chiavi = []
if cognome:
chiavi.append(f"cog3:{cognome[:3]}")
chiavi.append(f"fon:{metaphone(cognome)}")
if rec.get("email"):
chiavi.append(f"mail:{rec['email'].lower()}")
return chiavi
3. Confronto e scoring
Qui si sceglie la metrica giusta per il tipo di campo. Non esiste una similarità universale.
| Tipo di campo | Metrica tipica | Quando usarla |
|---|---|---|
| Nomi e cognomi | Jaro-Winkler | premia i prefissi comuni, tollera errori in coda |
| Stringhe lunghe (indirizzi) | token set / Jaccard su trigrammi | l'ordine delle parole varia molto |
| Codici, email | uguaglianza esatta | un carattere diverso è un'altra entità |
| Telefoni | uguaglianza sulle ultime 9 cifre | prefissi e formattazioni variano |
| Date | distanza in giorni con tolleranza | errori di battitura su giorno/mese |
| Importi, quantità | differenza relativa | il valore va confrontato, non la stringa |
Il confronto si fa campo per campo, non sull'intera stringa: due record possono avere nome identico e indirizzo completamente diverso, e la stringa concatenata non lo racconta.
Poi si combinano i punteggi in un unico valore. L'approccio formale è il modello probabilistico di Fellegi-Sunter, che pesa ogni campo in base a quanto è discriminante; nella pratica si parte spesso da pesi scelti a mano e si tarano sui risultati.
score = 0.35 * sim_nome
+ 0.25 * sim_email
+ 0.15 * sim_telefono
+ 0.15 * sim_indirizzo
+ 0.10 * sim_data_nascita
Due accorgimenti che cambiano tutto. Primo: un campo vuoto non deve pesare. Se il telefono manca su metà dei record, dargli peso 0.15 significa penalizzare sistematicamente chi non lo ha compilato. Secondo: un campo molto raro è molto informativo. Due record con la stessa email aziendale sono quasi certamente la stessa entità; due record con lo stesso nome comune no.
4. Decisione: le soglie
Dal punteggio alla decisione servono due soglie:
- sopra la soglia alta → match automatico;
- sotto la soglia bassa → non match;
- in mezzo → zona grigia, revisione manuale o ulteriori controlli.
La zona grigia è il cuore del lavoro. Contiene una frazione piccola delle coppie ma la maggior parte degli errori. Una coda di revisione ben fatta, con le coppie ordinate per punteggio e i campi a confronto affiancati, è spesso più efficace di qualsiasi raffinamento del modello.
Il clustering e il problema della transitività
Qui arriva la parte che sorprende chi affronta il problema la prima volta. I punteggi sono a coppie, ma le entità sono gruppi. E la similarità non è transitiva: A è simile a B, B è simile a C, ma A non è simile a C.
Se applichi la chiusura transitiva (connected components), un singolo ponte spurio può fondere due cluster grandi. Un caso classico: due omonimi in città diverse collegati da un record inserito male, e all'improvviso due persone distinte diventano un'unica entità con due indirizzi, due email e il doppio degli acquisti.
# union-find minimale: unisce le coppie sopra soglia
parent = {}
def find(x):
parent.setdefault(x, x)
while parent[x] != x:
parent[x] = parent[parent[x]]
x = parent[x]
return x
def union(a, b):
ra, rb = find(a), find(b)
if ra != rb:
parent[rb] = ra
Il codice è banale; il problema è decidere quali coppie passare a union. Alcune strategie difensive:
- usare una soglia più alta per il clustering che per il match a coppie;
- controllare i cluster anomali: un cluster con quaranta record è quasi sempre un errore, non un cliente con quaranta schede;
- scegliere un record rappresentante (il golden record) e collegare gli altri a quello, invece di collegarli tra loro;
- prevedere la possibilità di separare un cluster a posteriori, con un log delle operazioni.
Valutare la qualità
Senza una misura, l'entity resolution diventa un'opinione. Serve un campione etichettato a mano: qualche centinaio di coppie candidate, marcate come match o non match, e da lì si calcolano precision, recall e F1 a livello di coppia.
L'insidia è la sproporzione tra le classi. Le coppie non corrispondenti sono la stragrande maggioranza, quindi una misura calcolata su tutte le coppie possibili sembra ottima anche con molti falsi positivi. Va misurata sulle coppie candidate generate dal blocking, oppure campionando.
Un esempio di come cambia il quadro al variare della soglia (valori illustrativi, non misurati su un caso reale):
| Soglia | Precision | Recall | Coppie in revisione |
|---|---|---|---|
| 0.95 | alta | bassa | poche |
| 0.85 | media | media | molte |
| 0.70 | bassa | alta | moltissime |
La tabella va letta insieme al costo del falso positivo: se la soglia alta ti fa perdere un quinto dei match, ma elimina quasi tutte le fusioni sbagliate, spesso è la scelta giusta.
Mettere il risultato in produzione
Il risultato del lavoro non è un cluster, è una tabella di mapping: per ogni record di origine, l'identificativo canonico dell'entità.
CREATE TABLE entity_map (
entity_id bigint NOT NULL,
source_system text NOT NULL,
source_id text NOT NULL,
confidence numeric(4,3),
metodo text,
creato_il timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (source_system, source_id)
);
Quattro regole operative che evitano dolori:
- Il golden record è una vista, non una tabella di verità. I valori originali restano dove sono; la scelta di quale indirizzo "vince" (per precedenza di fonte, per frequenza o per data) va documentata e versionata.
- L'assegnazione incrementale batte il ricalcolo totale. Ricalcolare tutti i cluster a ogni esecuzione è costoso e produce identificativi instabili, che rompono report e storicizzazioni. Meglio: i nuovi record si confrontano con i cluster esistenti; il ricalcolo completo si fa raramente e in modo controllato.
- Traccia la provenienza. Per ogni decisione serve sapere con quale metodo e con quale punteggio è stata presa, altrimenti l'errore è impossibile da diagnosticare.
- Tratta il mapping come dato personale. La tabella che collega le identità è essa stessa un'informazione sensibile: nei dataset analitici dovrebbe entrare solo l'
entity_idpseudonimo, non la corrispondenza con le fonti.
Errori comuni
- Normalizzare senza conservare il valore originale.
- Usare come chiave di blocking un campo che è spesso sbagliato proprio nei casi interessanti.
- Confrontare l'intera riga invece dei singoli campi.
- Pesare allo stesso modo campi quasi sempre vuoti.
- Unire con chiusura transitiva senza controllare i cluster grandi.
- Non misurare nulla, o misurare su tutte le coppie possibili.
- Non prevedere la separazione manuale di un cluster errato.
- Dimenticare che le persone cambiano email, telefono e indirizzo: lo storico è un caso di dimensioni che cambiano, non un errore.
Conclusione
L'entity resolution non è un problema di algoritmi esotici: è un problema di compromessi espliciti.
- Decidi prima quale errore ti costa di più. Nella maggior parte dei casi il falso positivo è peggio del falso negativo, perché è silenzioso.
- Le quattro fasi restano le stesse: standardizzazione, blocking, scoring, clustering. Salta il blocking e non arrivi a fine giornata.
- Il punteggio è a coppie, l'entità è un gruppo. La transitività va gestita con soglie più prudenti e controlli sui cluster anomali.
- La zona grigia è il lavoro vero. Una coda di revisione ordinata vale più di dieci punti di modello in più.
- In produzione conta il mapping, con identificativi stabili, assegnazione incrementale e tracciabilità delle decisioni.
- Misura su un campione etichettato, non a sensazione, e ricorda che i dati che stai unendo sono dati personali.
Foto di copertina di Markus Spiske su Unsplash.