Jupyter : rejoignez l'orbite



Séminaire EDP, Strasbourg, 24 juin 2020


Matthieu Boileau
IRMA, CNRS, Université de Strasbourg

Introduction

Journées Mathrice, octobre 2015 à Orsay :


Mathrice
  • Thierry Dumont annonce l'entrée dans une nouvelle époque avec l'avènement des notebooks Jupyter : "mariage des technologies web, du développement et du calcul". C'était Notebook mania.
  • cinq ans plus tard, où en est la révolution Jupyter ?

Si vous avez manqué Notebook mania

Jupyter pour Julia-Python-R.

Les points de départ :

  • le notebook Sage
  • le notebook ipython

Une brève chronologie

  • 2001 : lancement du projet IPython
  • 2006 : les notebooks Sage
  • 2011 : première version publiée du notebook IPython
  • 2011-2014 : création du projet Jupyter, ouvert à d'autres langages que Python
  • Eté 2017 : publication de Jupyterlab. Plus d'un million de notebooks Jupyter détectés sur github

L'histoire est racontée sur le blog de Fernando Perez et dans cet article de Karlijn Willems.

Les ingrédients de base

La couche web

  • tornado pour le serveur web
  • JQuery pour le javascript
  • Codemirror pour l'édition de code
  • MathJax pour le rendu LaTeX

La couche langage

