Travaux pratiques N 1 : Data Preprosessing

Module: Data Mining (LSDM- S5)

College of Computing – Université Mohammed VI Polytechnique
Année universitaire 2024-2025
[email protected]
—————————————————————–

Le prétraitement des données est essentiel en machine learning pour garantir la qualité des données avant de
les utiliser dans des modèles. Dans ces travaux pratiques, nous allons étudier:

1- Traitement des Valeurs Aberrantes: Les valeurs aberrantes peuvent fausser les analyses. Elles peuvent
être supprimées ou ajustées après identification, souvent à l'aide de méthodes graphiques ou statistiques.

2- Traitement des Données Manquantes: Les données manquantes peuvent être imputées (remplacées par
des estimations) ou supprimées, selon la proportion et l’importance des données absentes.

3- Encodage des Variables Catégoriques: Les variables non numériques doivent être converties en
numériques via des méthodes comme le label encoding ou le one-hot encoding.

4- Normalisation et Standardisation: Ces techniques ajustent l’échelle des données pour qu’elles soient
comparables, cruciales pour certains algorithmes sensibles aux écarts d’échelle.

5- Transformation des Features Quantitatifs: Des transformations comme logarithmiques ou polynomiales

peuvent être appliquées pour rendre les relations entre variables plus exploitables par les modèles.

1 / 19
 1- Identi cation_Et_Traitement_Valeurs_Aberrantes

fi
keyboard_arrow_down
Imporation des packages

1 # Import des librairies nécessaires

2 import numpy as np
3 import pandas as pd
4 import matplotlib.pyplot as plt
5 import seaborn as sns
6 from scipy.stats import zscore
7 from sklearn.ensemble import IsolationForest

1 # Charger la base de données Boston Housing

2 from sklearn.datasets import load_boston
3 boston = load_boston()
4 data = pd.DataFrame(boston.data, columns=boston.feature_names)
5 data['PRICE'] = boston.target
6 print(data.head())
7

1 # Desciption de la base de données

2 data.describe()
3

Identi cation graphique des outliers

fi
keyboard_arrow_down
1 # Visualiser les outliers en utilisant un boxplot avec Seaborn
2 plt.figure(figsize=(12, 6))
3 sns.boxplot(data=data, x='PRICE')
4 plt.xlabel('Prix des maisons')
5 plt.title("Boxplot des prix des maisons à Boston")
6 plt.show()

Identi cation des outliers univariées

fi
keyboard_arrow_down
Identi cation des outliers IQR
fi
keyboard_arrow_down
La méthode de l'IQR est une approche courante pour identi er les valeurs aberrantes dans des données univariées. Elle utilise l'écart
fi
interquartile pour dé nir une plage de valeurs plausibles et identi e les observations qui sont en dehors de cette plage.
fi
fi
Dé nition
fi
keyboard_arrow_down
L'IQR est dé ni comme la différence entre le troisième quartile (Q3) et le premier quartile (Q1) de la distribution des données. Les bornes
fi
inférieure et supérieure de la plage plausible sont dé nies comme suit :
fi
Limite inférieure : Q1 - 1,5 x IQR
Limite supérieure : Q3 + 1,5 x IQR

Les observations en dehors de ces bornes sont considérées comme des valeurs aberrantes.

Avantages
La méthode de l'IQR est relativement simple à comprendre et à implémenter. Elle est également assez robuste aux valeurs aberrantes, car elle
utilise la médiane et l'écart interquartile pour calculer les bornes plausibles.

Inconvénients
La méthode de l'IQR peut ne pas fonctionner correctement dans certaines distributions non symétriques, car elle suppose une distribution
normale ou presque normale des données. Elle peut également ne pas fonctionner correctement si les données contiennent de nombreux
points de données aberrants. 2 / 19
 1 # Identification des données aberrantes - IQR
2 # Fonction pour détecter les outliers en utilisant l'IQR
3 def detect_outliers_iqr(data, column):
4 Q1 = data[column].quantile(0.25)
5 Q3 = data[column].quantile(0.75)
6 IQR = Q3 - Q1
7 lower_bound = Q1 - 1.5 * IQR
8 upper_bound = Q3 + 1.5 * IQR
9 return data[(data[column] < lower_bound) | (data[column] > upper_bound)]
10
11 # Trouver les outliers pour la colonne 'PRICE'
12 outliers = detect_outliers_iqr(data, 'PRICE')
13
14 # Afficher les outliers
15 print("Outliers détectés:")
16 print(outliers)

Identi cation des outliers avec Z-score

fi
Méthode du z-score
keyboard_arrow_down
La méthode du z-score est une autre approche courante pour identi er les valeurs aberrantes dans des données univariées. Elle utilise l'écart à
fi
la moyenne pour dé nir une plage de valeurs plausibles et identi e les observations qui sont en dehors de cette plage.
fi
fi
Dé nition
fi
Le z-score est dé ni comme la différence entre une observation et la moyenne de la distribution des données, divisée par l'écart-type de la
fi
distribution :

