Formation Python du 14 Octobre 2010

Transcription

1 Formation Python du 14 Octobre 2010 Version Dimitri Bonnet, François Cuenot, Alexandre Vaudrey 12 October 2010

2

3 Table des matières 1 Organisation Déroulement de la formation Préalables à la formation Outils à installer avant la formation (linux) Outils à installer avant la formation (windows) Introduction à Python Opérations de base Les variables Les blocs & sections de code Les types Définition de fonctions et passage de paramètres Exemple de structure de contrôle Numpy Introduction à numpy L indexing, le slicing et le broadcasting avec numpy Matplotlib Tracé de courbes Tracé d une fonction bidimensionnelle en courbes de niveaux Exemples Exemples de traitement d image Résolution approchée d équations non linéaires Optimisation Equations différentielles Quelques liens Index 45 i

4 ii

5 Auteurs : Dimitri Bonnet, François Cuenot, Alexandre Vaudrey. Table des matières 1

6 2 Table des matières

7 CHAPITRE 1 Organisation La séance de formation à Python aura lieu le jeudi 14 Octobre 2010 à partir de 14h, à la faculté des sciences de Belfort. Elle se tiendra dans une salle informatique (salles 204 et 205). Ainsi, ceux qui n ont pas d ordinateur portable pourront utiliser les ordinateurs de la fac. Pour ceux qui désirent venir avec leur propre ordinateur, nous vous demandons de préinstaller différents outils qui sont accessibles ici. 1.1 Déroulement de la formation heure formation lieu 14h - 14h45 Introduction à Python salles h45-15h45 Manipulation de tableaux avec Numpy salles h45-16h15 Pause 16h15-16h45 Tracés de graphiques avec Matplotlib salles h45-18h Exemples salles D autres informations à venir seront communiquées aux participants par mail. Mais vous pouvez aussi consulter ces pages. 3

8 4 Chapitre 1. Organisation

9 CHAPITRE 2 Préalables à la formation 2.1 Outils à installer avant la formation (linux) python 2.6 ou supérieur (Attention : ne pas installer une version 3) scipy numpy matplotlib PIL Ipython Warning : Ne pas installer la version 3 de Python!! 2.2 Outils à installer avant la formation (windows) Python(x, y) Note : Si vous avez un problème d installation, vous pouvez nous contacter ici 5

10 6 Chapitre 2. Préalables à la formation

11 CHAPITRE 3 Introduction à Python Python est un langage de programmation qui présente l avantage d être livré de base avec un interpréteur interactif. On peut ainsi facilement tester chaque commande avant de l inclure dans un programme. Ipython est l interpréteur que nous allons utiliser au cours de cette formation. Une fois l interpréteur lancé on peut saisir des commandes : In [0]: print("bonjour!") Bonjour! 3.1 Opérations de base In [1]: 1+1 Out[1]: 2 In [2]: 1-1 Out[2]: 0 In [3]: 2*3 Out[3]: 6 In [4]: 12%5 Out[4]: 2 In [5]: 2**8 Out[5]: Les variables In [6]: a = 1+1 le résultat de 1+1 est affecté à la variable a In [7]: a Out[7]: 2 7

12 3.2.1 Convention de nommage : les variables sont écrites en minuscule, les mots sont attachés et différentiés par des majuscules In [8]: unevariable = a #Copie de la valeur de "a" dans "unevariable" les constantes sont écrites en majuscule, les mots sont séparé par des _ In [9]: FARADAY_CONSTANT = 9.64e4 3.3 Les blocs & sections de code Lorsque l on programme on organise le code en blocs ou sections (class, fonctions, structures de contrôle... ). Python utilise l indentation pour repérer ces blocs, et les retours à la ligne pour détecter la fin d instruction. Ce code C de déclaration de fonction void disbonjour(){ print("bonjour"); //fin d instruction } //fin de bloc devient en python : def disbonjour() : print( Bonjour ) Attention : Attention à conserver le même nombre d espace pour l indentation (4) En enregistrant ce code dans un fichier texte salut.py, on peut l exécuter depuis IPython In [10]: %run salut.py In [11]: disbonjour() Out[11]: Bonjour Attention : Attention à l encodage, évitez les messages d erreur avec la ligne suivante à ajouter en début du fichier.py : # -*- coding: utf-8 -*- Pour empêcher un retour à la ligne d être considéré comme une fin d instruction on utilise \\ In [12]: resultat = \...: / \...: ** 2 Enfin la commande print associée au """ ou d afficher du texte sur plusieurs lignes sans recourir a \\ In [13]: print("""blabla blabla blabla blabla...: blabla blabla...: blabla blabla blabla bla""") blabla blabla blabla blabla blabla blabla blabla blabla blabla bla 8 Chapitre 3. Introduction à Python

13 3.4 Les types In [14]: entier = 1 In [15]: type(entier) Out[15]: <type int > In [16]: flotant = 1. In [17]: type(flotant) Out[17]: <type float > In [18]: complexe = 0+1j In [19]: complexe.real Out[19]: 0.0 In [20]: complexe.imag Out[20]: 1.0 In [21]: complexe**2 Out[21]: (-1+0j) In [22]: booleen = False In [23]: booleen == booleen Out[23]: True Attention : 3/2 = 1 alors que 3/2.= Les tuples & les listes In [24]: untuple = (1,2,3,4) In [25]: uneliste = [5,6,7,8] Pour accéder à un élément on précise entre [] le numéro de l élément voulu à partir de 0 In [26]: untuple[0] Out[26]: 1 In [27]: uneliste[2] Out[27]: 7 La différence entre les deux : une liste est modifiable un tuple ne l est pas In [28]: untuple[0] = 1 TypeError: tuple object does not support item assignment In [29]: uneliste[2] = 1 In [30]: uneliste Out[30]: [5, 6, 1, 8] À noter que les chaines sont accessibles comme les tuples In [31]: unechaine = "coucou" In [32]: unechaine[1] Out[32]: o 3.4. Les types 9

