Tutoriel - Partie 2 : Explorer et visualiser les données à l’aide de notebooks Microsoft Fabric

Article
11/15/2023

Dans ce tutoriel, vous découvrirez comment effectuer une analyse exploratoire des données (EDA) afin d’examiner les données tout en récapitulant leurs principales caractéristiques à l’aide des techniques de visualisation des données.

Nous utiliserons seaborn, est une bibliothèque de visualisation de données Python qui fournit une interface de haut niveau pour créer des objets visuels sur des DataFrames et des tableaux. Pour plus d’informations sur seaborn, consultez seaborn : visualisation des données statistiques.

Vous utiliserez également Data Wrangler, un outil basé sur un notebook qui vous offre une expérience immersive pour effectuer une analyse exploratoire des données et le nettoyage.

Les principales étapes de ce tutoriel sont :

Lire les données stockées à partir d’une table delta dans le lakehouse.
Convertir un DataFrame Spark en DataFrame Pandas, pris en charge par les bibliothèques de visualisation Python.
Utiliser Data Wrangler pour effectuer le nettoyage et la transformation initiaux des données.
Effectuer une analyse exploratoire des données au moyen de seaborn.

Prérequis

Obtenir un abonnement Microsoft Fabric. Ou, inscrivez-vous pour un essai gratuit de Microsoft Fabric.
Connectez-vous à Microsoft Fabric.
Utilisez le sélecteur d’expérience sur le côté gauche de votre page d’accueil pour passer à l’expérience science des données Synapse.

Il s’agit de la partie 2 sur 5 de la série de tutoriels. Pour suivre ce didacticiel, commencez par les étapes ci-dessous :

Partie 1 : Ingérer des données dans un lakehouse Microsoft Fabric à l’aide d’Apache Spark.

Suivez dans le notebook

2-explore-cleanse-data.ipynb est le notebook qui accompagne ce tutoriel.

Pour ouvrir le notebook accompagnant ce tutoriel, suivez les instructions fournies dans Préparer votre système pour le tutoriel sur la science des données afin d’importer les notebooks dans votre espace de travail.

Si vous préférez copier et coller le code de cette page, vous pouvez créer un nouveau notebook.

Assurez-vous d’attacher un lakehouse au notebook avant de commencer à exécuter du code.

Important

Attachez le même lakehouse que celui que vous avez utilisé dans la partie 1.

Lire des données brutes à partir du lakehouse

Lisez les données brutes de la section Fichiers du lakehouse. Vous avez chargé ces données dans le notebook précédent. Assurez-vous que vous avez attaché le même lakehouse que celui utilisé dans la partie 1 à ce notebook avant d’exécuter ce code.

df = (
    spark.read.option("header", True)
    .option("inferSchema", True)
    .csv("Files/churn/raw/churn.csv")
    .cache()
)

Créer un DataFrame Pandas à partir du jeu de données

Convertissez le DataFrame Spark en DataFrame Pandas pour faciliter le traitement et la visualisation.

df = df.toPandas()

Afficher les données brutes

Explorez les données brutes avec display, effectuez des statistiques de base et affichez des vues de graphique. Notez que vous devez d’abord importer les bibliothèques requises telles que Numpy, Pnadas Seaborn et Matplotlib pour l’analyse et la visualisation des données.

import seaborn as sns
sns.set_theme(style="whitegrid", palette="tab10", rc = {'figure.figsize':(9,6)})
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
from matplotlib import rc, rcParams
import numpy as np
import pandas as pd
import itertools

display(df, summary=True)

Utiliser Data Wrangler pour effectuer le nettoyage initial des données

Pour explorer et transformer tout DataFrame Pandas de votre notebook, lancez Data Wrangler directement à partir de ce dernier.

Remarque

Data Wrangler ne peut pas être ouvert si le noyau du notebook est occupé. L’exécution de la cellule doit être terminée avant le lancement de Data Wrangler.

Sous l’onglet Données du ruban du notebook, sélectionnez Lancer Data Wrangler. La liste des DataFrames Pandas activés disponibles pour modification s’affiche.
Sélectionnez le DataFrame que vous souhaitez ouvrir dans Data Wrangler. Étant donné que ce notebook ne contient qu’un seul DataFrame, df, sélectionnez df.

Capture d’écran montrant comment lancer le préparateur de données à partir d’un notebook.

Data Wrangler lance et génère une vue d’ensemble descriptive de vos données. La table au milieu affiche chaque colonne de données. Le volet Résumé en regard de la table affiche des informations sur le DataFrame. Lorsque vous sélectionnez une colonne de la table, le résumé est mis à jour avec des informations sur la colonne ainsi sélectionnée. Dans certains cas, les données affichées et résumées sont une vue tronquée de votre DataFrame. Lorsque cela se produit, l’image d’avertissement s’affichera dans le volet Résumé. Survolez cet avertissement à l’aide de la souris pour afficher le texte décrivant la situation.

