Un algorithme de déduplication pour les bases et entrepôts de données
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Un algorithme de déduplication pour les
bases et entrepôts de données
Faouzi Boufarès*, Aïcha Ben Salem*,**, Sebastiao Correia**
Laboratoire LIPN - UMR 7030 – CNRS, Université Paris 13,
Av. J. B. Clement 93430 Villetaneuse France
*
{boufares, bensalem}@lipn.univ-paris13.fr
Société Talend,
Av. Pagès 92150 Suresness France
**
{abensalem, scorreia}@talend.com
RÉSUMÉ. La déduplication des données est une étape très importante dans le processus
d'intégration de données hétérogènes. Elle assure une meilleure qualité pour les données
résultats. Ainsi, l'extraction de connaissances à partir de ces dernières sera plus
précise. Nous présentons dans cet article, un algorithme séquentiel pour l’élimination des
données similaires. Celui-ci est basé sur les fonctions Match et Merge que nous avons
définies. La fonction Match repose sur le calcul de distance de similarité en fonction du
type de données. Tandis que la fonction Merge utilise des règles logiques pour fusionner les
données. Nous évaluons expérimentalement différentes versions d’implémentation de notre
algorithme en utilisant un jeu de données généré aléatoirement.
ABSTRACT. Data deduplication is a very important step in the process of integration of
heterogeneous data. It ensures a better quality of data results. Thus, the extraction of
knowledge from these data is more accurate. We present in this paper, a sequential algorithm
to eliminate similar data. This algorithm is based on the Match and Merge functions that we
have defined. The match function is based on calculations of similarity distances depending
on the type of data. The Merge function uses logical rules. We experimentally
evaluate different versions of the implementation of our algorithm using a random generated
data.
MOTS-CLÉS : Qualité des données, Distance de similarité, Elimination des similaires,
Déduplication, Match, Merge.
KEYWORDS: Data Quality, Similarity Distance, Similar Data Elimination, Deduplication,
Match, Merge.1. Introduction
De nos jours les travaux sur l'extraction et la gestion de connaissance à partir de
gros volumes de données (contenus dans un entrepôt issu de sources hétérogènes et
distribuées), se basent principalement sur la recherche d'informations potentiellement
utiles et jusque-là inconnue. La qualité de l'information recueillie dépend de ces
données (Berti-Équille, 2006). Une bonne qualité des données stockées dans les
bases et entrepôts de données (BDs et EDs), est devenue une nécessité absolue dans
une organisation. Contrairement à ce que l’on peut penser, les données
rassemblées aujourd'hui dans les BDs et EDs, contiennent de nombreux problèmes
tels que les données similaires, les doublons, les valeurs aberrantes, les valeurs
nulles. Il s’ensuit une mauvaise qualité des données pour des fins décisionnelles
(Boufarès et al,, 2011). Les conséquences de la non-qualité des données peuvent être
très coûteuses. Par conséquent, il est important de nettoyer les données (éliminer les
doublons et les similaires) dans un délai raisonnable. Le problème de
l'élimination des données similaires est très difficile (Bilenko et al,, 2003), (Cohen et
al,, 2004). Il s'agit de vérifier la correspondance des données (Match) et ensuite de
les fusionner (Merge). Nous proposons dans ce papier un algorithme, inspiré de
(Benjalloun et al,, 2009), pour détecter, supprimer ces doublons et enrichir en
information les enregistrements restants. L'objectif de notre algorithme est de
dédoublonner les données provenant du processus d'intégration et de les enrichir afin
de fournir aux utilisateurs des données de bonne qualité et plus complètes.
Ce papier sera présenté comme suit. Dans la deuxième section, nous présentons
le processus de comparaison et de fusion de données (les fonctions Match et Merge).
L’algorithme d'élimination des similaires ainsi que des mesures de performance entre
différentes versions d’implémentation seront présentés, dans les sections 3 et 4. Dans
les sections suivantes, un bref aperçu sur les travaux connexes ainsi que nos travaux
futurs sont abordés.
2. Le processus de comparaison et de fusion (Fonctions Match et Merge)
L’élimination de données similaires nécessite le développement de deux
fonctions « Match » (Comparer) et « Merge » (fusionner) (Hernandez, 1998). La
fonction Match permet de définir si deux tuples dans une table sont similaires et la
fonction Merge génère un nouveau tuple en fusionnant les deux supposés similaires.
Différents algorithmes de calcul de distance de similarité existent dans la littérature
tels que ceux de Levenshtein, de Jaro-Winkler, de Jaccard (Berti-Équille, 2006). Ces
algorithmes sont utilisés dans le processus de comparaison.
Introduisons à présent quelques notations. Une table T(A1....An) est interprétée
par l'ensemble [[T]] de tous les {A1....An}-tuples sur [[Dk]]k=1,n avec A={A1....An}
l’ensemble des attributs de T. [[Dk]] est l'ensemble de valeurs concrètes d'un tuple de
données tels que les chaînes de caractères alphanumériques (String), les numériques(Number), les dates, les booléens (Boolean) ou encore des listes et des intervalles de
valeurs. [[T]] est l'ensemble des fonctions t : {A1....An} → ∪ [[Dk]] k=1,n, tel que
t(Ak) noté t.Ak est un élément de [[Dk]]. Chaque élément t de [[T]] est un tuple de la
table T et chaque t.Ak est une valeur de l'attribut dans t, que l’on notera aussi vk.
Définition 1 : Similarité entre valeurs (notée ≈) Pour un attribut Ak, on note t.Ak ≈
t'.Ak (ou v ≈ v'), ssi dk ≤ sk, avec dk la distance calculée de similarité et sk est le seuil
fixé par l’utilisateur (sk ∈ [0,1], sk∈ S, k=1..n). ■
Exemple 1: Adr1←t1.Adr et Adr2←t2.Adr ; Nom1←t1.Nom et Nom2←t2.Nom ;
Mail1←t1.Mail et Mail2←t2.Mail ; Tél1←t1.Tél et Tél 2←t2.Tél.
Les deux adresses suivantes Adr1 = "20 BOULEVARD CHAMPS ÉLYSÉES
PARIS" et Adr2= "20 BOULEVARD CHAMPS-ELYSÉES 75008 PARIS" sont
similaires, selon la méthode de Jaro-Winkler car la distance calculée d est de 0,051
inférieure à un seuil fixé s=0,2.
Définition 2 : Règle de similarité Une règle r de similarité est une conjonction de
similarités qui portent sur des attributs Ak (k=1,n) de l’ensemble A de la table T.
r=˄p=1.n (t.Ak ≈ t'.Ak) : r=(t.A1 ≈ t'.A1) ˄ (t.A2 ≈ t'.A2) ˄… ˄ (t.An ≈ t'.An) ■
Exemple 2 : Deux règles de similarités r1 et r2 : r1 = (Mail1 ≈ Mail2) ˄ (Tél1 ≈ Tél2)
r2 = (Nom1 ≈ Nom2) ˄ (Mail1 ≈ Mail2) ˄ (Adr1 ≈ Adr2).
Définition 3 : Similarité entre tuples Deux tuples t et t' sont similaires ssi la
disjonction de toutes les règles de similarité définies sur T est vraie. On note t ≈ t' ssi
˄j=1.q(rj) = vrai avec rj une règle de similarité définie sur les attributs de A.
t ≈ t' ssi r1 ˄ r2 ˄ ... ˄rk … ˄ rq (q étant le nombre de règles de similarité) ■
Exemple 3 : Deux tuples t1 et t2 sont similaires ssi r1 ˄ r2 : t1 ≈ t2 ssi [(Nom1 ≈
Nom2) ˄ (Mail1 ≈ Mail2) ˄ (Adr1 ≈ Adr2)] [(Mail1 ≈ Mail2) ˄ (Tél1 ≈ Tél2)].
REMARQUE. — Ces règles peuvent présenter toutefois des incohérences ou des
contradictions. L’étude de leur cohérence globale ou leur simplification ne fait pas
l’objet de cet article.
La fonction Match compare deux tuples. L’étude de similarité porte sur les
attributs de l’ensemble A selon les règles de similarité. La fonction Similar(v1,v2, si)
prend en paramètre deux valeurs (v1←t1.Ai et v2←t2.Ai) et si un seuil fixé par
l’utilisateur pour Ai. Une méthode de calcul de distance de similarité est appliquée
telle que Jaro-Winkler. La distance trouvée di est comparée au seuil si.
La fonction Merge traite deux tuples, supposés similaires. Elle retourne un
nouveau tuple t' qui apporte « plus » d’information à partir de chaque valeur (v)
résultant de la fusion: v:=Merge(expr, v1, v2) avec expr une règle métier permettant
de choisir la méthode de fusion de v1 et v2. Un enrichissement des données peut ainsi
être réalisé à la demande de l’utilisateur sur les attributs de l’ensemble A.Une implémentation personnalisée de la fonction Merge permet d’associer deux
valeurs selon le type de données de l’attribut en question: (i) si l’attribut est du type
chaîne de caractères, expr présente la plus longue chaîne des deux, si celle-ci vérifie
un ensemble d’expressions régulières proposé pour l’utilisateur. La fusion d’une
chaîne quelconque avec une valeur nulle (NULL) donne la chaîne elle-même ; (ii) si
l’attribut est du type numérique, la fusion peut correspondre à des calculs demandés
par l’utilisateur tels que la somme, la moyenne, le minimum ou le maximum des
valeurs. Des transformations peuvent être réalisées telles que des conversions dues à
des changements d’unité. Les valeurs nulles sont considérées égales à 0 ; (iii) si
l’attribut est du type date, la fusion peut permettre de garder la plus récente des deux,
selon le choix de l’utilisateur, après avoir unifié les formats et vérifié leurs validités.
3. Elimination des similaires
Le croisement de tous les tuples d’une table est le principe de base pour
l’élimination des données similaires. Il s’agit d’algorithme très coûteux pour de gros
volumes de données. L’idée est de réduire le nombre de comparaisons en fusionnant
les données qui concordent et de ne conserver que le tuple dominant pour les
prochaines comparaisons. L’originalité de notre travail consiste à faire
simultanément les comparaisons et les fusions. Nous avons développé précédemment
deux algorithmes inspirés de (Benjalloun et al,, 2009). Afin d’améliorer les
performances de nos précédents algorithmes, nous présentons dans ce qui suit, un
troisième algorithme dont le principe de fonctionnement est le suivant.
Afin de réduire le nombre de comparaisons, l’algorithme (voir annexe) se base
sur la notion des attributs clés (« features ») pour éliminer des similaires. Cet
algorithme utilise, outre les ensembles I (ensemble de tuples départ) et I' (les tuples
résultats), deux ensembles de données Pf (positifs) et Nf (négatifs) pour garder trace
des valeurs des attributs clés déjà rencontrées, et enregistrer les comparaisons
redondantes positives et négatives. Pf sauvegarde toutes les valeurs précédemment
rencontrées de l’attribut clé d’élimination et lui associe l’identifiant de tuple auquel
il appartient. Le tuple t est soit le premier enregistrement pour lequel la valeur v est
apparue pour l’attribut clé fi, ou celui qui a été dérivé à partir d’une séquence de
fusions des tuples. Si ce tuple n’existe pas (la valeur v, de l’attribut clé, est vue pour
la première fois), Pfi(v) retourne Null. Cependant, il ne peut y avoir au plus qu’un
tuple associé à la valeur v d’un attribut fi. Dans le cas où plusieurs tuples sont
présents, ces derniers sont fusionnés dans le tuple renvoyé par Pfi(v).
Nf est l’ensemble qui conserve les valeurs des attributs clés fi qui ont été
comparées avec toutes les valeurs des attributs pour les tuples de I' et ne correspond
à aucun d'entre eux. On évite alors des comparaisons redondantes dont la fonction
Match aurait renvoyé une valeur négative. Si le tuple en cours de traitement par
l'algorithme, a une valeur v qui apparaît dans Nfi, cette valeur n'a pas besoin d'être
davantage comparée. Quand un nouveau tuple t est traité par l'algorithme, ce derniersauvegarde, tout d'abord dans Pfi toutes les valeurs de chaque nouvel attribut, puis
vérifie si l'une de ces valeurs est déjà parue dans un tuple différent (en vérifiant son
identifiant). Les paires de valeurs des attributs clés P(f,v) qui correspondent, sont
immédiatement dirigées vers le processus de la fusion des tuples, et ne sont jamais
comparées de nouveau, tandis que les autres paires qui ne correspondent pas sont
ajoutées à Nfi, et de cette façon on garantit qu’elles ne seront jamais comparées à
nouveau.
Exemple 4: Pour deux attributs Nom et Prénom, les structures P et N à gérer,
présentées dans le tableau 2, sont (PNom, PPrenom, NNom et NPrenom):
P N
Nom RowIdN OccN Prenom RowIdP OccP Nom Prenom RowIdT
Le Bon t1 4 Adam t1 3 Le Bon Adam t1
Le B. t5 1 Adem t5 1 Dupond Jérémy t2
Dupond t2 3 Jérémy t2 2 …
Dupont t8 1 Jeremy t8 1
Tableau 1. Echantillon de l’ensemble de données Pfi et Nfi
Plusieurs versions de cet algorithme ont été développées selon les structures de P
et N. Ainsi P et N peuvent être aussi bien des listes gérées en mémoire vive que des
tables gérées par un SGBD. Il est aussi possible d’utiliser soit une table par attribut
clé, soit une table pour tous les attributs clés à la fois. Le partitionnement des tables
est alors appliqué pour gérer de gros volumes de données. Nous avons apporté
quelques modifications à la version donnée dans le papier (Benjalloun et al,, 2009)
afin de traiter différents cas de figure. Parmi ces modifications, lors de la fusion des
deux tuples (t, t’), les valeurs des attributs de t’ existent déjà dans les ensembles de
données Nf, il faut donc les mettre à jour de la même manière que ceux de Pf.
L’implémentation des différentes versions de notre algorithme est faite en JAVA en
utilisant des listes ou des tables sous SGBD Oracle 10g. Plusieurs versions existent
pour gérer de gros volumes de données. La complexité de cet algorithme réside dans
l’utilisation des deux ensembles Pf et Nf. Nous vérifions et comparons les taux
d’élimination pour chacun des algorithmes.
4. Mesure de performances de l’algorithme
Les mesures de performance sont effectuées sur trois versions de notre
algorithme présenté en annexe, sur des données générées aléatoirement en utilisant
GenerateData1. Nous avons ainsi généré et inséré des doublons dans notre jeu de
test. Notre table de test CLIENT a la description SQL suivante :
« CREATE TABLE CLIENT (PRENOM varchar2(100), NOM varchar2(100), RUE varchar2(100), CP
varchar2(10), VILLE varchar2(50), DATNAIS Date, TEL varchar2(100) ) ; »
1
http://www.generatedata.com/#generatorLes attributs Prenom, Nom, DatNais et Tel ont été choisis pour l’élimination des
similaires. Les algorithmes Jaro-winkler, Levenshtein et Jaccard ont été utilisés pour
le calcul de la distance de similarité. Un seuil a été fixé pour chacun des attributs
respectivement (0,2 ; 0,2 ; 0 ; 0,1). L’utilisateur peut demander l’enrichissement de
ses données afin d’éliminer, d’une part, d’éventuelles valeurs nulles, et d’autre part
de regrouper ou corriger certaines informations. Par exemple, dans la mesure où l’on
veut avoir plusieurs numéros de téléphone pour un même client, la définition de
l’attribut concerné (résultat de la fusion) devrait être suffisamment élargie, selon une
règle métier, pour mettre x valeurs (Tel varchar2(100) au lieu de Tel varchar2(10)). Deux
règles de similarité entre tuples ont été utilisées pour réaliser la fusion (Merge) :
Rules= r1 ˄ r2 où r1: d1 ≤ s1 ˄ d2 ≤ s2 ˄ d7 ≤ s7 ; r2: d2 ≤ s2 ˄ d6 ≤ s6
Différentes mesures ont été effectuées sur des tables allant de 103 à 106 lignes.
Notre jeu de données contient 40% de similaires et de doublons. Les trois versions
testées sont respectivement Version 1 (P et N des listes JAVA), Version 2 (P et N
des tables Oracle) et Version 3 (P et N dans une même table). Les mesures de
performance (figure 1) montrent que la version de l’algorithme, qui utilise les listes
pour P et N, est plus performante que les deux autres (des limitations de mémoire à
prévoir pour un nombre plus grand de tuples). Tandis que la version que nous avons
voulu optimiser en regroupant les deux tables P et N n’améliore pas vraiment le
temps de réponse, et que la version avec deux tables P et N reste plus performante.
Figure 1. Performances de l’algorithme selon ces trois versions
5. Travaux connexes
Plusieurs travaux sur l'élimination des données similaires et des doublons existent
dans la littérature (Benjalloun, 2009), (Cohen, 2004), (Bilenko, 2003), (Hernandez,
1998). La fonction Match utilise des règles de décision portant sur les n attributs. Il
existe deux types de décision : (i) dichotomique (similaires ou non) –c’est notre cas;ou (ii) trois réponses (similaires ou non et besoin de plus de révision) (Sarawagi,
2006). Aussi notre fonction Match est basée sur des valeurs d'attributs, tandis que
d'autres utilisent le concept de contexte (Köpcke, 2006). Plusieurs approches existent
pour fusionner différents tuples telles que celles basées sur les règles ou sur les
workflows ou encore les approches numériques. Concernant les approches basées sur
les règles, la fusion se fait selon une combinaison logique des conditions de
correspondance, alors que celles basées sur les workflows permettent des
combinaisons aléatoires (Köpcke, 2006).
6. Conclusion
Actuellement, un grand nombre d’applications utilisent des données hétérogènes
et distribuées de qualité variable. Le besoin d'intégration de données et d'évaluation
de la qualité des données se fait de plus en plus ressentir. Afin de redonner
d’avantage de sens dans les données rassemblées, nous abordons la problématique
complexe de l’élimination de similaires dans les ED. En effet, le développement de
nouveaux outils pour traiter les données similaires nécessite l’approfondissement,
d’une part, des deux concepts de base Match & Merge, et d’autre part, le
développement d’autres algorithmes pour parcourir et comparer les données dans des
environnements séquentiels et parallèles. Les types de données traités dans notre
étude sont les types caractère, numérique, date et logique. La concordance des
données se fait selon des règles proposées par l’utilisateur. Notre algorithme,
séquentiel, réalise le Match & Merge parallèlement. Les performances sont à
améliorer pour les données volumineuses. Le choix des règles de similarité sera
automatisé. De nouvelles méthodes de calculs de distance de similarité pour des
types de données complexes sont à développer ainsi que l’automatisation du choix
entre elles. Tels sont les objectifs que nous nous fixons dans nos travaux futurs.
7. Bibliographie
Benjalloun, O., Garcia-Molina, H., Menestria, D., Su, Q., Whang, S.E., Widom, J., « Swoosh:
A Generic Approach to Entity Resolution », The International Journal on Very Large
Data Bases (VLDB '09), New York, USA, 2009, pp. 255-276.
Berti-Équille, L., « Qualité des données », Techniques de l’Ingénieur H3700, collection
Technologies logicielles – Architecture des systèmes, France, 2006, pp. 1-19.
Bilenko, M., Mooney, R.J., « Adaptive Duplicate Detection Using Learnable String Similarity
Measures », Proceedings of the Ninth ACM SIGKDD International Conference on
Knowledge Discovery, and Data Mining, Washington DC, USA, 2003, pp. 39-48.
Boufarès, F., A. Ben-Salem, « Heterogeneous data-integration and data quality: Overview of
conflicts », Sciences of Electronic, Technologies of Information and Telecommunications
(SETIT’11), Sousse, Tunisie, 2011.Cohen, W.W., Richman, J., « Iterative Record Linkage for Cleaning and Integration »,
Proceedings of the 9th ACM SIGMOD workshop on Research issues in data mining and
knowledge discovery (DMKD’04), Paris, France, 2004, pp. 11-18.
Hamdoun, S., Boufarès, F., « Un formalisme pour l'intégration de données hétérogènes »,
6ème journées Francophones sur les entrepôts de données et l'Analyse en ligne
(EDA'10), Djerba-Tunisie, 2010, pp. 107-119.
Hernandez, M.A., Stolfo, S.J., « Real-world Data is Dirty: Data Cleansing and The
Merge/Purge Problem » Data Mining and Knowledge Discovery (DMKD’98), New York,
USA, 1998, pp. 9-37.
Köpcke, H., Rahm, E., « Frameworks for entity matching: A comparison », Data Knowledge
Engineering (DKE’09), 2009, pp. 197–210.
Sarawagi, S., Bhamidipaty, A., « Interactive Deduplication using Active Learning »,
Proceedings The 8th ACM International Conference on Knowledge Discovery and Data
Mining (SIGKDD’02), Alberta, Canada, 2002, pp. 269-278.
Annexe : Algorithme d’élimination de similaires
input : a set I of tuples, if buddy = null then /*If not look for Matches*/
output : a set Iprim of tuples, Iprim for all (f, v) of currentTuple do
Pf ← empty hash table, for each feature f , if v ∉ Nf then/* if a value never made it to
Nf ← empty set, for each feature f Nf*/
SaveTuples ← a set of tuples, Iprim ← Ø, for all t’ of Iprim do
currentTuple ← null if Match (t,t’) then buddy ← t’
while I ≠ Ø or currentTuple ≠ null exitfor endif
if currentTuple = null then endfor
currentTuple ← a Tuple from I if buddy ≠ null then exitfor endif
remove currentTuple from I add v to Nf endif
endif endfor
buddy←null endif
for all(f, v) of currentTuple do if buddy = null then add currentTuple to Iprim
if Pf(v) = null then currentTuple ← null
Pf(v) ← currentTuple else
SaveTuples ← (currentTuple, rowid) t’’ ←Merge (currentTuple, buddy)
endif remove buddy from Iprim
endfor /*update P*/
for all (f, v) of currentTuple do /*was any for all (f, v) where Pf(v) ∈{currentTuple, buddy}
value previously encountered*/ do Pf(v) ← t’’ endfor
if Pf(v) ≠ currentTuple then /*we /*update N*/
compare the value and the rowid*/ for all (f, v) where Nf(v) ∈ {currentTuple, buddy}
buddy ← SaveTuples(Pf(v)); exitfor do Nf(v) ← t’’ endfor
endif currentTuple ← t’’
endfor endif
endwhile
return IprimVous pouvez aussi lire
