diff --git a/SYNTHESE_TP05.md b/SYNTHESE_TP05.md new file mode 100644 index 0000000..e31df12 --- /dev/null +++ b/SYNTHESE_TP05.md @@ -0,0 +1,178 @@ +# TP05 - Synthèse : monitoring, dérive et redéploiement + +Fil rouge : prédiction de la consommation électrique (kWh, 128 clients portugais, pas de 15 min). + +Scénario : un modèle a été **entraîné sur 2011** et tourne toujours en production plusieurs années plus +tard. En ingénieur MLOps, on vérifie si les données **2014** observées en production ont **dérivé** par +rapport à l'entraînement, on analyse cette dérive avec **Evidently**, puis on mesure son **impact sur les +performances** (2012 -> 2014) pour décider d'une stratégie de maintenance. + +## Ce qui a été construit + +- **`tp_module5_monitoring_derive.ipynb`** (notebook exécuté) : Partie 1 (moyennes + histogrammes de + `lag_30d` 2011 vs 2014), Partie 2 (rapport de dérive Evidently `DataDriftPreset`), Partie 3 (modèle + linéaire entraîné sur 2011, évalué sur 2011-2014). Réutilise `lab/constants.py` (chemins, cible, features). +- **`tp05_evidently_drift_2011_vs_2014.html`** : rapport Evidently interactif complet (à ouvrir dans un + navigateur). +- **Choix technique** : la feature `lag_365d` (consommation 365 jours plus tôt) est **exclue** car elle + est indéfinie (NaN) sur **toute** l'année 2011 (première année, pas d'historique 2010). On travaille donc + sur les 5 features définies sur les deux périodes : `lag_1d, lag_7d, lag_30d, rolling_mean_7d, + rolling_mean_30d`. Cet ensemble sert à la fois au rapport de dérive et au modèle entraîné sur 2011. + +--- + +## Partie 1 - Observer une dérive + +Feature `lag_30d`, sur les années complètes 2011 (train) et 2014 (production) : + +| Année | Moyenne `lag_30d` | Effectif | +|--------------|-------------------|------------| +| 2011 (train) | **62.041 kWh** | 4 116 352 | +| 2014 (prod) | **54.054 kWh** | 4 485 120 | +| Écart | **-7.986 kWh** | **-12.9 %** | + +**1.1 - Les deux distributions semblent-elles similaires ?** +Non. Elles gardent la même **forme** générale (distribution asymétrique étalée vers la droite : beaucoup de +petites consommations, une longue queue de fortes valeurs), mais l'histogramme 2014 est **décalé vers les +valeurs plus faibles** et sa moyenne est nettement plus basse. Visuellement, le décalage est net. + +**1.2 - La moyenne a-t-elle évolué entre 2011 et 2014 ?** +Oui, franchement : de **62.04 kWh** à **54.05 kWh**, soit **-7.99 kWh (-12.9 %)**. La consommation moyenne +(observée via `lag_30d`) a **baissé d'environ 13 %** entre l'entraînement et la production. + +**1.3 - Cette évolution paraît-elle suffisamment importante pour parler de dérive ?** +Une baisse de ~13 % de la moyenne est un signal **fort et cohérent** d'un changement de distribution : c'est +un indice sérieux de dérive des données. Attention toutefois : la moyenne seule ne **prouve** pas une dérive +statistique (deux distributions peuvent avoir des moyennes proches et des formes différentes, ou l'inverse). +Il faut confirmer avec une analyse sur toute la distribution, avec un test et un seuil objectifs (Partie 2). + +**1.4 - Cette première analyse est-elle suffisante pour conclure sur l'état du modèle ? Pourquoi ?** +Non. Elle ne porte que sur **une** feature (`lag_30d`), via un **seul** indicateur (moyenne + comparaison +visuelle), **sans test statistique ni seuil**, et elle ne dit **rien** des autres features ni de l'**impact +réel sur la performance** du modèle. C'est un premier indice, pas une conclusion. Il faut (a) un outil de +monitoring qui teste toutes les features (Partie 2) et (b) mesurer la performance dans le temps (Partie 3). + +--- + +## Partie 2 - Analyse avec un outil de monitoring (Evidently) + +Rapport `DataDriftPreset` comparant 2011 (référence) et 2014 (courant), échantillon de 200 000 lignes par +période (seed fixe). Test choisi automatiquement par Evidently pour de grands échantillons numériques : +**distance de Wasserstein normalisée**, seuil **0.1**. + +| Feature | Test | Drift score | Seuil | Dérive ? | +|--------------------|-------------------------------|-------------|-------|----------| +| lag_1d | Wasserstein distance (normed) | 0.165 | 0.1 | Oui | +| lag_7d | Wasserstein distance (normed) | 0.167 | 0.1 | Oui | +| lag_30d | Wasserstein distance (normed) | 0.167 | 0.1 | Oui | +| rolling_mean_7d | Wasserstein distance (normed) | 0.188 | 0.1 | Oui | +| rolling_mean_30d | Wasserstein distance (normed) | 0.191 | 0.1 | Oui | + +Verdict global : **`dataset_drift = True`**, **5 / 5 features en dérive (100 %)**. + +**2.1 - Combien de features présentent une dérive ?** +**Les 5** features analysées présentent une dérive (5 / 5, soit 100 %). Toutes dépassent le seuil de 0.1. + +**2.2 - Toutes les features évoluent-elles de la même manière ?** +Toutes dérivent, mais **pas avec la même intensité**. Les distances de Wasserstein vont de **0.165** +(`lag_1d`) à **0.191** (`rolling_mean_30d`). Les **moyennes glissantes** (`rolling_mean_7d` 0.188, +`rolling_mean_30d` 0.191) dérivent un peu **plus** que les **lags bruts** (0.165-0.167) : les indicateurs +lissés/tendanciels captent davantage la baisse durable du niveau de consommation. + +**2.3 - Identifiez deux métriques ou indicateurs du rapport. À quoi servent-ils ?** +- **Le drift score par feature** (ici la distance de Wasserstein normalisée) : il **quantifie** l'écart + entre la distribution de référence (2011) et la distribution courante (2014) pour chaque variable, et le + compare à un **seuil** (0.1). Il sert à **détecter et localiser** la dérive, feature par feature. +- **Le verdict global "Dataset Drift" + la part de colonnes en dérive** : il **agrège** les décisions par + feature (nombre / pourcentage de colonnes dérivées, ici 5/5 = 100 %) en une conclusion **au niveau du + dataset entier**. Il sert à **trancher globalement** (le dataset a-t-il dérivé, oui/non). + (Le rapport affiche aussi, par feature, les **histogrammes de distribution référence vs courant**, utiles + pour visualiser la nature du décalage.) + +**2.4 - Le rapport conclut-il à une dérive globale du dataset ? Justifiez.** +**Oui.** `dataset_drift = True`. Le critère par défaut d'Evidently (déclarer une dérive du dataset quand la +**part de colonnes en dérive dépasse 50 %**) est **largement** franchi : **100 %** des colonnes dérivent. +Le rapport conclut donc sans ambiguïté à une dérive globale des données d'entrée. + +--- + +## Partie 3 - Mesurer l'impact sur les performances + +Modèle (régression linéaire) entraîné **sur 2011 uniquement**, évalué sur chaque année complète : + +| Année | Rôle | RMSE (kWh) | MAE (kWh) | +|-------|-------------------|------------|-----------| +| 2011 | train (référence) | 7.904 | 4.450 | +| 2012 | évaluation (prod) | 7.595 | 4.178 | +| 2013 | évaluation (prod) | 7.486 | 4.095 | +| 2014 | évaluation (prod) | **7.101** | **3.911** | + +**Résultat marquant : l'erreur ne se dégrade pas, elle diminue légèrement d'année en année.** + +**3.1 - Peut-on comparer 2011 vs 2012 au même titre que 2012 vs 2013 ?** +Non. **2011 est l'année d'entraînement** : l'erreur y est mesurée **in-sample** (le modèle a déjà vu ces +données), donc **optimiste**. Comparer 2011 (in-sample) à 2012 (hors échantillon) mélange deux régimes +différents, alors que 2012 vs 2013 compare **deux années hors échantillon** entre elles (comparaison +homogène). De plus, le **niveau de consommation change** d'une année à l'autre : comparer des **RMSE bruts** +est biaisé par l'échelle de la cible (voir 3.3). 2011 doit donc être traité comme **référence de train**, +pas comme un point de comparaison équivalent aux années de production. + +**3.2 - Observe-t-on une dégradation progressive ?** +**Non.** En valeur absolue, la performance **s'améliore** légèrement : RMSE 7.90 -> 7.60 -> 7.49 -> 7.10 et +MAE 4.45 -> 4.18 -> 4.10 -> 3.91 de 2011 à 2014. Aucune dégradation observée sur ces métriques. + +**3.3 - Cette (absence de) dégradation est-elle cohérente avec la dérive détectée ?** +À première vue c'est surprenant (dérive nette en Partie 2, mais pas de perte de performance), et c'est +**instructif** : **une dérive des données ne signifie pas automatiquement une dégradation du modèle**. +Explication : la consommation a **baissé** (~-13 % sur `lag_30d`, Partie 1), donc la **cible** (kWh) est plus +petite en 2014 ; comme RMSE et MAE sont des erreurs **absolues** en kWh, elles **diminuent mécaniquement** +quand l'échelle de la cible diminue. Pendant ce temps, la **relation features -> cible** (les lags prédisent +la consommation courante) est restée **stable**. On a donc une dérive des données **sans** dérive de la +relation. Pour comparer rigoureusement les années, il faudrait une métrique **indépendante de l'échelle** +(MAPE, R², RMSE normalisé). + +**3.4 - Peut-on conclure que le modèle 2011 est encore fiable en 2014 ?** +Sur la base des erreurs absolues, il **ne s'est pas dégradé** (il fait même un peu mieux en kWh). Mais on ne +peut pas **conclure** à sa pleine fiabilité sur ces seuls chiffres : (1) les métriques absolues sont +**trompeuses** quand l'échelle de la cible change ; (2) on n'a mesuré que l'**amplitude** de l'erreur, pas un +éventuel **biais systématique** (sur/sous-estimation) ni la performance par segment (client, saison). +Verdict prudent : **pas de signe de dégradation**, mais à **confirmer** avec des métriques relatives et une +analyse des résidus avant de déclarer le modèle fiable. + +**3.5 - Que faudrait-il faire ensuite : surveiller, réentraîner, ou redéployer ?** +**Surveiller.** La dérive des données est réelle, mais **sans impact mesuré** sur la performance : rien +n'impose un réentraînement ou un redéploiement immédiat (ce serait du travail et du risque pour un gain non +démontré). On met en place un **monitoring continu** (dérive des features + performance suivie avec une +métrique relative + dérive des prédictions et de la cible dès que la vérité terrain arrive) et on **déclenche +un réentraînement seulement si/quand** la performance se dégrade réellement ou qu'un concept drift apparaît. + +**3.6 - Quel type de dérive semble en jeu ? Quelles analyses préconisez-vous ?** +Type : **data drift** (dérive des covariables / *covariate shift*). Les distributions des features d'entrée +ont changé (baisse durable du niveau de consommation), tandis que la **relation** features -> cible semble +**stable** (pas de perte de performance) : **pas de concept drift évident**. Analyses préconisées : +- suivre une **métrique de performance indépendante de l'échelle** (MAPE, R², nRMSE) dans le temps, plutôt + que le RMSE brut ; +- monitorer aussi la **dérive des prédictions** et de la **cible** (*target drift*), pas seulement des + features en entrée ; +- **analyser les résidus** (biais moyen, hétéroscédasticité) et **segmenter** (par client, par saison) ; +- surtout, dès que la **vérité terrain** est disponible (avec délai), **recalculer la performance réelle en + production** pour détecter précocement un éventuel **concept drift** : c'est la fermeture de la *feedback + loop* MLOps (surveiller -> alerter -> réentraîner -> redéployer). + +--- + +## Reproduire + +Sur la VM, dans `~/tp` (venv `/opt/venvs/mlops`). Le TP05 est **100 % local** (données `/data/modelling`) : +aucun secret réseau (MLflow, S3) n'est nécessaire. + +```bash +# Ré-exécuter le notebook (régénère les sorties + le rapport HTML) +/opt/venvs/mlops/bin/jupyter nbconvert --to notebook --execute --inplace tp_module5_monitoring_derive.ipynb +``` + +Consultation interactive (service `jupyter-tp`, token `mlops`) : + +``` +https://jupyter.192-168-122-143.nip.io/lab/tree/tp_module5_monitoring_derive.ipynb?token=mlops +``` diff --git a/tp05_evidently_drift_2011_vs_2014.html b/tp05_evidently_drift_2011_vs_2014.html new file mode 100644 index 0000000..f5a58e0 --- /dev/null +++ b/tp05_evidently_drift_2011_vs_2014.html @@ -0,0 +1,646 @@ + + + + + + + + + + + + +
+