Chaque opération que vous effectuez peut être appliquée en quelques clics, ce qui met à jour l’affichage des données en temps réel et génère du code que vous pouvez enregistrer dans votre notebook en tant que fonction réutilisable.

Le reste de cette section vous guide tout au long des étapes de nettoyage des données avec Data Wrangler.

Supprimer les valeurs dupliquées

Le volet gauche affiche une liste d’opérations (telles que Rechercher et remplacer, Formater Formules, Données numériques) que vous pouvez effectuer sur le jeu de données.

Développez Rechercher et remplacer, puis sélectionnez Supprimer les lignes en double.
Un volet s’affiche pour vous permettre de sélectionner la liste des colonnes que vous souhaitez comparer afin de définir une ligne en double. Sélectionnez RowNumber et CustomerId.

Le volet central comporte un aperçu des résultats de cette opération. Sous la préversion se trouve le code pour effectuer l’opération. Dans cette instance, les données semblent inchangées. Mais étant donné que vous examinez une vue tronquée, il est judicieux de néanmoins appliquer l’opération.
Sélectionnez Appliquer (à côté ou en bas) pour passer à l’étape suivante.

Supprimer des lignes avec des données manquantes

Utilisez Data Wrangler pour supprimer des lignes avec des données manquantes sur toutes les colonnes.

Sélectionnez Supprimer les valeurs manquantes dans Rechercher et remplacer.
Choisissez Sélectionner tout dans les colonnes cibles.
Sélectionnez Appliquer pour passer à l’étape suivante.

Supprimer des colonnes

Utilisez Data Wrangler pour supprimer les colonnes dont vous n’avez pas besoin.

Développez Schéma, puis sélectionnez Supprimer des colonnes.
Sélectionnez RowNumber, CustomerId et Surname. Ces colonnes apparaissent en rouge dans la préversion, pour indiquer qu’elles sont modifiées par le code (dans ce cas, supprimées.)
Sélectionnez Appliquer pour passer à l’étape suivante.

Ajouter du code au notebook

Chaque fois que vous sélectionnez Appliquer, une nouvelle étape est créée dans le volet Étapes de nettoyage en bas à gauche. En bas du volet, sélectionnez Prévisualiser le code pour toutes les étapes afin d’afficher une combinaison de toutes les étapes distinctes.

Sélectionnez Ajouter du code au notebook en haut à gauche pour fermer Data Wrangler et ajouter automatiquement le code. L’option Ajouter du code au notebook enveloppe le code dans une fonction, puis appelle celle-ci.

Capture d’écran montrant un aperçu du code et où accéder à l’ajout au notebook.

Conseil

Le code généré par Data Wrangler n’est pas appliqué tant que vous n’exécutez pas manuellement la nouvelle cellule.

Si vous n’avez pas utilisé Data Wrangler, vous pouvez plutôt utiliser la cellule de code suivante.

Ce code est similaire au code produit par Data Wrangler, mais ajoute l’argument inplace=True à chacune des étapes générées. En définissant inplace=True, Pandas remplace le DataFrame d’origine au lieu de produire un nouveau DataFrame en tant que sortie.

# Modified version of code generated by Data Wrangler 
# Modification is to add in-place=True to each step

# Define a new function that include all above Data Wrangler operations
def clean_data(df):
    # Drop rows with missing data across all columns
    df.dropna(inplace=True)
    # Drop duplicate rows in columns: 'RowNumber', 'CustomerId'
    df.drop_duplicates(subset=['RowNumber', 'CustomerId'], inplace=True)
    # Drop columns: 'RowNumber', 'CustomerId', 'Surname'
    df.drop(columns=['RowNumber', 'CustomerId', 'Surname'], inplace=True)
    return df

df_clean = clean_data(df.copy())
df_clean.head()

Exploration des données

Affichez des résumés et des visualisations des données nettoyées.

Déterminer les attributs catégoriels, numériques et cibles

Utilisez ce code pour déterminer les attributs catégoriels, numériques et cibles.

# Determine the dependent (target) attribute
dependent_variable_name = "Exited"
print(dependent_variable_name)
# Determine the categorical attributes
categorical_variables = [col for col in df_clean.columns if col in "O"
                        or df_clean[col].nunique() <=5
                        and col not in "Exited"]
print(categorical_variables)
# Determine the numerical attributes
numeric_variables = [col for col in df_clean.columns if df_clean[col].dtype != "object"
                        and df_clean[col].nunique() >5]
print(numeric_variables)

Résumé à cinq nombres

Affichez le résumé en cinq nombres (le score minimum, le premier quartile, la médiane, le troisième quartile, le score maximum) pour les attributs numériques à l’aide de diagrammes en boîte.

