​

Cette page fait partie du cours de polytech PeiP1 et 2 Bio

5. Mise en pratique : Graphiques

5.1. Introduction

Dans ce TP nous allons apprendre à générer des graphiques avec Python.

Pour cela nous utiliserons le package matplotlib.

5.2. Tracé d'une fonction (plot)

On désire tracer une fonction réelle. On utilise pour cela la fonction plot.

On peut également utiliser la fonction savefig afin de sauvegarder un graphique.

5.2.1. Sans numpy

Voici une première version sans numpy. On utilise la fonction sinus et il est donc nécessaire de faire appel au module math (plot_function_without_numpy.py) :

  1. # import libraries / packages
  2. import matplotlib.pyplot as plt
  3. import math
  4.  
  5. # function to plot
  6. def f(x):
  7.   return x*x-3*x+6*math.sin(x)
  8.  
  9. # values for x, we use numpy
  10. # we generate 100 values from 0 to 100
  11. x_values = range(0, 10)
  12. print(x_values)
  13. y_values = [f(x) for x in x_values]
  14. print(y_values)
  15.  
  16.  
  17. plt.plot(x_values, y_values, color='orange')
  18. plt.grid(color='grey', linestyle='-', linewidth=1)
  19. plt.ylabel('f(x)')
  20. plt.savefig('img/plot_function_without_numpy.png')
  21. plt.show()
  22.  
  23.  

On calcule les valeurs pour x (x_values) puis celles de y(y_values) et enfin on dessine la courbe en utilisant ces valeurs.

5.2.2. Avec numpy

Voici une seconde version avec numpy ce qui permet de simplifier la génération des valeurs à la fois pour x et pour y. On notera l'utilisation de np.sin(x) au lieu de math.sin(x) dans le calcul de la fonction $f$ (plot_function_with_numpy.py) :

  1. # import libraries / packages
  2. import matplotlib.pyplot as plt
  3. import math
  4. import numpy as np
  5.  
  6. # function to plot
  7. def f(x):
  8.   return x * x - 3 * x + 6 * np.sin(x)
  9.  
  10. # values for x, we use numpy
  11. # we generate 100 values from 0 to 100
  12. x_values = np.linspace(0, 10, 100)
  13. print(x_values)
  14.  
  15. # we generate values for y by applying f()
  16. # on the numpy array v_calues
  17. y_values = f(x_values)
  18. print(y_values)
  19.  
  20.  
  21. plt.plot(x_values, y_values, color='green')
  22. plt.grid()
  23. plt.ylabel('f(x)')
  24. plt.show()
  25.  
  26.  

On remarquera que l'on utilise la fonction linspace de numpy afin de générer des valeurs dans l'intervalle [0,10].

Exercice 5.1
Afficher le graphique de la fonction : $$ f1(x) = (√|x| - 3) × x $$