z = (x - μ) / σ

Les bornes inférieure et supérieure de la plage plausible sont dé nies comme suit :
fi
Limite inférieure : μ - 3 x σ
Limite supérieure : μ + 3 x σ

Les observations en dehors de ces bornes sont considérées comme des valeurs aberrantes.

Avantages
La méthode du z-score est également relativement simple à comprendre et à implémenter. Elle est également assez robuste aux valeurs
aberrantes, car elle utilise la moyenne et l'écart-type pour calculer les bornes plausibles.

Inconvénients
Comme pour la méthode de l'IQR, la méthode du z-score peut ne pas fonctionner correctement dans certaines distributions non symétriques.
Elle peut également ne pas fonctionner correctement si les données contiennent de nombreux points de données aberrants.

1
2 # Identification des données aberrantes - Z-score
3 # Fonction pour détecter les outliers en utilisant le z-score
4 def detect_outliers_zscore(data, column, threshold=2):
5 z_scores = (data[column] - data[column].mean()) / data[column].std()
6 return data[np.abs(z_scores) > threshold]
7
8 # Trouver les outliers pour la colonne 'PRICE'
9 outliers = detect_outliers_zscore(data, 'PRICE')
10
11 # Afficher les outliers
12 print("Outliers détectés:")
13 print(outliers)
14

Identi cation des outliers avec des approches multivariées

fi
keyboard_arrow_down
3 / 19
keyboard_arrow_down
Analyse graphique