df_num_cols = df_clean[numeric_variables]
sns.set(font_scale = 0.7) 
fig, axes = plt.subplots(nrows = 2, ncols = 3, gridspec_kw =  dict(hspace=0.3), figsize = (17,8))
fig.tight_layout()
for ax,col in zip(axes.flatten(), df_num_cols.columns):
    sns.boxplot(x = df_num_cols[col], color='green', ax = ax)
fig.delaxes(axes[1,2])

Le graphique représente les résumés à cinq nombres.

Distribution des clients sortants et non sortants

Affichez la distribution des clients sortants et non sortants entre les attributs catégoriels.

attr_list = ['Geography', 'Gender', 'HasCrCard', 'IsActiveMember', 'NumOfProducts', 'Tenure']
fig, axarr = plt.subplots(2, 3, figsize=(15, 4))
for ind, item in enumerate (attr_list):
    sns.countplot(x = item, hue = 'Exited', data = df_clean, ax = axarr[ind%2][ind//2])
fig.subplots_adjust(hspace=0.7)

Distribution d’attributs numériques

Affichez la distribution de fréquence d’attributs numériques à l’aide de l’histogramme.

columns = df_num_cols.columns[: len(df_num_cols.columns)]
fig = plt.figure()
fig.set_size_inches(18, 8)
length = len(columns)
for i,j in itertools.zip_longest(columns, range(length)):
    plt.subplot((length // 2), 3, j+1)
    plt.subplots_adjust(wspace = 0.2, hspace = 0.5)
    df_num_cols[i].hist(bins = 20, edgecolor = 'black')
    plt.title(i)
plt.show()

Effectuer l’ingénierie de caractéristiques

Effectuez la caractérisation afin de générer de nouveaux attributs en fonction des attributs actuels :

df_clean["NewTenure"] = df_clean["Tenure"]/df_clean["Age"]
df_clean["NewCreditsScore"] = pd.qcut(df_clean['CreditScore'], 6, labels = [1, 2, 3, 4, 5, 6])
df_clean["NewAgeScore"] = pd.qcut(df_clean['Age'], 8, labels = [1, 2, 3, 4, 5, 6, 7, 8])
df_clean["NewBalanceScore"] = pd.qcut(df_clean['Balance'].rank(method="first"), 5, labels = [1, 2, 3, 4, 5])
df_clean["NewEstSalaryScore"] = pd.qcut(df_clean['EstimatedSalary'], 10, labels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

Utiliser Data Wrangler pour effectuer un encodage à chaud

Data Wrangler peut également être utilisé pour effectuer un encodage un parmi n. Pour ce faire, rouvrez Data Wrangler. Cette fois, sélectionnez les données df_clean.

Développez Formules, puis sélectionnez Encodage un parmi n.
Un volet s’affiche pour vous permettre de sélectionner la liste des colonnes sur lesquelles vous souhaitez effectuer l’encodage un parmi n. Sélectionnez Zone géographique et Sexe.

Vous pouvez copier le code généré, fermer Data Wrangler pour revenir au notebook, puis coller le code dans une nouvelle cellule. Vous pouvez également sélectionner Ajouter du code au notebook en haut à gauche pour fermer Data Wrangler et ajouter automatiquement le code.

Si vous n’avez pas utilisé Data Wrangler, vous pouvez plutôt utiliser la cellule de code suivante :

# This is the same code that Data Wrangler will generate
 
import pandas as pd
 
def clean_data(df_clean):
    # One-hot encode columns: 'Geography', 'Gender'
    df_clean = pd.get_dummies(df_clean, columns=['Geography', 'Gender'])
    return df_clean
 
df_clean_1 = clean_data(df_clean.copy())
df_clean_1.head()

Résumé des observations de l’analyse exploratoire des données

La plupart des clients proviennent de la France par rapport à l’Espagne et à l’Allemagne, tandis que l’Espagne a le taux d’attrition le plus faible par rapport à la France et à l’Allemagne.
La plupart des clients ont des cartes de crédit.
Il existe des clients dont le score d’âge et de crédit est supérieur à 60 et inférieur à 400, respectivement, mais ils ne peuvent pas être considérés comme des valeurs hors norme.
Très peu de clients ont plus de deux des produits de la banque.
Les clients qui ne sont pas actifs ont un taux d’attrition plus élevé.
L’ancienneté et le sexe ne semblent pas avoir un impact sur la décision du client de fermer le compte bancaire.

Créer une table delta pour les données nettoyées

Vous utiliserez ces données dans le notebook suivant de cette série.

table_name = "df_clean"
# Create Spark DataFrame from pandas
sparkDF=spark.createDataFrame(df_clean_1) 
sparkDF.write.mode("overwrite").format("delta").save(f"Tables/{table_name}")
print(f"Spark dataframe saved to delta table: {table_name}")

Étape suivante

Entraîner et enregistrer des modèles Machine Learning avec ces données :

Partie 3 : Entraîner et enregistrer des modèles Machine Learning.

Partager via