Continue le cleaning

Author: linogaliana

content/modelisation/0_preprocessing.qmd

@@ -262,9 +262,6 @@ fig_plotly.show()
 
 
 
-
-
-
 # La démarche générale
 
 Dans ce chapitre, nous allons nous focaliser sur la préparation
@@ -312,15 +309,11 @@ notamment la relation des variables explicatives
 à la variable dépendante (le score du parti républicain)
 ainsi que les relations entre les variables explicatives. 
 
-::: {.cell .markdown}
-```{=html}
-<div class="alert alert-success" role="alert">
-<h3 class="alert-heading"><i class="fa-solid fa-pencil"></i> Exercice 2 : Regarder les corrélations entre les variables</h3>
-```
+::: {.exercise}
+## Exercice 2 (optionnel) : Regarder les corrélations entre les variables
 
 __Cet exercice est OPTIONNEL__
 
-
 1. Créer un DataFrame `df2` plus petit avec les variables `winner`, `votes_gop`, `Unemployment_rate_2019`,
 `Median_Household_Income_2019`,
 `Percent of adults with less than a high school diploma, 2015-19`,
@@ -329,9 +322,6 @@ __Cet exercice est OPTIONNEL__
 3. Représenter une matrice de nuages de points des variables de la base `df2` avec `pd.plotting.scatter_matrix`
 4. (optionnel) Refaire ces figures avec `Plotly` qui offre également la possibilité de faire une matrice de corrélation. 
 
-```{=html}
-</div>
-```
 :::
 
 ```{python}
@@ -345,27 +335,52 @@ df2 = votes.set_index("GEOID").loc[: , ["winner", "votes_gop",
           "Percent of adults with a bachelor's degree or higher, 2015-19"]]
 ```
 
+La matrice construite avec `seaborn` (question 2) aura l'aspect suivant :
+
 ```{python}
-#| output: false
-#| echo: true
+import numpy as np
+import matplotlib.pyplot as plt
 import seaborn as sns
 
-# 2. Matrice de corrélation graphique
-g1 = sns.heatmap(df2.drop("winner", axis = 1).corr(), cmap='coolwarm', annot=True, fmt=".2f")
+corr = df2.drop("winner", axis = 1).corr()
+
+mask = np.zeros_like(corr, dtype=bool)
+mask[np.triu_indices_from(mask)] = True
+
+# Set up the matplotlib figure
+fig = plt.figure()
+
+# Generate a custom diverging colormap
+cmap = sns.diverging_palette(220, 10, as_cmap=True)
+
+# Draw the heatmap with the mask and correct aspect ratio
+# More details at https://seaborn.pydata.org/generated/seaborn.heatmap.html
+sns.heatmap(
+    corr,          # The data to plot
+    mask=mask,     # Mask some cells
+    cmap=cmap,     # What colors to plot the heatmap as
+    annot=True,    # Should the values be plotted in the cells?
+    vmax=.3,       # The maximum value of the legend. All higher vals will be same color
+    vmin=-.3,      # The minimum value of the legend. All lower vals will be same color
+    center=0,      # The center value of the legend. With divergent cmap, where white is
+    square=True,   # Force cells to be square
+    linewidths=.5, # Width of lines that divide cells
+    cbar_kws={"shrink": .5}  # Extra kwargs for the legend; in this case, shrink by 50%
+)
 
-# Construction directement avec pandas également possible
-g2 = df2.drop("winner", axis = 1).corr().style.background_gradient(cmap='coolwarm').format('{:.2f}')
+plt.show(fig)
 ```
 
-La matrice construite avec `seaborn` (question 2) aura l'aspect suivant :
+Alors que celle construite directement avec `corr` de `Pandas`
+ressemblera plutôt à ce tableau :
 
 ```{python}
-g1
+#| output: false
+#| echo: true
+# Construction directement avec pandas également possible
+g2 = df2.drop("winner", axis = 1).corr().style.background_gradient(cmap='coolwarm').format('{:.2f}')
 ```
 
-Alors que celle construite directement avec `corr` de `Pandas`
-ressemblera plutôt à ce tableau :
-
 ```{python}
 g2
 ```
@@ -375,12 +390,9 @@ Le nuage de point obtenu à l'issue de la question 3 ressemblera à :
 ```{python}
 #| echo: true
 # 3. Matrice de nuages de points
-ax = pd.plotting.scatter_matrix(df2, figsize = (15,15))
+pd.plotting.scatter_matrix(df2)
 ```
 
-```{python}
-ax
-```
 
 Le résultat de la question 4 devrait, quant à lui,
 ressembler au graphique suivant :
@@ -405,58 +417,49 @@ Par exemple, dans le cadre
 de la régression linéaire, les variables catégorielles ne sont pas traitées à la même
 enseigne que les variables ayant valeur dans $\mathbb{R}$. Une variable
 discrète (prenant un nombre fini de valeurs) devra être transformée en suite de
-variables 0/1 par rapport à une modalité de référence pour être en adéquation
+variables 0/1 (des _dummies_) par rapport à une modalité de référence pour être en adéquation
 avec les hypothèses de la régression linéaire.
 On appelle ce type de transformation
 *one-hot encoding*, sur laquelle nous reviendrons. Il s'agit d'une transformation,
-parmi d'autres, disponibles dans `scikit` pour mettre en adéquation un jeu de
+parmi d'autres, disponibles dans `Scikit` pour mettre en adéquation un jeu de
 données et des hypothèses mathématiques. 
 
-L'ensemble de ces tâches s'appelle le *preprocessing*. L'un des intérêts
+L'ensemble de ces tâches de préparation de données s'appelle le *preprocessing* ou le _feature engineering_. L'un des intérêts
 d'utiliser `Scikit` est qu'on peut considérer qu'une tâche de _preprocessing_
 est, en fait, une tâche d'apprentissage. En effet, le _preprocessing_ 
 consiste à apprendre des paramètres d'une structure 
 de données (par exemple estimer moyennes et variances pour les retrancher à chaque
 observation) et on peut très bien appliquer ces paramètres
 à des observations qui n'ont pas servi à construire
-ceux-ci. Ainsi, en gardant en tête l'approche générale avec `Scikit`,
+ceux-ci. Autrement dit, cette préparation de données s'intègre très bien dans le _pipeline_ @fig-ml-pipeline. 
 
