Marc BUFFAT

Marc BUFFAT

Professeur au département de Mécanique, Lyon 1 e-mail

Blog scientifique et pédagogique utilisant des notebooks IPython et Linux

Cours Python scientifique

Table des matières

In [1]:
%matplotlib inline
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
from matplotlib import rcParams
rcParams['font.family'] = 'serif'
rcParams['font.size'] = 14
# option de mise en page
from IPython.core.display import HTML,display
css_file = 'style.css'
HTML(open(css_file, "r").read())
# edit metadata   "livereveal": {"scroll": true }
# https://damianavila.github.io/RISE/customize.html"
Out[1]:

Calcul scientifique avec Python

Marc BUFFAT, dpt mécanique, Université Lyon 1

(**) voir le cours “Scientific Python Lectures” by Robert Johansson

Licence Creative Commons
Mise à disposition selon les termes de la Licence Creative Commons
Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 2.0 France.

Objectifs

Apprendre:

  • concept fondamentaux en programmation
  • différentes techniques de base
  • démarche de programmation scientifique
  • syntaxe du langage Python

À la fin du cours, vous pourrez:

  • résoudre des problèmes scientifiques (à l’aide de Python)
  • appliquer la démarche de programmation scientifique avec d’autres langages (matlab, scilab, ..)

Fonctionnement d’un ordinateur

ordinateur = matériel (CPU, mémoire, disque,..) + logiciel (OS, programmes,..)

composants

OS

Système d’exploitation (OS) = gestion d’un ordinateur + environement

Linux/Unix = vue abstraite et générique indépendante du matériel

programmes + données

  • programme = processus
  • données = fichiers (files, devices, streams)
  • gestion des droits: notion d’utilisateur (user), groupes (group), autres (other)
  • super-utilisateur: root

Principes

  • small is beautiful

  • generality is better than specificity

  • communication is important (format ouvert pour les données)

programmes / processus

