Les exercices sont présentés sous la forme de notebook jupyter. Ils peuvent être exécutés dans plusieurs environnement, au gré des préférences et des connaissances de chacun :

• Sur un environnement temporaire ;
• Sur une installation personnelle ;
• Dans un conteneur docker.

Concernant la première méthode, qui est celle recommandée, chaque chapitre présente les badges suivants qui permettent d’ouvrir la page web en question dans l’environnement de prédilection. Par exemple, pour ouvrir le chapitre relatif à numpy dans l’un des environnements temporaires proposés, les badges suivants sont proposés:

Quelque soit l’environnement d’exécution des scripts, l’un des objectifs de ce cours est d’adopter un environnement favorable à la reproductibilité des traitements. Ils devraient donc fonctionner, dès lors que l’environnement est bien configuré, d’une manière similaire quel que soit la machine qui exécute le code.

Comme la reproductibilité est une notion centrale dans une démarche scientifique mais également importante dans le monde de l’entreprise ou de l’administration, en supplément des notions relatives à Python, ce cours montrera comment utiliser Git avec Python et évoquera un certain nombre de critères de qualité du code qui sont devenus des standards dans la communauté open-source, dans l’industrie et dans l’administration. Ces compétences ne sont pas propres à Python et seront utiles pour tout projet ultérieur. Un cours dédié à cette question est proposé par Romain Avouac et moi en dernière année de l’ENSAE. Son contenu est disponible sur https://ensae-reproductibilite.netlify.app/.

Le projet final devra impérativement être associé à un dépôt sur Github (nous reviendrons dessus) et répondre à ces critères de qualité, qui serviront toute la vie.

Ce cours vise à acculturer à la conduite de projets de data-science avec Python. L’environnement foisonnant de la data-science nécessite un certain nombre d’éléments supplémentaires à Python. La suite de ce chapitre permettra de décrire les configurations à mettre en oeuvre pour être en mesure d’exploiter la richesse de l’écosystème Python.

Installer un environnement adapté à la data-science sur son ordinateur personnel

Cette partie présente plusieurs éléments de configuration d’un environnement en local. Cependant, cette approche est de moins en moins fréquente. En effet, plusieurs facteurs conjoints ont amené à privilégier des serveurs plutôt que des installations locales (évolutions dans les technologies cloud, besoins accrus de ressources, besoins de plus de contrôle sur la confidentialité des données en limitant leur prolifération…). Au sein des administrations et des entreprises, les approches cloud, où l’utilisateur se voit mis à disposition une interface graphique alors que les calculs sont déportés sur un serveur distant, est de plus en plus fréquent.

Installer Python en local

Pour installer Python, il est recommandé d’utiliser la distribution Anaconda qui permet d’installer une distribution minimale de Python ainsi qu’éventuellement un environnement plus complet :

• Sous Windows, il suffit de télécharger l’exécutable puis l’exécuter (cf. la doc officielle ou ce site).
• Sous Mac, se reporter à la doc officielle
• Sous Linux, suivre les instructions de la doc officielle selon sa distribution

Passer par Anaconda permet:

• d’installer Python ;
• d’installer par défaut une multitude de packages utiles (liste ici) ;
• de pouvoir utiliser un gestionnaire de package nommé conda.

Anaconda permet de créer des environnements isolés et facilite l’installation de certaines librairies qui nécessitent l’usage de langages externes (par exemple du C++).

Installer un environnement de développement

Les notebooks Jupyter (extension .ipynb) sont très utilisés en data science. Ils sont en particulier très adaptés à la réalisation d’analyses exploratoires. Les notebooks permettent de mêler du code, du texte et des sorties graphiques ou des tableaux. L’intérêt principal des notebooks est qu’ils permettent d’exécuter du code très facilement dans un environnement Python donné (le kernel Jupyter). Ils sont particulièrement pratiques pour ajouter du code ou du texte à un document déjà existant, d’où le terme de notebook.

Néanmoins, passé l’étape d’exploration, il est recommandé de plutôt recourir à des scripts au format .py. L’utilisation du format .py est l’un des premiers gestes pour favoriser la reproductibilité des analyses. Ces scripts peuvent être édités à l’aide d’éditeurs de texte adaptés au code, comme Visual Studio (mon préféré), Sublime Text, ou PyCharm (privilégier Pycharm Community Edition) entre autres.

Ces éditeurs offrent des fonctionalités supplémentaires pratiques :

• nombreux plugins pour une pleine utilisation de l’écosystème Python: éditeur de Markdown, interface Git, etc.
• fonctionalités classiques d’un IDE dont manque Jupyter: autocomplétion, diagnostic du code, etc.
• intégration avec les environnements Conda

Installation de Git

Le principe de Git ainsi que son usage avec Python sont présentés dans une partie dédiée. Cette partie se concentre ainsi sur la question de la configuration de Git.

Git est un langage dont la fonction est de tracer l’historique de modification d’un fichier. Pour disposer de ce langage, il est nécessaire d’installer le logiciel Git Bash. Grâce à lui, Git sera disponible et des outils externes, notamment les interfaces de développement comme Visual Studio, pourront l’utiliser.