1
2 # Détecter les outliers pour les colonnes 'RM' et 'PRICE'
3 outliers_rm = detect_outliers_iqr(data, 'RM')
4 outliers_price = detect_outliers_iqr(data, 'PRICE')
5
6 # Ajouter une colonne pour indiquer si la valeur est extrême
7 data['Outlier'] = False
8 data.loc[outliers_rm.index, 'Outlier'] = True
9 data.loc[outliers_price.index, 'Outlier'] = True
10
11 # Créer un nuage de points (scatter plot) avec Seaborn en mettant en évidence les valeurs ext
12 plt.figure(figsize=(12, 6))
13 sns.scatterplot(data=data, x='RM', y='PRICE', hue='Outlier', palette='viridis')
14 plt.xlabel('Nombre moyen de pièces par logement')
15 plt.ylabel('Prix des maisons')
16 plt.title("Nuage de points entre le nombre de pièces et le prix des maisons à Boston (valeurs
17 plt.show()

Isolation Forest
keyboard_arrow_down
L'Isolation Forest est une méthode d'apprentissage automatique non supervisée pour identi er les valeurs aberrantes dans des données

fi
univariées et multivariées. Elle fonctionne en construisant plusieurs arbres de décision aléatoires et en calculant un score d'anomalie pour
chaque observation en fonction de la profondeur moyenne à laquelle elle est isolée des autres observations.

Dé nition
fi
keyboard_arrow_down
L'Isolation Forest est basée sur l'idée que les valeurs aberrantes sont plus faciles à isoler que les valeurs normales. Elle construit plusieurs
arbres de décision aléatoires et divise les données en sous-ensembles aléatoires à chaque nœud. L'algorithme isole les observations en
fonction de la profondeur moyenne à laquelle elles sont isolées par rapport aux autres observations. Les observations qui sont isolées plus
rapidement que la moyenne sont considérées comme des valeurs aberrantes.

Avantages
L'Isolation Forest est capable de détecter les valeurs aberrantes dans des données univariées et multivariées. Elle fonctionne également bien
avec des distributions non symétriques et est assez robuste aux valeurs aberrantes.

Inconvénients
L'Isolation Forest peut être sensible aux paramètres tels que le nombre d'arbres et la taille des sous-échantillons. De plus, elle peut parfois être
di cile à interpréter, en particulier pour les données multivariées.
ffi
1 from sklearn.ensemble import IsolationForest
2
3 # Appliquer l'Isolation Forest
4 iso_forest = IsolationForest(contamination=0.1, random_state=42)
5 outlier_labels = iso_forest.fit_predict(data)
6
7 # Ajouter les labels d'anomalie au DataFrame
8 data['Outlier'] = outlier_labels
9
10 # Afficher les outliers
11 outliers = data[data['Outlier'] == -1]
12 print("Outliers détectés:")
13 print(outliers)

Solutions pour traiter les valeurs extrêmes

keyboard_arrow_down
Type de valeur aberrante Solutions pour les traiter

Erreur 1. Correction de l'erreur si possible (ex. erreurs de saisie)

2. Suppression de l'observation si la correction n'est pas possible et si l'erreur est clairement une anomalie

4 / 19
3. Remplacer par une valeur manquante et imputer avec les techniques d'imputation
Type de valeur aberrante Solutions pour les traiter

Extrême 1. Transformation des données (ex. logarithmique, racine carrée) pour réduire l'impact des valeurs extrêmes

2. Winsorisation : remplacer les valeurs extrêmes par des percentiles spéci ques (ex. 1er et 99e percentiles)

fi
3. Utiliser des modèles d'apprentissage automatique robustes aux valeurs extrêmes (ex. modèles basés sur les rangs)

4. Discrétiser la variable

5. Faire le modèle avec et sans les valeurs extrêmes et analyser l'impact

1 Commencez à coder ou à générer avec l'IA.

5 / 19
 2- Missing Data Treatment
keyboard_arrow_down
Chargement des données

1 import pandas as pd
2 import numpy as np
3 import missingno as msno
4 import matplotlib.pyplot as plt
5 from sklearn.experimental import enable_iterative_imputer
6 from sklearn.impute import MissingIndicator, KNNImputer,SimpleImputer
7 from sklearn.impute import IterativeImputer
8
9 import seaborn as sns

1
2 # Charger l'ensemble de données Pima Indians Diabetes
3 df = pd.read_csv("horse.csv")
4 df.head(10)

1 print(df.info())

1 # Visualiser les valeurs manquantes avec missingno

2 msno.matrix(df)
3 plt.show()

1 msno.bar(df)
2 plt.show()

1 msno.heatmap(df)
2 plt.show()
3

1 # Tableau des valeurs manquantes par colonne

2 missing_values = df.isnull().sum()
3 missing_percent = (missing_values / len(df)) * 100
4 missing_table = pd.DataFrame({'Missing Values': missing_values, 'Percentage': missing_percent
5 print(missing_table)
6

1 # Analyser la corrélation entre les valeurs manquantes

2 msno.dendrogram(df)
3 plt.show()

Imputation par la médiane, la moyenne et le mode

keyboard_arrow_down
L'imputation par la moyenne, la médiane et le mode sont des méthodes simples pour remplacer les valeurs manquantes dans une variable.

L'imputation par la moyenne consiste à remplacer les valeurs manquantes par la moyenne des valeurs non manquantes dans la variable. Cette
méthode est utile pour les variables continues et symétriques.

L'imputation par la médiane consiste à remplacer les valeurs manquantes par la médiane des valeurs non manquantes dans la variable. Cette
méthode est utile pour les variables continues qui ont une distribution asymétrique ou pour les variables ordinales.

L'imputation par le mode consiste à remplacer les valeurs manquantes par le mode, c'est-à-dire la valeur la plus fréquente, dans la variable.
Cette méthode est utile pour les variables catégorielles ou nominales.

Ces méthodes sont simples à mettre en œuvre et peuvent être e caces lorsque les données manquantes sont MCAR (Missing Completely At
ffi
Random), c'est-à-dire que les valeurs manquantes sont indépendantes des autres variables. Toutefois, elles peuvent introduire un biais dans les
données si les valeurs manquantes sont liées à d'autres variables dans les données.

6 / 19
keyboard_arrow_down
Imputation par la médiane

1 imputer_median = SimpleImputer(strategy='median')
2 df['total_protein_impute'] = imputer_median.fit_transform(df[['total_protein']])
3
4 df.isnull().mean()

1 # Autre méthode
2
3 # Imputation par la médiane pour la colonne 'total_protein'
4 median = df['packed_cell_volume'].median()
5 df['packed_cell_volume_impute']=df['packed_cell_volume'].fillna(median)
6
7 # Vérifier les valeurs manquantes après imputation
8 missing_values_after = df.isnull().mean()
9 print("\nMissing Values After Treatment:\n", missing_values_after)

Imputation par la moyenne

keyboard_arrow_down
1 imputer_mean = SimpleImputer(strategy='mean')
2 df['pulse_imp'] = imputer_mean.fit_transform(df[['pulse']])
3
4 df.isnull().mean()

1 # Autre méthode
2
3 # Imputation par la moyenne pour la colonne 'total_protein'
4 mean = df['total_protein'].mean()
5 df['total_protein_imp']=df['total_protein'].fillna(mean)
6
7 # Vérifier les valeurs manquantes après imputation
8 missing_values_after = df.isnull().mean()
9 print("\nMissing Values After Treatment:\n", missing_values_after)

Imputation par le mode

keyboard_arrow_down
1 # Imputation par le mode
2 imputer_mode = SimpleImputer(strategy='most_frequent')
3 df['peripheral_pulse_imputed'] = imputer_mode.fit_transform(df[['peripheral_pulse']])
4

1 # Vérifier les valeurs manquantes après traitement

2 missing_values = df.isnull().sum()
3 print("\nMissing Values After Treatment:\n", missing_values)

1 # Autre approche
2
3 # imputation par le mode
4 mode = df.surgery.mode()
5 df['surgery_imputed'] = df['surgery'].fillna(mode)
6 df.isnull().mean()
7

KNN imputer
keyboard_arrow_down
L'algorithme KNNImputer de scikit-learn est une méthode d'imputation des valeurs manquantes basée sur les k plus proches voisins. Il s'agit
d'une approche non-paramétrique qui utilise les valeurs des k plus proches voisins pour imputer les valeurs manquantes.

L'algorithme fonctionne en plusieurs étapes :

7 /proches
1. Définir la valeur de k, qui représente le nombre de voisins les plus 19 à considérer pour l'imputation.
 2. Pour chaque valeur manquante, trouver les k plus proches voisins parmi les autres observations qui ont des valeurs non manquantes pour
la variable en question. La distance entre les observations peut être mesurée de différentes manières, telles que la distance euclidienne
ou la distance de Manhattan.

3. Imputer la valeur manquante par la valeur moyenne ou médiane des k voisins les plus proches.

L'algorithme KNNImputer est utile lorsque les données manquantes sont MCAR (Missing Completely At Random) ou MAR (Missing At
Random), c'est-à-dire que les valeurs manquantes ne sont pas liées à la valeur de la variable elle-même. Il peut être utilisé pour imputer des
variables continues ou catégorielles. Toutefois, il peut être plus lent que d'autres méthodes d'imputation telles que la simple imputation ou
l'imputation par la régression.

1 # Imputation par KNN Imputer

2 # KNN imputer avec 3 voisins pour plusieurs colonnes
3 imputer = KNNImputer(n_neighbors=3)
4
5 df[['total_protein_impute_knn', 'rectal_temp_impute_knn', 'pulse_impute_knn']] = imputer.fit_t
6
7 df.isnull().mean()

IterativeImputer
keyboard_arrow_down
L'algorithme IterativeImputer de scikit-learn est une méthode d'imputation des valeurs manquantes basée sur la régression. Il s'agit d'une
approche itérative qui utilise un modèle de régression pour imputer les valeurs manquantes à chaque itération, en utilisant les autres variables
pour prédire la variable manquante.

L'algorithme fonctionne en plusieurs étapes :

1. Imputer les valeurs manquantes initiales par une stratégie simple comme la moyenne, la médiane ou le mode.

2. Ensuite, le modèle de régression est ajusté pour prédire les valeurs manquantes à partir des autres variables. Cette régression peut être
linéaire, non linéaire ou de tout autre type en fonction des données.

3. Les valeurs manquantes sont alors imputées à l'aide du modèle de régression.

4. Les étapes 2 et 3 sont répétées plusieurs fois jusqu'à ce que la convergence soit atteinte. La convergence est déterminée par un critère
d'arrêt défini, tel que le nombre maximal d'itérations ou la convergence de la moyenne des différences entre les imputations consécutives.

L'algorithme IterativeImputer est utile lorsque les données manquantes sont MNAR (Missing Not At Random), c'est-à-dire que les valeurs
manquantes sont liées à la valeur de la variable elle-même. Il peut être utilisé pour imputer des variables continues ou catégorielles. Toutefois,
il peut être plus lent que d'autres méthodes d'imputation telles que la simple imputation.

1 # Créer un imputer IterativeImputer avec une stratégie de 'mean'

2 imputer = IterativeImputer(max_iter=10, random_state=0, sample_posterior=True)
3
4 # Imputer les colonnes 'total_protein', 'rectal_temp' et 'pulse' de la DataFrame df
5 df_imputed = pd.DataFrame(imputer.fit_transform(df[['total_protein', 'rectal_temp', 'pulse']])
6
7 # Concaténer la DataFrame imputée avec la DataFrame originale
8 df = pd.concat([df, df_imputed], axis=1)
9 df.isnull().mean()

8 / 19
 3- Encoding
keyboard_arrow_down
1 import pandas as pd
2 from sklearn.preprocessing import (LabelEncoder, OrdinalEncoder, OneHotEncoder,
3 LabelBinarizer, MultiLabelBinarizer)

Encoding des variables catégorielles

keyboard_arrow_down
Forme d'encodage Dé nition Avantages
fi
Label Encoding Transformation des valeurs catégorielles en entiers Facile à implémenter, adapté aux algorithmes de machine learning Création d'u

One-Hot Encoding Transformation des valeurs catégorielles en vecteurs binaires Ne crée pas de relation d'ordre arti cielle, adapté à de nombreux algorithmes de machine learning Peut créer d

fi
1
2 # Charger un exemple de dataset
3 df = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data",
4 df.columns = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'class']
5 print("Dataset original : ")
6 print(df.head())

Label Encoding
keyboard_arrow_down
Le Label Encoding est une technique de transformation de variables catégorielles en valeurs numériques ordinales. Chaque catégorie possible
de la variable est remplacée par un entier unique, en fonction de l'ordre dans lequel les catégories apparaissent dans la variable.

Avantages
Le Label Encoding présente plusieurs avantages :

Il est simple à mettre en œuvre et ne nécessite pas beaucoup de ressources.

Il préserve l'ordre des catégories si elle est importante pour l'analyse.

Inconvénients
Le Label Encoding présente également quelques inconvénients :

Il crée une relation d'ordre arti cielle entre les catégories.

fi
Il n'est pas adapté à certains algorithmes de machine learning, tels que les réseaux de neurones et les machines à vecteurs de support,
qui peuvent interpréter les valeurs numériques comme des valeurs continues plutôt que des catégories.

Conditions d'utilisation
Le Label Encoding est adapté aux variables catégorielles qui ont une relation d'ordre naturelle et pour lesquelles l'interprétation en termes de
valeurs numériques est pertinente. Cependant, il est important de prendre en compte les avantages, les inconvénients et les conditions
d'utilisation de cette technique pour éviter des erreurs d'interprétation ou des problèmes d'analyse.

En général, le Label Encoding est une technique simple et rapide pour encoder des variables catégorielles en valeurs numériques ordinales,
mais il est important de bien comprendre ses limites et d'utiliser d'autres techniques d'encodage pour des analyses plus avancées ou pour des
algorithmes de machine learning plus complexes.

1 # Label encoding
2 le = LabelEncoder()
3 df['class_le'] = le.fit_transform(df['class'])
4 print("Label encoding : ")
5 print(df[['class', 'class_le']].head())
6 print("Valeurs Unique")
7 print(df.class_le.unique())
8 # Réalisation de la table de contingence
9 table = pd.crosstab(df['class_le'], df['class'])
10 print(table)

One-Hot Encoding
keyboard_arrow_down
9 / 19
 Le One-Hot Encoding est une technique de transformation de variables catégorielles en vecteurs binaires. Chaque catégorie possible de la
variable est représentée par une colonne binaire, et chaque observation est représentée par un vecteur binaire de la même dimension que le
nombre de catégories possibles.

Avantages
Le One-Hot Encoding présente plusieurs avantages :

Il ne crée pas de relation d'ordre arti cielle entre les catégories.

fi
Il est adapté à de nombreux algorithmes de machine learning, tels que les réseaux de neurones, les arbres de décision et les machines à
vecteurs de support.
Il permet de prendre en compte des variables catégorielles avec un grand nombre de catégories.

Inconvénients
Le One-Hot Encoding présente également quelques inconvénients :

Il peut créer des colonnes redondantes si une variable catégorielle a un grand nombre de catégories.
Il peut augmenter considérablement la taille des données si plusieurs variables catégorielles sont encodées de cette manière.

Conditions d'utilisation
Le One-Hot Encoding est adapté aux variables catégorielles qui ne sont pas ordonnées et qui ont un nombre raisonnable de catégories
possibles. Si une variable catégorielle a un grand nombre de catégories, il peut être préférable d'utiliser d'autres techniques d'encodage, telles
que le Target Encoding ou le Binary Encoding.

En général, le One-Hot Encoding est une technique e cace pour encoder des variables catégorielles et les utiliser dans des algorithmes de
ffi
machine learning. Cependant, il est important de prendre en compte les avantages, les inconvénients et les conditions d'utilisation de cette
technique pour éviter des problèmes de dimensionnalité ou des erreurs d'interprétation.

1
2 # One-hot encoding
3 ohe = OneHotEncoder(sparse=False)
4 ohe_result = ohe.fit_transform(df[['class']])
5 df_ohe = pd.DataFrame(ohe_result, columns=ohe.get_feature_names(['class']))
6 print("One-hot encoding : ")
7 print(df_ohe)
8
9
10

Target Encoding
keyboard_arrow_down
Le Target Encoding est une technique de transformation de variables catégorielles en valeurs numériques en fonction de la variable cible.
Chaque catégorie possible de la variable est remplacée par la moyenne, la médiane ou tout autre agrégat de la variable cible pour cette
catégorie.

Avantages
Le Target Encoding présente plusieurs avantages :

Il peut capturer des informations importantes sur la relation entre la variable catégorielle et la variable cible.
Il peut être adapté à des variables catégorielles avec un grand nombre de catégories ou des catégories rares.

Inconvénients
Le Target Encoding présente également quelques inconvénients :

Il peut être sensible aux valeurs aberrantes et aux échantillons de petite taille.
Il peut surajuster les données d'entraînement s'il n'est pas utilisé avec prudence.

Conditions d'utilisation
Le Target Encoding est adapté aux variables catégorielles pour lesquelles la relation avec la variable cible est importante pour l'analyse ou la
prédiction. Il est important de prendre en compte les avantages et les inconvénients de cette technique pour éviter des erreurs d'interprétation
ou des problèmes d'analyse.

En général, le Target Encoding est une technique utile pour encoder des variables catégorielles en valeurs numériques en fonction de la variable
cible, mais il est important de bien comprendre ses limites et d'utiliser d'autres techniques d'encodage pour des analyses plus avancées ou
10 / 19
pour des algorithmes de machine learning plus complexes.

1 Commencez à coder ou à générer avec l'IA.

11 / 19
 4- Normalisation et Standardisation
keyboard_arrow_down
En machine learning, il est souvent nécessaire de normaliser ou de standardiser les données pour améliorer les performances des modèles.
Ces deux techniques permettent de mettre les données à une échelle commune et de faciliter l'apprentissage des algorithmes.

Normalisation

# Ce texte est au format code

MinMax scaler
La normalisation min max consiste à mettre les données à l'échelle entre 0 et 1. Cela se fait en soustrayant la valeur minimale de chaque point
de données et en divisant par la différence entre la valeur maximale et la valeur minimale. La formule mathématique de la normalisation est la
suivante :
𝑥 − 𝑥𝑚𝑖𝑛
𝑥𝑛𝑜𝑟𝑚 =
𝑥𝑚𝑎𝑥 − 𝑥𝑚𝑖𝑛
La normalisation est particulièrement utile lorsque les données ont des écarts importants entre les valeurs, par exemple dans les images ou les
sons.

MaxAbsScaler
Le MaxAbsScaler est une technique de mise à l'échelle qui divise chaque valeur par la valeur absolue maximale de la colonne. La formule
mathématique pour le MaxAbsScaler est la suivante :
𝑥
𝑥𝑠𝑐𝑎𝑙𝑒𝑑 =
|𝑥𝑚𝑎𝑥 |
Le MaxAbsScaler est utile lorsque vous voulez mettre à l'échelle les données sans déformer la distribution des données, en particulier lorsque
les valeurs sont centrées autour de zéro. Par exemple, si vous avez des données qui ont une moyenne de zéro et une plage de valeurs qui va de
-100 à 100, le MaxAbsScaler peut être une bonne option.

Standardisation

Standard Scaler
La standardisation consiste à mettre les données à l'échelle de telle sorte que la moyenne soit égale à zéro et l'écart type égal à 1. Cela se fait
en soustrayant la moyenne de chaque point de données et en divisant par l'écart type. La formule mathématique de la standardisation est la
suivante :
𝑥−𝜇
𝑥𝑠𝑡𝑑 =
𝜎
La standardisation est particulièrement utile lorsque les données sont normalement distribuées.

Robust Scaler
Le RobustScaler est un outil de standardisation qui permet de centrer les données autour de la médiane et de réduire l'effet des valeurs
aberrantes en les ramenant à un certain point. Cela se fait en soustrayant la médiane de chaque point de données et en divisant par l'écart
interquartile (IQR). La formule mathématique de la normalisation est la suivante :
𝑥 − médiane(𝑥)
𝑥𝑟𝑜𝑏𝑢𝑠𝑡 =
IQR(𝑥)
Le RobustScaler est particulièrement utile lorsque les données contiennent des valeurs aberrantes qui pourraient in uencer la moyenne et
fl
l'écart-type dans le cas d'une StandardScaler classique. Il est également résistant aux valeurs aberrantes et peut être utilisé dans les données
qui ne suivent pas une distribution normale.

Comment choisir entre la normalisation et la standardisation

Le choix entre la normalisation et la standardisation dépend des données et du modèle utilisé. En général, la normalisation est utilisée pour les
données qui ont des écarts importants entre les valeurs, tandis que la standardisation est utilisée pour les données qui sont normalement
distribuées.

Il est recommandé de tester les deux méthodes pour voir laquelle fonctionne le mieux pour un modèle donné.
Critère Normalisation

Objectif Mettre les valeurs dans un intervalle borné

Formule (x - min) / (max - min)

Plage de sortie [0, 1]

Sensibilité aux valeurs aberrantes Sensible : les valeurs extrêmes ont un impact sur la plage de sortie

Interprétation
12 / 19
Les valeurs normalisées sont plus facilement interprétables, car elles sont mises à l'échelle d'une plage spéci que
fi
 Critère Normalisation

Utilisation Pour les algorithmes qui requièrent des données sur une plage bornée, tels que les réseaux de neurones et les algorithmes de clustering basés sur la distance

Exemples d'algorithmes MinMaxScaler, MaxAbsScaler

1 import pandas as pd
2 import numpy as np
3 import matplotlib.pyplot as plt
4 from sklearn.datasets import load_iris
5 from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler, MaxAbsScaler

1 # Charger les données Iris

2 iris = load_iris()
3 X = iris.data
4 y = iris.target

1 # Normalisation
2 scaler = MinMaxScaler()
3 X_norm = scaler.fit_transform(X)
4
5
6 # Comparer les distributions avant et après la normalisation et la standardisation
7 fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(12, 8))
8 axs[0, 0].hist(X[:, 0], bins=20)
9 axs[0, 0].set_title('Distribution de la longueur des sépales')
10 axs[0, 1].hist(X_norm[:, 0], bins=20)
11 axs[0, 1].set_title('Distribution normalisée de la longueur des sépales')
12 axs[1, 0].hist(X[:, 1], bins=20)
13 axs[1, 0].set_title('Distribution de la largeur des sépales')
14 axs[1, 1].hist(X_norm[:, 1], bins=20)
15 axs[1, 1].set_title('Distribution normalisée de la largeur des sépales')
16 fig.tight_layout()
17 plt.show()
18
19

1 # Standardisation
2 scaler = StandardScaler()
3 X_std = scaler.fit_transform(X)

1 fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(12, 8))

