Recherche de site Web

7 façons d'améliorer vos compétences en nettoyage de données avec Python

Améliorez le nettoyage de vos données Python en corrigeant les entrées invalides, en convertissant les types, en encodant les variables, en gérant les valeurs aberrantes, en sélectionnant les fonctionnalités, en mettant à l'échelle et en remplissant les valeurs manquantes.

Image de l'auteur

Le nettoyage des données est l'une des parties les plus importantes et les plus longues de tout projet de science des données.

Avec le meilleur algorithme, vous avez toujours besoin de données propres pour obtenir de bons résultats.

Dans cet article, je vais vous donner sept astuces pour améliorer votre jeu de nettoyage de données en Python.

1. Gestion des entrées de données invalides

Les ensembles de données réels contiennent souvent des entrées de données non valides. Pour éviter toute corruption ou valeurs inattendues, celles-ci doivent être corrigées avant toute analyse.

Prédire le prix

Nous utiliserons ce projet des cinq manières suivantes. Haensel AMS a utilisé ce projet de données dans le processus de recrutement pour le poste de data scientist. Ici se trouve le lien vers ce projet.

Candidature

Dans notre ensemble de données, le loc1 La colonne contient des valeurs de chaîne inattendues telles que 'S' et 'T', qui ne devrait pas être présent si loc1 devrait être numérique.

# Check for invalid entries in 'loc1'
df["loc1"].value_counts()

Voici le résultat.

Maintenant, supprimons les lignes qui incluent des valeurs non valides.

# Remove rows with invalid 'loc1' values
df = df[(df["loc1"].str.contains("S") == False) & (df["loc1"].str.contains("T") == False)] 
df.shape

Voici le résultat.

Évaluons le résultat.

  • Avant le nettoyage : le value_counts() la sortie montre que 'S' et 'T' apparaît une fois chacun dans loc1 .
  • Après le nettoyage : la suppression de ces entrées réduit la taille de l'ensemble de données de 10 000 à 9 998 lignes.
  • Impact : l'élimination des entrées non valides garantit que les données erronées ne faussent pas les analyses et les modèles ultérieurs.

2. Conversion appropriée des types de données

Les types de données utilisés doivent être corrects pour que vous puissiez ultérieurement effectuer des opérations spécifiques. La conversion des données dans le type approprié permet de garantir des calculs corrects et d'éviter les erreurs.

Candidature

Le loc1 et loc2 sont initialement de type objet, probablement en raison de zéros non numériques ou de caractères non numériques. Ils doivent être convertis en types numériques pour analyse.

Voici le code.

df["loc2"] = pd.to_numeric(df["loc2"], errors='coerce')
df["loc1"] = pd.to_numeric(df["loc1"], errors='coerce')
df.dropna(inplace = True)
df.shape

Voici le résultat.

Évaluons ce que nous avons fait ici.

  • Après conversion : ils sont convertis en float64 ou int64 types.
  • Perte de données : la taille de l'ensemble de données diminue légèrement (de 9 998 à 9 993 lignes) en raison de la suppression des lignes contenant des valeurs non convertibles.
  • Impact : la conversion des types de données permet des opérations numériques et est essentielle pour la modélisation.

3. Encodage des variables catégorielles

Les modèles d'apprentissage automatique ne peuvent consommer que des entrées numériques. Ainsi, les valeurs catégorielles doivent subir le processus d'encodage, les transformant en une forme numérique, qui préservera leurs informations inhérentes.

Candidature

Le dow (jour du semaine) est catégorique avec des valeurs telles que 'Mon', 'Tue', etc. Vous avez utilisé deux méthodes pour encoder ces données :

  1. One-Hot Encoding : création de colonnes binaires pour chaque catégorie.
  2. Encodage ordinal : mappage des catégories à des valeurs numériques.

Voyons des exemples.

Encodage à chaud

# Create dummy variables
dow_dummies = pd.get_dummies(df['dow'])
df = df.join(dow_dummies).drop('dow', axis=1)
df.head()

Voici le résultat.

Codage ordinal

# Map days of the week to numerical values
days_of_week = {'Mon': 1, 'Tue': 2, 'Wed': 3, 'Thu': 4, 'Fri': 5, 'Sat': 6, 'Sun': 7}
df['dow'] = df['dow'].map(days_of_week)
df.head()

Voici le résultat.

Évaluons le résultat.

  • One-Hot Encoding : ajoute de nouvelles colonnes (Lun, Mar, etc.) avec indicateurs binaires.
  • Codage ordinal : remplace les valeurs dow avec des représentations numériques.
  • Impact : les deux méthodes convertissent les données catégorielles dans un format adapté à la modélisation. L'encodage ponctuel est préférable lorsqu'il n'y a pas d'ordre inhérent, tandis que l'encodage ordinal suppose un ordre.

4. Gestion des valeurs aberrantes

Les valeurs aberrantes peuvent fausser vos analyses statistiques et ruiner vos modèles. L'identification et le contrôle des valeurs aberrantes sont un moyen de contrebalancer cela et d'augmenter la robustesse de vos résultats.

Candidature

Vérifions d'abord les valeurs aberrantes. Voici le c
ode.

from pandas.plotting import scatter_matrix

# Suppress the output of the scatter_matrix function
_ = scatter_matrix(result.iloc[:,0:7], figsize=(12, 8))

Voici le résultat.

Voyons les valeurs de para1

result["para1"].value_counts()

Voici le résultat.

Nous avons identifié que le para1 La colonne a des valeurs extrêmes (par exemple, 337), qui sont des valeurs aberrantes par rapport au reste des données. Filtrons cette colonne.

# Analyze 'para1' value counts
print(result["para1"].value_counts())

# Remove outliers in 'para1'
result = result[result["para1"] < 10]

Voici l'évaluation du résultat.

  • Avant la suppression : para1 a des valeurs jusqu'à 337, alors que la plupart des entrées sont comprises entre 0 et 7.
  • Après suppression : entrées avec para1 >= 10 sont supprimés, réduisant ainsi la taille de l'ensemble de données.
  • Impact : la suppression des valeurs aberrantes les empêche de fausser l'analyse et améliore les performances du modèle.

5. Sélection de fonctionnalités basée sur la corrélation

Seules les fonctionnalités fortement corrélées à la variable cible sont sélectionnées, ce qui peut augmenter la précision du modèle et réduire la complexité.

Candidature

Vous avez calculé la corrélation entre les fonctionnalités et la variable cible prix, en sélectionnant les principales fonctionnalités.

five_best = []
df_5 = pd.DataFrame(result.corr()["price"]).sort_values(by = "price", ascending = False)
df_5 = df_5.drop(df_5.index[0]).head(5)
for i in range(len(df_5)):
    five_best.append(df_5.index[i])
five_best

Voici le résultat.

Voici l'évaluation de ce que nous avons fait.

  • Principales fonctionnalités identifiées : ['para2', 'para4', 'para3', 'para1', ' Vendredi]
  • Impact : utilisation de fonctionnalités présentant une corrélation plus élevée avec le prix peut améliorer la puissance prédictive de vos modèles.

6. Fonctionnalités de mise à l'échelle

La mise à l'échelle garantit que toutes les fonctionnalités contribuent de manière égale au processus de formation du modèle, ce qui est particulièrement important pour les algorithmes sensibles aux échelles de fonctionnalités.

La mise à l'échelle de chaque fonctionnalité et la garantie que toutes les fonctionnalités contribuent de la même manière au modèle sont très importantes dans l'apprentissage automatique, en particulier pour certains algorithmes sensibles aux différentes échelles des fonctionnalités d'entrée.

Candidature

Nous avons appliqué différentes techniques de mise à l'échelle :

  • Mise à l'échelle min-max
  • Mise à l'échelle standard
  • Mise à l'échelle robuste

Alors, regardons leur application.

Exemple de mise à l'échelle standard

from sklearn.preprocessing import StandardScaler

# Separate features and target
X = result.drop('price', axis=1)
y = result['price']

# Apply Standard Scaling
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Évaluons ce que nous avons fait.

  • Performances du modèle : la mise à l'échelle a amélioré les erreurs d'entraînement et de test du modèle.
  • Comparaison : vous avez comparé les performances de différentes méthodes de mise à l'échelle.
  • Impact : une mise à l'échelle appropriée peut conduire à une convergence plus rapide et à une meilleure précision du modèle.

7. Gestion des valeurs manquantes

Les modèles d'apprentissage automatique peuvent devenir bizarres avec des valeurs manquantes. Remplir signifie s'assurer que l'ensemble destiné à la formation est entièrement réalisé.

Création de modèles sur un ensemble de données synthétiques

Ce projet de données a été utilisé lors du recrutement pour les postes en science des données de Capital One. Voici le lien.

Candidature

Vos ensembles de données contiennent des valeurs manquantes dans plusieurs entités. Pour maintenir l'intégrité des données, vous avez choisi de remplir ces valeurs manquantes avec la médiane de chaque entité.

Vérifions d'abord les valeurs manquantes.

# Check missing values in train_data
missing_train = train_data.isna().sum()
print("Missing values in train_data:")
print(missing_train[missing_train > 0])

# Check missing values in test_data
missing_test = test_data.isna().sum()
print("\nMissing values in test_data:")
print(missing_test[missing_test > 0])

Voici le résultat.

Voyons maintenant quel code nous allons utiliser pour nettoyer.

# Filling missing values in train_data with median
for column in train_data.columns:
    median_value = train_data[column].median()
    train_data[column].fillna(median_value, inplace=True)

# Filling missing values in test_data with median
for column in test_data.columns:
    median_value = test_data[column].median()
    test_data[column].fillna(median_value, inplace=True)

Maintenant, vérifions encore une fois. Voici le code.

# Check missing values in train_data
missing_train = train_data.isna().sum()
print("Missing values in train_data:")
print(missing_train[missing_train > 0])

# Check missing values in test_data
missing_test = test_data.isna().sum()
print("\nMissing values in test_data:")
print(missing_test[missing_test > 0])

Voici le résultat.

Évaluons ce que nous avons fait ici.

  • Avant imputation : de nombreuses entités ont des valeurs manquantes dans les deux ensembles de données.
  • Après imputation : toutes les valeurs manquantes sont remplies ; les ensembles de données sont complets.
  • Impact : améliore les performances du modèle en fournissant un ensemble de données complet pour la formation et l'évaluation.

Réflexions finales

Dans cet article, nous avons découvert sept méthodes clés de nettoyage des données qui vous en apprendront davantage sur Python et vous aideront à créer de meilleurs modèles. Consultez également ces Bibliothèques Python pour le nettoyage des données.

L'utilisation de ces méthodes améliorera considérablement votre analyse de données, en particulier sur les projets de données réels. Il vous préparera également au processus de recrutement de data scientists.