Exécution dans un environnement temporaire sur un serveur distant

Comme évoqué précedemment, les technologies dominantes dans le domaine du traitement des données ont amené à une évolution des pratiques depuis quelques années. La multiplication de données volumineuses qui dépassent les capacités en RAM voire en stockage des machines personnelles, les progrès dans les technologies de stockage type cloud, l’adhésion de la communauté aux outils de versioning (le plus connu étant Git) sont autant de facteurs ayant amené à repenser la manière de traiter des données. Les infrastructures à l’état de l’art permettent ainsi de découpler stockage des données, stockage du code et exécution des traitements sur les données. L’exécution des traitements s’effectue ainsi sur des machines à la durée de vie courte qui stockent temporairement données et code ensembles pour tester les traitements.

Avec les dépôts sur Github ou Gitlab, on dissocie environnement de stockage des codes et d’exécution de ceux-ci. Un système de stockage S3, présenté dans un chapitre ultérieur, permet en supplément de dissocier l’environnement de stockage des données de ces deux premiers environnements. Sur le dépôt github de ce cours , on peut naviguer dans les fichiers (et voir tout l’historique de modification de ceux-ci). Mais, comment exécuter les scripts sans passer par un poste local ?

Depuis quelques années, des services en ligne permettant de lancer une instance Jupyter à distance (analogue à celle que vous pouvez lancer en local en utilisant Anaconda) ont émergé. Parmi celles-ci :

• Le SSP Cloud

  

  plateforme développée par l’Insee qui fournit des environnements bac à sable basés sur des technologie de conteneurisation
• Google collaboratory

  

  ; Github Visual Studio Editor

  

  ;
• Binder

  

  ;

Il est également possible d’exécuter des codes sur les services d’intégration continue de Gitlab (service Gitlab CI) ou de Github (via Github Actions). Il s’agit d’une approche bash, c’est-à-dire que les scripts sont exécutés par une console à chaque interaction avec le dépôt distant Gitlab/Github, sans session ouverte pour les éditer. Cette approche est très appropriée pour assurer la reproductibilité d’une chaîne de traitement (on peut aller jusqu’au déploiement de visualisations automatiques[^2]) mais n’est pas très pratique pour le griffonnage.

[^2] A cet égard, il est recommandé de consulter le cours de dernière année de l’ENSAE déjà cité: https://ensae-reproductibilite.netlify.app/

Kaggle propose des compétitions de code mais donne également la possibilité d’exécuter des notebooks, comme les solutions précédentes. Il existe une API Kaggle pour accéder à des données Kaggle hors du système Kaggle

SSP-Cloud

Onyxia, l’autre petit nom du SSP-Cloud, est une plateforme libre service mutualisée de traitement de données statistiques et de datascience.

Ce cloud met à disposition aux statisticiens et aux data scientists de l’État un catalogue de services et un environnement de travail simple, rapide et collaboratif, permettant de lancer facilement ces outils et d’y connecter ses données et son code.

Au-delà des ressources techniques, cette plateforme représente une opportunité pour les statisticiens publics et les étudiants de découvrir et d’adopter de nouvelles méthodes de travail. Elle est aussi utilisé à des fins de formations et d’auto-formations.

Dans cet environnement, Jupyter et Visual Studio sont tous deux disponibles.

Google collaboratory

Google met à disposition une plateforme de calculs basée sur le format Jupyter Notebook. Un grand avantage de cette solution est la mise à disposition gratuite de GPUs de qualité raisonnable, outil quasi-indispensable dans les projets basés sur des méthodes de deep learning. Il est possible de connecter les notebooks ouverts à Google Drive ou à github. L’icone

Github Visual Studio Editor

Microsoft qui possède à la fois Github et Visual Studio a récemment lancé une offre Github dev qui permet d’ouvrir et lancer un notebook Jupyter depuis un navigateur web.

En plus des fonctionalités attendues du logiciel Visual Studio Cette interface permet également de gérer les issues et pull request d’un dépôt Github.

Binder

En cliquant sur cette icône

La technologie en arrière-plan: Docker