processus = programme executé sur un ordinateur

  • pid = numéro du processus
  • programme (utilisateur ou commande système)
  • E/S: entrée par défaut (input stream=stdin), sortie par défaut (output stream=stdout)
  • sortie programme = entrée d’un autre programme : pipe ou |
    • pge 1 | pge 2 | pge 3
  • controle des processus: kill pid ou ctrl+C, stop (ctrl+Z) , tache de fond (bg) , ps, top
  • éxecution des commandes à travers une interface
    • un terminal avec un shell (interpérteur de commande): bash (avec auto-complétion)
    • un GUI (gnome, KDE, ..)

  • syntaxe (attention majuscule # minuscule, espace = séparateur d’arguemnts)

    cde [-options] arguments

In [2]:
%%bash
ps -au buffat | head

  PID TTY          TIME CMD
 2182 pts/7    00:00:00 bash
 2713 ?        00:02:03 firefox
 3311 pts/17   00:00:00 bash
 3525 ?        00:00:09 Web Content
 4187 ?        00:00:24 Web Content
 4618 pts/1    00:00:00 more
 4906 ?        00:02:01 Web Content
 5148 ?        00:00:37 thunderbird
 5391 pts/18   00:00:00 bash

Système de fichiers (Unix)

  • vu arborescente abstraite indépendante du matériel à partir de la racine (root) /

  • notation

    • fichier = nom de fichier + répertoire + droits d’accés
    • / séparateur de répertoire (directory)
    • . répértoire courant
    • .. répértoire parent
    • pwd : affiche répertoire courant
    • lien symbolique
    • fichiers cachés: commence par .

  • principales commandes

    • ls : liste des fichiers
    • mkdir : création répertoire
    • rm : éfface un fichier
    • cd : change de répertoire (directory)
    • help cde : aide
    • cat file : affiche le contenu du fichier
In [3]:
%%bash
ls -al | head

total 3852
drwxrwxr-x  8 buffat buffat    4096 févr. 15 14:52 .
drwxrwxr-x 14 buffat buffat    4096 févr. 15 14:38 ..
-rw-rw-r--  1 buffat buffat   26226 févr. 15 14:47 Algorithme.ipynb
-rw-rw-r--  1 buffat buffat    1854 févr.  1 11:36 alunissage.py
-rw-rw-r--  1 buffat buffat    2146 févr.  1 11:07 alunissage.pyc
-rw-rw-r--  1 buffat buffat    2136 févr.  2 12:42 anim_pendule.py
-rw-rw-r--  1 buffat buffat   80050 févr. 15 14:50 BaseProgrammation.ipynb
-rw-rw-r--  1 buffat buffat  219784 févr. 15 14:52 BibliothequeScientifique.ipynb
-rw-rw-r--  1 buffat buffat  168303 févr. 15 14:52 CalculSymbolique.ipynb

execution d’un programme

Calcul de la somme d’une série

$$ S = x - \frac{x^2}{2} + \frac{x^3}{3} + .. = \sum_{i=1}^n (-1)^{i+1} x^i/i $$

Algorithme de base

Algorithme Serie(x,n)
   somme = 0
   pour i de 1 a n
      somme=somme + (-1)^(i+1)*x^i/i
   retour somme

Ecrire un algorithme plus efficace en notant que:

$$ (-1)^{i+1} \frac{x^i}{i} = - \frac{x}{i} (-1)^{i} x^{i-1} $$

Execution sur un ordinateur

L’ordinateur (le CPU) n’éxécute que des instructions machines codées en binaire.

Problème: comment transformer un algorithme en langage machine ?

Langage machine (binaire)

  • suite d’instruction binaire executer par le processeur: 01010111 (suite 0 ou 1 : bits)
  • représentation en hexadécimal (octet ou bytes):
    • f8 = 248
  • instructions et données sont stockées en mémoire (à une adresse donnée)
    • @000141 instruction f8
  • spécifiques au processeur (intel, ARM, power, AMD, ..)
  • spécifique au système d’exploitation OS
In [4]:
%%bash
od -x -N 100 data/a.out
./data/a.out

0000000 457f 464c 0102 0001 0000 0000 0000 0000
0000020 0002 003e 0001 0000 0870 0040 0000 0000
0000040 0040 0000 0000 0000 21b0 0000 0000 0000
0000060 0000 0000 0040 0038 0009 0040 001e 001b
0000100 0006 0000 0005 0000 0040 0000 0000 0000
0000120 0040 0040 0000 0000 0040 0040 0000 0000
0000140 01f8 0000
0000144
Calcul de la serie pour n=20 et x=0.2
Somme de la serie = 0.182322
Log(1+x)=0.182322

Langage assembleur

L’assembleur traduit le code source en code binaire

  • notation des instructions machines (move, push, load, add, mul)
  • programme + assembleur = code machine
In [5]:
%%bash
head -15 data/serie.s

	.file	"serie.C"
	.local	_ZStL8__ioinit
	.comm	_ZStL8__ioinit,1,1
	.text
	.globl	_Z5seriedi
	.type	_Z5seriedi, @function
_Z5seriedi:
.LFB971:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movsd	%xmm0, -40(%rbp)

Langage compilé: compilateur

le compilateur transforme le code source en assembleur (compilation), éffectue l’édition avec des librairies pour obtenir un binaire qui dépend de l’ordinateur cible, mais qui s’exécute sans le compilateur et sans le code source.

  • C++ Fortran C
  • programme source + compilateur = programme binaire
  • programme source = portable
  • programme binaire = spécifique à l’ordinateur (non portable)

langage C

In [6]:
%%bash
head -17 data/serie.C

#include <stdlib.h>
#include <math.h>
#include <iostream>
//
// calcul de la somme de n termes de la serie x-x^2/2+x^3/3-
//
double serie(double x,int n)
{
	double coef=x;
	double somme=0.0;
	for (int i=1; i<=n; i++)
	{
		somme = somme + coef/i;
		coef = -coef*x;
	}
	return somme;
}
In [7]:
%%bash
g++ data/serie.C -o serie
./serie

Calcul de la serie pour n=20 et x=0.2
Somme   = 0.182322
Log(1+x)= 0.182322

Langage interprété:

l’interpéteur exécute de façon interactive chaque ligne du fichier pour la traduire en code machine et l’execute interactivement. Pour exécuter le code, on a donc toujours besoin de l’interpréteur et du code source.

  • Python, Matlab
  • programme + interpréteur
  • portable = indépendant du système (Linux, MacOS, Windows)

langage python

Python est un language de programmation moderne de haut niveau, logiciel libre, généraliste, multi-plateformes, multi-architecture, multi-OS (linux, windows, MacOS,..). Un programme python peut s’executer sur un tout petit raspberry Pi à 30€ (ARM), sur des smartphones, des portables, des PC jusqu’aux super-calculateurs HPC avec $10^9$ coeurs de calcul.

In [8]:
%%bash
cat data/serie.py

#! /usr/bin/env python
from math import log

def serie(x,n):
    """ calcul de la somme de n termes de la serie x-x^2/2+x^3/3- """
    coef=x
    somme=0.0
    for i in range(1,n+1):
        somme = somme + coef/i
        coef  = -coef*x
    return somme
#
x=0.2
n=20
print "Calcul de la serie pour x=",x," et n=",n
print "somme    = ",serie(x,n)
print "log(1+x) = ", log(1+x)
In [9]:
%%bash
python data/serie.py

Calcul de la serie pour x= 0.2  et n= 20
somme    =  0.182321556794
log(1+x) =  0.182321556794

Historique des langages

malbolge

Langages de programmation

  • Années 1950 (approches expérimentales) :

    • FORTRAN, LISP, COBOL…

  • Années 1960 (langages universels) :

    • ALGOL, PL/1, PASCAL…

  • Années 1970 (génie logiciel) :

    • C, MODULA-2, ADA…

  • Années 1980 (programmation objet) :

    • C++, Eiffel…

  • Années 1980 (boites à outils):

    • LabView, Matlab…

  • Années 1990 (langages interprétés objet) :

    • Java, Perl, Python…

Langages pour les scientifiques

Pour le calcul intensif (HPC) (Argonne Lab)

  1. C,C++
  2. Fortran
  3. Python

Matlab est très utilisé pour le traitement des données, mais peut être avantageusement remplacer par Python avec ses librairies numpy et matplotlib et pandas

Exigences du calcul scientifique

“Le logiciel (software) est une des pierres angulaires de la science moderne. Sans logiciel, la science du vingt et unième siècle serait impossible. Mais sans de meilleurs logiciels, la science ne peut pas progresser” [http://sciencecodemanifesto.org/]

Réplicabilité et de reproductibilité sont des pierres angulaires de la méthode scientifique. En ce qui concerne le travail numérique, se conformer à ces concepts a des implications pratiques suivantes:

  • Réplicable: L’auteur d’un article scientifique qui implique des calculs numériques doit être en mesure de relancer les simulations et de reproduire les résultats sur demande. D’autres scientifiques devraient également être en mesure d’effectuer les mêmes calculs et d’obtenir les mêmes résultats, compte tenu des informations sur les méthodes utilisées dans une publication.

  • Reproductible: Les résultats obtenus à partir de simulations numériques doivent être reproductibles avec une mise en oeuvre indépendante du procédé, ou en utilisant un procédé tout à fait différent.

En résumé: un résultat scientifique solide doit être reproductible, et une étude scientifique solide doit être réplicable.

    • importance de la documentation

    • importance de la validation

    • importance de la maîtrise du code et des transformations de données (logiciels libres)

      </ol>

Démarche du calcul scientifique

  1. Modèle mathématique
  2. Discrétisation numérique: solution approchée
  3. Recherche solution algorithmique
  4. Programmation
  5. Validation

Algorithme

algorithme = suite finie et non ambigüe d’opérations ou d’instructions sur des données permettant d’obtenir un résultat (numérique) pour résoudre un problème

Dans un algorithme numérique

  • identifier les données
  • identifier le résultat
  • identifier les transformations des données pour obtenir le résultat

  • définir des cas de validation

    l’algorithme est ensuite traduit dans un langage de programmation sous forme de fonction (ou procédure)

    Attention fonction algorithmique $\neq$ fonction mathématique

Exemple: calcul d’une série

Formulation mathématique: calcul de la somme d’une série

$$ S_N = x - \frac{x^2}{2} + \frac{x^3}{3} + .. = \sum_{i=1}^n (-1)^{i+1} x^i/i $$

Solutions algorithmiques

1ere solution

Algorithme Serie(x,n)
   somme = 0
   pour i de 1 a n
      somme=somme + (-1)^(i+1)*x^i/i
   retour somme

2nde solution (optimisée)

Algorithme Serie(x,n)
   somme = 0
   coeff = x
   pour i de 1 a n
      somme = somme + coef/i
      coef  = -coef*x
   retour somme

implémentation

In [10]:
# algorithme en Python
from numpy  import log
def serie(x,n):
    """ calcul de la somme de n termes de la serie x-x^2/2+x^3/3- """
    coef=x
    somme=0.0
    for i in range(1,n+1):
        somme = somme + coef/i
        coef  = -coef*x
    return somme

Test et Validation

$$ \lim_{N\rightarrow\infty} S_N = log(1+x) $$
In [11]:
# utilisation et validation
x=0.2
n=10
print("Calcul de la serie pour x=",x," et n=",n)
print("somme    = ",serie(x,n))
print("log(1+x) = ", log(1+x))
err = serie(x,n) - log(1+x)
print("erreur: ",err)

Calcul de la serie pour x= 0.2  et n= 10
somme    =  0.18232155522031748
log(1+x) =  0.182321556794
erreur:  -1.57363710951e-09

Langage Python

Créé en 1989 par Guido van Rossum

Cours en ligne sur Python

Introduction au calcul scientifique avec Python

Caractéristiques de Python

Python (http://www.python.org/) est un langage de programmation moderne de haut niveau, orienté objet et d’usage général.

Caractéristiques générales de Python:

  • Langage simple: facile à lire et à apprendre avec une syntaxe minimaliste.
  • Langage concis et expressif: moins de lignes de code, moins de bugs, plus facile à maintenir.

Détails techniques:

  • Typé dynamiquement: Pas besoin de définir le type des variables, les arguments ou le type des fonctions.
  • La gestion automatique de la mémoire: Aucune nécessité d’allouer explicitement et désallouer la mémoire pour les variables et les tableaux de données. Aucun bug de fuite de mémoire.
  • Interprété: Pas besoin de compiler le code. L’interpréteur Python lit et exécute le code python directement.

Avantages:

  • Le principal avantage est la facilité de programmation, qui minimise le temps nécessaire pour développer, déboguer et maintenir le code.
  • Langage bien conçu qui encouragent les bonnes pratiques de programmation:
    • Modulaire et orientée objet, permet l’encapsulation et la réutilisation de code. Il en résulte souvent un code plus transparent, maintenable et sans bug.
    • Documentation intégré avec le code.
  • De nombreuses bibliothèques standards, et de nombreux packages add-on.

Inconvénient:

  • peut etre (très) lent, mais c’est le propre des langages interprétés
  • manque de certaines boites à outils (simulink,…)

Les bonnes pratiques de la programmation

In [12]:
import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Qui utilise Python ?

entreprises

• Google, YouTube

• JPMorgan, Chase

• NASA, Los Alamos, Fermilab, JPL , NSA

• Intel, Cisco, Seagate, IBM , HP

• Pixar

• CEA, EDF, Renault, Onera

logiciels

• Paraview, Visit, Elsa, Aster, Blender …

Outils de programmation

interpréteur Python

In [13]:
%%bash
python <<EOF
print 1+2./537
EOF

1.00372439479

programmation (avec un éditeur)

In [14]:
%%bash
cat data/serie.py

#! /usr/bin/env python
from math import log

def serie(x,n):
    """ calcul de la somme de n termes de la serie x-x^2/2+x^3/3- """
    coef=x
    somme=0.0
    for i in range(1,n+1):
        somme = somme + coef/i
        coef  = -coef*x
    return somme
#
x=0.2
n=20
print "Calcul de la serie pour x=",x," et n=",n
print "somme    = ",serie(x,n)
print "log(1+x) = ", log(1+x)
In [15]:
%%bash
python data/serie.py

Calcul de la serie pour x= 0.2  et n= 20
somme    =  0.182321556794
log(1+x) =  0.182321556794

Ipython Notebook

IPython notebook est un environnement portable sous HTML pour Python, similaire à Mathematica ou maple. Il est basé sur un shell IPython, mais offre un environnement à base de cellules avec une grande interactivité, où les calculs peuvent être organisées documentée de manière structurée.

Par defaut les cellules executent du code Python en cliquant sur le bouton “run” ou en entrant ctrl+entrée; avec le menu Cell->Run All on execute toutes les cellules dans l’ordre. On peut aussi éffacer toute les sorties avec All output -> Clear

In [16]:
print("hello ceci est mon premier programme")

hello ceci est mon premier programme

On peut aussi ajouter du texte en changeant le type de cellule de code a markdown

On peut alors utiliser des balises de mise en page markdown (documentation sur le lien ci-dessous)

[http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Working%20With%20Markdown%20Cells.html]

exemples

 #    titre niveau 1
 ##   titre niveau 2
 ###  titre niveau 3
 **texte**  écriture texte en gras 
 $ formule $ affichage formule en LaTeX
 $$ equation $$ ou une équation

remarque en double cliquant sur une cellule, on peut modifier cette cellule

De nombreux exemples de notebook sont accesibles [http://nbviewer.jupyter.org/] ou sur le site [http://jupyter.org/]

In [17]:
HTML('<iframe src="http://nbviewer.jupyter.org/" height=400 width=800/>')
Out[17]: