Comment utiliser l’IA pour nettoyer et transformer des données en Python

L’IA permet de nettoyer et transformer des données en Python plus rapidement, notamment avec pandas, scikit-learn et des modèles de langage capables d’analyser des colonnes, de suggérer des corrections et de générer des traitements. Ce guide explique comment utiliser l’IA pour détecter les erreurs, gérer les valeurs manquantes, normaliser les formats, traiter les textes et valider automatiquement les résultats.

Pourquoi utiliser l’IA pour nettoyer des données en Python ?

Le nettoyage des données représente souvent une part importante d’un projet d’analyse ou de machine learning. Un fichier CSV peut contenir des dates dans plusieurs formats, des doublons, des valeurs manquantes, des fautes de frappe ou des unités incohérentes.

L’IA peut accélérer plusieurs tâches :

• identifier les colonnes mal nommées ou mal typées ;
• repérer les valeurs aberrantes ;
• suggérer une stratégie pour les données manquantes ;
• convertir des formats hétérogènes ;
• normaliser des catégories textuelles ;
• détecter les doublons proches mais non identiques ;
• générer du code pandas ;
• expliquer les erreurs rencontrées dans un pipeline ;
• proposer des règles de validation.

L’IA ne remplace toutefois pas la vérification humaine. Une correction statistiquement probable peut être fausse sur le plan métier. Par exemple, une valeur de température négative peut être normale dans un pays donné, tandis qu’un prix négatif est généralement suspect.

Quel rôle l’IA peut-elle jouer dans un pipeline de données ?

Un pipeline de nettoyage efficace sépare généralement cinq étapes :

1. Exploration : comprendre la structure et le contenu du jeu de données.
2. Détection : repérer les erreurs, valeurs atypiques et incohérences.
3. Transformation : appliquer les corrections nécessaires.
4. Validation : vérifier que les résultats respectent les règles attendues.
5. Traçabilité : conserver les règles et les modifications effectuées.

L’IA intervient surtout dans l’exploration, la détection et la génération de transformations. Python reste indispensable pour appliquer les opérations de manière reproductible.

Les principales approches d’IA

Les modèles de langage

Les modèles de langage peuvent analyser un échantillon de données ou une description de colonnes et suggérer :

• des opérations pandas ;
• des expressions régulières ;
• des règles de conversion ;
• des contrôles qualité ;
• une structure de pipeline.

Ils sont particulièrement utiles pour les colonnes textuelles et les erreurs difficiles à formaliser.

Le machine learning classique

Des algorithmes peuvent détecter automatiquement des anomalies ou regrouper des valeurs similaires :

• `IsolationForest` pour identifier des observations atypiques ;
• `LocalOutlierFactor` pour repérer des anomalies locales ;
• `KMeans` ou d’autres méthodes de clustering pour explorer des groupes ;
• `TfidfVectorizer` et des modèles de classification pour catégoriser des textes ;
• des modèles d’imputation pour estimer certaines valeurs manquantes.

Les bibliothèques d’aide au nettoyage

L’écosystème Python fournit plusieurs outils utiles :

• pandas pour manipuler les tableaux ;
• NumPy pour les calculs numériques ;
• scikit-learn pour les transformations et l’imputation ;
• pyjanitor pour simplifier les opérations de nettoyage ;
• Great Expectations ou Pandera pour contrôler la qualité des données ;
• RapidFuzz pour comparer des chaînes proches ;
• OpenAI, Mistral, Anthropic ou d’autres API pour les tâches de langage, selon les exigences de confidentialité.

Préparer l’environnement Python

Avant d’utiliser l’IA, il faut disposer d’un environnement isolé et reproductible. Python 3.10 ou une version plus récente convient à la plupart des projets modernes.

Les dépendances courantes peuvent être installées avec la commande `pip install pandas numpy scikit-learn openpyxl rapidfuzz pandera`. Pour les fichiers Excel, `openpyxl` est généralement nécessaire. Pour les formats Parquet, le paquet `pyarrow` peut être ajouté.

Une structure simple peut contenir :

• `data/raw/` pour les fichiers originaux ;
• `data/processed/` pour les données nettoyées ;
• `notebooks/` pour l’exploration ;
• `src/` pour le code réutilisable ;
• `reports/` pour les rapports qualité ;
• `requirements.txt` ou `pyproject.toml` pour les dépendances.

Le fichier original doit rester intact. Les corrections doivent être écrites dans une nouvelle version afin de pouvoir comparer les résultats et revenir en arrière.

Étape 1 : explorer les données avant toute correction

L’IA donne de meilleurs résultats lorsqu’elle reçoit un contexte clair. Il faut donc commencer par examiner la structure du fichier avec pandas.

Les commandes essentielles sont :

• `df.shape` pour connaître le nombre de lignes et de colonnes ;
• `df.head()` pour visualiser les premières lignes ;
• `df.info()` pour observer les types et les valeurs non nulles ;
• `df.describe(include="all")` pour obtenir des statistiques générales ;
• `df.isna().sum()` pour compter les valeurs manquantes ;
• `df.nunique()` pour connaître le nombre de valeurs distinctes ;
• `df.duplicated().sum()` pour compter les doublons exacts.

Une première analyse assistée par IA peut s’appuyer sur un résumé plutôt que sur les données complètes. Il est préférable d’envoyer :

• le nom des colonnes ;
• les types détectés ;
• quelques lignes anonymisées ;
• les statistiques principales ;
• les contraintes métier connues.

Un prompt efficace peut être formulé ainsi :

Analyse ce schéma de données. Pour chaque colonne, indique le type attendu, les problèmes possibles, les valeurs manquantes à surveiller, les transformations recommandées et les contrôles à ajouter. Ne modifie aucune donnée et signale les hypothèses.

Cette méthode limite le risque d’exposer des informations personnelles ou confidentielles.

Étape 2 : utiliser l’IA pour détecter les problèmes de qualité

Détecter les valeurs manquantes

Une cellule vide peut être représentée par `NaN`, une chaîne vide, `"N/A"`, `"inconnu"`, `"null"` ou une valeur comme `-1`. Avant de calculer les taux de valeurs manquantes, ces représentations doivent être harmonisées.

Par exemple, `df.replace(["", "N/A", "NA", "null", "inconnu"], np.nan)` permet de convertir plusieurs marqueurs en valeurs manquantes.

L’IA peut suggérer une stratégie, mais la décision dépend du contexte :

• supprimer une ligne si une colonne essentielle est absente ;
• remplacer une valeur numérique par la médiane ;
• utiliser la moyenne si la distribution est stable ;
• utiliser la modalité la plus fréquente pour une catégorie ;
• créer une catégorie `"Inconnu"` ;
• utiliser une imputation fondée sur d’autres variables ;
• conserver l’absence comme une information à part entière.

La suppression automatique des lignes est risquée. Elle peut modifier la représentativité de l’échantillon et introduire un biais.

Repérer les doublons

Il existe deux types de doublons :

• les doublons exacts, détectables avec `df.duplicated()` ;
• les doublons approximatifs, où les noms ou adresses présentent de petites différences.

Pour rapprocher des chaînes comme `"Société Dupont"` et `"Societe Dupont"`, la bibliothèque `RapidFuzz` peut calculer une similarité. L’IA peut ensuite proposer des règles de regroupement, mais un seuil automatique doit être validé.

Une bonne pratique consiste à définir une clé métier :

• identifiant client ;
• adresse e-mail ;
• combinaison nom-date ;
• numéro de commande ;
• référence produit.

Deux lignes très similaires ne doivent pas être fusionnées si elles correspondent à deux transactions différentes.

Détecter les valeurs aberrantes

Une valeur aberrante n’est pas nécessairement une erreur. Elle peut correspondre à un événement rare mais réel.

Les méthodes courantes sont :