14 On peut accéder à des sections (on reverra le slicing en détail avec numpy) In [33]: unechaine[0:3] # Les 3 première lettres Out[33]: cou In [34]: unechaine[1:-1] # Du second à l avant dernier caractère Out[34]: ouco In [35]: unechaine[::2] # 1 caractère sur 2 Out[35]: cuo In [36]: unechaine[::-1] # La chaine à l envers Out[36]: uocuoc In [37]: unechaine[::-2] # 1 caractère sur 2 de la chaine à l envers Out[37]: uco On peut les concaténer : In [38]: unechaine+unechaine Out[38]: coucoucoucou In [39]: unechaine*2 Out[39]: coucoucoucou Les dictionnaires In [40]: dic = { list : [1,2,3],...: str : coucou } In [41]: dic[ str ] Out[41]: coucou In [42]: dic[ list ][0] Out[42]: Définition de fonctions et passage de paramètres In [43]: def somme(a,b,c) :...: return a + b + c...: In [44]: somme(2,3,3) Out[44]: 8 In [45]: somme(*[2,3,3]) Out[45]: Exemple de structure de contrôle if/elif/else In [46]: prenom = raw_input( Prénom : ) Prénom : François 10 Chapitre 3. Introduction à Python

15 In [47]: if prenom == Chef :...: print("bonjour Chef")...: elif prenom in ( Alex, Dimitri, François ) :...: print("bravo!")...: else :...: print("salut %s" %prenom)...: Bravo! for/range In [48]: for i in range(3) :...: print(i)...: In [49]: for organisateur in ( Alex, Dimitri, François ):...: print(organisateur)...: Alex Dimitri François In [50]: for index, organisateur in enumerate( Alex, Dimitri, François ):...: print index, organisateur 0 Alex 1 Dimitri 2 François while/break/continue In [51]: a = [1, 0, 2, 4] In [52]: for element in a :...: if element == 0 :...: continue...: print 1. / element...: In [53]: end = False In [54]: while not end :...: end = raw_input( Stop ou Encore? )...: if end == Stop :...: print("voilà c est fini!")...: end = True...: elif end == Encore :...: print("on continue!")...: end = False...: else :...: print("on sent la fatigue ; FIN!")...: break...: 3.6. Exemple de structure de contrôle 11

16 12 Chapitre 3. Introduction à Python

17 CHAPITRE 4 Numpy 4.1 Introduction à numpy Numpy est un module python qui permet de manipuler des tableaux (array) de différentes dimensions. Pour pouvoir utiliser numpy, on doit commencer par importer ce module : In [1]: import numpy La création d un tableau peut se faire de la manière suivante : In [2]: a = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) In [3]: a Out[3]: array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) Ensuite, on peut effectuer tous les calculs usuels. Attention, par défaut ce n est pas du calcul matriciel : In [4]: b = numpy.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) In [5]: b Out[5]: array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) In [6]: a*b Out[6]: array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) Le produit matriciel existe tout de même dans numpy, mais ne ce note pas * : In [7]: numpy.dot(a, b) Out[7]: array([[ 6, 6, 6], [15, 15, 15], [24, 24, 24]]) numpy permet de faire des opérations sur les tableaux sans avoir à recourir à des boucles. En plus des opérations sur les tableaux, numpy a des méthodes de créations de tableau. Quelques exemples : 13

18 In [8]: numpy.zeros((3, 4)) Out[8]: array([[ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.]]) In [9]: numpy.ones((3, 4)) Out[9]: array([[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]]) In [10]: numpy.diag((1, 2, 3, 4)) Out[10]: array([[1, 0, 0, 0], [0, 2, 0, 0], [0, 0, 3, 0], [0, 0, 0, 4]]) In [11]: numpy.random.random((3, 4)) Out[11]: array([[ , , , ], [ , , , ], [ , , , ]]) In [12]: numpy.arange(0, 10) Out[12]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) Il est aussi possible de créer des grilles : In [13]: x = numpy.arange(0, 10) In [14]: y = numpy.arange(0, 4) In [15]: x Out[15]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) In [16]: y Out[16]: array([0, 1, 2, 3]) In [17]: X, Y = numpy.meshgrid(x, y) In [18]: X Out[18]: array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]) In [19]: Y Out[19]: array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3]]) Avec numpy, on peut aussi obtenir des informations sur les tableaux : In [20]: X.dtype Out[20]: dtype( int64 ) In [21]: X.shape Out[21]: (4, 10) 14 Chapitre 4. Numpy

19 On peut aussi redimensionner des tableaux : In [21]: a = numpy.ones((3, 4)) In [22]: a Out[22]: array([[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]]) In [23]: a.reshape((4, 3)) Out[23]: array([[ 1., 1., 1.], [ 1., 1., 1.], [ 1., 1., 1.], [ 1., 1., 1.]]) In [24]: a Out[24]: array([[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]]) On remarque que la méthode reshape n assigne pas de valeur à a, mais elle crée un résultat indépendant de a. On peut utiliser autant de dimensions que désirées : In [25]: a = numpy.random.random((3, 4, 2)) In [26]: a Out[26]: array([[[ , ], [ , ], [ , ], [ , ]], [[ , ], [ , ], [ , ], [ , ]], [[ , ], [ , ], [ , ], [ , ]]]) In [27]: a.shape Out[27]: (3, 4, 2) 4.2 L indexing, le slicing et le broadcasting avec numpy L indexing L indexing permet d obtenir la valeur du tableau à un indice donné : In [1]: import numpy In [2]: a = numpy.random.random_integers(0, 10, (3, 4)) 4.2. L indexing, le slicing et le broadcasting avec numpy 15

