Les notebooks : notre laboratoire de data science

Le dataset UCI Heart Disease : un cas d’étude réaliste

Les données sales : la réalité du terrain

• Les valeurs manquantes représentent le problème numéro un. Un capteur qui déconne, un formulaire pas entièrement rempli, une base de données corrompue… Les trous dans les données sont partout. Parfois c’est 5% des valeurs, parfois c’est 40%.
• Les doublons polluent les datasets, surtout quand plusieurs sources alimentent la même base. Un patient qui consulte deux fois le même mois peut se retrouver enregistré en double avec des infos légèrement différentes. Dans notre cas, certains patients peuvent apparaître plusieurs fois avec des mesures prises à des moments différents.
• Les erreurs de saisie créent des aberrations : des âges négatifs, des tensions artérielles à 500, des codes pays fantaisistes. Ces outliers extrêmes peuvent complètement biaiser tes modèles.
• Les formats incohérents compliquent l’analyse. Les dates en DD/MM/YYYY et MM/DD/YYYY dans le même fichier, les noms en majuscules et minuscules mélangées, les unités de mesure différentes selon les colonnes.

ydata_profiling : l’outil qui révèle tout

import pandas as pd
from ydata_profiling import ProfileReport


# Charger les données
df = pd.read_csv('/mnt/ch1/heart_disease.csv')

# Générer le rapport d'exploration dans le notebook
profile = ProfileReport(df, title="UCI Heart Disease - Exploration")
profile.to_notebook_iframe()

• La section “Variables” montre des histogrammes pour les variables numériques et des graphiques en barres pour les catégorielles.
• La partie “Interactions” révèle les corrélations entre variables. C’est là qu’apparaît la fameuse matrice de corrélation, ce tableau qui montre comment chaque variable influence les autres. Les corrélations fortes (proches de 1 ou -1) indiquent des relations linéaires, tandis que les valeurs proches de 0 suggèrent une indépendance.

Seaborn et matplotlib : nos outils de visualisation sur mesure

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

def plot_histogram(df, column, title=None):
    """Histogramme simple avec seaborn"""
    plt.figure(figsize=(8, 5))
    if isinstance(column, list):
        for col in column:
            sns.histplot(df[col], alpha=0.6, label=col)
        plt.legend()
    else:
        sns.histplot(df[column])
    plt.title(title or f'Distribution')
    plt.show()


def plot_scatter(df, x, y, hue=None):
    """Scatter plot avec régression"""
    plt.figure(figsize=(8, 6))
    sns.scatterplot(data=df, x=x, y=y, hue=hue)
    sns.regplot(data=df, x=x, y=y, scatter=False, color='red')
    plt.show()


def plot_boxplot(df, column, by=None):
    """Boxplot simple ou groupé"""
    plt.figure(figsize=(10, 6))
    data = df[column] if not isinstance(column, list) else df[column].melt()
    
    if isinstance(column, list):
        sns.boxplot(data=data, x='variable', y='value', hue=by)
    else:
        sns.boxplot(data=df, x=by, y=column) if by else sns.boxplot(data=df, y=column)
    
    plt.tight_layout()
    plt.show()


def plot_barplot(df, column):
    """Graphique en barres"""
    plt.figure(figsize=(10, 6))
    if isinstance(column, list):
        fig, axes = plt.subplots(1, len(column), figsize=(5*len(column), 6))
        for i, col in enumerate(column):
            df[col].value_counts().plot(kind='barh', ax=axes[i] if len(column)>1 else axes)
    else:
        df[column].value_counts().plot(kind='barh')
    plt.tight_layout()
    plt.show()


def plot_correlation(df):
    """Matrice de corrélation"""
    plt.figure(figsize=(10, 8))
    sns.heatmap(df.select_dtypes(include=[np.number]).corr(), annot=True, cmap='RdBu_r')
    plt.show()

# Exemples d'utilisation
plot_histogram(df, 'age')                    # Distribution d'une variable
plot_histogram(df, ['age', 'trestbps'])      # Comparer deux distributions
plot_scatter(df, 'age', 'chol', hue='sex')   # Relation avec couleur par sexe
plot_boxplot(df, 'trestbps', by='cp')        # Tension par type de douleur
plot_correlation(df)                         # Matrice complète

Poser les bonnes questions : analyser les patterns

• Le sexe influence-t-il la sévérité des maladies cardiaques ? Cette question nous amène à comparer les distributions de la sévérité de la maladie entre hommes et femmes. On peut s’attendre à des différences, car les maladies cardiaques affectent différemment les deux sexes.
• Comment l’âge se relate-t-il à la sévérité de la maladie ? L’intuition suggère que l’âge et les problèmes cardiaques sont liés, mais quelle est la nature exacte de cette relation ? Linéaire ? Exponentielle ? Y a-t-il des seuils d’âge critiques ?
• Existe-t-il des profils de patients à risque ? En croisant plusieurs variables (âge, sexe, cholestérol, tension), peut-on identifier des combinaisons particulièrement dangereuses ?

Graphiques usuels : raconter l’histoire des données

Le raffinement : transformer les données brutes en or

Étape 1 : La déduplication – éliminer les doublons

# D'abord, regardons la taille de notre dataset
print(f"Taille originale du dataset : {df.shape}")
print(f"Nombre de lignes : {df.shape[0]}")
print(f"Nombre de colonnes : {df.shape[1]}")

# Chercher les doublons parfaits (toutes les colonnes identiques)
doublons_parfaits = df.duplicated()
print(f"Nombre de doublons parfaits : {doublons_parfaits.sum()}")