2 axs[0, 0].hist(X[:, 0], bins=20)
3 axs[0, 0].set_title('Distribution de la longueur des sépales')
4 axs[0, 1].hist(X_std[:, 0], bins=20)
5 axs[0, 1].set_title('Distribution standardisée de la longueur des sépales')
6 axs[1, 0].hist(X[:, 1], bins=20)
7 axs[1, 0].set_title('Distribution de la largeur des sépales')
8 axs[1, 1].hist(X_std[:, 1], bins=20)
9 axs[1, 1].set_title('Distribution standardisée de la largeur des sépales')
10 fig.tight_layout()
11 plt.show()

1 # RobustScaler
2 scaler = RobustScaler()
3 X_robust = scaler.fit_transform(X)
4
5
6 fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(12, 8))
7 axs[0, 0].hist(X[:, 0], bins=20)
8 axs[0, 0].set_title('Distribution de la longueur des sépales')
9 axs[0, 1].hist(X_robust[:, 0], bins=20)
10 axs[0, 1].set_title('Distribution avec RobustScaler de la longueur des sépales')
11 axs[1, 0].hist(X[:, 1], bins=20)
12 axs[1, 0].set_title('Distribution de la largeur des sépales')
13 axs[1, 1].hist(X_robust[:, 1], bins=20)
14 axs[1, 1].set_title('Distribution avec RobustScaler de la largeur des sépales')
15 fig 13 / 19
16

