La duplication de données est un gros problème auquel de nombreuses organisations sont confrontées.

Ça pose problème parce que :

  • Ça gaspille de l'espace de stockage.

  • Ça peut mener à des analyses de données incorrectes.

  • Ça peut entraîner des erreurs de reporting, et bien plus encore.

En lisant ça, tu te dis peut-être qu'on peut supprimer les doublons avec des méthodes classiques comme df.drop_duplicates().

Illustration montrant Pandas retirer les lignes en doublon d'un tableau de données grâce à drop_duplicates().

Utiliser Pandas pour supprimer les doublons

Mais que se passe-t-il si tes données contiennent des doublons flous ?

Les doublons flous, ce sont des enregistrements qui ne sont pas des copies exactes les uns des autres, mais qui, d'une manière ou d'une autre, semblent désigner la même chose. C'est ce que montre l'exemple ci-dessous :

Tableau comparant deux enregistrements avec le même prénom, une adresse similaire et un numéro de téléphone presque identique.

Les enregistrements ont le même prénom, une adresse similaire, et un numéro de téléphone presque identique.

La méthode Pandas sera inefficace, car elle ne supprime que les doublons exacts.

Alors, que faire ?

Imaginons que tes données contiennent plus d'un million d'enregistrements.

Comment identifierais-tu les doublons flous dans ce dataset ?

Une première option serait de comparer naïvement chaque paire d'enregistrements, comme illustré ci-dessous :

Schéma montrant chaque enregistrement comparé à tous les autres enregistrements du dataset.

Comparer chaque paire d'enregistrements

On peut définir une métrique de distance pour chaque champ et générer un score de similarité pour chaque paire d'enregistrements.

Mais cette approche est irréalisable à grande échelle.

Par exemple, sur un dataset d'à peine un million d'enregistrements, comparer chaque paire donnerait 10¹² comparaisons (n²).

Schéma illustrant que l'approche naïve génère 10 puissance 12 comparaisons sur un dataset d'un million d'enregistrements.

Complexité de l'approche naïve

Même en supposant une vitesse correcte de 10 000 comparaisons par seconde, cette approche prendrait environ 3 ans pour se terminer.

Peut-on faire mieux ?

Bien sûr que oui !

Mais d'abord, il faut comprendre une propriété particulière des doublons flous.

Si deux enregistrements sont des doublons, ils vont forcément partager un certain chevauchement lexical (ou textuel).

Par exemple, prends le dataset ci-dessous :

Tableau de données montrant des enregistrements sans chevauchement lexical, donc garantis distincts, malgré des champs partiellement similaires.

Ici, comparer le prénom "Daniel" à "Philip" ou "Shannon" à "Julia" n'a aucun sens. Il n'y a littéralement aucun chevauchement lexical.

Ils sont donc garantis d'être des enregistrements distincts.

Ça fait aussi sens intuitivement.

Si on appelle deux enregistrements des "doublons", il doit forcément y avoir un chevauchement lexical.

Pourtant, l'approche naïve va quand même perdre du temps à les comparer.

On peut exploiter cette propriété de "chevauchement lexical" des doublons pour réduire intelligemment le nombre total de comparaisons.

Plus précisément, on segmente les données en plus petits buckets en appliquant certaines règles.

Par exemple, reprends le dataset précédent. Une règle possible serait de créer des buckets basés sur les trois premières lettres du prénom.

Tableau de données regroupé selon les trois premières lettres du prénom, formant les buckets Dan, Ala, Phi, Sha et Jul.

Grouper les données selon des règles

Ainsi, on ne comparera deux enregistrements que s'ils se trouvent dans le même bucket.

Si les trois premières lettres sont différentes, les enregistrements tomberont dans des buckets différents. Ils ne seront donc jamais comparés.

Après avoir segmenté les enregistrements, on aurait éliminé près de 98-99 % des comparaisons inutiles qui auraient eu lieu sinon.

❝

Le chiffre "98-99 %" vient de mon expérience pratique sur la résolution de ce problème sur un dataset de cette taille.

Enfin, on peut appliquer notre algorithme de comparaison naïf sur chaque bucket, individuellement.

Schéma montrant les enregistrements répartis en 4 buckets, chacun traité séparément par l'algorithme de comparaison.

Grouper les enregistrements selon des règles

L'approche optimisée peut tourner en quelques heures seulement, au lieu de prendre des années.

De cette manière, on réduit drastiquement le temps d'exécution tout en obtenant une excellente précision de dédoublonnage.

Plutôt cool, non ?

Bien sûr, il faudra analyser les données en profondeur pour définir ces règles de segmentation.

Mais qu'est-ce qui est le plus malin :

  • Utiliser l'approche naïve, qui prend trois ans à tourner, OU,

  • Passer un peu de temps à analyser les données, concevoir des règles, et exécuter le dédoublonnage en quelques heures ?

👉 À toi de jouer : peux-tu encore optimiser cette approche ?

Envie d'aller plus loin ? DataXp t'attend : formations et parcours pour progresser en data science, machine learning et IA.

Commentaires

Avatar

ou participer

À lire ensuite

Des shots dans la même veine, à lire entre deux tâches.

Voir tous les shots
caret-right