Description

Le langage Python est un langage interprété multi-paradigme utilisable dans de très nombreux contextes grâce à des bibliothèques spécialisées. La communauté Python ne cesse de s'élargir en offrant à ce langage de plus en plus de possibilités. Un ensemble d'outils en calcul et en visualisation scientifique permettent d'utiliser le langage Python comme un langage de haut niveau pour le prototypage et l’environnement des codes de calcul. Il permet également le développement d'applications performantes « sur mesure » car il est interfaçable facilement avec des routines écrites en langages de bas niveau (Fortran, C ou C++). Ce langage aide ainsi à réaliser rapidement des codes de recherche efficaces. De plus, il facilite l'évolution de ces codes vers de vrais logiciels puisqu'il existe un ensemble de modules permettant de faire rapidement des interfaces graphiques, des applications web, ... Les utilisateurs peuvent ainsi interagir sur leurs simulations numériques et visualiser les résultats obtenus de façon confortable.

Cette formation avait pour but d’expliquer l’intérêt du langage Python dans le domaine du calcul scientifique, dans tous les aspects du développement, du cycle de vie, et de l’utilisation d’un code de calcul.

Lors de cette formation, nous avons considèré un modèle mathématique issu d'un problème le plus multidisciplinaire possible. Il a servit de fil conducteur pour développer un code de calcul le plus abouti possible, c’est-à-dire avec pré et post-traitement des données et packaging.

La formation s'est déroulée sous forme de cours théoriques qui ont été mis en pratique lors de TP. Cela a permis de parcourir tous les stades de conception d'un tel logiciel et de voir à chaque étape quels sont les modules Python les plus adaptés.

Les points abordés lors de cette formation ont été les suivants:

  • Les principaux concepts du langage Python.
  • Les modules Python dédiés au calcul: manipulation de tableaux multidimensionnels (numpy), bibliothèques scientifiques (scipy).
  • Les outils de debogage et de profilage.
  • L'interfaçage Python avec des routines écrites en langages bas niveaux : Fortran (f2py) et C/C++(swig), pour avoir des codes performants et réutiliser les sources existantes.
  • Visualisation des résultats numériques obtenus en temps réel (vtk, matplotlib, VPython et Qwt), ou à l’issu du calcul (interfaçage de Paraview).
  • Le packaging.
  • Les outils de parallélisation.

Programme

lundi 06/12

09:00 10:00

Présentation générale de Python

par Loïc Gouarin

Télécharger le support Support du cours
Télécharger le support Vidéo du cours
  • Bref historique
  • Que peut-on faire avec Python ?
  • L'interpréteur de base et IPython
  • Les types de base
  • Les modules
  • Les entrées/sorties
  • Les classes
  • ...
10:15 11:15

Cours Numpy

par Marc Poinot

Télécharger le support Support du cours
Télécharger le support Vidéos du cours
  • Introduction :

    • historique
    • contexte calcul intensif
    • migration numarray ?
  • Manipulations de base :

    • création
    • indexing/slicing
    • quelques méthodes
  • Détails des tableaux :

    • shape, dtype, order
    • I/O
    • print options
    • masked arrays
    • fonctions utilisateur "UFuncs"
    • extension de types
  • Divers :

    • quelques packages (random, matrices, strings, ...)
    • gestion des erreurs
    • méthodes et fonctions supplémentaires
11:30 12:30

Cours Scipy

par Sylvain Faure

Télécharger le support Support du cours
Télécharger le support Vidéos du cours
  • Présentation générale du module et de ce qu'il contient

  • Présentation plus détaillée du contenu de quelques sous-modules :

    • interpolation
    • FFT
    • intégration (résolution ODE)
    • algèbre linéaire
    • matrices creuses
    • optimisation
14:00 17:30 Pas de résumé disponible

TP sur les bases de Python, Numpy et scipy

par Sylvain Faure, Loïc Gouarin, Konrad Hinsen, Marc Poinot

Télécharger le support TP système solaire
Télécharger le support TP équation de poisson
Télécharger le support Énoncé
Télécharger le support TP Scipy
Télécharger le support données