if doublons_parfaits.sum() > 0:
    print("Exemples de lignes dupliquées :")
    print(df[doublons_parfaits].head())

# Supprimer les doublons parfaits
df_sans_doublons = df.drop_duplicates()
print(f"Après suppression des doublons : {df_sans_doublons.shape[0]} lignes")

Étape 2 : Traiter les valeurs manquantes avec isnull()

# Identifier toutes les valeurs manquantes
valeurs_manquantes = df_sans_doublons.isnull().sum()
print("Valeurs manquantes par colonne :")
print(valeurs_manquantes)

# Voir le pourcentage de valeurs manquantes
pourcentage_manquant = (df_sans_doublons.isnull().sum() / len(df_sans_doublons)) * 100
print("\nPourcentage de valeurs manquantes :")
for col, pct in pourcentage_manquant.items():
    if pct > 0:
        print(f"{col}: {pct:.1f}%")

Pour les variables numériques, on peut remplacer les valeurs manquantes par la moyenne (si les données suivent une distribution normale) ou la médiane (plus robuste aux outliers).

# Remplacer les valeurs manquantes numériques par la médiane
df_propre = df_sans_doublons.copy()




# Exemple avec la colonne cholestérol si elle a des valeurs manquantes
if 'chol' in df_propre.columns and df_propre['chol'].isnull().sum() > 0:
    mediane_chol = df_propre['chol'].median()
    df_propre['chol'].fillna(mediane_chol, inplace=True)
    print(f"Valeurs manquantes cholestérol remplacées par {mediane_chol}")

Pour les variables catégorielles, on utilise le mode (la valeur la plus fréquente).

# Remplacer les valeurs manquantes catégorielles par le mode
colonnes_categorielles = ['sex', 'cp', 'fbs', 'restecg', 'exang', 'slope', 'thal']


for col in colonnes_categorielles:
    if col in df_propre.columns and df_propre[col].isnull().sum() > 0:
        mode_col = df_propre[col].mode()[0]  # mode() renvoie une série, on prend le premier élément
        df_propre[col].fillna(mode_col, inplace=True)
        print(f"Valeurs manquantes {col} remplacées par {mode_col}")

Étape 3 : Gérer les outliers – les valeurs aberrantes

# Identifier les outliers avec des statistiques descriptives
print("Statistiques des variables numériques :")
print(df_propre.describe())

# Chercher les valeurs suspectes dans la tension artérielle
if 'trestbps' in df_propre.columns:
    tension_stats = df_propre['trestbps'].describe()
    print(f"\nTension artérielle - Min: {tension_stats['min']}, Max: {tension_stats['max']}")
   
    # Valeurs anormalement hautes ou basses
    tension_extreme_haute = df_propre[df_propre['trestbps'] > 250]
    tension_extreme_basse = df_propre[df_propre['trestbps'] < 50]
   
    print(f"Patients avec tension > 250: {len(tension_extreme_haute)}")
    print(f"Patients avec tension < 50: {len(tension_extreme_basse)}")

# Supprimer ou corriger les outliers extrêmes
# Ici on supprime les valeurs impossibles pour la tension
if 'trestbps' in df_propre.columns:
    taille_avant = len(df_propre)
    df_propre = df_propre[(df_propre['trestbps'] >= 50) & (df_propre['trestbps'] <= 250)]
    taille_apres = len(df_propre)
    print(f"Outliers supprimés: {taille_avant - taille_apres} lignes")

# Même traitement pour d'autres variables si nécessaire
if 'chol' in df_propre.columns:
    # Cholestérol négatif = impossible
    df_propre = df_propre[df_propre['chol'] >= 0]

Étape 4 : Convertir les types de données

# Convertir les variables catégorielles
colonnes_categorielles = ['sex', 'cp', 'fbs', 'restecg', 'exang', 'slope', 'thal']


for col in colonnes_categorielles:
    if col in df_propre.columns:
        df_propre[col] = df_propre[col].astype('category')
        print(f"{col} converti en type category")

# Vérifier les types finaux
print("\nTypes de données après nettoyage :")
print(df_propre.dtypes)

L’impact sur la performance des modèles

Résumé: de l’exploration au dataset propre

Exercice pratique : nettoyage du dataset Titanic

1. Exploration initiale
   1. Génère un rapport ydata_profiling du dataset brut
   2. Identifie les colonnes avec des valeurs manquantes
   3. Repère les variables qui semblent avoir des outliers
   4. Pose-toi des questions analytiques : “L’âge influence-t-il la survie ?”, “Les femmes survivent-elles plus que les hommes ?”, “La classe du billet impact-il la survie ?”
2. Déduplication
   1. Recherche les doublons parfaits avec `duplicated()`
   2. Attention : certains passagers peuvent avoir le même nom (famille) mais être des personnes différentes
   3. Utilise plusieurs colonnes pour identifier les vrais doublons (nom + âge + classe par exemple)
3. Traitement des valeurs manquantes
   1. Variable `Age` : utilise la médiane (plus robuste que la moyenne)
   2. Variable `Embarked` (port d’embarquement) : utilise le mode
   3. Variable `Cabin` : cette colonne a énormément de valeurs manquantes, réfléchis si tu la gardes ou la supprimes
4. Gestion des outliers
   1. Variable `Fare` (prix du billet) : certains prix sont anormalement élevés ou bas
   2. Variable `Age` : vérifie s’il y a des âges impossibles (négatifs, > 150 ans)