1 # MaxAbsScaler
2 scaler = MaxAbsScaler()
3 X_maxabs = scaler.fit_transform(X)

1 # Comparer les distributions avant et après la normalisation

2 fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(12, 8))
3 axs[0, 0].hist(X[:, 0], bins=20)
4 axs[0, 0].set_title('Distribution de la longueur des sépales')
5 axs[0, 1].hist(X_maxabs[:, 0], bins=20)
6 axs[0, 1].set_title('Distribution MaxAbs normalisée de la longueur des sépales')
7 axs[1, 0].hist(X[:, 1], bins=20)
8 axs[1, 0].set_title('Distribution de la largeur des sépales')
9 axs[1, 1].hist(X_maxabs[:, 1], bins=20)
10 axs[1, 1].set_title('Distribution MaxAbs normalisée de la largeur des sépales')
11 fig.tight_layout()
12 plt.show()

1 Commencez à coder ou à générer avec l'IA.

14 / 19
 5-Transformation des features quantitatifs en machine
learning
keyboard_arrow_down
Dans les modèles de machine learning, on peut souvent être amené à transformer les variables
pour avoir des distributions normales. Dans ce notebook, nous allons explorer trois techniques
différentes de transformation des features:

- La Transformartion puissance de Box-Cox

- La transformation de Yeo-Johnson