20 In [3]: a Out[3]: array([[ 2, 10, 8, 2], [ 5, 5, 1, 2], [ 7, 0, 4, 3]]) In [4]: a[2, 1] Out[4]: 0 Le premier indice représente le premier axe, le deuxième indice représente le second axe... Warning : En python, le premier indice est 0. Avec l indexing, on obtient un vue de l élément du tableau, c est à dire qu on ne crée pas une nouvelle variable, mais qu on ne fait que visualiser l élément. Ainsi, si on modifie la valeur de cet élément, la nouvelle valeur sera affectée au tableau. Exemple : In [5]: a[0,1] = 999 In [6]: a Out[6]: array([[ 2, 999, 8, 2], [ 5, 5, 1, 2], [ 7, 0, 4, 3]]) On peut aussi utiliser plusieurs indices : In [7]: a[(0, 2), (0, 1)] Out[7]: array([2, 0]) Dans cet exemple, on obtient un tableau composé de la valeur de a[0,0] = 2 et de a[2,1] = 0. Il est également possible d obtenir les valeurs d un tableau en utilisant des booléens : In [8]: booleen = (a <= 2) In [9]: booleen Out[9]: array([[ True, False, False, True], [False, False, True, True], [False, True, False, False]], dtype=bool) In [10]: a[booleen] Out[10]: array([2, 2, 1, 2, 0]) In [11]: a[booleen] Out[11]: array([2, 2, 1, 2, 0]) In [12]: a[(a <= 2)] Out[12]: array([2, 2, 1, 2, 0]) On appelle ce booléen un masque. On peut aussi donner une valeur à ce masque : In [20]: a[booleen] = 3333 In [23]: a Out[23]: array([[3333, 999, 8, 3333], [ 5, 5, 3333, 3333], [ 7, 3333, 4, 3]]) 16 Chapitre 4. Numpy

21 4.2.2 Le slicing Le slicing est une méthode qui permet de découper un tableau. Pour chaque axe, on peut découper le tableau en indiquant le premier indice à partir du quel on va couper le tableau, puis le dernier indice et enfin le pas utilisé : In [1]: import numpy In [2]: a = numpy.arange(12) In [3]: a Out[3]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) In [4]: a[3:9:2] Out[4]: array([3, 5, 7]) a est coupé à partir de l indice 3 (on compte en slice, le slice 3 se situe avant l indice 3, entre l indice 2 et l indice 3) jusqu à l indice 8 (en compte en slice, le slice 9 se situe entre l indice 8 et l indice 9) en prenant un pas de 2 unités. Le pas est optionnel : In [5]: a[3:9] Out[5]: array([3, 4, 5, 6, 7, 8]) Si on n indique pas le premier slice, on commence du début : In [6]: a[:9] Out[6]: array([0, 1, 2, 3, 4, 5, 6, 7, 8]) Si on n indique pas le dernier slice, on termine au dernier : In [7]: a[3:] Out[7]: array([ 3, 4, 5, 6, 7, 8, 9, 10, 11]) Il est aussi possible de compter en indices négatifs, on commence alors depuis la fin : In [8]: a[-5:-2] Out[8]: array([7, 8, 9]) In [9]: a[3:-2] Out[9]: array([3, 4, 5, 6, 7, 8, 9]) Ces opérations peuvent se faire sur toutes les dimensions : In [19]: a = numpy.random.random_integers(0, 10, (4, 5)) In [20]: a Out[20]: array([[ 7, 6, 2, 8, 9], [ 8, 9, 1, 4, 4], [ 9, 4, 10, 7, 0], [ 9, 0, 6, 4, 6]]) In [21]: a[0:2, 2:5] Out[21]: array([[2, 8, 9], [1, 4, 4]]) Le slice sur la première dimension est indiqué en premier, puis on indique le slice sur la seconde dimension..., chaque dimension est séparée par une, L indexing, le slicing et le broadcasting avec numpy 17

22 4.2.3 Le broadcasting Le broadcasting est une fonctionnalité de numpy qui permet de réaliser des opérations entre des tableaux de dimensions différentes tant qu une consistence existe entre ces tableaux. Quelques exemples : In [1]: import numpy In [2]: a = numpy.arange(9).reshape((3,3)) In [3]: a = numpy.arange(9).reshape((3,3)) In [4]: a + 1 Out[4]: array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) In [5]: a = numpy.arange(0, 40, 10).reshape((4, 1)) In [6]: a Out[6]: array([[ 0], [10], [20], [30]]) In [7]: b = numpy.arange(4) In [8]: b Out[8]: array([0, 1, 2, 3]) In [9]: a + b Out[9]: array([[ 0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33]]) In [10]: a = numpy.zeros((4, 4)) In [11]: a Out[11]: array([[ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.]]) In [12]: b = numpy.arange(4) In [13]: b Out[13]: array([0, 1, 2, 3]) In [14]: a + b Out[14]: array([[ 0., 1., 2., 3.], [ 0., 1., 2., 3.], [ 0., 1., 2., 3.], [ 0., 1., 2., 3.]]) 18 Chapitre 4. Numpy

