Jupyter : rejoignez l'orbite



Sem'in, Strasbourg, 12 novembre 2020


Matthieu Boileau
IRMA, CNRS, Université de Strasbourg

Introduction

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
  • 2015 : première version "grand public" de Jupyter
  • 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.

Cet exposé

Objectifs

  • Un retour après 5 ans d'utilisation dans un contexte d'enseignement et de recherche
  • Une invitation au voyage
  • Un aperçu de l'écosystème Jupyter en 2020

Plan

  • Anatomie d'un notebook
  • Interagir avec le notebook
  • Un outil pour les sciences
  • Travailler avec les notebooks
  • Usages avancés

Anatomie d'un notebook Jupyter

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 :

Une séquence de cellules

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

  • cellules de texte : éditables et mises en forme
  • cellules de code : éditables et exécutables

On bénéficie de la technologie du web : texte riche, rendu des images, sons et vidéos, 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 exemple de gif animé

© 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 [1]:
def dit_hopla(mot=''):
    print(f"Hopla {mot}!")
dit_hopla('Geiss')
Hopla Geiss!

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

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

Pour les tracés graphiques, patience...

Interagir avec le notebook

Editer, exécuter, convertir

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

  • Edition
  • Rendu et exécution
  • Conversion

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

Les 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

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 [3]:
%lsmagic
Out[3]:
Available line magics:
%alias  %alias_magic  %autoawait  %autocall  %automagic  %autosave  %bookmark  %cat  %cd  %clear  %colors  %conda  %config  %connect_info  %cp  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %lf  %lk  %ll  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %lx  %macro  %magic  %man  %matplotlib  %mkdir  %more  %mv  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %pip  %popd  %pprint  %precision  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %rep  %rerun  %reset  %reset_selective  %rm  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode

Available cell magics:
%%!  %%HTML  %%SVG  %%bash  %%capture  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%markdown  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile

Automagic is ON, % prefix IS NOT needed for line magics.

Un outil pour les sciences

Intérêt 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.

Exemple 1 : du calcul scientifique

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

Allons sur GPU avec PyOpenCL : 04-opencl-tp.ipynb

Exemple 2 : 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 [4]:
%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 [5]:
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
Out[5]:

Les widgets ipython

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

In [6]:
def plot_walk(nstep: int):
    """Calcule et trace une marche aléatoire de nstep pas"""
    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 [7]:
interact(plot_walk, nstep=slider);
Out[7]:
<function __main__.plot_walk(nstep: int)>

Exemple 3 : 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

Exemple 4 : 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 avec les notebooks

Les notebooks au quotidien

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 [8]:
#%%bash
#jupyter nbconvert --to html rejoindre-jupyter.ipynb --template classic
#ls -al rejoindre-jupyter.html

qui produit le fichier rejoindre-jupyter.html:

In [9]:
#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 :
  • le coût matériel et humain pour maintenir un Jupyterhub
  • 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://jupyter.math.unistra.fr

nbgrader

Vos évaluations sous forme de notebooks.

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

Une documentation assez faible mais l'auteur est facile à trouver : bureau I101.

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

Les notebooks Jupyter :

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

Prêt à rejoindre l'orbite ?