• règle de l’écart interquartile ;
• score Z ;
• `IsolationForest` ;
• comparaison à des seuils métier ;
• analyse de séries temporelles ;
• regroupement par catégorie ou par région.

Avec `IsolationForest`, l’algorithme peut identifier des observations inhabituelles dans plusieurs variables numériques. Le résultat doit être interprété comme un signal à examiner, et non comme une preuve d’erreur.

Un prompt utile peut demander :

Décris les valeurs potentiellement aberrantes à partir de ces statistiques. Sépare les anomalies statistiques des violations de règles métier et propose un contrôle Python pour chaque cas.

Étape 3 : normaliser les types et les formats

Les erreurs de type sont fréquentes dans les fichiers importés depuis Excel ou des applications métier.

Convertir les nombres

Une colonne de prix peut contenir :

• `12,50 €` ;
• `12.50` ;
• `1 250,00` ;
• `N/A`.

Avant conversion, il faut retirer les symboles monétaires et harmoniser les séparateurs. La fonction `pd.to_numeric(..., errors="coerce")` permet de convertir les valeurs invalides en valeurs manquantes.

L’IA peut générer une expression de nettoyage, mais celle-ci doit être testée sur des exemples représentatifs. Une confusion entre virgule décimale et séparateur de milliers peut multiplier ou diviser les montants par 100.

Convertir les dates

Les dates peuvent être écrites sous plusieurs formes :

• `31/12/2024` ;
• `2024-12-31` ;
• `12/31/2024` ;
• `31 décembre 2024`.

La fonction `pd.to_datetime` facilite la conversion, mais le paramètre `dayfirst=True` doit être utilisé avec prudence. Une date ambiguë comme `03/04/2024` peut désigner le 3 avril ou le 4 mars.

Pour chaque colonne de date, il faut contrôler :

• la période couverte ;
• les dates futures inattendues ;
• les dates antérieures à la création de l’entreprise ;
• la cohérence entre date de début et date de fin.

Normaliser les catégories

Une même catégorie peut apparaître sous plusieurs formes : `"France"`, `"france"`, `"FR"` ou `"Fr."`.

Une stratégie fiable consiste à :

1. supprimer les espaces inutiles avec `str.strip()` ;
2. harmoniser la casse avec `str.lower()` ou `str.upper()` ;
3. supprimer les accents si le contexte le justifie ;
4. utiliser un dictionnaire de correspondance ;
5. contrôler les valeurs non reconnues.

L’IA peut proposer ce dictionnaire à partir d’une liste de valeurs distinctes. Chaque correspondance doit cependant être vérifiée, notamment pour les noms de villes, de produits et de clients.

Étape 4 : transformer les données avec pandas

Après la détection, les transformations doivent être explicites et reproductibles.

Renommer les colonnes

Des noms standardisés simplifient les traitements. Une convention courante utilise des noms en minuscules séparés par des underscores : `date_commande`, `prix_unitaire`, `id_client`.

L’IA peut générer une fonction de normalisation des noms, mais il faut vérifier les collisions. Les colonnes `"Code client"` et `"code_client"` pourraient produire le même nom final.

Créer des variables dérivées

Python peut calculer de nouvelles colonnes :

• montant total ;
• durée entre deux dates ;
• tranche d’âge ;
• taux de conversion ;
• marge ;
• indicateur de retard.

Par exemple, `df["montant_total"] = df["quantite"] * df["prix_unitaire"]` crée un montant à partir de deux colonnes. Une règle métier doit préciser le traitement des quantités nulles, négatives ou non numériques.

Transformer les textes avec l’IA

Les modèles de langage sont adaptés aux tâches suivantes :

• classer des commentaires ;
• extraire une ville ou une entreprise ;
• détecter la langue ;
• résumer des tickets ;
• attribuer une catégorie ;
• repérer un sentiment ;
• extraire des informations dans des descriptions libres.

Une méthode robuste consiste à demander une sortie structurée avec des champs précis, par exemple `categorie`, `priorite` et `justification`. La réponse doit ensuite être validée avant son intégration dans pandas.

Pour les gros volumes, l’envoi ligne par ligne à une API peut coûter cher et ralentir le traitement. Il est préférable de :

• dédupliquer les textes avant analyse ;
• traiter les données par lots ;
• mettre en cache les résultats ;
• définir une liste fermée de catégories ;
• utiliser un modèle local si les données sont sensibles ;
• prévoir une gestion des erreurs et des nouvelles tentatives.

Étape 5 : détecter les anomalies avec scikit-learn

Pour les colonnes numériques, un modèle d’anomalie peut compléter les règles classiques.

Le principe général est le suivant :

1. sélectionner les variables pertinentes ;
2. traiter les valeurs manquantes ;
3. standardiser les échelles si nécessaire ;
4. entraîner le modèle sur les données disponibles ;
5. ajouter un indicateur d’anomalie ;
6. examiner les observations signalées.

Avec `IsolationForest`, la variable `contamination` estime la proportion attendue d’anomalies. Ce paramètre ne doit pas être choisi au hasard : une valeur trop élevée marquera trop de lignes, tandis qu’une valeur trop basse laissera passer des erreurs.

Pour les variables catégorielles, une conversion directe en nombres peut créer une fausse hiérarchie. Il est préférable d’utiliser un encodage adapté, comme `OneHotEncoder`, ou une méthode fondée sur les fréquences.

Étape 6 : faire valider le résultat par des règles automatiques

L’IA peut suggérer des corrections, mais les règles de validation garantissent la qualité finale.

Avec Pandera, il est possible de vérifier :

• le type d’une colonne ;
• l’absence de valeurs nulles ;
• une plage numérique ;
• une expression régulière ;
• l’unicité d’un identifiant ;
• une relation entre plusieurs colonnes.

Exemples de contrôles utiles :

• `prix_unitaire >= 0` ;
• `quantite` entier et supérieur ou égal à zéro ;
• `date_fin >= date_debut` ;
• `email` conforme à un format attendu ;
• `id_client` unique lorsque cela est requis ;
• nombre de lignes final proche du nombre attendu ;
• aucune nouvelle valeur imprévue dans une catégorie.

Un rapport qualité devrait contenir :

• le nombre de lignes avant et après nettoyage ;
• le nombre de doublons supprimés ;
• le taux de valeurs manquantes par colonne ;
• les transformations appliquées ;
• les anomalies détectées ;
• les lignes écartées et leur raison ;
• la date et la version du traitement.

Comment demander du code Python à une IA ?

Une demande vague comme « nettoie ce fichier » produit souvent un code incomplet. Un prompt plus précis doit fournir :

1. le format des données ;
2. la liste des colonnes ;
3. quelques exemples anonymisés ;
4. les types attendus ;
5. les règles métier ;
6. les valeurs à considérer comme manquantes ;
7. le format de sortie souhaité ;
8. l’obligation de commenter les hypothèses.

Exemple de consigne :

Génère un pipeline pandas reproductible pour un fichier CSV de commandes. Convertis les dates au format ISO, transforme les montants en nombres décimaux, signale les doublons selon `id_commande`, conserve les lignes invalides dans un fichier séparé et ajoute des contrôles de validation. Explique chaque hypothèse et ne supprime aucune ligne sans justification.

Il faut demander à l’IA de séparer la détection de la correction. Cette précaution évite qu’une erreur soit modifiée silencieusement.

Confidentialité et sécurité des données

Avant d’envoyer des données à une API d’IA, il faut évaluer leur sensibilité. Les informations personnelles, données de santé, coordonnées bancaires, secrets commerciaux et identifiants internes ne doivent pas être transmis sans cadre juridique et technique approprié.

Les mesures recommandées sont :