-![](https://minio.lab.sspcloud.fr/lgaliana/generative-art/pythonds/scikit_predict.png)
+## _Preprocessing_ de variables continues
 
-nous allons voir deux processus très classiques de *preprocessing* : 
+Nous allons voir deux processus très classiques de *preprocessing* pour des variables continues : 
 
 1. La **standardisation** transforme des données pour que la distribution empirique suive une loi $\mathcal{N}(0,1)$.
 
 2. La **normalisation**  transforme les données de manière à obtenir une norme ($\mathcal{l}_1$ ou $\mathcal{l}_2$) unitaire. Autrement dit, avec la norme adéquate, la somme des éléments est égale à 1.
 
-::: {.cell .markdown}
-```{=html}
-<div class="alert alert-danger" role="alert">
-<h3 class="alert-heading"><i class="fa-solid fa-triangle-exclamation"></i> Warning</h3>
-```
-Pour un statisticien,
+Il en existe d'autres, par exemple le `MinMaxScaler` pour renormaliser les variables en fonction des bornes minimales et maximales des valeurs observées. Le choix de la méthode a mettre en oeuvre dépend du type d'algorithmes choisis par la suite: les hypothèses des k plus proches voisins (knn) seront différentes de celles d'une _random forest_. C'est pour cette raison que, normalement, on définit des _pipelines_ complets, intégrant à la fois _preprocessing_ et apprentissage. Ce sera l'objet des prochains chapitres.
+
+::: {.caution}
+Pour les statisticiens.ennes,
 le terme _normalization_ dans le vocable `Scikit` peut avoir un sens contre-intuitif.
 On s'attendrait à ce que la normalisation consiste à transformer une variable de manière à ce que $X \sim \mathcal{N}(0,1)$.
 C'est, en fait, la **standardisation** en `Scikit` qui fait cela.
 
-```{=html}
-</div>
-```
 :::
 
 
-## Standardisation
-
-La standardisation consiste à transformer des données pour que la distribution empirique suive une loi $\mathcal{N}(0,1)$. Pour être performants, la plupart des modèles de _machine learning_ nécessitent souvent d'avoir des données dans cette distribution.
+### Standardisation
 
-::: {.cell .markdown}
-```{=html}
-<div class="alert alert-success" role="alert">
-<h3 class="alert-heading"><i class="fa-solid fa-pencil"></i> Exercice 3: Standardisation</h3>
-```
+La standardisation consiste à transformer des données pour que la distribution empirique suive une loi $\mathcal{N}(0,1)$. Pour être performants, la plupart des modèles de _machine learning_ nécessitent souvent d'avoir des données dans cette distribution. Même lorsque ce n'est pas indispensable, par exemple avec des régressions logistiques, cela peut accélérer la vitesse de convergence des algorithmes.
 
+::: {.exercise}
+## Exercice 3: Standardisation
 
-1. Standardiser la variable `Median_Household_Income_2019` (ne pas écraser les valeurs !) et regarder l'histogramme avant/après normalisation.
+1. Standardiser la variable `Median_Household_Income_2019` (ne pas écraser les valeurs !) et regarder l'histogramme avant/après normalisation. Cette transformation est à appliquer à toute la colonne ; les prochaines questions se préoccuperont du sujet de découpage d'échantillon et d'extrapolation. 
 
 *Note : On obtient bien une distribution centrée à zéro et on pourrait vérifier que la variance empirique soit bien égale à 1. On pourrait aussi vérifier que ceci est vrai également quand on transforme plusieurs colonnes à la fois.*
 
@@ -474,45 +477,141 @@ dimensions coïncident.
 *Note : Une fois appliqués à un autre `DataFrame`, on peut remarquer que la distribution n'est pas exactement centrée-réduite dans le `DataFrame` sur lequel les paramètres n'ont pas été estimés. C'est normal, l'échantillon initial n'était pas aléatoire, les moyennes et variances de cet échantillon n'ont pas de raison de coïncider avec les moments de l'échantillon complet.*
 
 
-```{=html}
-</div>
-```
 :::
 
+Avant standardisation, notre variable a cette distribution:
+
+```{python}
+(
+  ggplot(df2, aes(x = "Median_Household_Income_2019")) +
+  geom_histogram() +
+  theme_minimal() +
+  labs(
+    x = "2019 Median household income (standardized)",
+    y = "Density (number observations)"
+    )
+)
+```
+
+Après standardisation, l'échelle de la variable a changé. 
+
 ```{python}
 # 1. Standardisation de Median_Household_Income_2019 et histogramme
 import matplotlib.pyplot as plt
 from sklearn import preprocessing
 
-df2['y_standard'] = preprocessing.scale(df2['Median_Household_Income_2019'])
-f, axes = plt.subplots(2, figsize=(10, 10))
-sns.histplot(df2["Median_Household_Income_2019"] , color="skyblue", ax=axes[0])
-sns.histplot(df2["y_standard"] , color="olive", ax=axes[1])
+df2['y_standard'] = preprocessing.scale(
+  df2['Median_Household_Income_2019']
+)
+
+(
+  ggplot(df2, aes(x = "y_standard")) +
+  geom_histogram() +
+  theme_minimal() +
+  labs(
+    x = "2019 Median household income (standardized)",
+    y = "Density (number observations)"
+    )
+)
 ```
 
+On obtient bien une moyenne égale à 0 et une variance égale à 1, aux approximations numériques prêt :
+
+```{python}
+pd.DataFrame(
+  {
+    "Statistique": ["Mean", "Variance"],
+    "Valeur": [df2['y_standard'].mean().round(), df2['y_standard'].var()]
+  }
+)
+```
+
+A la question 2, si on essaie de représenter les statistiques obtenues dans un tableau lisible, on obtient
+
 ```{python}
 # 2. Créer un scaler
-df2 = df2.drop("winner", axis = 1)
-print("Moyenne de chaque variable sur 1000 premières observations avant : ", np.array(df2.head(1000).mean(axis=0)))
-print("Ecart-type de chaque variable sur 1000 premières observations avant : ", np.array(df2.head(1000).std(axis=0)))
-scaler = preprocessing.StandardScaler().fit(df2.head(1000))
-scaler.transform(df2.head(1000))
-print("Moyenne de chaque variable sur 1000 premières observations après : ", scaler.transform(df2.head(1000)).mean(axis=0))
-print("Ecart-type de chaque variable sur 1000 premières observations après : ", scaler.transform(df2.head(1000)).std(axis=0))
+
+df2 = df2.drop("winner", axis=1)
+
+first_rows = df2.head(1000)
+
+# Calculate mean and standard deviation before scaling
+mean_before = np.array(first_rows.mean(axis=0))
+std_before = np.array(first_rows.std(axis=0))
+
+# Initialize and apply the scaler
+scaler = preprocessing.StandardScaler().fit(first_rows)
+scaled_data = scaler.transform(first_rows)
+
+# Calculate mean and standard deviation after scaling
+mean_after = scaled_data.mean(axis=0)
+std_after = scaled_data.std(axis=0)
+
+# Create DataFrame to store results
+result_df = pd.DataFrame({
+    "Variable": df2.columns,
+    "Mean before Scaling": mean_before,
+    "Std before Scaling": std_before,
+    "Mean after Scaling": mean_after,
+    "Std after Scaling": std_after
+})
+```
+
+```{python}
+from great_tables import *
+(
+  GT(result_df)
+  .fmt_nanoplot("Mean before Scaling", options = {"interactive_data_values": False})
+  .fmt_nanoplot("Std before Scaling")
+  .fmt_nanoplot("Mean after Scaling")
+  .fmt_nanoplot("Std after Scaling")
+)
 ```
 
+On voit très clairement dans ce tableau que la standardisation a bien fonctionné. 
+
+Maintenant, si on construit un _transformer_ formel pour nos variables
 
 ```{python}
 # 3. Appliquer le scaler à toutes les autres lignes
-X1 = scaler.transform(df2.head(1000))
-X2 = scaler.transform(df2[1000:])
-col_pos = df2.columns.get_loc("Median_Household_Income_2019")
+standarisation = scaler.fit(df2.head(1000))
+standarisation
+```
 
-f, axes = plt.subplots(2, figsize=(10, 10))
-sns.histplot(X1[:,col_pos] , color="skyblue", ax=axes[0])
-sns.histplot(X2[:,col_pos] , color="olive", ax=axes[1])
+On peut extrapoler notre standardiseur à un ensemble plus large de données. Si on regarde la distribution obtenue sur les 1000 premières lignes, on retrouve une échelle cohérente avec une loi $\mathcal{N(0,1)}$
+
+```{python}
+X1 = pd.DataFrame(scaler.fit_transform(df2[1000:]))
+X1.columns = df2.columns
+
+X2 = pd.DataFrame(scaler.transform(df2[:1000]))
+X2.columns = df2.columns
+
+(
+  ggplot(X1, aes(x = "Unemployment_rate_2019")) +
+  geom_histogram() +
+  labs(x = "Unemployment rate (standardized), 1000 first rows")
+)
 ```
 
+En revanche on voit que cette distribution ne correspond pas à celle qui permettrait de normaliser vraiment le reste des données. C'est un problème classique en _machine learning_, le _data drift_ lorsqu'on essaie d'extrapoler à des données dont la distribution ne correspond plus à celle des données d'apprentissage, typiquement des données non stationnaires en série temporelle. 
+
+```{python}
+(
+  ggplot(X2, aes(x = "Unemployment_rate_2019")) +
+  geom_histogram() +
+  labs(x = "Unemployment rate (standardized), other rows")
+)
+
+```
+
+::: {.important}
+Le data drift désigne un changement dans la distribution des données au fil du temps, entraînant une dégradation des performances d’un modèle de _machine learning_ qui, par construction, a été entraîné sur des données passées. 
+
+Ce phénomène peut survenir à cause de variations dans la population cible, de changements dans les caractéristiques des données ou de facteurs externes. 
+
+Il est crucial de détecter le data drift pour ajuster ou réentraîner le modèle, afin de maintenir sa pertinence et sa précision. Les techniques de détection incluent des tests statistiques et le suivi de métriques spécifiques.
+:::
 
 ## Normalisation
 
@@ -537,6 +636,7 @@ Cette transformation est particulièrement utilisée en classification de texte
 :::
 
 ```{python}
+#| eval: false
 # 1. Normalisation de Median_Household_Income_2019 et histogrammes
 scaler = preprocessing.Normalizer().fit(df2.head(1000))
 X1 = scaler.transform(df2.dropna(how = "any").head(1000))
@@ -547,6 +647,7 @@ sns.histplot(X1[:,col_pos] , color="olive", ax=axes[1])
 ```
 
 ```{python}
+#| eval: false
 # 2. Vérification de la norme L2
 np.sqrt(np.sum(X1**2, axis=1))[:10] # L2-norm
 ```