Exercice 5.2
Afficher sur le même graphique les fonctions : $$\{\table f1(x) = x; f2(x) = x × \log(x); f3(x) = x × x; $$

5.3. Données en barres (bar, barh)

Il est parfois nécessaire de modéliser les données sous forme graphique et les graphes qui utilisent des barres permettent de rendre compte d'une donnée numérique associée à une catégorie.

A titre d'exemple, considérons que nous avons interrogé 75 personnes et que nous leur avons demandé quel langage de programmation elles utilisent le plus souvent. Voici les résultats de ce sondage :

5.3.1. Barres verticales (bar)

On peut représenter ces données sous forme de barres verticales ce qui permet tout de suite de voir quel langage est le plus utilisé et quel langage est le moins utilisé, est-ce qu'un langage se démarque des autres, etc.

Voici le code (plot_bar_chart.py) :

  1. import matplotlib.pyplot as plt
  2. from matplotlib import cm
  3. import math
  4. import numpy as np
  5.  
  6. # langages de programmation
  7. y_labels = [ 'C++', 'Ruby', 'Python', 'Php' ]
  8.  
  9. # x_values indique sur l'axe des x où on doit situer
  10. # la barre verticale
  11. x_values = [ 1, 2, 3, 4 ]
  12.  
  13. # y_values représentent les données associées à chaque langage
  14. y_values = [ 20, 10, 30, 15 ]
  15.  
  16. plt.bar(x=x_values, height=y_values, width=0.9,
  17.   color='#7788aa', tick_label = y_labels)
  18. plt.savefig('img/plot_bar_chart.png')
  19. plt.show()
  20.  
  21.  

5.3.2. Barres horizontales (barh)

On peut procéder de la même manière mais avec des barres horizontales.

Voici le même exemple (plot_barh_chart.py) :

  1. import matplotlib.pyplot as plt
  2. from matplotlib import cm
  3. import math
  4. import numpy as np
  5.  
  6. # langages de programmation
  7. x_labels = [ 'C++', 'Ruby', 'Python', 'Php' ]
  8.  
  9. x_values = [ 1, 2, 3, 4 ]
  10. y_values = [ 20, 10, 30, 15 ]
  11.  
  12. plt.barh(y=x_values, width=y_values, height=0.9,
  13.   color=['#be7733', '#138ABc', '#89bf76', '#4A987f'],
  14.   tick_label = x_labels, hatch="/",
  15.   edgecolor='#888888')
  16. plt.savefig('img/plot_barh_chart.png')
  17. plt.show()
  18.  
  19.  

5.4. Camembert (pie)

Le camembert ou (pie chart en anglais) permet également, tout comme les graphes de barres, de donner une idée de la répartition des données mais sous forme de pourcentage.

Le code du camembert est le suivant (plot_pie_chart.py) :

  1. import matplotlib.pyplot as plt
  2. from matplotlib import cm
  3. import math
  4. import numpy as np
  5.  
  6. x_labels = [ 'C++', 'Ruby', 'Python', 'Php' ]
  7. x_values = [ 20, 10, 30, 15 ]
  8. x_explode = (0, 0, 0.1, 0)
  9.  
  10. plt.pie(x_values, labels=x_labels, autopct='%1.1f%%', explode=x_explode)
  11. plt.title("Utilisation des langages de programmation")
  12. plt.savefig('img/plot_pie_chart.png')
  13. plt.show()
  14.  
  15.  

Exercice 5.3
Afficher un graphique sous forme de camembert pour un ensemble de valeurs générées aléatoirement. Faire en sorte que la valeur la plus grande soit détachée du graphique.

5.5. Graphe de points (scatter)

5.5.1. Exemple classique

Dans certains cas, on dispose de données éparses et on désire les afficher afin de savoir si elle sont corrélées.

Voici un premier exemple généré de manière aléatoire en utilisant numpy (plot_scatter_random.py) :

  1. import matplotlib.pyplot as plt
  2. import math
  3. import numpy as np
  4.  
  5. x_values = np.random.uniform(-1.0, 1.0, 50)
  6. y_values = np.random.uniform(-1.0, 1.0, 50)
  7.  
  8. plt.scatter(x_values, y_values)
  9. plt.savefig('img/plot_scatter_random.png')
  10. plt.show()
  11.  
  12.  

Le deuxième exemple utilise une fonction linéaire pour associer les données (plot_scatter_correlated.py) :

  1. import matplotlib.pyplot as plt
  2. import math
  3. import numpy as np
  4.  
  5. def f(x):
  6.   return 2*x+5
  7.  
  8. x_values = np.random.uniform(-1.0, 1.0, 50)
  9. y_values = f(x_values) + np.random.uniform(-0.2, 0.3, 50)
  10.  
  11. plt.scatter(x_values, y_values)
  12. plt.savefig('img/plot_scatter_correlated.png')
  13. plt.show()
  14.  
  15.  

5.5.2. Exemple des iris

Un exemple classique utilisé en Apprentissage est celui des iris de Fisher. On dispose de données concernant trois espéces d'iris (Setosa, Versicolor, Virginica) qui concernent la longueur et largeur de leurs pétales et sépales.

"sepal.length","sepal.width","petal.length","petal.width","variety"
5.1,3.5,1.4,.2,"Setosa"
4.9,3,1.4,.2,"Setosa"
4.7,3.2,1.3,.2,"Setosa"
4.6,3.1,1.5,.2,"Setosa"
5,3.6,1.4,.2,"Setosa"
...

On désire afficher, en fonction de la longueur et largeur des sépales, la catégorie à laquelle appartient l'iris.

Le code associé à l'image précédente est le suivant (plot_scatter_iris_sepal.py) :

  1. import matplotlib.pyplot as plt
  2. import matplotlib.colors as col
  3. import numpy as np
  4. import pandas as pd
  5. import sys
  6.  
  7. iris_df = pd.read_csv('iris.csv')
  8.  
  9.  
  10. #for k,v in col.CSS4_COLORS.items():
  11. # print(k, ' ', v)
  12.  
  13. colors = [ col.CSS4_COLORS['goldenrod'], col.CSS4_COLORS['yellowgreen'], col.CSS4_COLORS['maroon'] ]
  14. species = ['Setosa', 'Versicolor', 'Virginica']
  15.  
  16. i = 0
  17. for s in species:
  18.   df = iris_df[ iris_df.variety == s ]
  19.   # prendre sepal.length pour x_values
  20.   x_values = df.iloc[:,0]
  21.   # prendre sepal width pour y_values
  22.   y_values = df.iloc[:,1]
  23.  
  24.   plt.scatter(x_values, y_values, color=colors[i])
  25.   i = i + 1
  26.  
  27. plt.xlabel('longueur sépale')
  28. plt.ylabel('largeur sépale')
  29. plt.savefig('img/plot_scatter_iris_sepal.png')
  30. plt.show()
  31.  
  32.  

Exercice 5.4

Affichez la corrélation entre longueur et largeur des pétales. Qu'observe t-on ?

5.5.3. Exemple pairplot des iris

Un autre type de graphique intéressant pour établir des corrélations entre données est le pairplot que l'on peut générer en utilisant la bibliothèque seaborn (plot_pairplot.py) :

  1. import matplotlib.pyplot as plt
  2. import pandas as pd
  3. import seaborn as sns
  4.  
  5. iris_df = pd.read_csv('iris.csv')
  6.  
  7. g1 = sns.pairplot(iris_df, vars=iris_df.columns[0:4], palette=sns.color_palette("Paired",10))
  8. g2 = sns.pairplot(iris_df, hue='variety', markers=['o','s','D'])
  9. g3 = sns.pairplot(iris_df, hue='variety', kind = 'reg')
  10. plt.show();
  11.  

Le code précédent génère 3 graphiques :

On remarquera que les deuxième et troisième graphiques affichent sur la diagonale une Estimation par noyau (en anglais : Kernel Density Estimation) des données. Pour ce genre de graphe on utilise une gaussienne qui sera de coordonnée sur y d'autant plus grande que les données sont centrées autour de x.