- Les transformations logarithmiques

- Les transformations puissances

Importation des packages

keyboard_arrow_down
1 import numpy as np
2 import pandas as pd
3 import seaborn as sns
4 import matplotlib.pyplot as plt
5 from scipy.stats import boxcox, yeojohnson

La transformation de Box-Cox
keyboard_arrow_down
La puissance de Box-Cox est une technique qui est utile lorsque les données ont une distribution
non normale. Box-Cox utilise une transformation de puissance pour créer une distribution plus
normale en ajustant la valeur de lambda.

La formule de la transformation de Box-Cox est la suivante :

{ log(𝑦)
𝑦𝜆 −1
𝑦(𝜆) = 𝜆
si 𝜆 ≠ 0
si 𝜆 = 0
où y est la variable à transformer et lambda est la valeur qui maximise la vraisemblance.

15 / 19
 Avantages de la transformation de Box-Cox
keyboard_arrow_down
Crée une distribution plus normale des données
La valeur optimale de lambda est choisie automatiquement pour maximiser la
vraisemblance.

Inconvénients de la transformation de Box-Cox

Ne peut être appliquée qu'aux données positives.
Si lambda est proche de zéro, la transformation est similaire à une transformation
logarithmique, ce qui peut avoir des effets indésirables sur les données.
Si lambda est très grand, la transformation peut être instable.

1
2 # Créer des données simulées avec une distribution asymétriq
3 np.random.seed(123)
4 x = np.random.exponential(5, 1000)
5
6 # Afficher un histogramme des données d'origine
7 sns.histplot(x, kde=True)
8 plt.show()
9

1
2 # Appliquer la transformation de Box-Cox à la variable x
3 x_boxcox, lambda_boxcox = boxcox(x)
4
5 # Afficher un histogramme de la variable transformée
6 sns.histplot(x_boxcox, kde=True)
7 plt.show()

La transformation de Yeo-Johnson
keyboard_arrow_down
La transformation de Yeo-Johnson
keyboard_arrow_down
La transformation de Yeo-Johnson est une technique similaire à la transformation de Box-Cox,
mais elle peut être utilisée pour des distributions non normales et avec des valeurs négatives.
Yeo-Johnson applique une transformation qui est une combinaison de la transformation de
puissance et de la transformation logarithmique. Comme pour Box-Cox, l'algorithme choisit
automatiquement la transformation optimale pour maximiser la vraisemblance.
16 / 19
 La formule de la transformation de Yeo-Johnson est la suivante :
⎧ (𝑦+1)𝜆 −1
⎪ 𝜆 si 𝑦 ≥ 0, 𝜆 ≠ 0
⎪ log(𝑦 + 1) si 𝑦 ≥ 0, 𝜆 = 0
𝑦(𝜆) = ⎨ (−𝑦+1)2−𝜆−1
⎪− si 𝑦 < 0, 𝜆 ≠ 2
⎪ 2−𝜆
⎩ − log(−𝑦 + 1) si 𝑦 < 0, 𝜆 = 2
où y est la variable à transformer et lambda est la valeur qui maximise la vraisemblance.

Avantages de la transformation de Yeo-Johnson

Peut être utilisée pour des distributions non normales et avec des valeurs négatives.
Comme pour Box-Cox, la valeur optimale de lambda est choisie automatiquement pour
maximiser la vraisemblance.

Inconvénients de la transformation de Yeo-Johnson

Peut être plus lente à calculer que la transformation de Box-Cox.
La transformation peut être instable pour certaines valeurs de lambda.

1 # Créer des données simulées avec une distribution asymétriq

2 np.random.seed(123)
3 x = np.random.normal(-2, 1, 1000)
4 x[:100] = x[:100] - 5
5
6 # Afficher un histogramme des données d'origine
7 sns.histplot(x, kde=True)
8 plt.show()
9

1 # Appliquer la transformation de Yeo-Johnson à la variable x

2 x_yeojohnson, lambda_yeojohnson = yeojohnson(x + 5)
3
4 # Afficher un histogramme de la variable transformée
5 sns.histplot(x_yeojohnson, kde=True)
6 plt.show()

Transformation logarithmique
keyboard_arrow_down
Les logarithmes sont une technique courante pour transformer des variables qui ont des
distributions très asymétriques. La transformation logarithmique est particulièrement utile pour
les variables qui ont des valeurs très grandes ou très petites.

La formule de la transformation logarithmique

17 /est
19la suivante :
 𝑦′ = log(𝑦)
où y est la variable à transformer.

Avantages de la transformation logarithmique

keyboard_arrow_down
Utile pour les variables qui ont des valeurs très grandes ou très petites.
Facile à calculer.

Inconvénients de la transformation logarithmique

Ne peut être appliquée qu'aux données positives.
Si les données ont des valeurs nulles ou négatives, une transformation différente doit être
utilisée.
La transformation peut être affectée par les valeurs extrêmes (outliers) dans les données.

1 # Créer des données simulées avec une distribution exponenti

2 np.random.seed(123)
3 x = np.random.exponential(2, 1000)
4
5 # Afficher un histogramme des données d'origine
6 sns.histplot(x, kde=True)
7 plt.show()
8

1 # Appliquer la transformation logarithmique à la variable x

2 x_log = np.log(x)
3
4 # Afficher un histogramme de la variable transformée
5 sns.histplot(x_log, kde=True)
6 plt.show()

Transformation puissance
keyboard_arrow_down
Les transformations puissances sont une technique qui permet d'appliquer une transformation
de puissance à une variable.

La formule de la transformation de puissance est la suivante :

𝑦′ = 𝑦𝜆
où y est la variable à transformer et 𝜆 est la valeur de la puissance. Il est important de noter que
la valeur de 𝜆 peut être positive, négative ou même fractionnaire.
18 / 19
keyboard_arrow_down
Avantages des transformations puissances

Peuvent être utilisées pour créer une distribution plus normale des données lorsque la
transformation logarithmique ne fonctionne pas.
Peuvent être utilisées pour ajuster la distribution des données à un modèle spéci que.

fi
Inconvénients des transformations puissances
La valeur de 𝜆 doit être choisie manuellement, ce qui peut être di cile et peut affecter les

ffi
performances du modèle si elle est mal choisie.
Les transformations puissances ne fonctionnent pas pour toutes les distributions de
données, et peuvent même aggraver les asymétries de certaines distributions.

1 # Créer des données simulées avec une distribution asymétriq

2 np.random.seed(123)
3 x = np.random.gamma(3, 1, 1000)
4
5 # Afficher un histogramme des données d'origine
6 sns.histplot(x, kde=True)
7 plt.show()

1 # Appliquer la transformation de puissance à la variable x

2 x_power = np.power(x, 0.4)
3
4 # Afficher un histogramme de la variable transformée
5 sns.histplot(x_power, kde=True)
6 plt.show()

19 / 19