utils/eda_utils.py

"""eda_utils.py
Ce module contient des fonctions utilitaires pour l'analyse exploratoire des données (EDA) et l'analyse en composantes principales (PCA).
Les fonctions incluent :
- check_duplicates : vérifie les doublons dans un dataframe
- check_missing_values : vérifie les valeurs manquantes dans un dataframe
- summarize_dataframe : résume les caractéristiques d'un dataframe
- run_pca : effectue une analyse en composantes principales (PCA) sur les données fournies
"""

import pandas as pd
from IPython.display import display
import numpy as np

def check_duplicates(df,list_col=None):
    """
    Vérifie les doublons dans un dataframe en fonction d'une liste de colonnes
    args:
    df: dataframe à vérifier
    list_col: liste des colonnes à utiliser pour vérifier les doublons

    si pas de list_col, la fonction vérifie les doublons sur toutes les colonnes du dataframe
    la fonction affiche le nombre de doublons.
    la fonction retourne un dataframe contenant les doublons.

    return: dataframe contenant les doublons
    """
    try:
        import pandas as pd
        if list_col is None:
            list_col = df.columns.tolist()
        duplicate_rows = df[df.duplicated(subset=list_col, keep=False)]
        print(f"Nombre de doublons : {duplicate_rows.shape[0]}")
        return duplicate_rows
    except ImportError as e:
        print("Erreur d'importation : ", e)
        return None

def check_missing_values(df, list_col=None, group_by=None):
    """ Vérifie les valeurs manquantes dans un dataframe
    args:
    df: dataframe à vérifier
    optionnel: list_col: liste des colonnes à utiliser pour vérifier les valeurs manquantes
    optionnel: regrouper les valeurs manquantes par une ou plusieurs colonnes (ex: par année, par pays, etc.)
    la fonction affiche le taux de valeurs manquantes pour chaque colonne du dataframe
    return: dataframe contenant le taux de valeurs manquantes pour chaque colonne du dataframe
    """
    try:
            if list_col is None:
                list_col = df.columns.tolist()

            if isinstance(list_col, str):
                list_col = [list_col]

            missing_values = df[list_col].isna().sum()
            missing_values_percentage = (missing_values / len(df) * 100).round(2)

            missing_values_df = pd.DataFrame({
                "column": missing_values.index,
                "missing_values": missing_values.values,
                "missing_values_percentage": missing_values_percentage.values
            })

            if group_by is not None:
                grouped_missing = (
                    df.groupby(group_by, as_index=False)[list_col]
                    .apply(lambda x: x.isna().mean() * 100)
                    .round(2)
                    .reset_index()
                )
                display(grouped_missing)
                return grouped_missing
            else:
                display(missing_values_df)
                return missing_values_df

    except Exception as e:
        print("Erreur lors de l'analyse des valeurs manquantes :", e)




def summarize_dataframe(df):
    """ Résume les caractéristiques d'un dataframe
    args:
    df: dataframe à résumer
    la fonction affiche :
    - les 5 premières et dernières lignes du dataframe
    - le nombre de lignes et de colonnes du dataframe
    - les infos du dataframe (types de données, valeurs manquantes, etc.)
    - les statistiques descriptives du dataframe (moyenne, écart-type, etc.) pour les colonnes numériques
    - les statistiques descriptives du dataframe (moyenne, écart-type, etc.) pour les colonnes objects
    """
    try:
        print("5 premières lignes du dataframe :")
        display(df.head())
        print(f"\nNombre de lignes : {df.shape[0]}, Nombre de colonnes : {df.shape[1]}")
        print("\nInfos du dataframe :")
        display(df.info())
        print("\nStatistiques descriptives pour les colonnes numériques :")
        display(df.describe())
        print("\nStatistiques descriptives pour les colonnes objects :")
        display(df.describe(include=['object']))
    except Exception as e:
        print("Erreur lors de la summarisation du dataframe : ", e)


from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

def run_pca(df, features):
    """
    Effectue une analyse en composantes principales (PCA) sur les données fournies.
    Args:
        df (pd.DataFrame): Le DataFrame contenant les données à analyser.
        features (list): Liste des noms de colonnes à utiliser pour la PCA.
    Returns:
        explained_var (np.array): Pourcentage de variance expliquée par chaque composante principale.
        cumulative_var (np.array): Variance cumulée expliquée par les composantes principales.
        X_pca (np.array): Les données transformées dans l'espace des composantes principales.
        pca (PCA object): L'objet PCA ajusté, contenant les composantes et les valeurs propres.
    """
    try:
        X = df[features]
        X_scaled = StandardScaler().fit_transform(X)
        
        pca = PCA()
        X_pca = pca.fit_transform(X_scaled)
        
        explained_var = pca.explained_variance_ratio_ * 100
        cumulative_var = np.cumsum(explained_var)
        print("PCA effectuée avec succès.")
    except Exception as e:
        print(f"Erreur lors de l'exécution de la PCA : {e}")
        explained_var, cumulative_var, X_pca, pca = None, None, None, None
    
    return explained_var, cumulative_var, X_pca, pca