Docker est l’outil open-source de référence en matière de création d’environnements isolés et auto-suffisants ( les conteneurs. En pratique, une application codée en Python ne repose que rarement seulement sur du code produit par son développeur, elle fait généralement intervenir des dépendances : d’autres librairies Python, ainsi que des librairies liées au système d’exploitation sur laquelle elle est développée. Docker va permettre d’empaqueter l’application ainsi que toutes ses dépendances et rendre son exécution portable, c’est à dire indépendante du système sur laquelle elle est éxécutée.

Docker est utilisé dans le cadre de cours afin d’assurer la reproductibilité des exemples. Plus de détails sont disponibles dans le cours de dernière année d’ENSAE dédié à la mise en production de projets data-science (ensae-reproductibilite.netlify.app/).

Il est possible d’utiliser les images Docker sur lesquelles reposent l’environnement de reproductibilité du cours. Celles-ci sont mises à disposition sur DockerHub, le principal réseau de mise à disposition d’images Docker. Il existe une image minimale qui intègre Python et Quarto.

Pour utiliser l’image Visual Studio:

docker pull linogaliana/python-datascientist-vstudio
docker run --rm -p 8787:8787 -e PASSWORD=test linogaliana/python-datascientist-vstudio

En se rendant depuis un navigateur sur localhost:8887/, et en rentrant le mot de passe test (défini plus haut), on peut ainsi accéder à l’interface désirée (attention il s’agit d’un environnement temporaire, pas pérenne).

Installer des packages supplémentaires

Un module est un script qui a vocation à définir des objets utilisés postérieurement par un interpréteur. C’est un script .py autosuffisant, définissant des objets et des relations entre eux et le monde extérieur (d’autres modules). Un package est un ensemble cohérent de modules. Par exemple scikit-learn propose de nombreux modules utiles pour le machine learning.

Python, sans ajout de briques supplémentaires, trouvera rapidement ses limites. Même dans les scripts les plus simples, on a généralement besoin de packages qui évitent de réinventer la roue.

Les packages sont les éléments qui font la richesse des langages open-source.
Ils sont l’équivalent des packages R ou Stata. Le monde de développeurs Python est très prolifique : des mises à jour sont très souvent disponibles, les bibliothèques de packages sont très nombreuses. Un data-scientist prendra l’habitude de jongler avec des dizaines de packages dont il connaîtra quelques fonctions et où, surtout, il saura aller chercher de l’information. Le rythme des mises à jour et des ajouts de fonctionalités s’est accéléré ces dernières années. Les grandes compagnies du numérique ont elles-mêmes opensourcées des librairies devenues centrales dans l’écosystème de la data-science (TensorFlow par Google, PyTorch par Facebook…)

Les forums, notamment StackOverflow regorgent de bons conseils. Les deux meilleurs conseils qu’on puisse donner :

• regarder la documentation officielle d’un package. Les bons packages sont généralement très bien documentés et beaucoup d’erreurs peuvent être évitées en apprenant à chercher dans la documentation ;
• en cas d’erreur : copiez-collez l’erreur sur votre moteur de recherche préféré. Quelqu’un aura déjà posé la question, sans doute sur stackoverflow. Néanmoins, ne copiez-collez pas la réponse sans comprendre la solution.

Les gestionnaires de packages

Les packages d’un langage open-source sont mis à disposition sur des dépôts. Le CTAN est ainsi le dépôt \(\LaTeX\) le plus connu, le CRAN celui du langage R.

En Python, il existe deux gestionnaires de packages qu’on utilise associés à deux dépôts différents :

• pip associé au dépôt PyPi
• conda associé au dépôt Anaconda

Anaconda a permis, il y a quelques années, de faciliter grandement l’installation de librairies dépendants d’autres langages que Python (notamment des librairies C pour améliorer la performance des calculs). Ces dernières sont compliquées à installer, notamment sur Windows. Le fait de proposer des librairies pré-compilées sur une grande variété de systèmes d’exploitation a été une avancée d’anaconda. PyPi a adopté ce même principe avec les wheels ce qui finalement, rend les installations avec pip à nouveau intéressantes (sauf pour certaines librairies en Windows).

Anaconda a deux défauts par rapport à pip :

• l’installation de packages via pip est plus rapide que via conda. conda est en effet plus précautionneux sur l’interaction entre les différentes versions des packages installés. mamba a récemment été développé pour accélérer l’installation de packages dans un environnement conda¹
• les versions disponibles sur PyPi sont plus récentes que celles sur le canal par défaut d’Anaconda. En effet, pour un développeur de packages, il est possible de publier un package de manière automatique sur PyPi L’utilisation du canal alternatif qu’est la conda forge permet de disposer de versions plus récentes des packages et limite l’écart avec les versions disponibles sur PyPi.

Comment installer des packages

Avec Anaconda, il faut passer par la ligne de commande et taper

conda install <nom_module>

Par exemple conda install geopandas. Depuis une cellule de notebook Jupyter, on ajoute un point d’exclamation pour indiquer à Jupyter que la commande doit être interprétée comme une commande shell et non une commande Python

!conda install <nom_module> -y

L’option -y permet d’éviter que conda nous demande confirmation sur l’installation du package. Pour mettre à jour un package, on fera conda upgrade plutôt que conda install

Avec pip, on va cette fois taper

pip install <nom_module>

pip permet également d’installer des librairies directement depuis Github à condition que Anaconda et Git sachent communiquer (ce qui implique en général que Git soit dans le PATH du système d’exploitation). Par exemple, pour installer le package pynsee

pip install git+https://github.com/InseeFrLab/Py-Insee-Data.git#egg=pynsee

La partie dédiée aux environnement virtuels du cours de dernière année de l’ENSAE présente plus d’éléments sur les différences moins évidentes entre pip et conda.