23 CHAPITRE 5 Matplotlib Matplotlib est un module qui permet de réaliser des graphes 2D (et quelques graphes 3D de base, pour la 3D il est préférable de se tourner vers Mayavi) 5.1 Tracé de courbes Pour tracer des courbes, il faut utiliser l outils plot. Détaillons un exemple : In [1]: import numpy In [2]: import matplotlib as mpl In [3]: import matplotlib.pyplot as plt In [4]: from matplotlib import rc Note : matplotlib et pyplot sont les outils pour les tracés, rc est utilisé ici pour avoir un rendu Latex des formules. In [6]: X = numpy.linspace(-2, 2, 20) In [7]: X Out[7]: array([-2., , , , , , , , , , , , , , , , , , , 2. ]) Note : Ici, nous avons créé un tableau qui nous servira d absices In [8]: Y1 = numpy.exp(x) In [9]: Y2 = X ** 2 In [10]: Y3 = 2 * numpy.sin(x) + 4. Note : Ici, nous avons créé 3 tableaux représentant les ordonnées relatives à X pour 3 fonctions. In [11]: plt.plot(x, Y1, b-, label = r $e^{x}$ ) Out[11]: [<matplotlib.lines.line2d object at 0x35b4f10>] 19

24 In [12]: plt.plot(x, Y2, r+, label = r $x^{2}$ ) Out[12]: [<matplotlib.lines.line2d object at 0x >] In [13]: plt.plot(x, Y3, ks--, linewidth = 2, label = r $2 \times sin(x) + 4$ )Out[13]: [<matplo In [14]: plt.xlabel( x ) Out[14]: <matplotlib.text.text object at 0x3db2f90> In [15]: plt.ylabel( y ) Out[15]: <matplotlib.text.text object at 0x3db5cd0> In [16]: plt.legend() Out[16]: <matplotlib.legend.legend object at 0x39769d0> In [17]: plt.grid( True ) In [17]: plt.show() Note : Enfin, les tracés sont réalisés en indiquant un tableau pour les abscisses et un pour les ordonnées. En option, on peut ajouter la couleur de la courbe b pour bleu, r pour rouge... La forme des points +, s... la forme de la ligne -,... peuvent compléter cette option. On peut choisir l épaisseur de la ligne linewidth et on peut ajouter un titre label. Pour avoir la légende affichée, il faut utiliser plt.legend(). Et pour avoir une grille on emploie plt.grid( True ). Le nom des axes sont donnés avec plt.xlabel et plt.ylabel Le résultat obtenu : 20 Chapitre 5. Matplotlib

25 5.2 Tracé d une fonction bidimensionnelle en courbes de niveaux La représentation graphique de l évolution d une fonction f de deux variables x et y n est pas une tâche facile, surtout si le graphique en question est destiné à être imprimé. Dans ce type de cas, un graphe faisant apparaître les lignes de niveaux de la fonction en question peut être une solution intéressante et lisible. Commençons donc par considérer l exemple simple d une fonction de Rosenbrock de la forme : f(x, y) = (1 x) 2 + ( y x 2) 2 (5.1) Que l on déclare en python de la façon suivante : In [1]: def f(x,y):...: """Fonction de Rosenbrock."""...: return (1-x)**2+(y-x**2)**2 Le tracé de cette fonction en courbes de niveaux va nécessiter la création d un maillage bidimensionnel permettant de stocker l intervalle de chacune des variables x et y. La fonction destinée à cela s appelle meshgrid (incluse dans NumPy ). On construit donc le maillage en question sur l intervalle (x, y) [ 1; 1] [ 1; 2] : In [2]: import numpy as np In [3]: x, y = np.meshgrid(np.linspace(-1,1,201),np.linspace(-1,2,201)) In [4]: z = f(x,y) La fonction meshgrid fait appel dans ce cas à deux fonctions linspace pour chacune des variables. z est ici un objet array qui contient les valeurs de la fonction f sur chaque noeud du maillage. Pour tracer l évolution de f en lignes de niveaux, de fonctions sont adaptées, appelées respectivement contour et contourf. La première ne trace que les lignes de niveaux alors que la seconde colore le graphe entre ces lignes de niveaux : In [5]: graphe = contour(x,y,z,20) Avec comme arguments, les variables x et y, les valeurs de z correspondantes ainsi que le nombre (ici 20) de lignes de niveaux choisit. Par défaut, ces courbes de niveaux sont colorées en fonction de leur altitude z correspondante. On peut par ailleurs imposer une couleur uniforme pour le graphe précédent : In [6]: graphe = contour(x,y,z,20,colors= grey ) Ce qui donne : Comme dit précédemment, la fonction contourf colore toute la surface représentant la fonction : In [7]: graphe = contourf(x,y,z,20) In [8]: colorbar() Out[8]: <matplotlib.colorbar.colorbar instance at 0x3cc5758> Ce qui donne : S il n est pas possible d utiliser de la couleur, comme dans un article ou un rapport imprimé en noir et blanc, on peut utiliser des labels sur les lignes de niveaux afin de repérer leurs altitudes. La fonction en question s appelle clabel et prend comme principal argument la variable graphe précédente. In [9]: graphe = contour(x,y,z,20,colors= grey ) In [10]: clabel(graphe,inline=1,fontsize=10,fmt= %3.2f ) Out[10]: <a list of 21 text.text objects> Qui donne : La première option inline=1 impose d écrire les valeurs sur les lignes de niveaux, les deux options suivantes gérant la taille de la police utilisée et le format d écriture des valeurs Tracé d une fonction bidimensionnelle en courbes de niveaux 21

26 22 Chapitre 5. Matplotlib

27 5.2. Tracé d une fonction bidimensionnelle en courbes de niveaux 23

28 24 Chapitre 5. Matplotlib

29 CHAPITRE 6 Exemples 6.1 Exemples de traitement d image Voici quelques exemples de traitement d image, basés sur une image de référence en traitement d image : Lena Seuillage Le seuillage est une opération qui affecte la valeur 0 à tous les pixels dont le niveau est inférieur à celui du seuil. Ici, sur une image 8 bits (les niveaux varient de 0 à 255), on réalise un seuillage avec un niveau de seuil à 100. La méthode numpy.where crée un masque et ici remplace par 0 toutes les valeurs du tableau lena inférieures à 100. import matplotlib as mpl import matplotlib.pyplot as plt import numpy import scipy lena = scipy.lena() # opération de seuillage lena_seuil = numpy.where(lena > 100, lena, 0) fig = plt.figure() ax1 = fig.add_subplot(1, 2, 1) plt.title( lena ) ax1.imshow(lena, cmap = mpl.cm.gray) ax2 = fig.add_subplot(1, 2, 2) plt.title( seuillage (100) ) ax2.imshow(lena_seuil, cmap = mpl.cm.gray) plt.show() Sélection d une partie de l image Pour sélectionner une partie de l image, on peut utiliser le slicing de Numpy. import matplotlib as mpl import matplotlib.pyplot as plt import numpy import scipy 25

30 lena = scipy.lena() # slicing lena_select = lena[200:400, 100:300] fig = plt.figure() ax1 = fig.add_subplot(1, 2, 1) plt.title( lena ) ax1.imshow(lena, cmap = mpl.cm.gray) ax2 = fig.add_subplot(1, 2, 2) plt.title( Selection [200:400, 100:300] ) ax2.imshow(lena_select, cmap = mpl.cm.gray) plt.show() Transformée de Fourier On peut réaliser une transformée de Fourier sur une image en utilisant la méthode de transformée de Fourier rapide de Numpy en dimension 2 : numpy.fft.fft2. Un exemple de transformée de Fourier et de transformée inverse sur le module et sur la phase : import matplotlib as mpl import matplotlib.pyplot as plt import numpy import scipy 26 Chapitre 6. Exemples

31 # fonction de normalisation def norma(mat): mat1 = mat.real mat1 -= mat1.min() mat1 *= 255. / mat1.max() return mat1 #fonction de normailsation sur une échelle logarithmique def normalog(mat): mat1 = norma(mat) mat1 = numpy.log(1 + mat1) mat1 *= 255. / mat1.max() return mat1 lena = scipy.lena() # transformée de Fourier de l image lena_fft = numpy.fft.fft2(lena) # module de la transformée de Fourier de l image lena_fft_abs = abs(lena_fft) # centré lena_fft_abs_centre = numpy.fft.fftshift(lena_fft_abs) # phase de la transformée de Fourier de l image lena_fft_phase = lena_fft / lena_fft_abs # centré lena_fft_phase_centre = numpy.fft.fftshift(lena_fft_phase) 6.1. Exemples de traitement d image 27

32 # transformée de Fourier inverse du module lena_abs = numpy.fft.ifft2(lena_fft_abs) # transformée de Fourier inverse de la phase lena_phase = numpy.fft.ifft2(lena_fft_phase) fig = plt.figure() ax1 = fig.add_subplot(2, 3, 1) plt.title( lena ) ax1.imshow(lena, cmap = mpl.cm.gray) ax2 = fig.add_subplot(2, 3, 2) plt.title( fft module ) ax2.imshow(normalog(lena_fft_abs_centre), cmap = mpl.cm.gray) ax3 = fig.add_subplot(2, 3, 3) plt.title( fft phase ) ax3.imshow(norma(lena_fft_phase_centre), cmap = mpl.cm.gray) ax5 = fig.add_subplot(2, 3, 5) plt.title( module ) ax5.imshow(normalog(lena_abs), cmap = mpl.cm.gray) ax6 = fig.add_subplot(2, 3, 6) plt.title( phase ) ax6.imshow(norma(lena_phase), cmap = mpl.cm.gray) plt.show() 28 Chapitre 6. Exemples

33 6.1.4 Filtrage Gradient Pour l opération gradient, on utilise ici une convolution selon chaque axe de l image entre l image et un filtre représentatif du gradient selon ces axes. import matplotlib as mpl import matplotlib.pyplot as plt import numpy import scipy import scipy.signal lena = scipy.lena() # définition des filtres fx = numpy.array([[-1, 0, 1]]) fy = numpy.transpose(fx) # convolutions lena_convol_x = scipy.signal.convolve2d(lena, fx, mode = same ) lena_convol_y = scipy.signal.convolve2d(lena, fy, mode = same ) lena_gradient = numpy.sqrt(lena_convol_x**2 + lena_convol_y**2) fig = plt.figure() ax1 = fig.add_subplot(1, 2, 1) plt.title( lena ) ax1.imshow(lena, cmap = mpl.cm.gray) ax2 = fig.add_subplot(1, 2, 2) plt.title( Gradient ) ax2.imshow(lena_gradient, cmap = mpl.cm.gray) plt.show() Transformations Rotation Dans scipy, il existe un module pour les images : scipy.ndimage. Dans ce module, on peut trouver différentes fonctions comme la rotation. La rotation est effectuée en utilisant une matrice de rotation et une interpolation en spline cubique est ensuite réaliser pour obtenir les valeurs des pixels de la nouvelle grille. import matplotlib as mpl import matplotlib.pyplot as plt import numpy import scipy import, lena = scipy.lena() # angle de rotation désiré angle = 30. # roations lena_30_degresf = scipy.ndimage.rotate(lena, angle, reshape = False) lena_30_degrest = scipy.ndimage.rotate(lena, angle, reshape = True) fig = plt.figure() 6.1. Exemples de traitement d image 29

34 ax1 = fig.add_subplot(1, 3, 1) plt.title( lena ) ax1.imshow(lena, cmap = mpl.cm.gray) ax2 = fig.add_subplot(1, 3, 2) plt.title( 30 degres\nnon redimensionne ) ax2.imshow(lena_30_degresf, cmap = mpl.cm.gray) ax3 = fig.add_subplot(1, 3, 3) plt.title( 30 degres\n redimensionne ) ax3.imshow(lena_30_degrest, cmap = mpl.cm.gray) plt.show() Transformation géométrique On peut créer ses propres déformation avec la fonction scipy.ndimage.geometric_transform, qui renvoie une image avec un système de coordonnées souhaité. Une interpolation en spline cubique est là aussi réaliser pour obtenir la valeur des pixels sur la nouvelle grille. import matplotlib as mpl import matplotlib.pyplot as plt import numpy import scipy import scipy.ndimage lena = scipy.lena() 30 Chapitre 6. Exemples

35 # définition du système de coordonnées def deformation(coordonnees): return (coordonnees[0], \ coordonnees[1] + (coordonnees[1] - lena.shape[1])/2.) # transformation géométrique lena_deform = scipy.ndimage.geometric_transform(lena, deformation) fig = plt.figure() ax1 = fig.add_subplot(1, 2, 1) plt.title( lena ) ax1.imshow(lena, cmap = mpl.cm.gray) ax2 = fig.add_subplot(1, 2, 2) plt.title( Deformation ) ax2.imshow(lena_deform, cmap = mpl.cm.gray) plt.show() 6.2 Résolution approchée d équations non linéaires Fonction scalaire Voyons comment approcher la solution d une équation du type f(x) = 0 avec f une fonction réelle quelconque. Considérons pour commencer la fonction scalaire f(x) = x exp( x) qui dispose d une racine comprise entre 0 et 1. La première étape consiste à déclarer cette fonction : 6.2. Résolution approchée d équations non linéaires 31

36 In [1]: import numpy as np In [2]: def f(x):...: """Fonction dont on cherche une racine."""...: return x-np.exp(-x) Pour se convaincre de l existence de cette racine, on peut par exemple tracer l allure de cette fonction entre 0 et 1 à l aide de matplotlib : In [3]: import pylab as plt In [4]: x = np.linspace(0,1,101) In [4]: plt.plot(x,f(x), b- ) In [5]: plt.grid(true) La fonction fsolve que nous allons utiliser pour résoudre notre problème est comprise dans le package SciPy/Optimisation : In [6]: import scipy.optimize as op L appel de cette fonction nécessite au minimum deux arguments, la fonction f précédemment déclarée et un point de départ x 0 de l algorithme, estimation initiale de la solution. En utilisant x 0 = 0.0 comme point de départ, la solution est ainsi : In [7]: op.fsolve(f,0.0) Out[7]: Chapitre 6. Exemples

37 6.2.2 Fonction vectorielle Une démarche strictement identique doit être suivie pour obtenir la solution à un système d équation non linéaires, à condition de n utiliser qu un seul argument (list ou tuple) pour stocker les différentes composantes du vecteur x = (x 1, x 2,..., x N ) considéré. En guise d exemple, considérons le système non-linéaire [1] formé par les fonctions f 1 (x 1, x 2 ) = x log 10 (x 1 ) x 2 2 et f 2 (x 1, x 2 ) = 2 x 2 1 x 1 x 2 5 x La déclaration de la fonction f est désormais classique : In [8]: def f(x):...: return [x[0]+3*log10(x[0])-x[1]**2,2*x[0]**2-x[0]*x[1]-5*x[0]+1] En considérant comme point de départ le vecteur x 0 = (5.0, 5.0), on obtient : In [9]: op.fsolve(f,(5.0,5.0)) Out[9]: array([ , ]) Références [1] B. Démidovitch et I. Maron, Eléments de calcul numérique, Editions MIR, Optimisation Un premier problème d optimisation Afin de tester les fonctionnalités des algorithmes d optimisation compris dans la bibliothèque SciPy, nous allons utiliser comme support une classique fonction de Rosenbrock bidimensionnelle : f(x 1, x 2 ) = (1 x 1 ) 2 + (x 2 x 2 1) 2 (6.1) Fonction de deux variables que nous étudierons sur l intervalle (x 1, x 2 ) [0; 2] [0; 2]. On commence donc par déclarer cette fonction comme n appelant qu un seul argument qui peut être une liste ou un tuple : In [1]: def f(x):...: """Fonction de Rosenbrock a deux variables"""...: return (1-x[0])**2+(x[1]-x[0]**2)**2 On définit ensuite l intervalle de variation de x 1 et x 2 à l aide de la fonction meshgrid de NumPy : In [2]: x1, x2 = np.meshgrid(np.linspace(0,2,201),np.linspace(0,2,201)) Le tracé en lignes de niveaux de cette fonction fait clairement apparaître l existence de cet optimum : In [3]: contourf(x1,x2,f([x1,x2]),linspace(0,1,21)) In [4]: colorbar() Ce qui donne : On peut alors chercher la coordonnée de cet optimum en utilisant la fonction fmin comprise dans la partie optimisation de la bibliothèque SciPy : In [5]: import scipy.optimize as op In [6]: %time op.fmin(f,(0.0,0.0)) Optimization terminated successfully. Current function value: Iterations: 67 Function evaluations: 129 CPU times: user 0.02 s, sys: 0.00 s, total: 0.02 s Wall time: 0.05 s Out[7]: array([ , ]) 6.3. Optimisation 33

38 La fonction fmin est basée sur l utilisation de l algorithme du simplexe, qui après 67 itérations et 129 évaluations de la fonction f a localisé un minimum au point (x 1, x 2 ) = (1.0, 1.0). Différents types de fonctions fmin existent dans SciPy, dont une qui utilise l algorithme du gradient conjugué, appelée fmin_cg : In [8]: op.fmin_cg(f,(0.0,0.0)) Optimization terminated successfully. Current function value: Iterations: 18 Function evaluations: 132 Gradient evaluations: 33 Out[8]: array([ , ]) Le résultat affiché précise par ailleurs le nombre d évaluations du gradient de la fonction f, calculé ici de manière approchée. Notons qu il est possible de fournir à la fonction fmin_cg l expression analytique du gradient de la fonction objectif, sous forme de fonction Python. Chacune des fonction fmin précédentes accepte certains arguments optionnels, comme par exemple le chemin parcouru par l algorithme. Dans le cas du simplexe, on peut ainsi afficher : In [9]: solsimplexe = op.fmin(f,(0.0,0.0),retall=1) Et le chemin suivit par l algorithme est stocké dans la variable solsimplexe[1]. Une fois ce chemin tracé, on obtient : Le même procédé peut être utilisé pour étudié le chemin suivi par le gradient conjugué, que l on peut superposer à celui suivi par le simplexe : 34 Chapitre 6. Exemples

39 6.3. Optimisation 35

40 6.3.2 Problème d optimisation de type moindres carrés Un problème très courant d optimisation est celui qui cherche à minimiser le résidu formé par la différence entre une fonction de structure donnée et un ensemble de points issus d expérimentations. Le critère le plus courant pour minimiser un tel résidu est celui dit, des moindres carrés, qui exprime cet écart sous la forme de la somme des carrés des écart en chaque point, soit par exemple : S(p) = N (y(x i, p) ỹ i ) 2 (6.2) i=1 avec S le critère servant de fonction objectif, y la fonction de structure connue (polynôme, spline, etc.) dépendante d un ensemble de paramètres p et ỹ les données expérimentales définies sur N points. Ce type très particulier de problème d optimisation bénéficie de méthodes numériques spécialement dédiées, dont celle de Levenberg-Marquardt [1,2] justement implémentée dans SciPy. Comprise dans la partie optimisation de SciPy, elle se nomme leastsq et prend comme argument la différence y(x i, p) ỹ i. Comme exemple pratique d application, on peut traiter les données expérimentales contenues dans le fichier donnees-moindrescarres.dat. On importe donc ces données à l aide de la fonction loadtxt de NumPy : In [1]: import numpy as np In [2]: donnees = np.loadtxt( donnees-moindrescarres.dat,skiprows=1) L option skiprows=1 sert ici à négliger la première ligne du fichier qui contient les entêtes. On extrait ensuite les informations, le temps t et la grandeur mesurée notée ỹ : In [3]: t, yb = donnees[:,0], donnees[:,1] L étape suivante consiste à tracé l évolution de y en fonction de t : In [4]: plot(t,yb, bo ) In [5]: grid(true) In [6]: xlabel(r $t$,size=20) In [7]: ylabel(r $\tilde{y}$,size=20) In [8]: title(r Donn\ {e}es exp\ {e}rimentales,size=18) Ce qui donne : L évolution des données ressemblant globalement à une exponentielle décroissante, la fonction utilisée pour les représenter sera de la forme : y(t, p) = p 1 exp( p 2 t) (6.3) Qui est fonction du temps et du vecteur des paramètres p = (p 1, p 2 ). On créé donc la fonction en question : In [9]: def y(t,p):...: """Exponentielle decroissante."""...: return p[0]*np.exp(-p[1]*t) Il faut ensuite créer la fonction résidu qui sera utilisée comme argument par leastsq et qui ne comprend comme argument que le vecteur des paramètres : In [10]: def residu(p):...: """Residu."""...: return y(t,p)-yb Et la fonction leastsq fonctionne directement sur la fonction residu, de la manière suivante : In [11]: LM = op.leastsq(residu,[1.0,1.0],full_output=1) L option full_output étant ici activée afin de tirer le maximum d informations du résultat, en premier lieux la valeur du vecteur des paramètres recherché : 36 Chapitre 6. Exemples

41 In [12]: LM[0] Out[12]: array([ , ]) Ce qui permet au passage de comparer la courbe d ajustement obtenue avec les données de départ : La seconde information contenue dans la variable LM est très importante puisqu il s agit de la matrice de covariance du résultat obtenu : In [13]: LM[1] Out[13]: array([[ , ],[ , ]]) D autres informations sont contenues dans la variable LM dont par exemple le nombre d appels de la fonction objectif : In [14]: LM[2][ nfev ] Out[14]: Références [1] Kenneth Levenberg (1944). A Method for the Solution of Certain Non-Linear Problems in Least Squares. The Quarterly of Applied Mathematics 2 : [2] Donald Marquardt (1963). An Algorithm for Least-Squares Estimation of Nonlinear Parameters. SIAM Journal on Applied Mathematics 11 : Optimisation 37

42 6.4 Equations différentielles Résolution approchée d une équation différentielle logistique La résolution approchée d équations ou de systèmes d équations différentielles peut être faite dans SciPy à l aide de la fonction odeint : In [1]: from scipy. import odeint Comme dans n importe quel autre logiciel de ce type (matlab,etc.), l équation différentielle ou le système différentiel doivent être écrits sous la forme d un système du premier du type : dy (x) = F (x, y) (6.4) dx avec y(x) = (y 1 (x),..., y N (x)) le vecteur des fonctions recherchées, dépendant de la variable x et F une fonction de forme quelconque. En guise d exemple, considérons une équation logistique simple de la forme : ( dy (t) = r y(t) 1 y(t) ) (6.5) dx K Pour les besoins de la résolution numérique, on considère que r = 1, 5 et K = 6. On créé alors la fonction F : In [2]: def F(y,t):...: """Equation logistique"""...: return 1.5*y*(1-y/6) Et la fonction odeint peut être appelée avec au minimum trois arguments, la fonction F, la condition initiale y 0 = y(t = 0) et le temps t comme variable principale : 38 Chapitre 6. Exemples

43 In [3]: y0 = 1.0 In [4]: t = linspace(0,5,201) In [5]: sol = odeint(f,y0,t) Et la fonction y recherchée peut alors être tirée du résultat : In [6]: y = sol[:,0] et tracée sur un graphique : Le système de Lotka-Volterra Proposées indépendamment par Alfred James Lotka en 1925 et Vito Volterra en 1926, les équations dites de Lotka- Volterra ou modèle proie-prédateur peuvent servir à reproduire les évolutions temporelles de deux populations animales, l une étant le prédateur de l autre. Si ces deux populations sont représentées par des variables contiunes x 1 et x 2, le système différentiel en question est alors : dx 1 dt (t) = x 1(t) (a b x 2 (t)) (6.6) Puis : dx 2 dt (t) = x 2(t) (c d x 1 (t)) (6.7) Pour les besoins de la résolution numérique, nous considérerons dans la suite que a = 2, b = 1, c = 1 et d = 0, 3. On déclare ainsi la fonction F sous forme vectorielle, en la faisant toujours dépendre de la variable temporelle même si ce n est pas le cas dans la formulation mathématique de départ : 6.4. Equations différentielles 39

44 In [1]: def F(x,t):...: """Systeme de Lotka-Volterra"""...: return [x[0]*(2-x[1]),-x[1]*(1-0.3*x[0])] En faisant varier le temps sur l intervalle t [0; 10] et en prenant comme condition initiale le vecteur x 0 = (2.0, 1.0) : In [2]: t = linspace(0,10,201) In [3]: x0 = [2.0,1.0] La résolution se fait alors de la même manière que précédemment : In [4]: lokvol = odeint(f,y0,t) In [5]: x1, x2 = lokvol[:,0], lokvol[:,1] Le tracé des évolutions de x 1 et x 2 en fonction du temps t donne : Ou encore sous forme paramétrique : 40 Chapitre 6. Exemples

45 6.4. Equations différentielles 41

46 42 Chapitre 6. Exemples

47 CHAPITRE 7 Quelques liens... Voici une liste de références pour les outils présentés lors de la formation. De cette manière, vous pourrez appronfondir les concepts vus pendant la formation. Vous pourrez y rencontrer un grand nombre d exemples libres d utilisation. Une excellente documentation python très détaillée et très didactique de Gérard Swinnen. La galerie matplotlib où de nombreux exemples sont détaillés. 43

48 44 Chapitre 7. Quelques liens...

49 Index broadcasting, 18 cmap, 25 contour, 21 contourf, 21 couleur, 20 courbes, 19 courbes de niveaux, 21 création de tableau, 13 date, 3 documentation, 43 dtype, 14 equation différentielle logistique, 38 equations différentielles, 38 equations non linéaires, 31 exemples, 25 filtrage, 29 fonction scalaire, 31 fonction vectorielle, 33 gradient, 29 gradient conjugué, 33 grille, 14 image, 25 indexing, 15 indice, 15 inline, 21 installation, 5 label, 20 latex, 19 Lena, 25 Levenberg, 36 Levenberg-Marquardt, 36 liens, 43 lieu, 3 ligne, 20 linewidth, 20 LM, 36 log, 26 Lotka, 39 Lotka-Volterra, 39 Marquardt, 36 masque, 15 Matplotlib, 19, 43 moindres carrés, 36 multiplication, 13 normalisation, 26 numpy, 13 numpy.arange, 13 numpy.array, 13 numpy.diag, 13 numpy.dot, 13 numpy.fft, 26 numpy.fft.fft2, 26 numpy.fft.fftshift, 26 numpy.fft.ifft2, 26 numpy.linspace, 19, 33 numpy.log, 26 numpy.meshgrid, 14, 21, 33 numpy.ones, 13 numpy.random.random, 13 numpy.random.random_integers, 15 numpy.transpose, 29 numpy.where, 25 numpy.zeros, 13 odeint, 38 op, 31, 33 op.fmin, 33 op.fsolve, 31 op.leastsq, 36 optimisation, 33 optimum, 33 organisation, 3 plot, 19 plt.grid, 20 plt.legend, 20 plt.xlabel, 20 45

50 plt.ylabel, 20 préalables, 5 préparation, 5 pyplot, 19 Python, 25 résidu, 36 résolution, 31, 38 redimensionner, 14 reshape, 14 Rosenbrock, 21, 33 rotation, 29 sélection, 25 scipy.integrat, 38 scipy.lena, 25 scipy.ndimage, 29 scipy.ndimage.geometric_transform, 30 scipy.ndimage.rotate, 29 scipy.optimize, 31, 33 scipy.signal, 29 scipy.signal.convolve2d, 29 seuillage, 25 shape, 14 simplexe, 33 slice, 17 slicing, 17, 25 tableau, 13 taille, 14 traitement d image, 25 transforamtions, 29 transformée de Fourier, 26 transformée de Fourier inverse, 26 transformation géométrique, 30 type, 14 Volterra, Index