Une multitude de noyaux :

  • les officiels : Python, Julia, R
  • les noyaux maintenus par la communauté : Sagemath, Cling (C++), Fortran, bash, go, etc.
  • Actuellement près de 140 noyaux communautaires ! (contre 50 à l'époque de Notebook mania)

Qu'est-ce qu'un notebook Jupyter ?

Une page web dynamique constituée d'une séquence de cellules de deux types :

  • cellules de texte : éditables
  • cellules de code : éditables et exécutables

On bénéficie de la techno web : texte riche, rendu des principaux formats de médias, aides en ligne, etc.

Cellules de texte enrichi

Formattage et reconnaissance syntaxique avec markdown

Si j'écris :

```bash
ls -al
```

la cellule markdown est rendue en bash :

ls -al

Maintenant :

```python
def dit_hopla():
    print("Hopla!")
dit_hopla()
```

Rendu en python :

def dit_hopla():
    print("Hopla!")
dit_hopla()

Rendu $\LaTeX$ (avec MathJax)

$$\frac{\partial u}{\partial t} + u \frac{\partial u}{\partial x} = 0 $$

Contenu média

  • images

© SNCF (source https://giphy.com)

  • vidéo/son

Note : Attention à l'ajout de contenu html/javascript qui peut créer des interactions non voulues, en particulier lors des conversions.

Cellules de code éditables et exécutables

  • le code est exécuté dans le langage du noyau
  • les sorties standard et d'erreur se font sous la cellule
  • le compteur d'exécutions est incrémenté dans la colonne de gauche
  • avec les bibliothèques graphiques, on peut afficher et interagir avec des tracés !
In [ ]:
def dit_hopla():
    print("Hopla!")
dit_hopla()

Le compteur affiche In [*] pendant l'exécution :

In [ ]:
import time
time.sleep(2)  # attend 2 secondes
dit_hopla()

Pour les tracés, patience...

Interopérabilité et ergonomie

Des magic commands en ligne et par cellule qui permettent d'interagir avec le système ou d'appeler d'autres langages.

In [ ]:
%lsmagic

Fonctionnalités de base

Pour découvrir l'utilisation des notebooks, l'aide propose un tour guidé : Help > User interface tour.

Du point de vue utilisateur, on peut regrouper les fonctionnalités dans trois catégories :

  • Edition
  • Rendu et exécution
  • Conversion

Interaction avec le notebook

Deux modes (un peu comme dans vi) :

  • mode édition
  • mode commande

Mode édition

  • à la souris
  • au clavier : raccourcis très utiles (Help > Keyboard shortcuts)

Mode commande

  • pour se déplacer
  • pour sélectionner une ou des cellules
  • pour exécuter des cellules de code

Intérêt des notebooks pour les sciences

  • communication scientifique
  • reproductibilité
  • pédagogie
  • une interface vers des logiciels : SageMath, MatLab, codes maison, etc.
  • une chaîne de traitement documentée, un cas-test numérique, etc.

Note : pour SageMath, les notebooks Sage sont désormais remplacés par les notebooks Jupyter.

On veut des exemples !

Du calcul

Allons sur GPU avec PyOpenCL : orszag-tang_v100.ipynb

Dans cet exemple :

  • on exploite la puissance de calcul d'un serveur distant
  • on visualise les résultats de manière interactive avec un simple navigateur

Des probas : marche aléatoire sur $\mathbb{Z}^2$

Extrait du cours de Marielle Simon dans la Master Class Probabilités 2020 à l'IRMA.
Notebooks complets sur https://gitlab.math.unistra.fr/proba-mc2020/proba-mc2020

Quelques initialisations

In [ ]:
%matplotlib inline
from matplotlib import rcParams
from matplotlib import pyplot as plt
from ipywidgets import interact, IntSlider
rcParams['figure.figsize'] = (10., 8.)  # Enlarge figure
rcParams['animation.html'] = 'html5'  # to render animation in notebook
import srw  # Import simple random walk module from srw.py

Une animation

On crée et on joue une animation pour une marche aléatoire de $nstep$ pas qui démarre en $(x, y) = (0, 0)$.

In [ ]:
walk = srw.Walk2D(nstep=100)  # Create a 100-step random walk
anim = walk.generate_animation()
plt.close(anim._fig)  # Close the initial figure to display only the animation figure
anim  # Now play

Les widgets ipython

On tire des marches complètes pour un nombre variable $nstep$ de pas.

In [ ]:
def plot_walk(nstep: int):
    srw.Walk2D(nstep).plot()

slider = IntSlider(min=100, max=20000, step=100, value=5000,
                   continuous_update=False)

Les ipwidgets améliorent et simplifient l'interaction avec le code :

In [ ]:
interact(plot_walk, nstep=slider);

An interactive book about the Riemann problem for hyperbolic PDEs

Un exemple très riche dans ce cours de Randall J. LeVeque :

On y trouve :

  • l'utilisation des widgets
  • le travail d'export de contenu dynamique vers un contenu statique propre
  • la compilation de notebooks comme chapitres d'un livre avec bookbook

Python proba stat

python-prob-stat.jpg

Par Vincent Vigon et Léo Bois :

  • 14 chapitres et autant de notebooks
  • Commandez aujourd'hui la version brochée l'édition 2020 et recevez-là le 1er juillet !
  • Parcourez les notebooks sur le site de Vincent

Travailler en pratique avec les notebooks ?

C'est très beau, je veux travailler avec ! Comment fais-je ?...

Trois problématiques principales :

  • partager
  • convertir
  • exécuter

Mais pour quels besoins ? Enseignement ? Communication scientifique ? Calcul ? Voire calcul intensif ?

Partager

Tout est stocké dans un fichier au format texte json (y compris les sorties d'exécution) donc :

  • GitLab
  • GitHub
  • Intégration dans les sites webs : générateurs de sites statiques

Convertir

avec nbconvert, de nombreux exports sont disponibles :

  • page html
  • diaporama REVEAL.js (ce support en est un !)
  • pdf (traduit par pandoc en $\LaTeX$ puis compilé)

Le notebook peut être exécuté lors de l'export pour contenir la sortie des exécutions.

Un exemple de conversion

In [ ]:
%%bash
jupyter nbconvert --to html rejoindre-jupyter.ipynb
ls -al rejoindre-jupyter.html

qui produit le fichier rejoindre-jupyter.html:

In [ ]:
import os, webbrowser
webbrowser.open_new_tab(f'file:///{os.getcwd()}/rejoindre-jupyter.html');

Exécuter

Partage, conversion et publication peuvent être facilement assurés par une chaîne d'intégration continue telle que GitLab-CI.

Par exemple, ce notebook est publié sur https://boileau.pages.math.unistra.fr/rejoindre-jupyter en ajoutant le simple fichier .gitlab-ci.yml suivant dans la racine du projet :

image: boileaum/jupyter
pages:
  script:
    - make
  tags:
    - pages
  artifacts:
    paths:
      - public

Le morceau difficile, c'est l'exécution...

Les solutions

Le serveur jupyter local : votre machine, celles de vos étudiants, etc.

Avantages :
  • pas de serveur/comptes/stockage à installer et à maintenir
  • chaque exécution est indépendante en terme de ressources
Inconvénients :
  • nécessite d'installer Jupyter côté utilisateur
  • pour Python, la suite Anaconda fait très bien ce travail pour toutes les plateformes (Windows, Mac, Linux) mais certaines dépendances spécifiques peuvent manquer
  • dès qu'on sort des distributions packagées, la diffusion se complique
  • on est limité par la ressource du poste utilisateur : CPU, mémoire, GPU, etc.
Logo Jupyterhub

Le serveur Jupyterhub

Avantages :
  • l'utilisateur a uniquement besoin d'une connexion dans son navigateur
  • on assure une configuration matérielle et logicielle conforme aux besoins d'une session
  • on bénéficie de la puissance de calcul du serveur
Inconvénients :
  • L'effort pour maintenir un Jupyterhub
  • Problème de l'accès concurrentiel aux ressources : le notebook est basé sur un usage interactif qui ne se prête pas naturellement à l'ordonnancement

Deux jupyterhubs à l'IRMA !


Logo Jupyterhub

Sur ces deux serveurs Jupyter, vous accédez à votre compte file.math.unistra.fr.

Voir la doc sur l'intranet.

logo Binder

Binder - https://mybinder.org

Basé sur repo2docker.

Avantages :
  • extrêmement souple : ajout des dépendances par fichiers requirements.txt, apt.txt, environment.yml ou même Dockerfile
  • gratuit (mais limité en temps et ressources) !
Inconvénients :
  • pas de persistance des données
  • ne gère que des notebooks publics

Un lien suffit pour tester cette présentation : Binder

CoCalc Logo

Cocalc - https://cocalc.com/

Avantages :
  • un très grand nombre de noyaux disponibles
  • des outils collaboratifs faciles à prendre en main
Inconvénients :
  • la ressource coûte cher
  • maintenu par une petite équipe

$\implies$ La solution "riche".

logo colab

Google Colaboratory - https://colab.research.google.com

Avantages :
  • Même principe que cocalc mais entièrement gratuit
  • Accès à des ressources GPU (vGPU)
  • Les données sont hébergées sur Google Drive
  • Très facile à utiliser
Inconvénients :
  • Les données sont hébergées sur Google Drive
  • Les ressources de calcul sont limitées (mise en attente, limite de temps, etc.).

Usages avancés et évolution

Jupyterlab

  • Première publication à l'été 2017
  • destiné à remplacer le serveur jupyter classique
  • encore en évolution : certaines fonctionnalités des notebooks Jupyter classiques ne sont pas dans Jupyterlab

Un exemple : https://v100.math.unistra.fr

nbgrader

Deux modes

  • Mode local (récupération manuelle des formulaires)
  • Mode hébergé (avec JupyterHub)

Le principe

  • Encadrement de la solution par des balises
  • Auto vérification par des évaluations booléennes
  • Vérification manuelle avec possibilité d'anonymat

Les étapes

  1. Version enseignant
  2. Auto-génération de la version étudiant
  3. Publication de la version étudiant
  4. Récupération des soumissions (sans effort avec la version hébergée)
  5. Auto-évaluation
  6. Evaluation manuelle
  7. Commentaires écrits aux étudiants

La vidéo qui dit tout.

Les extensions

Elles sont nombreuses !

capture d'écran des extensions jupyter

Attention

  • les extensions de votre instance locale ne sont pas installées dans la distribution Jupyter de base, ce qui peut rendre plus difficile la distribution de vos notebooks.
  • toutes ne sont pas transférées dans Jupyterlab

Regrouper des notebooks

bookbook : un notebook = un chapitre

  • Références croisées entre notebooks
  • Numérotation des équations
  • Citations bibliographiques
  • export html avec animations
  • export pdf qualité impression
  • Un exemple de référence
  • Un autre exemple artisanal

Attention : projet en sommeil.

logo jupyter book

https://jupyterbook.org :

  • Un livre en ligne sous forme de notebooks
  • un projet récent et en évolution

nbcourse : votre cours en notebooks

Un outil python qui vous aide à mettre en ligne votre support de cours basé sur les notebooks :

  • en publiant chapitre après chapitre (au fur et à mesure des séances)
  • en facilitant le téléchargement (une archive par chapitre)
  • en fournissant un aperçu en ligne du rendu statique des notebooks exécutés
  • en fournissant le lien pour exécuter dans binder
  • en compilant tous les chapitres comme un livre (format pdf)

En bonus, la publication avec GitLab Pages :

  • permet de vérifier que les notebooks s'exécutent correctement
  • vous assure que la version en ligne correspond au dernier commit que vous avez poussé sur GitLab.

Un exemple avec https://gitlab.math.unistra.fr/boileau/proba-mc2020

Besoin d'aide pour utiliser nbcourse ? Contactez-moi !

C'est très beau tout ça mais tous mes supports de cours sont en $\LaTeX$ ou en beamer !

Heureusement, tex2ipy est là pour convertir vos .tex en .ipynb.

Il y aura probablement à travailler un peu dans le fichier customize.py pour limiter les ajustements à la main.

Exemple de conversion avec le cours de Samuel Maistre

Beamer Jupyter (REVEAL)
beamer
reveal

Vers des applications web ?

Avec sa bibliothèque de widgets, Jupyter peut être vu également comme un atelier de fabrication d'applications web pour le calcul et le traitement des données.

En particulier, voila permet de transformer un notebook en une application web standalone.

Deux exemples :

Logo Jupyter

Conclusion

  • s'appuie sur la technologie du web pour documenter et exécuter du code de manière intéractive et portable,
  • intéresse un très large spectre de communautés scientifiques,
  • présente un intérêt évident pour les mathématiques (enseignement et recherche),
  • nécessite de posséder et de maîtriser un certain environnement matériel et logiciel.
Mathrice

Prêt à vous mettre en orbite ?