Loading...

+
+ + + + + + + diff --git a/tp_module5_monitoring_derive.ipynb b/tp_module5_monitoring_derive.ipynb new file mode 100644 index 0000000..15d5694 --- /dev/null +++ b/tp_module5_monitoring_derive.ipynb @@ -0,0 +1,597 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "eced4520", + "metadata": {}, + "source": [ + "# TP05 : Monitoring, dérive et redéploiement\n", + "\n", + "Fil rouge : prédiction de la **consommation électrique** (kWh, 128 clients portugais, pas de 15 min).\n", + "\n", + "**Scénario.** Un modèle a été **entraîné sur 2011** et tourne toujours en production plusieurs années\n", + "plus tard. En tant qu'ingénieur MLOps, on vérifie si les données **2014** observées en production ont\n", + "**dérivé** par rapport à l'entraînement, on analyse cette dérive avec **Evidently**, puis on mesure son\n", + "**impact sur les performances** (2012 -> 2014).\n", + "\n", + "Les réponses rédigées aux questions **1.1 - 3.6** sont dans `SYNTHESE_TP05.md`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6fba1bc0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T08:08:26.297146Z", + "iopub.status.busy": "2026-07-25T08:08:26.296988Z", + "iopub.status.idle": "2026-07-25T08:08:36.139225Z", + "shell.execute_reply": "2026-07-25T08:08:36.138397Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "features : (17952768, 6) | colonnes : ['lag_1d', 'lag_7d', 'lag_30d', 'lag_365d', 'rolling_mean_7d', 'rolling_mean_30d']\n", + "cible : consumption_kwh\n", + "années : [np.int32(2011), np.int32(2012), np.int32(2013), np.int32(2014), np.int32(2015)]\n", + "feature set TP05 (lag_365d exclu) : ['lag_1d', 'lag_7d', 'lag_30d', 'rolling_mean_7d', 'rolling_mean_30d']\n" + ] + } + ], + "source": [ + "import sys\n", + "from pathlib import Path\n", + "sys.path.insert(0, str(Path.cwd())) # rendre le package lab/ importable\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.metrics import root_mean_squared_error, mean_absolute_error\n", + "\n", + "from lab import constants\n", + "\n", + "RANDOM_STATE = 42\n", + "TARGET = constants.TARGET\n", + "\n", + "# Données source déjà préparées (features + cible), cf. lab/split/cli.py\n", + "features = pd.read_parquet(constants.SOURCE_DIR / constants.FEATURE_FILENAME)\n", + "target = pd.read_parquet(constants.SOURCE_DIR / constants.TARGET_FILENAME)\n", + "df = features.join(target)\n", + "\n", + "# Année de chaque observation (index MultiIndex : individual, timestamp)\n", + "df[\"year\"] = df.index.get_level_values(\"timestamp\").year\n", + "\n", + "# lag_365d est indéfini (NaN) sur TOUTE l'année 2011 (première année, pas d'historique 2010).\n", + "# On l'exclut donc du modèle entraîné sur 2011 ET du rapport de dérive, afin de comparer des\n", + "# distributions bien définies sur les deux périodes (2011 et 2014).\n", + "DRIFT_FEATURES = [\"lag_1d\", \"lag_7d\", \"lag_30d\", \"rolling_mean_7d\", \"rolling_mean_30d\"]\n", + "\n", + "print(\"features :\", features.shape, \"| colonnes :\", list(features.columns))\n", + "print(\"cible :\", TARGET)\n", + "print(\"années :\", sorted(df[\"year\"].unique()))\n", + "print(\"feature set TP05 (lag_365d exclu) :\", DRIFT_FEATURES)\n" + ] + }, + { + "cell_type": "markdown", + "id": "8a984f27", + "metadata": {}, + "source": [ + "## Partie 1 - Observer une dérive\n", + "\n", + "Comparaison simple des données d'entraînement (**2011**) et des données observées en production\n", + "(**2014**), à partir de la feature **`lag_30d`** (consommation 30 jours plus tôt) :\n", + "moyenne des deux distributions, puis histogrammes superposés.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "124db852", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T08:08:36.141150Z", + "iopub.status.busy": "2026-07-25T08:08:36.140967Z", + "iopub.status.idle": "2026-07-25T08:08:36.282318Z", + "shell.execute_reply": "2026-07-25T08:08:36.281575Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "lag_30d - moyenne 2011 (train) : 62.041 kWh (n = 4,116,352)\n", + "lag_30d - moyenne 2014 (prod) : 54.054 kWh (n = 4,485,120)\n", + "écart 2014 - 2011 : -7.986 kWh (-12.9 %)\n" + ] + } + ], + "source": [ + "lag_2011 = df.loc[df[\"year\"] == 2011, \"lag_30d\"].dropna()\n", + "lag_2014 = df.loc[df[\"year\"] == 2014, \"lag_30d\"].dropna()\n", + "\n", + "mean_2011 = lag_2011.mean()\n", + "mean_2014 = lag_2014.mean()\n", + "delta = mean_2014 - mean_2011\n", + "delta_pct = 100 * delta / mean_2011\n", + "\n", + "print(f\"lag_30d - moyenne 2011 (train) : {mean_2011:10.3f} kWh (n = {len(lag_2011):,})\")\n", + "print(f\"lag_30d - moyenne 2014 (prod) : {mean_2014:10.3f} kWh (n = {len(lag_2014):,})\")\n", + "print(f\"écart 2014 - 2011 : {delta:+10.3f} kWh ({delta_pct:+.1f} %)\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7a72975c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T08:08:36.284002Z", + "iopub.status.busy": "2026-07-25T08:08:36.283859Z", + "iopub.status.idle": "2026-07-25T08:08:36.616584Z", + "shell.execute_reply": "2026-07-25T08:08:36.615737Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Histogrammes en densité (les effectifs 2011/2014 diffèrent). Bornes communes ; on tronque\n", + "# la queue de distribution (très étalée) au 99e centile pour la lisibilité.\n", + "x_max = float(np.quantile(pd.concat([lag_2011, lag_2014]), 0.99))\n", + "bins = np.linspace(0, x_max, 60)\n", + "\n", + "plt.figure(figsize=(9, 5))\n", + "plt.hist(lag_2011, bins=bins, density=True, alpha=0.55, label=f\"2011 (train) - moy = {mean_2011:.1f}\")\n", + "plt.hist(lag_2014, bins=bins, density=True, alpha=0.55, label=f\"2014 (prod) - moy = {mean_2014:.1f}\")\n", + "plt.axvline(mean_2011, color=\"C0\", linestyle=\"--\", linewidth=1)\n", + "plt.axvline(mean_2014, color=\"C1\", linestyle=\"--\", linewidth=1)\n", + "plt.xlabel(\"lag_30d (kWh)\")\n", + "plt.ylabel(\"densité\")\n", + "plt.title(\"Distribution de lag_30d : 2011 (train) vs 2014 (production)\")\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "38fa0900", + "metadata": {}, + "source": [ + "**Lecture rapide.** On compare visuellement les deux distributions et l'écart des moyennes.\n", + "Cette approche mono-feature est un premier indice, mais elle reste partielle (une seule variable,\n", + "pas de test statistique, pas de vue sur les autres features ni sur la performance). Réponses\n", + "détaillées 1.1 - 1.4 dans `SYNTHESE_TP05.md`.\n" + ] + }, + { + "cell_type": "markdown", + "id": "6296ac74", + "metadata": {}, + "source": [ + "## Partie 2 - Analyse avec un outil de monitoring (Evidently)\n", + "\n", + "On génère un **rapport de dérive** Evidently (`DataDriftPreset`) comparant les distributions de\n", + "**2011 (référence)** et **2014 (courant)** sur l'ensemble des features du modèle. Evidently choisit\n", + "automatiquement un test statistique par feature (pour de grands échantillons : *Wasserstein distance\n", + "normalisée*, seuil 0.1) et conclut feature par feature puis au niveau du dataset.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "239dee1e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T08:08:36.618548Z", + "iopub.status.busy": "2026-07-25T08:08:36.618427Z", + "iopub.status.idle": "2026-07-25T08:08:41.584708Z", + "shell.execute_reply": "2026-07-25T08:08:41.583602Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "reference 2011 : (200000, 5) | current 2014 : (200000, 5)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rapport HTML enregistré : tp05_evidently_drift_2011_vs_2014.html\n" + ] + } + ], + "source": [ + "from evidently.report import Report\n", + "from evidently.metric_preset import DataDriftPreset\n", + "\n", + "N_SAMPLE = 200_000 # échantillon (seed fixe) : distributions représentatives + temps de calcul maîtrisé\n", + "\n", + "reference = df.loc[df[\"year\"] == 2011, DRIFT_FEATURES].dropna()\n", + "current = df.loc[df[\"year\"] == 2014, DRIFT_FEATURES].dropna()\n", + "# reset_index : Evidently trace les distributions sur un index simple ; on retire le\n", + "# MultiIndex (individual, timestamp) qui n'est pas pertinent pour la comparaison de dérive.\n", + "reference = reference.sample(n=min(N_SAMPLE, len(reference)), random_state=RANDOM_STATE).reset_index(drop=True)\n", + "current = current.sample(n=min(N_SAMPLE, len(current)), random_state=RANDOM_STATE).reset_index(drop=True)\n", + "print(\"reference 2011 :\", reference.shape, \"| current 2014 :\", current.shape)\n", + "\n", + "report = Report(metrics=[DataDriftPreset()])\n", + "report.run(reference_data=reference, current_data=current)\n", + "report.save_html(\"tp05_evidently_drift_2011_vs_2014.html\")\n", + "print(\"Rapport HTML enregistré : tp05_evidently_drift_2011_vs_2014.html\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f8559f73", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T08:08:41.586885Z", + "iopub.status.busy": "2026-07-25T08:08:41.586772Z", + "iopub.status.idle": "2026-07-25T08:08:41.611360Z", + "shell.execute_reply": "2026-07-25T08:08:41.610742Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dérive globale du dataset (dataset_drift) : True\n", + "Features en dérive : 5 / 5 (100%)\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
testscoreseuildérive ?
feature
lag_1dWasserstein distance (normed)0.16530.1True
lag_30dWasserstein distance (normed)0.16730.1True
lag_7dWasserstein distance (normed)0.16690.1True
rolling_mean_30dWasserstein distance (normed)0.19060.1True
rolling_mean_7dWasserstein distance (normed)0.18830.1True
\n", + "
" + ], + "text/plain": [ + " test score seuil dérive ?\n", + "feature \n", + "lag_1d Wasserstein distance (normed) 0.1653 0.1 True\n", + "lag_30d Wasserstein distance (normed) 0.1673 0.1 True\n", + "lag_7d Wasserstein distance (normed) 0.1669 0.1 True\n", + "rolling_mean_30d Wasserstein distance (normed) 0.1906 0.1 True\n", + "rolling_mean_7d Wasserstein distance (normed) 0.1883 0.1 True" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d = report.as_dict()[\"metrics\"]\n", + "summary = d[0][\"result\"] # DatasetDriftMetric\n", + "table = d[1][\"result\"][\"drift_by_columns\"] # DataDriftTable (détail par feature)\n", + "\n", + "print(f\"Dérive globale du dataset (dataset_drift) : {summary['dataset_drift']}\")\n", + "print(f\"Features en dérive : {summary['number_of_drifted_columns']} / {summary['number_of_columns']}\"\n", + " f\" ({summary['share_of_drifted_columns']:.0%})\")\n", + "print()\n", + "\n", + "drift_table = pd.DataFrame([\n", + " {\n", + " \"feature\": c[\"column_name\"],\n", + " \"test\": c[\"stattest_name\"],\n", + " \"score\": round(float(c[\"drift_score\"]), 4),\n", + " \"seuil\": c[\"stattest_threshold\"],\n", + " \"dérive ?\": c[\"drift_detected\"],\n", + " }\n", + " for c in table.values()\n", + "]).set_index(\"feature\")\n", + "drift_table\n" + ] + }, + { + "cell_type": "markdown", + "id": "9898c098", + "metadata": {}, + "source": [ + "**Rapport interactif complet** : `tp05_evidently_drift_2011_vs_2014.html` (à ouvrir dans un\n", + "navigateur). Réponses détaillées 2.1 - 2.4 dans `SYNTHESE_TP05.md`.\n" + ] + }, + { + "cell_type": "markdown", + "id": "9ae1fd55", + "metadata": {}, + "source": [ + "## Partie 3 - Mesurer l'impact sur les performances\n", + "\n", + "On entraîne un modèle (régression linéaire) **sur 2011 uniquement**, puis on l'évalue sur **2011**\n", + "(référence, données vues), **2012**, **2013** et **2014**. Métriques : **RMSE** et **MAE** (kWh).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7c203deb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T08:08:41.613938Z", + "iopub.status.busy": "2026-07-25T08:08:41.613743Z", + "iopub.status.idle": "2026-07-25T08:08:45.384820Z", + "shell.execute_reply": "2026-07-25T08:08:45.376857Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Modèle entraîné sur 2011 : 4,116,352 observations | features ['lag_1d', 'lag_7d', 'lag_30d', 'rolling_mean_7d', 'rolling_mean_30d']\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nRMSEMAErôle
année
201141163527.9044.450train (référence)
201244974087.5954.178évaluation (prod)
201344851207.4864.095évaluation (prod)
201444851207.1013.911évaluation (prod)
\n", + "
" + ], + "text/plain": [ + " n RMSE MAE rôle\n", + "année \n", + "2011 4116352 7.904 4.450 train (référence)\n", + "2012 4497408 7.595 4.178 évaluation (prod)\n", + "2013 4485120 7.486 4.095 évaluation (prod)\n", + "2014 4485120 7.101 3.911 évaluation (prod)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def year_xy(year):\n", + " d = df.loc[df[\"year\"] == year, DRIFT_FEATURES + [TARGET]].dropna()\n", + " return d[DRIFT_FEATURES], d[TARGET]\n", + "\n", + "X_train, y_train = year_xy(2011)\n", + "model = LinearRegression().fit(X_train, y_train)\n", + "print(f\"Modèle entraîné sur 2011 : {len(X_train):,} observations | features {DRIFT_FEATURES}\")\n", + "\n", + "rows = []\n", + "for year in [2011, 2012, 2013, 2014]:\n", + " X, y_true = year_xy(year)\n", + " pred = model.predict(X)\n", + " rows.append({\n", + " \"année\": year,\n", + " \"n\": len(X),\n", + " \"RMSE\": root_mean_squared_error(y_true, pred),\n", + " \"MAE\": mean_absolute_error(y_true, pred),\n", + " \"rôle\": \"train (référence)\" if year == 2011 else \"évaluation (prod)\",\n", + " })\n", + "perf = pd.DataFrame(rows).set_index(\"année\")\n", + "perf.round(3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "870dc8a0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T08:08:45.433507Z", + "iopub.status.busy": "2026-07-25T08:08:45.433163Z", + "iopub.status.idle": "2026-07-25T08:08:45.576318Z", + "shell.execute_reply": "2026-07-25T08:08:45.575591Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 5))\n", + "plt.plot(perf.index, perf[\"RMSE\"], marker=\"o\", label=\"RMSE\")\n", + "plt.plot(perf.index, perf[\"MAE\"], marker=\"s\", label=\"MAE\")\n", + "plt.xticks(perf.index)\n", + "plt.xlabel(\"année d'évaluation\")\n", + "plt.ylabel(\"erreur (kWh)\")\n", + "plt.title(\"Performance du modèle entraîné sur 2011, au fil des années\")\n", + "plt.legend()\n", + "plt.grid(alpha=0.3)\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "1ea70b7a", + "metadata": {}, + "source": [ + "**Synthèse.** On confronte la dérive détectée (Parties 1-2) à l'évolution des performances\n", + "(Partie 3) pour caractériser le type de dérive (data drift vs concept drift) et décider de la\n", + "stratégie : surveiller, réentraîner ou redéployer. Réponses détaillées 3.1 - 3.6 dans\n", + "`SYNTHESE_TP05.md`.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}