mardi 07/12

08:00 09:30

Cours Matplotlib, PyQwt, guiqwt

par Pierre Raybaut

Télécharger le support Support du cours
Télécharger le support Vidéos du cours
  • Introduction: tour d'horizon des modules Python de visualisation (2D et 3D)

  • Matplotlib: visualisation 2D (et 3D) interactive

  • PyQwt: visualisation performante bas niveau

  • guiqwt (avec guidata) :

    • visualisation performante haut niveau
    • aide à la conception de logiciels de traitement du signal et de l'image
09:45 10:45

Cours VTK, paraview

par Sylvain Faure

Télécharger le support Support du cours
Télécharger le support Vidéos du cours
  • Présentation de la librairie graphique VTK

  • Lecture des données et formats de fichiers de données

  • Pipeline graphique et filtres

  • Exemples d'utilisation de quelques filtres :

    • champ de vecteurs
    • plans de coupe
    • isosurfaces
    • rendu volumique
    • ...
11:00 12:30 Pas de résumé disponible

TP Matplotlib, PyQwt, guiqwt

par Romaric David, Pierre Raybaut

Télécharger le support Support du cours
Télécharger le support Données
11:00 12:30 Pas de résumé disponible

TP VTK, paraview

par Sylvain Faure, Loïc Gouarin

Télécharger le support TP système solaire
Télécharger le support Autre source
Télécharger le support Corrigé du TP vtk
14:00 14:45 Pas de support disponible Pas de résumé disponible

Spyder et Python(x,y)

par Pierre Raybaut

15:00 15:45

Cours débogage, profilage

par Konrad Hinsen

Télécharger le support Support du cours
Télécharger le support Vidéo du cours
  • Techniques de débogage
  • Présentation du débogeur PDB
  • Analyse post-mortem
  • Point d'arrêt
  • Observation de variables
  • Stratégies de débogage
16:00 18:00 Télécharger le support Pas de résumé disponible

TP débogage, profilage

par Romaric David, Konrad Hinsen, Marc Poinot

mercredi 08/12

09:00 10:00

Cours API C, Swig

par Xavier Juvigny

Télécharger le support Support du cours
Télécharger le support Vidéo du cours
  • Présentation d'un problème type : calcul des temps de vol des suites de Syracuse
  • Lenteur du langage Python : motivation pour interfacer avec un autre langage
  • Présentation du module ctypes et sa performance
  • Bref rappel sur f2py et comparaison des temps avec les approches précédentes
  • Présentation et optimisation du problème avec Swig
  • Inconvénient de Swig (contrôle de fin de la durée de vie ou du comportement des objets impossible, etc)
  • Présentation API C via le problème modèle et performance
  • Utilisation de l'API Numpy avec l'API C et les problèmes de cycle de vie des tableaux
  • Création de nouvelles classes via l'API C et définition des opérateurs
  • Gestion de l'héritage
  • Conclusions
10:15 11:00

Cours f2py

par Pierre Navaro

Télécharger le support Support du cours
Télécharger le support Vidéo du cours
  • Pourquoi interfacer Python avec Fortran ?
  • Quels outils pour interfaçage Python-Fortran ?
  • Prérequis pour l'utilisation de f2py.
  • Première interface.
  • Appel des fonctions f2py dans Python.
  • Ajouter une variable de sortie calculée par une subroutine fortran.
  • Documentation des fonctions interfacées.
  • Les directives pour améliorer l'interface.
  • La compilation d'une application mixte Python/Fortran.
  • Créer et éditer les fichiers signature.
  • Interfaçage avec le langage C.
  • Comment gérer un module Fortran 90 ?
  • Encapsulation de données et subroutines Fortran dans un objet Python.
  • Bonus: Implémenter des subroutines Fortran dans un notebook SAGEMATH.
11:15 12:00

Cours Cython

par Konrad Hinsen

Télécharger le support Support du cours
Télécharger le support Exemples
Télécharger le support Vidéo du cours
  • Le rôle des modules d'extension en Python: optimisation et interfaçage.
  • Présentation du langage Cython.
  • L'optimisation ligne par ligne.
  • L'interfaçage avec du code en C.
  • Travailler avec des tableaux NumPy.
  • Classes et types d'extension: les avantages du C++ sans ses désagréments.
  • Contourner le GIL pour profiter des processeurs multicoeurs.
14:00 17:00 Pas de support disponible Pas de résumé disponible

TP API C, Swig

par Xavier Juvigny, Marc Poinot

14:00 17:00 Télécharger le support Pas de résumé disponible

TP f2py

par Romaric David, Pierre Navaro

14:00 17:00 Télécharger le support Pas de résumé disponible

TP Cython

par Konrad Hinsen

17:15 18:00

Cours Sphinx

par Marc Poinot

Télécharger le support Support du cours
Télécharger le support Vidéo du cours
  • Introduction :

    • Principe
    • ReST
  • Fonctions :

    • Architecture de la documentation
    • Directives
    • Production HTML et Latex
  • Mise en oeuvre :

    • Package Python
    • C / C++ / Fortran
    • Exemples

jeudi 09/12

09:00 10:00

Cours multi-processing

par Konrad Hinsen

Télécharger le support Support du cours
Télécharger le support Exemples
Télécharger le support Vidéo du cours
  • Le parallélisme en Python
  • Le problème du GIL
  • Présentation du module multiprocessing
  • Stratégies de parallélisation
  • L'avenir : futures
10:30 11:30

Cours MPI

par Loïc Gouarin

Télécharger le support Support du cours
Télécharger le support Vidéo du cours
  • Présentation des différents modules permettant d'utiliser MPI

  • Présentation détaillée de mpi4py :

    • nombre de processus, rang d'un processus
    • communications point à point
    • communications collectives
  • Exemple détaillé

14:00 17:00 Pas de résumé disponible

TP multi-processing

par Sylvain Faure, Konrad Hinsen

Télécharger le support Support du TP
Télécharger le support Numpy shared memory
14:00 17:00 Pas de résumé disponible

TP MPI

par Romaric David, Loïc Gouarin

Télécharger le support Support du TP
Télécharger le support Corrigé du TP
17:00 18:00 Pas de résumé disponible

Sage

par Thierry Dumont

Télécharger le support Support du cours
Télécharger le support Vidéo de la présentation

vendredi 10/12

09:00 10:30

Cours packaging et tests unitaires

par Loïc Gouarin, Xavier Juvigny

Télécharger le support Support du cours packaging
Télécharger le support Vidéo du cours
Télécharger le support Support du cours test unitaires
Télécharger le support Vidéo du cours
  • distutils : Un utilitaire python pour produire et distribuer despackages python

    • Qu'est-ce qu'un package ?
    • Contrôle de la compilation des modules C/Fortran
    • Gestion de Numpy
  • Utilitaire Scons : basé sur le langage python

    • Scons, un langage descriptif
    • Exemple de compilation d'un programme Fortran, C
    • Utilisation des distutils au sein de Scons
  • Tests unitaires

    • Présentation du module unittest
    • Présentation du module nose
11:00 12:30 Pas de résumé disponible

TP packaging et tests unitaires

par Loïc Gouarin, Xavier Juvigny

Télécharger le support Support du TP packaging
Télécharger le support Support du TP SCons

Organisation

  • Romaric David (Direction Informatique, Strasbourg)
  • Thierry Dumont (Institut Camille Jordan, Lyon)
  • Sylvain Faure (Maths, Orsay)
  • Konrad Hinsen (Centre de Biophysique Moléculaire, Orléans)
  • Loïc Gouarin (Maths, Orsay)
  • Xavier Juvigny (ONERA, Châtillon)
  • Pierre Navaro (IRMA, Strasbourg)
  • Violaine Louvet (Institut Camille Jordan, Lyon)
  • Marc Poinot (ONERA, Châtillon)
  • Pierre Raybaut (CEA, Paris)
  • Eric Sonnendrucker (IRMA, Strasbourg)