• anonymiser les noms, e-mails et numéros de téléphone ;
• remplacer les identifiants par des valeurs fictives ;
• envoyer uniquement un échantillon ;
• vérifier la politique de conservation du fournisseur ;
• utiliser une solution hébergée dans une région compatible avec les obligations applicables ;
• limiter les droits de l’API ;
• journaliser les appels ;
• éviter d’inclure des clés secrètes dans le code ;
• stocker les secrets dans des variables d’environnement.

Le RGPD peut s’appliquer dès qu’un fichier contient des données permettant d’identifier une personne. L’utilisation d’une IA ne supprime pas les obligations relatives à la minimisation, à la sécurité et à la base légale du traitement.

Combien coûte l’utilisation de l’IA pour le nettoyage des données ?

Le coût dépend de la méthode choisie :

• pandas et scikit-learn sont gratuits et exécutés localement ;
• une API de modèle de langage facture généralement selon le volume de texte traité ;
• une solution cloud peut ajouter les coûts de stockage, de calcul et de réseau ;
• un modèle local nécessite davantage de ressources matérielles et de maintenance.

Pour réduire les coûts :

• commencer par des règles Python déterministes ;
• utiliser l’IA uniquement pour les cas ambigus ;
• regrouper les requêtes ;
• réduire la taille des prompts ;
• mémoriser les résultats déjà obtenus ;
• préférer un modèle moins coûteux pour la classification simple ;
• évaluer la qualité sur un échantillon avant de traiter tout le fichier.

Quand ne faut-il pas utiliser l’IA ?

L’IA n’est pas toujours nécessaire. Des règles classiques sont préférables lorsque :

• le format est parfaitement connu ;
• la transformation est déterministe ;
• le volume est très important ;
• les données sont extrêmement sensibles ;
• une exigence réglementaire impose une traçabilité stricte ;
• l’erreur peut entraîner une conséquence financière ou médicale importante ;
• la décision doit être entièrement explicable.

La meilleure approche est souvent hybride : pandas pour les transformations prévisibles, scikit-learn pour les anomalies quantitatives et IA générative pour les textes ou les cas ambigus.

Bonnes pratiques pour un pipeline fiable

Quelques principes améliorent fortement la qualité du projet :

• conserver une copie immuable des données brutes ;
• versionner le code et les règles ;
• utiliser des jeux de tests représentatifs ;
• documenter chaque transformation ;
• comparer les distributions avant et après nettoyage ;
• mesurer le taux de lignes modifiées ;
• ajouter des contrôles dans l’intégration continue ;
• distinguer les erreurs bloquantes des alertes ;
• examiner un échantillon de corrections manuellement ;
• éviter les décisions irréversibles ;
• conserver les valeurs originales dans des colonnes séparées lorsque cela est utile.

Il faut également surveiller le data leakage dans les projets de machine learning. Une imputation, une normalisation ou une transformation doit être ajustée uniquement sur les données d’entraînement, puis appliquée aux données de validation et de test. Les pipelines scikit-learn avec `Pipeline` et `ColumnTransformer` facilitent cette séparation.

Conclusion : les points clés à retenir

L’IA peut accélérer le nettoyage et la transformation des données en Python, mais elle doit être utilisée comme un assistant contrôlable plutôt que comme une autorité automatique.

Les principes essentiels sont les suivants :

• commencer par explorer la structure et la qualité des données ;
• utiliser l’IA pour suggérer des règles, du code et des diagnostics ;
• appliquer les transformations avec pandas ou scikit-learn ;
• traiter séparément les valeurs manquantes, les doublons, les types et les anomalies ;
• valider chaque correction avec des règles métier ;
• protéger les données sensibles avant tout appel à une API ;
• conserver les fichiers originaux et les journaux de transformation ;
• privilégier une approche hybride combinant règles déterministes et IA ;
• tester le résultat sur un échantillon avant le traitement complet.

Un pipeline bien conçu ne se contente pas de produire un fichier « propre ». Il explique ce qui a été modifié, pourquoi la modification a été effectuée et comment vérifier qu’elle est correcte.