diff --git a/_quarto.yml b/_quarto.yml
index 71ecc2288..fecf402c5 100644
--- a/_quarto.yml
+++ b/_quarto.yml
@@ -15,8 +15,10 @@ project:
     - content/manipulation/01_numpy.qmd
     - content/manipulation/02a_pandas_tutorial.qmd
     - content/manipulation/02b_pandas_TP.qmd
-    - content/modelisation/0_preprocessing.qmd
+    - content/visualisation/index.qmd
+    - content/modelisation/index.qmd
     - content/NLP/index.qmd
+    - content/annexes/evaluation.qmd
 
 website:
   title: "Python pour la data science"
diff --git a/content/annexes/evaluation.qmd b/content/annexes/evaluation.qmd
index 4edc0f61c..0b1c6cfb9 100644
--- a/content/annexes/evaluation.qmd
+++ b/content/annexes/evaluation.qmd
@@ -6,94 +6,190 @@ description: |
 image: https://minio.lab.sspcloud.fr/lgaliana/generative-art/pythonds/kid.png
 ---
 
-Résumé : 
+# Résumé 
 
 * A la fin du semestre, les étudiants rendront un projet informatique par __groupe de 2-3 personnes.__
-* Ce projet dont le __sujet est libre__ devra comporter
-    - Un jeu de données (de préférence collecté par le groupe ou _a minima_ enrichi)
-    - De la visualisation
-    - De la modélisation
+* Ce projet dont le __sujet est libre__ devra comporter:
+    - Une valorisation d'un ou plusieurs jeux de données _open data_ ou collectés par le biais de _scraping_ ou d'API ; 
+    - De la visualisation ;
+    - De la modélisation. 
 * Les étudiants sont invités à proposer des sujets qui leur plaisent, à faire valider par le chargé de TD.
 * __Le projet doit utiliser `Git` et être disponible sous
-[Github](https://github.com/) <a href="https://github.com" class="github"><i class="fab fa-github"></i></a> ou [gitlab](https://gitlab.com/)__ <a href="https://gitlab.com" class="gitlab"><i class="fab fa-gitlab"></i></a> (dépôt public ou dépôt privé à partager avec le chargé de TD)
+[`Github`](https://github.com/) <a href="https://github.com" class="github"><i class="fab fa-github"></i></a>__ (dépôt public ou dépôt privé à partager avec le chargé de TD) ;
+* Le projet doit être __reproductible__ sous peine de sanction forte. Cela implique des morceaux de code reproductibles, une description des dépendances et des explications si nécessaire sur la récupération des données ;
 * La __date du rendu__ est fixée au : **30 décembre 2023 23h59**
 * Le **12 janvier 2024**, auront lieu des __soutenances__
  
 
-## Attentes du projet
+# Attentes du projet
 
 Le projet est une problématique à laquelle vous souhaitez répondre à
 l’aide d’un ou de plusieurs jeu(s) de données.
 
-Il faut donc dans un premier temps se pencher sur la recherche de problématisation et de contextualisation. Nous vous recommandons de prendre un sujet qui vous intéresse pour intéresser également le lecteur.
+Il faut donc dans un premier temps se pencher sur la recherche de problématisation et de contextualisation. Nous vous recommandons de prendre un sujet qui vous plaît afin d'être
+motivé à impliquer le lecteur dans votre démarche.
 
 Trois dimensions doivent être présentes dans le projet.
 Pour chacune de ces parties, il est possible d’aller plus ou moins loin. Il est recommandé d’aller loin sur au moins une des 3 dimensions.
 
 
-### La récupération et le traitement des données
+## La récupération et le traitement des données
 
-Ces données peuvent être directement disponibles sous la forme de fichiers txt, csv … ou provenir de sites internet (scraping, API). Plus le travail sur la récupération de données est important (par exemple scraping sur plusieurs sites), plus la partie obtiendra de points. Si le jeu de données utilisé est un téléchargement d’un jeu propre existant, il faudra chercher à le compléter d’une manière ou d’une autre pour obtenir des points sur cette partie.
+Ces données peuvent être directement disponibles sous la forme de fichiers txt, csv … ou provenir de sites internet (scraping, API). Plus le travail sur la récupération de données est important (par exemple _scraping_ sur plusieurs sites, données croisées récupérées par le biais d'API et de fichiers...), plus la partie obtiendra de points. Si le jeu de données utilisé est un téléchargement d’un jeu propre existant, il faudra chercher à le compléter d’une manière ou d’une autre pour obtenir des points sur cette partie.
 
-Vous obtiendrez vraisemblablement des données qui ne sont pas « propres » du premier coup : mettez en place des protocoles de nettoyage pour obtenir à la fin de cette étape un ou des jeux de données fiable et robuste pour mener ensuite votre analyse. C’est également le moment de créer des variables plus appréhendables, mieux identifiées etc.
+Vous obtiendrez vraisemblablement des données qui ne sont pas « propres » du premier coup : mettez en place des protocoles de nettoyage pour obtenir à la fin de cette étape un ou des jeux de données fiable et robuste pour mener ensuite votre analyse. C’est également le moment de créer des variables plus appréhendables, mieux identifiées. N'oubliez pas de justifier les choix méthodologiques que vous avez pu faire car le chargé de TD ne connaît pas forcément la base de données en question. 
 
-### L’analyse descriptive et la représentation graphique
+## L’analyse descriptive et la représentation graphique
 
-La présence de statistiques descriptives est indispensable dans le projet. De la description de la base aux premières grandes tendances des données, cette partie permet d’avoir une vision globale des données : le lien avec la problématique, comment elle permet d’y répondre, quels sont les premiers éléments de réponse… Chaque résultat doit être interprété : pas la peine de faire un describe et de ne pas le commenter.
- En termes de représentation graphique, plusieurs niveaux sont envisageables. Vous pouvez simplement représenter vos données en utilisant matplotlib, aller plus loin avec seaborn ou scikit-plot, (voire D3.js pour les plus motivés). La base d’une bonne visualisation est de trouver le type de graphique adéquat pour ce que vous voulez montrer (faut-il un scatter ou un line pour représenter une évolution ?) et de le rendre visible : une légende qui a du sens, des axes avec des noms etc. Encore une fois, il faudra commenter votre graphique, qu’est ce qu’il montre, en quoi cela valide / contredit votre argumentaire ?
+La présence de statistiques descriptives est indispensable dans le projet. De la description de la base aux premières grandes tendances des données, cette partie permet d’avoir une vision globale des données : le lien avec la problématique, comment elle permet d’y répondre, quels sont les premiers éléments de réponse… Chaque résultat doit être interprété : pas la peine de faire un `describe` et de ne pas le commenter.
 
-### La modélisation
+En termes de représentation graphique, plusieurs niveaux sont envisageables, selon le degré d'approfondissement de cette partie. La base d’une bonne visualisation est de trouver le type de graphique adéquat pour ce que vous voulez montrer et de le rendre visible : une légende qui a du sens, des axes avec des noms etc.
 
- Vient ensuite la phase de modélisation : un modèle peut être le bienvenu quand des statistiques descriptives ne suffisent pas à apporter une solution complète à votre problématique ou pour compléter / renforcer l’analyse descriptive. Le modèle importe peu (régression linéaire, random forest ou autre) : il doit être approprié (répondre à votre problématique) et justifié.
+Encore une fois, il faudra commenter votre graphique: qu’est ce qu’il montre, en quoi cela valide / contredit votre argumentaire ?
+
+
+::: {#nte-appli .callout-note collapse="true"}
+## Les applications réactives
+
+Dans le cadre de ce cours, nous présentons plusieurs librairies graphiques permettant de créer des visualisations de données interactives, notamment `Plotly` ou `Leaflet`. Pour aller plus loin, vous pouvez désirer créer des applications encapsulant plusieurs graphiques construits automatiquement
+en fonction de choix de l'utilisateur sur une interface graphique.
+
+Tout d'abord, ce n'est pas un prérequis pour ce cours. Le cours de 3e année ["Mise en production de projets de _data science_"](https://ensae-reproductibilite.github.io/website/)
+que Romain Avouac et moi donnons à l'ENSAE vous permettra de mettre en oeuvre ceci, qui fait appel à des concepts plus avancés qu'une introduction à `Python` pour la science des données. 
+
+C'est néanmoins un plus qui est apprécié et si vous désirez aller dans cette voie, il est recommandé de bien choisir son écosystème. Il vaut mieux mettre en oeuvre des _frameworks web_ modernes comme
+`Streamlit` que des clients lourds comme `tkinter` qui rendent le code difficilement reproductible
+car adhérant à une configuration logicielle. Pour en savoir plus, se reporter
+à l'[introduction de la partie visualisation](/content/visualisation/index.qmd).
+
+Si vous faites une application réactive, vous n'êtes pas obligé de rédiger un _notebook_.
+Cependant, faites en sorte que votre application propose une page présentant votre démarche
+afin de faire comprendre à votre lecteur la problématique et les solutions mises en oeuvre.  
+Cette application doit être reproductible sur le `SSPCloud` par le biais, par exemple, 
+d'un `streamlit run`. Il est donc vivement recommandé de développer celle-ci sur le SSPCloud
+où la reproductibilité est maximale. 
+:::
+
+## La modélisation
+
+Vient ensuite la phase de modélisation : un modèle peut être le bienvenu quand des statistiques descriptives ne suffisent pas à apporter une solution complète à votre problématique ou pour compléter / renforcer l’analyse descriptive. Le modèle importe peu (régression linéaire, random forest ou autre) : il doit être approprié (répondre à votre problématique) et justifié.
 Vous pouvez aussi confronter plusieurs modèles qui n’ont pas la même vocation : par exemple une CAH pour catégoriser et créer des nouvelles variables / faire des groupes puis une régression. 
 Même si le projet n’est pas celui du cours de stats, il faut que la démarche soit scientifique et que les résultats soient interprétés.
 
 
-## Format du rendu
+# Format du rendu
 
- Sur le format du rendu, vous devrez :
+Sur le format du rendu, vous devrez :
 
-* Écrire un rapport sous forme de `Notebook` (quelques exceptions à cette règle peuvent exister, par exemple si vous développer une appli `Dash`)
-* Avoir un répertoire `Github` avec le rapport. Les données utilisées doivent être accessibles également, dans le dépôt ou sur internet.
+* Écrire un rapport sous forme de _Notebook_ (quelques exceptions à cette règle peuvent exister, par exemple si vous développer une appli `Dash` ou `Streamlit` comme expliqué dans la @nte-appli) ou de `Quarto Markdown`. Soyez vigilant avec le contrôle de version (@imp-gitnb)
+* Avoir un projet `Github` avec le rapport. Les données utilisées doivent être accessibles également, dans le dépôt, sur internet ou sur l'espace de stockage du `SSPCloud` (@tip-s3).
 * Les __dépôts `Github` où seul un *upload* du projet a été réalisé seront pénalisés__. A l'inverse, les dépôts dans lequels le contrôle de version et le travail collaboratif ont été activement pratiqués (`commits` fréquents, `pull requests`, ..) seront valorisés.
 * Le code contenu dans le rapport devra être un maximum propre (pas de copier coller de cellule, préférez des fonctions)
 
-[Ce post](https://towardsdatascience.com/8-guidelines-to-create-professional-data-science-notebooks-97572894b2e5) donne
-quelques conseils pour avoir des notebooks agréables à lire. N'oubliez pas cette règle :
 
-> code is read much more often than written
 
-Lors de l'évaluation, une attention particulière sera donnée à la *reproductibilité* de votre projet.
-Chaque étape (récupération et traitement des données, analyses descriptives, modélisation) doit pouvoir être reproduite à partir du notebook final. Pour les opérations qui prennent du temps (ex : web scraping massif, requêtage d'API avec des limites de nombre de requêtes, entraînement de modèle, etc.), vous devez inclure l'output (base de données, modèle entraîné..) dans le dépôt, afin que les étapes suivantes puissent s'éxecuter sans problème.
-Le test à réaliser : faire tourner toutes les cellules de votre notebook et ne pas avoir d’erreur est une condition _sine qua non_ pour avoir la moyenne.
+::: {#imp-gitnb .callout-important collapse="true"}
+## `Git` et les _notebooks_
+
+Faites attention au contrôle de version avec les _notebooks_, cela ne fait pas toujours bon ménage.  
+
+Comme expliqué dans le [chapitre sur `Git`](/content/git/exogit.qmd), lorsque vous travaillez sur le même fichier en même temps vous pouvez vous retrouver avec un conflit de version lorsque vous résolvez les différences dans vos dépôts.
+Dans les _notebooks_ cela peut se traduire par de multiples conflits de version car deux _notebooks_ en apparence similaires peuvent contenir beaucoup d'éléments différents dans les fichiers bruts (un `JSON` assez complexe, embarquant notamment des _id_ d'exécution de cellules changeant systématiquement). Un _merge_ mal géré peut rendre un _notebook_ invalide. 
+
+Il est recommandé de ne pas travailler sur un même _notebook_ sur une même branche en même temps. Cela fait donc beaucoup de conditions pour arriver à un conflit de version mais dans le _rush_ inhérent à tout projet cela peut vite arriver. Outre la coordination, nous pouvons vous conseiller
+de déporter une partie du code dans des fichiers `.py` importés sous forme de module par le _notebook_. De toute manière, c'est une bonne pratique de ne pas accumuler de trop longues instructions de code dans un _notebook_ car cela freine la lisibilité et l'intelligibilité de celui-ci. 
+:::
+
+
+::: {#tip-s3 .callout-tip collapse="true"}
+## Sauvegarder des données sur le système de stockage du `SSPCloud`
+
+⚠️ __Cette approche n'est pertinente que pour des données dont le temps d'acquisition est suffisamment long pour être dérangeant et ne doit pas être considéré comme une carte blanche à l'absence de reproductibilité.__
 
+Il peut être pénible de refaire tourner fréquemment le code de récupération des données, notamment
+si celui-ci est long. Sous cette condition, il est normal de vouloir écrire des données
+intermédiaires pour des analyses ultérieures (au format `CSV` ou encore mieux au format `Parquet`).
+Se pose alors la question de l'enregistrement pérenne de celles-ci, les conteneurs sur le
+_SSPCloud_ n'étant pas persistant. 
 
-## Barème approximatif
+Ces données ne doivent pas être mises dans le dépôt `Github`, ce n'est pas le lieu adapté. 
+Pour le stockage pérenne de données, le _sspcloud_ propose un système de
+stockage `S3` (technologie identique à celle des principaux _cloud providers_).
+Dans un service ayant moins de 24 heures, afin d'avoir des jetons de connexion
+n'étant pas périmés, on instancie la connexion avec 
 
-* Données (collecte et nettoyage) : 4 points
-* Analyse descriptive : 4 points
-* Modélisation : 2 points
-* Démarche scientifique et reproductibilité du projet : 4 points
-* Format du code (code propre et github) : 2 points
-* Soutenance : 4 points
+```python
+import s3fs
+fs = s3fs.S3FileSystem(
+    client_kwargs={'endpoint_url': 'https://'+'minio.lab.sspcloud.fr'}
+)
+```
 
-Le projet doit être réalisé en groupe de trois, voire deux. 
+Cette connexion permet de créer un système de fichier distant
+comme si on était en local. 
+Pour écrire un fichier au format `Parquet` sur cet espace avec `Pandas`, il suffit
+de partir du modèle suivant
+
+```python
+with fs.open("s3/<USERNAME>/<dossier(s)>/<fichier>.parquet") as f:
+  df.to_parquet(f)
+```
+
+Ce principe peut être utilisé pour tout type d'objet, en prenant
+le format adéquat.
+
+A ce stade, ce fichier est privé. Il n'est donc pas lisible
+par un autre utilisateur. Pour le rendre disponible à quelqu'un
+d'autre, il faut rendre disponible ce fichier à un accès _anonyme_. Pour
+cela, en ligne de commande il faut faire:
+
+```shell
+mc anonymous set download s3/<USERNAME>/<dossier(s)>/<fichier>.parquet
+```
+
+Ce fichier devient disponible à n'importe qui par un lien HTTPS. Pour le 
+lire, il suffira de faire
+
+```python
+import pandas as pd
+pd.read_parquet("https://minio.lab.sspcloud.fr/<USERNAME>/<dossier(s)>/<fichier>.parquet")
+```
+
+Pour en savoir plus sur le système S3, les 
+librairies `Python` ou les différentes
+manières de procéder, consulter [ce chapitre](/content/modern-ds/s3.qmd)
+
+:::
+
+
+
+# Barème approximatif
+
+| Catégorie                                         | Points |
+|---------------------------------------------------|--------|
+| Données (collecte et nettoyage)                   | 4      |
+| Analyse descriptive                               | 4      |
+| Modélisation                                      | 2      |
+| Démarche scientifique et reproductibilité du projet | 4      |
+| Format du code (code propre et github)            | 2      |
+| Soutenance                                        | 4      |
+
+Lors de l'évaluation, une attention particulière sera donnée à la *reproductibilité* de votre projet.
+Chaque étape (récupération et traitement des données, analyses descriptives, modélisation) doit pouvoir être reproduite à partir du notebook final. 
+
+Le test à réaliser : faire tourner toutes les cellules de votre notebook et ne pas avoir d’erreur est une condition _sine qua non_ pour avoir la moyenne.
 
 
-## Projets menés par les étudiants
+# Projets menés par les étudiants 😍
 
 | Projet | Auteurs | URL projet <a href="https://github.com" class="github"><i class="fab fa-github"></i></a> | Tags |
 |--------|---------|------------|------|
-| GPS vélo intégrant les bornes Vélib, les accidents, la congestion et la météo | Vinciane Desbois ; Imane Fares ; Romane Gajdos | https://github.com/ImaneFa/Projet_Python | Vélib ; Pistes cyclables ; Accidents ; Folium|
-| Quiz Generator | Adrien Servière ; Mélissa Tamine | https://github.com/taminemelissa/quiz-generator | Machine Learning ; Natural Language Processing ; Question Generation ; Word2Vec |
-| Analyse de sentiments sur les vaccins COVID administrés en France | KOAGNE FONGUIENG Florette ; KONKOBO Idrissa | https://github.com/kidrissa/projetpy | API ; NLP ; Wordcloud ; Modélisation prédictive|
-| Estimation de l'empreinte carbone d'une recette de cuisine | Jean-Baptiste Laval ; Hadrien Lolivier ; Sirine Louati | https://github.com/sirinelouati/Plat_CO2 | scraping ; Dashboard ; Empreinte carbone ; Alimentation |
-| Le "bon sens du boucher-charcutier de Tourcoing vaut-il mieux que les enquêtes de victimation ?" | Conrad Thiounn ; Gaston Vermersch | https://github.com/cthiounn/python-datascience-ENSAE-2A | API ; Open-data ; ACP ; CAH ; LASSO |
-| Prédiction du revenu généré par un film en fonction de ses caractéristiques | Dmitri Lebrun ; Corentin Pernot ; Nina Stizi | https://github.com/NinaStizi/Python_ENSAE_2A | Scrapping ; Cinéma ; Machine Learning |
-| Analyse du réseau ferré de la SNCF: Comment expliquer les retards permanents de la compagnie française ? | Diego Renaud ; Victor Parent ; Marion Chabrol | https://github.com/NinaStizi/Python_ENSAE_2A | API ; SNCF ; LASSO |
-| Le "bon sens du boucher-charcutier de Tourcoing vaut-il mieux que les enquêtes de victimation ?" | Conrad Thiounn ; Gaston Vermersch | https://github.com/cthiounn/python-datascience-ENSAE-2A | API ; Open-data ; ACP ; CAH ; LASSO |
-| Prédiction du revenu généré par un film en fonction de ses caractéristiques | Dmitri Lebrun ; Corentin Pernot ; Nina Stizi | https://github.com/NinaStizi/Python_ENSAE_2A | Scrapping ; Cinéma ; Machine Learning |
-| Analyse du réseau ferré de la SNCF: Comment expliquer les retards permanents de la compagnie française ? | Diego Renaud ; Victor Parent ; Marion Chabrol | https://github.com/NinaStizi/Python_ENSAE_2A | API ; SNCF ; LASSO |
+| GPS vélo intégrant les bornes Vélib, les accidents, la congestion et la météo | Vinciane Desbois ; Imane Fares ; Romane Gajdos | [https://github.com/ImaneFa/Projet_Python](https://github.com/ImaneFa/Projet_Python) | Vélib ; Pistes cyclables ; Accidents ; Folium|
+| Quiz Generator | Adrien Servière ; Mélissa Tamine | [https://github.com/taminemelissa/quiz-generator](https://github.com/taminemelissa/quiz-generator)| Machine Learning ; Natural Language Processing ; Question Generation ; Word2Vec |
+| Estimation de l'empreinte carbone d'une recette de cuisine | Jean-Baptiste Laval ; Hadrien Lolivier ; Sirine Louati | [https://github.com/sirinelouati/Plat_CO2](https://github.com/sirinelouati/Plat_CO2) | scraping ; Dashboard ; Empreinte carbone ; Alimentation |
+| Le "bon sens du boucher-charcutier de Tourcoing vaut-il mieux que les enquêtes de victimation ?" | Conrad Thiounn ; Gaston Vermersch | [https://github.com/cthiounn/python-datascience-ENSAE-2A](https://github.com/sirinelouati/Plat_CO2) | API ; Open-data ; ACP ; CAH ; LASSO |
+| Prédiction du revenu généré par un film en fonction de ses caractéristiques | Dmitri Lebrun ; Corentin Pernot ; Nina Stizi | [https://github.com/NinaStizi/Python_ENSAE_2A](https://github.com/sirinelouati/Plat_CO2) | Scrapping ; Cinéma ; Machine Learning |
+| Analyse du réseau ferré de la SNCF: Comment expliquer les retards permanents de la compagnie française ? | Diego Renaud ; Victor Parent ; Marion Chabrol | [https://github.com/NinaStizi/Python_ENSAE_2A](https://github.com/NinaStizi/Python_ENSAE_2A) | API ; SNCF ; LASSO |
 
 <!---
 -----Suivre ce modèle------
diff --git a/content/visualisation/index.qmd b/content/visualisation/index.qmd
index 8315283cc..191513ed4 100644
--- a/content/visualisation/index.qmd
+++ b/content/visualisation/index.qmd
@@ -1,5 +1,5 @@
 ---
-title: "Partie 2: visualiser les données"
+title: "Partie 2: communiquer à partir de données"
 categories:
   - Introduction
   - Visualisation
@@ -13,7 +13,56 @@ image: https://minio.lab.sspcloud.fr/lgaliana/generative-art/pythonds/snake-char
 bibliography: ../../reference.bib
 ---
 
-La visualisation de données est l'art et la science de représenter visuellement des informations complexes et abstraites à l'aide d'éléments visuels.
+# Introduction
+
+Une partie essentielle du travail du _data scientist_
+consiste à synthétiser l'information que
+contient ses 
+jeux de données afin de distinguer
+ce qui relève du signal, sur lequel il 
+pourra se concentrer, et ce qui relève
+du bruit
+inhérent à tout jeu de données. 
+Dans le travail du _data scientist_, lors d'une phase
+exploratoire, il y a
+donc un aller-retour constant entre information synthétique
+et jeu de données désagrégé. Il 
+est ainsi essentiel de savoir synthétiser l'information
+dans un jeu de données avant d'en saisir la structure, cette
+dernière pouvant ensuite guider les exploitations ultérieures,
+pour une phase de modélisation ou de correction de
+données (détection d'anomalies ou de mauvaises remontées de données).
+
+Nous avons déjà exploré une partie essentielle de ce travail,
+à savoir la construction de statistiques descriptives pertinentes
+et fiables. Néanmoins, si on se contentait de présenter l'information
+en utilisant des sorties brutes issues du combo `groupby` et `agg`
+sur un _DataFrame_ `Pandas`, notre connaissance des données serait assez
+limitée. La mise en oeuvre de tableaux stylisés à partir
+de `great tables` constituait déjà un progrès dans cette démarche mais, en vérité,
+notre cerveau se représente l'information de manière beaucoup plus intuitive
+par le biais de visualisations graphiques simples. 
+
+## La visualisation des données, une part essentiel du travail de communication
+
+En tant qu'humains,
+nos
+capacités cognitives étant limitées, nous ne pouvons
+appréhender qu'une information limitée là où l'ordinateur est capable de traiter
+de grands volumes d'information. En tant que _data scientist_, cela signifie
+qu'utiliser nos compétences informatiques et statistiques pour obtenir
+des représentations synthétiques de nos nombreux jeux de données est
+essentiel pour être en mesure de répondre à nos besoins opérationnels ou
+statistiques. 
+L'ensemble des méthodes et des outils qui constituent la boîte à outil
+des _data scientists_ vise à simplifier l'appréhension puis l'exploitation
+de jeux de données dont le volume dépasse nos capacités cognitives. 
+
+
+Ceci nous entraîne vers la question de la visualisation des données,
+un ensemble d'outils et de principes pour représenter de manière
+synthétique des faits stylisés ou contextualiser une donnée individuelle.
+La visualisation de données est l'art et la science de __représenter visuellement des informations complexes et abstraites à l'aide d'éléments visuels__.
 Son objectif principal est de synthétiser l'information présente dans un ensemble de données afin de faciliter
 la compréhension des enjeux de celle-ci pour une analyse ultérieure. 
 La visualisation de données permet, entre autres, de mettre en évidence des tendances, des corrélations ou
@@ -25,7 +74,44 @@ processus d'analyse de données en fournissant des moyens visuels pour explorer,
 Elle facilite la communication entre experts de la données, décideurs et grand public,
 en permettant de raconter des histoires basées sur les données de manière plus convaincante et engageante.
 
-La visualisation de données a une place à part dans 
+## La place de la visualisation dans le processus de valorisation de la donnée
+
+La visualisation des données n'est pas restreinte à la phase finale d'un projet,
+à la communication de résultats à une audience qui n'a pas accès à la donnée
+ou n'a pas les moyens de la valoriser. 
+La visualisation intervient à toutes les étapes du processus de valorisation
+de la donnée. Il s'agit d'ailleurs d'un travail essentiel pour trouver
+comment basculer de l'enregistrement, un instantané d'un phénomène, à une donnée,
+un enregistrement qui a une valeur parce qu'il porte une information en tant que telle
+ou lorsqu'il est combiné avec d'autres enregistrements. 
+
+Le travail quotidien du _data scientist_ 
+consiste à regarder un jeu de données sous toutes ses coutures
+pour identifier les axes prioritaires d'extraction de valeur. 
+Savoir rapidement quelles statistiques représenter, et comment,
+est essentiel pour gagner du temps sur cette partie exploratoire. 
+Il s'agit principalement d'un travail de communication envers soi-même
+qui peut se permettre d'être brouillon car il s'agit de dégrossir
+le travail avant de polir certains angles. L'enjeu à ce niveau du
+processus est de ne pas manquer une dimension qui pourrait être
+porteuse de valeur. 
+
+Le travail de communication réellement chronophage intervient plutôt
+lorsqu'on communique à une audience ayant un accès limité à des
+données, ne connaissant pas bien les sources, ayant
+un temps d'attention sur limité
+ou n'ayant pas des compétences quantitatives. Ces
+publics ne peuvent se satisfaire d'une sortie brute comme
+un _DataFrame_ dans un _notebook_ ou un graphique produit 
+en quelques secondes avec la méthode `plot` de `Pandas`. 
+Il convient de s'adapter à leurs attentes, qui évoluent, 
+et aux outils qu'ils connaissent, d'où la place de plus en
+plus importante prise par les sites
+web de _data visualisations_. 
+
+# Communiquer, une ouverture au _data storytelling_
+
+La visualisation de données a ainsi une place à part dans 
 l'ensemble des techniques de la _data science_. 
 Elle intervient à tous les stades du processus de 
 production de la donnée, de
@@ -51,32 +137,7 @@ produire rapidement quelques visualisations permettant
 de synthétiser les jeux de données à sa disposition. 
 Une visualisation claire et lisible tout en restant simple
 peut être meilleure qu'un discours pour faire passer un message.
-Je recommande notamment
-ce [post de blog](https://www.icem7.fr/datavisualisation/recreation-recreation-semiologique/)
-d'Eric Mauvière qui revient sur deux graphiques dans une publication
-récente
-du [Service statistique du Ministère de la Santé (DREES)](https://drees.solidarites-sante.gouv.fr/publications-communique-de-presse/etudes-et-resultats/mesures-socio-fiscales-2017-2022-une-hausse)
-et montre la manière dont on peut améliorer le message transmis
-par des figures :
 
-::: {#fig-dataviz-amelioree1 layout-ncol=2 layout-valign="bottom"}
-
-![Figure 1 originale](https://www.icem7.fr/wp-content/uploads/2023/08/recreation-aires1.png){group="figure1-mauviere"}
-
-![Figure 1 modifiée](https://www.icem7.fr/wp-content/uploads/2023/08/recreation-aires35.png){group="figure1-mauviere"}
-
-Décomposition du revenu disponible d'une personne seule en juillet 2022, selon son salaire brut
-:::
-
-
-::: {#fig-dataviz-amelioree2 layout-ncol=2 layout-valign="bottom"}
-
-![Figure 2 originale](https://www.icem7.fr/wp-content/uploads/2023/08/recreation-barres1.png){group="figure2-mauviere"}
-
-![Figure 2 modifiée](https://www.icem7.fr/wp-content/uploads/2023/08/recreation-barres35.png){group="figure2-mauviere"}
-
-Evolution du revenu disponible d'une personne seule entre juillet 2017 et juillet 2022, selon son niveau de salaire brut
-:::
 
 De même qu'un discours, une visualisation est une communication
 pour laquelle un locuteur - la personne construisant la visualisation - 
@@ -93,9 +154,76 @@ techniques mises en oeuvre pour transmettre un message
 graphique et de nombreuses visualisations, si elles
 suivaient quelques-unes de ces règles, pourraient
 être améliorées à peu de frais. 
-L'Insee a publié, il y a quelques années, un guide de 
-sémiologie graphique très utile qu'il
-est intéressant de consulter de temps en temps [@inseeSemiologie].
+
+Eric Mauvière, statisticien français héritier
+de l'école de la sémiologie graphique de Bertin, 
+propose d'excellents contenus sur le sujet. Certaines
+des présentations qu'il a pu faire, notamment
+celle pour le [`SSPHub`](https://ssphub.netlify.app/)
+présentées dans la @nte-mauviere
+devraient être visionnées dans toutes les formations
+de _data science_ tant elles évoquent les nombreux
+écueils rencontrés par les _data scientists_. 
+
+![Un exemple de deux visualisations faites sur le même jeu de données par Eric Mauvière, voir @nte-mauviere](https://raw.githubusercontent.com/InseeFrLab/ssphub/main/talk/2024-02-29-mauviere/mauviere.png)
+
+
+
+::: {#nte-mauviere .callout-note collapse="true"}
+## Une conférence d'Eric Mauvière sur le sujet
+
+```{ojs}
+//| echo: false
+html`${slides_button}`
+```
+
+
+{{< video src="https://minio.lab.sspcloud.fr/lgaliana/ssphub/replay/20240229-dataviz-mauviere/video1991622347.mp4" controls="yes" >}}
+
+
+```{ojs}
+//| echo: false
+slides = "https://minio.lab.sspcloud.fr/lgaliana/ssphub/replay/20240229-dataviz-mauviere/conf_ssphub_icem7.pdf"
+```
+
+```{ojs}
+//| echo: false
+slides_button = html`<p class="text-center">
+  <a class="btn btn-primary btn-lg cv-download" href="${slides}" target="_blank">
+    <i class="fa-solid fa-file-arrow-down"></i>&ensp;Télécharger les slides
+  </a>
+</p>`
+```
+
+:::
+
+
+# Communiquer, une ouverture à la mise à disposition d'applications
+
+L'objectif de ce cours est d'introduire aux principaux outils
+et à la démarche que doivent adopter les _data scientists_
+face à divers jeux de données. Il devient néanmoins de
+plus en plus commun pour les _data scientists_
+de développer et mettre à disposition des applications
+interactives proposant un certain nombre d'explorations
+et de visualisations automatisées de données. 
+Il s'agit d'enjeux plus avancés que ce cours mais qui constituent
+souvent un point d'entrée vers la _data science_ pour des
+publics proches des _data scientists_. 
+
+Nous évoquerons certains des outils privilégiés pour faire
+cela, notamment les écosystèmes liés aux applications _web_
+et aux outils `Javascript`. Ce besoin, devenu assez standard
+pour les _data scientists_, fait la passerelle avec la mise
+en production,
+l'enjeu principal d'un cours de 3e année de l'ENSAE
+construit par Romain Avouac et moi-même ([site web du cours](https://ensae-reproductibilite.github.io/website/)). Le présent site web, par exemple, est construit
+selon ce principe grâce à des outils permettant d'exécuter de manière 
+reproductible du `Python` sur des serveurs standardisés et ensuite
+mettre à disposition ce code par le biais d'un site web. 
+
+
+# L'écosystème `Python` {{< fa brands python >}}
 
 Pour revenir à notre cours,
 nous présenterons dans cette partie quelques librairies
@@ -104,10 +232,9 @@ partir sur de bonnes bases. Les ressources pour
 approfondir et progresser dans l'art de la visualisation
 ne manquent pas, comme [cet ouvrage](https://clauswilke.com/dataviz/) [@wilke2019fundamentals]. 
 
+## Les _packages_ de visualisations de données
 
-## L'écosystème `Python` {.unnumbered}
-
-L'écosystème `Python` pour la valorisation de données est très riche et
+L'écosystème `Python` pour la visualisation de données est très riche et
 très éclaté.
 Il est
 possible de consacrer des livres entiers à celui-ci [@dale2022data].
@@ -119,9 +246,9 @@ Les librairies graphiques se distinguent principalement en deux familles:
 
 - Les librairies de __représentations figées__. Celles-ci ont plutôt vocation à être intégrées
 dans des publications figées type PDF ou documents texte. Nous présenterons 
-principalement `Matplotlib` et `Seaborn` mais il en existe d'autres,
-comme [`Plotnine`](https://plotnine.readthedocs.io/en/stable/).
-- Les librairies de __représentations dynamiques__.  Celles-ci sont adaptées à des représentations
+principalement `Matplotlib` et `Seaborn` mais il en existe d'autres, en pleine émergence,
+comme [`Plotnine`](https://plotnine.readthedocs.io/en/stable/), l'adaptation de [`ggplot2`](https://juba.github.io/tidyverse/08-ggplot2.html) à l'écosystème `Python`.
+- Les librairies de __représentations réactives__.  Celles-ci sont adaptées à des représentations
 _web_ et offrent la possibilité aux lecteurs d'agir sur la représentation graphique affichée. 
 Les librairies qui proposent ces fonctionnalités reposent généralement sur `JavaScript`, l'écosystème
 du développement _web_, pour lequel elles offrent un point d'entrée via `Python`. 
@@ -129,7 +256,7 @@ Nous évoquerons principalement `Plotly` et `Folium` dans cette famille mais il
 autres _frameworks_ dans ce domaine[^2].
 
 
-[^1]: Pour être honnête, `Python` est sur ce point un peu moins agréable
+[^1]: Pour être honnête, pendant longtemps `Python` a été sur ce point un peu moins agréable
 que `R` qui bénéficie de
 l'incontournable librairie [`ggplot2`](https://juba.github.io/tidyverse/08-ggplot2.html).
 
@@ -153,32 +280,108 @@ de données. La librairie [`Plot`](https://observablehq.com/plot/) pourrait deve
 un nouveau standard dans les prochaines années, sorte d'intermédiaire
 entre `ggplot` et `d3`. 
 
+Il est tout à fait possible
+de faire des visualisations sophistiquées avec
+une chaine de bout en bout `Python` puisqu'il s'agit d'un langage couteau-suisse
+dont l'écosystème est très 
+riche. Néanmoins, `Python` n'est pas la panacée et il peut parfois
+être utile, pour obtenir un produit fini parfaitement poli,
+de finaliser le travail avec d'autres langages, comme `Javascript` 
+pour les visualisations réactives ou `QGIS` pour le
+travail cartographique. Ce cours donnera les outils minimums
+pour faire un travail rapide et plaisant mais le diable étant dans
+les détails, il ne faut pas s'arcbouter à vouloir utiliser
+`Python` pour tout et n'importe quoi. 
+
 Dans le domaine de la visualisation, ce cours adopte le parti pris
 d'explorer quelques
 librairies centrales à partir d'un nombre restreint d'exemples en
 répliquant des graphiques qu'on peut trouver sur le site d'*open data* de la 
 mairie de Paris. 
-La meilleure école pour la visualisation est la pratique sur des jeux de données. 
+La meilleure école pour la visualisation restant
+la pratique sur des jeux de données, il est recommandé d'explorer la richesse
+de l'écosystème de l'_open data_ pour expérimenter des visualisations. 
+
 
-### Les applications de visualisation {.unnumbered}
+## Les applications de visualisation
 
 Cette partie du cours se focalise sur des représentations synthétiques simples. 
 Elle n'évoque pas (_encore ?_) la construction d'applications de visualisation
 de données où un ensemble de graphiques se mettent à jour de manière synchrone
 en fonction d'actions d'utilisateurs. 
 
-Ceci dépasse en effet le cadre d'un cours d'introduction car cela implique 
+Ceci dépasse en effet le cadre d'un cours d'introduction car construire
+ces applications
+impliquent
 de maîtriser des concepts plus complexes comme l'interaction entre une page
-_web_ et un serveur (local). Néanmoins, j'ai déjà construit
-avec [Romain Avouac](https://github.com/avouacr)
-un [tutoriel 101](https://inseefrlab.github.io/funathon2023_sujet4/) très détaillé sur `Streamlit`
-(permettant de créer une [application type `Yuka`](https://myyuka.lab.sspcloud.fr/))
-pour une formation à l'Insee. 
-
-
-## Résumé de cette partie {.unnumbered}
+_web_ et un serveur, d'avoir des rudiments de connaissance en `Linux`, etc.
+Les concepts nécessaires à la compréhension de ces outils sont au coeur
+du cours de 3e année ["Mise en production de projets de _data science_"](https://ensae-reproductibilite.github.io/website/)
+que Romain Avouac donnons en 3e année d'ENSAE. 
+
+Néanmoins, comme la valorisation de données sous une forme applicative est très
+commune, il
+il est utile _a minima_ d'évoquer la dualité entre sites statiques
+et applications dynamiques afin de donner les bons gestes et pointer vers les 
+outils adéquat. 
+Dans le monde de l'applicatif, il est important de distinguer le _front_ (la page
+visible par les utilisateurs de l'application) du _back office_ (le moteur
+qui effectue des actions en fonction des paramètres choisis par l'utilisateur
+de la page). 
+
+Il existe principalement deux paradigmes pour faire
+interagir ces deux éléments. La distinction principale entre ces deux approches est qu’elles s’appuient sur des serveurs différents. Un site statique repose sur un serveur web là où `Streamlit` s’appuie sur serveur classique en _backend_. La différence principale entre ces deux types de serveurs réside principalement dans leur fonction et leur utilisation:
+
+* Un serveur _web_ est spécifiquement conçu pour stocker, traiter et livrer des pages web (le _front_) aux clients. Cela inclut des fichiers HTML, CSS, JavaScript, images, etc. Les serveurs web écoutent les requêtes HTTP/HTTPS provenant des navigateurs des utilisateurs et y répondent en envoyant les données demandées. Cela n'empêche pas d'avoir des étapes complexes de valorisation de données, ni de la réactivité en embarquant du `Javascript` dans l'application mais les étapes de traitement en `Python` sont faites en amont de la mise à disposition de l'application. Pour les utilisateurs de `Python`, il existe plusieurs constructeurs de sites statiques avant une mise à disposition par le biais d'un hébergement sur [`Github Pages`](https://pages.github.com/). Les deux écosystèmes les plus communs sont [`Quarto Markdown`](https://quarto.org/) et [`Django`](https://www.djangoproject.com/), le premier étant plus simple d'usage et de maintenance que le second. Ce site, par exemple, est construit grâce à `Quarto` ce qui assure la reproductibilité des exemples présentés et une mise en forme ergonomique et paramétrable des résultats.  
+* Un serveur _backend_ classique est conçu pour effectuer des opérations en réponse à un _front_, en l’occurrence une page _web_. Dans le contexte d’une application construite avec `Python`, il s’agit d’un serveur avec l’environnement `Python` _ad hoc_ pour exécuter le code nécessaire à répondre à toute action d’un utilisateur de l’application. Le code est exécuté à la volée et non une fois pour toute comme dans l'approche précédente. Il s'agit donc d'un paradigme pouvant permettre plus de complexité applicative mais représentant un défi supplémentaire lors de la phase de mise en production. Dans l'écosystème `Python`, les deux principaux outils permettant de construire de telles applications sont [`Streamlit`](https://streamlit.io/) et [`Dash`](https://dash.plotly.com/), le premier étant plus rapide à mettre en oeuvre que le second. Plus récemment, l'écosystème équivalent dominant en `R`, [`Shiny`](https://shiny.posit.co/) a été adapté en `Python` par `Posit`. 
+
+::: {.callout-note collapse="true"}
+## Fait-on toujours du `tkinter` ?
+
+Les écosystèmes présentés ci-dessus pour les applications réactives sont des _frameworks web_. Il se distinguent des clients lourds comme [`tkinter`](https://docs.python.org/fr/3/library/tkinter.html),
+l'outil historique pour faire des interfaces graphiques. Outre l'aspect plus rudimentaire des
+interfaces `tkinter` par rapport à celles de `Streamlit`, `Dash` ou `Shiny`, il existe
+des raisons fortes pour privilégier ces derniers à `tkinter`. 
+
+Ce dernier est un client lourd. Autrement dit, il est adhérent à un système d'exploitation
+et à des installations de _packages_ en amont du fonctionnement de l'interface.
+Il est bien sûr possible de rendre portable celle-ci mais, comme cela est développé
+dans le [cours de mise en production](https://ensae-reproductibilite.github.io/website/),
+il y a de nombreuses raisons pour lesquelles cette approche peut provoquer des erreurs
+ou des _bugs_ inattendus. Les _frameworks_ _web_ présentent l'intérêt de simplifier
+cette mise à disposition en dissociant le _front_ (des pages HTML et du CSS) du _back_ (du
+code `Python`). Ils se sont donc imposés naturellement même si on retrouve encore beaucoup 
+de ressources en ligne datées sur le développement d'applications avec  `tkinter`.
+:::
 
-Cette partie est divisée en deux et chaque chapitre est lui-même
+En ce qui concerne la construction d'applications, le premier réflexe
+à avoir est: _"ai-je besoin de faire une application réactive ou un site
+statique ne suffit-il pas ? "_. Ce dernier étant beaucoup plus facile à
+mettre en oeuvre et ayant une charge de maintenance minimale, c'est souvent
+un choix rationnel. S'il devient complexe de faire un site statique, par
+exemple parce qu'ils impliquent des calculs sophistiqués qu'il serait
+complexe de mettre en oeuvre sans compétences `JavaScript`, on peut alors
+se poser la question de la séparation entre _front_ et _back_
+en reportant les calculs vers une API, construite par exemple par le biais de [`FastAPI`](https://fastapi.tiangolo.com/). Il s'agit, par exemple, d'une méthode pratique pour mettre
+à disposition un modèle de _machine learning_ comme le
+dernier chapitre
+de la partie modélisation l'évoquera. Si la mise en oeuvre d'une API
+est compliquée ou bien est un bazooka pour tuer une mouche,
+alors on pourra aller vers une application réactive du type
+de `Streamlit`.
+
+Encore une fois, la construction d'une application fait
+appel à des concepts qui dépassent
+un niveau introductif en `Python`. Avoir conscience des bons réflexes
+peut néanmoins faire économiser un temps non négligeable en évitant de patauger
+dans la semoule à cause d'un mauvais choix initial. 
+
+
+
+## Résumé de cette partie
+
+Pour en revenir au contenu de cette partie après cet _aparté_, celle-ci
+est divisée en deux et chaque chapitre est lui-même
 dual, selon qu'on s'intéresse aux représentations figées
 ou dynamiques :
 
@@ -193,7 +396,7 @@ cartographiques:
     + Les cartes réactives avec `Folium` (adaptation `Python` de la librairie `Leaflet.js`)
 
 
-## Références utiles {.unnumbered}
+## Références utiles
 
 La visualisation de données est un art qui s'apprend, au début, principalement
 par la pratique. Néanmoins, il n'est pas évident de produire
@@ -201,6 +404,7 @@ des visualisations lisibles et ergonomiques
 et il est utile de s'inspirer d'exemples de
 spécialistes (les grands titres de presse disposent d'excellentes visualisations).
 
+
 Voici quelques ressources utiles sur ces sujets :
 
 - [`Datawrapper`](https://blog.datawrapper.de/) propose un excellent blog sur les 
@@ -214,6 +418,18 @@ celui-ci sur les [textes](https://blog.datawrapper.de/text-in-data-visualization
 - Le _New York Times_ (les rois de la _dataviz_) revient tous les ans sur les meilleures visualisations
 de l'année dans la veine du [_data scrollytelling_](https://makina-corpus-blog-scrollytelling.netlify.app/). Voir par exemple la [rétrospective de l'année 2022](https://www.nytimes.com/interactive/2022/12/28/us/2022-year-in-graphics.html).
 
+::: {.callout-tip}
+## Quelques ressources sur `Streamlit` ou `Dash`
+
+Outre notre [cours de 3e année](https://ensae-reproductibilite.github.io/website/),
+le lab de _data science_ de l'Insee a construit de nombreux tutoriels 
+pour s'appropier les écosystèmes d'applications réactives en `Python` qui
+sont l'un des produits les plus attractifs de l'écosystème `Python`. 
+
+Voici par exemple un [tutoriel 101](https://inseefrlab.github.io/funathon2023_sujet4/) très détaillé sur `Streamlit` permettant de créer une [application type `Yuka`](https://myyuka.lab.sspcloud.fr/)
+sur les données de l'_openfoodfacts_. 
+:::
+
 Et quelques références supplémentaires, citées dans cette introduction :
 
 ::: {#refs}