From 4960f2b7850219bfd5b476ac136c5b5160535550 Mon Sep 17 00:00:00 2001 From: Lino Galiana Date: Wed, 22 Nov 2023 12:02:32 +0100 Subject: [PATCH] Chapitre pipeline scikit sur DVF (#454) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Initialisation du chapitre dvf * update * ajoute des éléments * dvf * probleme * update * version paris only * update * duckdb * version remote * remove * remove * retour du bon header * mef --- content/modelisation/6_pipeline.qmd | 1161 +++++++++++++++------------ reference.bib | 21 + requirements.txt | 3 +- 3 files changed, 657 insertions(+), 528 deletions(-) diff --git a/content/modelisation/6_pipeline.qmd b/content/modelisation/6_pipeline.qmd index 62c1a92d7..28b14fe35 100644 --- a/content/modelisation/6_pipeline.qmd +++ b/content/modelisation/6_pipeline.qmd @@ -1,10 +1,8 @@ --- title: "Premier pas vers l'industrialisation avec les pipelines scikit" -date: 2020-10-20T13:00:00Z -draft: false +date: 2023-10-20T13:00:00Z weight: 60 slug: pipeline-scikit -type: book tags: - scikit - Machine Learning @@ -15,13 +13,15 @@ categories: - Modélisation - Tutoriel description: | - Les _pipelines_ `scikit` permettent d'intégrer de manière très flexible + Les _pipelines_ `Scikit` permettent d'intégrer de manière très flexible un ensemble d'opérations de pre-processing et d'entraînement de modèles dans une chaîne d'opérations. Il s'agit d'une approche particulièrement appropriée pour réduire la difficulté à changer d'algorithme ou pour - faciliter la ré-application d'un code à de nouvelles données + faciliter la ré-application d'un code à de nouvelles données. eval: false +echo: false image: featured.png +bibliography: ../../reference.bib --- @@ -41,26 +41,76 @@ print_badges("content/modelisation/6_pipeline.qmd") ``` ::: -## Pourquoi utiliser les pipelines ? +Pour lire les données de manière efficace, nous +proposons d'utiliser le _package_ `duckdb`. +Pour l'installer, voici la commande: + +```{python} +#| eval: true +#| output: false +#| echo: true +!pip install duckdb +``` + +## Pourquoi utiliser les _pipelines_ ? + +### Définitions préalables + +Ce chapitre nous amènera à explorer plusieurs écosystèmes, pour lesquels on retrouve quelques buzz-words dont voici les définitions : + +| Terme | Définition | +|-------|------------| +| _DevOps_ | Mouvement en ingénierie informatique et une pratique technique visant à l’unification du développement logiciel (dev) et de l’administration des infrastructures informatiques (ops) | +| _MLOps_ | Ensemble de pratiques qui vise à déployer et maintenir des modèles de machine learning en production de manière fiable et efficace | + +Ce chapitre fera des références régulières au cours +de 3e année de l'ENSAE +[_"Mise en production de projets data science"_](https://ensae-reproductibilite.github.io/website/). + + +### Objectif Les chapitres précédents ont permis de montrer des bouts de code épars pour entraîner des modèles ou faire du _preprocessing_. Cette démarche est intéressante pour tâtonner mais risque d'être coûteuse -ultérieurement s'il est nécessaire d'ajouter une étape de preprocessing +ultérieurement s'il est nécessaire d'ajouter une étape de _preprocessing_ ou de changer d'algorithme. -Heureusement, `scikit` propose un excellent outil pour proposer un cadre +Les _pipelines_ sont pensés pour simplifier la mise en production +ultérieure d'un modèle de _machine learning_. +Ils sont au coeur de la démarche de _MLOps_ qui est +présentée +dans le cours de 3e année de l'ENSAE +de [_"Mise en production de projets data science"_](https://ensae-reproductibilite.github.io/website/). +qui vise à simplifier la mise en oeuvre opérationnelle de +projets utilisant des techniques de _machine learning_. + +```{python} +#| echo: true +#| eval: true +import matplotlib.pyplot as plt +import seaborn as sns +import numpy as np +import pandas as pd +``` + +### Les _pipelines_ `Scikit` + +Heureusement, `Scikit` propose un excellent outil pour proposer un cadre général pour créer une chaîne de production *machine learning*. Il s'agit des [_pipelines_](https://scikit-learn.org/stable/modules/compose.html). Ils présentent de nombreux intérêts, parmi lesquels: -* Ils sont très __pratiques__ et __lisibles__. On rentre des données en entrée, on n'appelle qu'une seule fois les méthodes `fit` et `predict` ce qui permet de s'assurer une gestion cohérente des transformations de variables, par exemple après l'appel d'un `StandardScaler` -* La __modularité__ rend aisée la mise à jour d'un pipeline et renforce la capacité à le réutiliser -* Ils permettent de facilement chercher les hyperparamètres d'un modèle. Sans *pipeline*, écrire un code qui fait du *tuning* d'hyperparamètres peut être pénible. Avec les *pipelines*, c'est une ligne de code. +* Ils sont très __pratiques__ et __lisibles__. On rentre des données en entrée, on n'appelle qu'une seule fois les méthodes `fit` et `predict` ce qui permet de s'assurer une gestion cohérente des transformations de variables, par exemple après l'appel d'un `StandardScaler` ; +* La __modularité__ rend aisée la mise à jour d'un pipeline et renforce la capacité à le réutiliser ; +* Ils permettent de facilement chercher les hyperparamètres d'un modèle. Sans *pipeline*, écrire un code qui fait du *tuning* d'hyperparamètres peut être pénible. Avec les *pipelines*, c'est une ligne de code ; * La __sécurité__ d'être certain que les étapes de preprocessing sont bien appliquées aux jeux de données désirés avant l'estimation. + + + ::: {.cell .markdown} ```{=html}