Histogrammes avec Matplotlib

Introduction

Selon Wikipedia, un histogramme est une représentation graphique fidèle de la distribution de données numériques. Il s’agit d’une estimation de la distribution de probabilité d’une variable continue (variable quantitative) et a été introduit pour la première fois par Karl Pearson. C’est un type de diagramme en barres. Pour construire un histogramme, la première étape consiste à regrouper (« binner ») l’intervalle des valeurs : on divise l’ensemble de l’intervalle en une série de classes, puis on compte combien de valeurs tombent dans chaque classe. Les classes sont généralement des intervalles consécutifs et non chevauchants d’une variable. Elles doivent être adjacentes et sont souvent (mais pas nécessairement) de même taille.

Au-delà des données numériques, les histogrammes peuvent aussi servir à visualiser la distribution d’images, puisque celles-ci ne sont qu’un assemblage de pixels dont les valeurs vont de 0 à 255. L’axe des x d’un histogramme indique le nombre de classes, tandis que l’axe des y représente la fréquence d’une classe donnée. Le nombre de classes est un paramètre que vous pouvez faire varier selon la façon dont vous souhaitez représenter la distribution de vos données.

Par exemple : disons que vous voulez tracer l’histogramme d’une image RVB dont les pixels varient de 0 à 255. Le nombre maximal de classes possibles est 255. Si vous fixez l’axe x (nombre de classes) à 255, alors l’axe y indiquera la fréquence de chaque valeur de pixel dans cette image.

Les histogrammes sont proches, dans l’esprit, des graphiques en barres. Jetons un œil à un exemple visuel d’histogramme :

Un histogramme est un excellent outil pour visualiser et comprendre la distribution probabiliste de données numériques ou d’images, et il est intuitivement compris par presque tous. Python offre de nombreuses options pour construire et tracer des histogrammes. Parmi ses bibliothèques dédiées aux graphiques, l’une des plus utilisées est matplotlib.

Dans le tutoriel d’aujourd’hui, vous utiliserez principalement matplotlib pour créer et visualiser des histogrammes sur différents types de jeux de données.

Sans plus attendre, commençons.

Tracer un histogramme avec NumPy et Matplotlib

import numpy as np
Propulsé par

Pour assurer la reproductibilité, vous utiliserez la fonction seed de NumPy, qui garantit le même résultat à chaque exécution.

Vous allez tracer l’histogramme d’une distribution gaussienne (normale) de moyenne 0 et d’écart-type 1.

np.random.seed(100)
np_hist = np.random.normal(loc=0, scale=1, size=1000)
Propulsé par

np_hist[:10]
Propulsé par

array([-1.74976547,  0.3426804 ,  1.1530358 , -0.25243604,  0.98132079,
        0.51421884,  0.22117967, -1.07004333, -0.18949583,  0.25500144])
Propulsé par

Vérifions la moyenne et l’écart-type de la distribution ci-dessus.

np_hist.mean(),np_hist.std()
Propulsé par

(-0.016772157343909157, 1.0458427194167)
Propulsé par

Ensuite, vous utiliserez la fonction histogram de NumPy, qui renvoie hist et bin_edges.

hist,bin_edges = np.histogram(np_hist)
Propulsé par

hist
Propulsé par

array([  7,  37, 111, 207, 275, 213, 105,  31,  10,   4])
Propulsé par

bin_edges
Propulsé par

array([-3.20995538, -2.50316588, -1.79637637, -1.08958687, -0.38279736,
        0.32399215,  1.03078165,  1.73757116,  2.44436066,  3.15115017,
        3.85793967])
Propulsé par

Traçons maintenant l’histogramme avec la fonction plt.bar de Matplotlib, où l’axe des x et l’axe des y seront respectivement bin_edges et hist.

import matplotlib.pyplot as plt
%matplotlib inline
Propulsé par

plt.figure(figsize=[10,8])

plt.bar(bin_edges[:-1], hist, width = 0.5, color='#0504aa',alpha=0.7)
plt.xlim(min(bin_edges), max(bin_edges))
plt.grid(axis='y', alpha=0.75)
plt.xlabel('Valeur',fontsize=15)
plt.ylabel('Fréquence',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('Fréquence',fontsize=15)
plt.title('Histogramme d\'une distribution normale',fontsize=15)
plt.show()
Propulsé par

Arrondissons les bin_edges à l’entier.

bin_edges = np.round(bin_edges,0)
Propulsé par

plt.figure(figsize=[10,8])

plt.bar(bin_edges[:-1], hist, width = 0.5, color='#0504aa',alpha=0.7)
plt.xlim(min(bin_edges), max(bin_edges))
plt.grid(axis='y', alpha=0.75)
plt.xlabel('Valeur',fontsize=15)
plt.ylabel('Fréquence',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('Fréquence',fontsize=15)
plt.title('Histogramme d\'une distribution normale',fontsize=15)
plt.show()
Propulsé par

Le graphique est déjà plus lisible, n’est-ce pas ?

Pour bien comprendre hist et bin_edges, prenons un exemple :

Définissez un tableau de valeurs arbitraires et des classes avec un intervalle de 5.

hist, bin_edges = np.histogram([1, 1, 2, 2, 2, 2, 3],bins=range(5))
Propulsé par

hist
Propulsé par

array([0, 2, 4, 1])
Propulsé par

Dans la sortie ci-dessus, hist indique qu’il y a 0 élément dans la classe 0, 2 dans la classe 1, 4 dans la classe 2, 1 dans la classe 3.

bin_edges
Propulsé par

array([0, 1, 2, 3, 4])
Propulsé par

De même, la sortie des bin_edges ci-dessus signifie : la classe 0 correspond à l’intervalle [0,1), la classe 1 à [1,2), la classe 2 à [2,3), la classe 3 à [3,4).

Tracer un histogramme uniquement avec Matplotlib

Tracer un histogramme avec matplotlib est un jeu d’enfant. Il vous suffit d’utiliser la fonction plt.hist() en lui passant les données, le nombre de classes et quelques paramètres optionnels.

Dans plt.hist(), utiliser bins='auto' vous donne un nombre de classes « idéal ». L’idée est de choisir une largeur de classe qui représente au mieux vos données.

Voilà tout. Traçons donc l’histogramme de la normal_distribution que vous avez créée avec numpy.

plt.figure(figsize=[10,8])
n, bins, patches = plt.hist(x=np_hist, bins=8, color='#0504aa',alpha=0.7, rwidth=0.85)
plt.grid(axis='y', alpha=0.75)
plt.xlabel('Valeur',fontsize=15)
plt.ylabel('Fréquence',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('Fréquence',fontsize=15)
plt.title('Histogramme d\'une distribution normale',fontsize=15)
plt.show()
Propulsé par

Tracer deux histogrammes ensemble

plt.figure(figsize=[10,8])
x = 0.3*np.random.randn(1000)
y = 0.3*np.random.randn(1000)
n, bins, patches = plt.hist([x, y])
Propulsé par

Tracer l’histogramme des données Iris avec Pandas

Vous utiliserez sklearn pour charger le jeu de données iris. Dans sklearn, la bibliothèque datasets inclut Iris, que vous pouvez charger à la volée. Commençons par le charger.

from sklearn.datasets import load_iris
import pandas as pd
Propulsé par

data = load_iris().data
Propulsé par

names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width']
Propulsé par

Créez ensuite le DataFrame du jeu de données iris.

dataset = pd.DataFrame(data,columns=names)
Propulsé par

dataset.head()
Propulsé par

dataset.columns[0]
Propulsé par

'sepal-length'
Propulsé par

Enfin, utilisez la fonction intégrée .hist() de pandas, qui trace automatiquement des histogrammes pour toutes les variables du jeu de données.

Pratique, non ?

fig = plt.figure(figsize = (8,8))
ax = fig.gca()
dataset.hist(ax=ax)
plt.show()
Propulsé par

Les variables petal-length, petal-width et sepal-length affichent une distribution unimodale, tandis que sepal-width se rapproche d’une courbe gaussienne. Ces observations sont utiles : vous pouvez ensuite envisager des algorithmes adaptés à ce type de distribution.

Tracer un histogramme avec Matplotlib

plt.figure(figsize=[10,10])
f,a = plt.subplots(2,2)
a = a.ravel()
for idx,ax in enumerate(a):
    ax.hist(dataset.iloc[:,idx], bins='auto', color='#0504aa',alpha=0.7, rwidth=0.85)
    ax.set_title(dataset.columns[idx])
plt.tight_layout()
Propulsé par

<Figure size 720x720 with 0 Axes>
Propulsé par

Tracer l’histogramme d’images binaires et RVB

Dans la dernière partie du tutoriel, vous allez visualiser deux types d’images : des images binaires (document) et des images naturelles. Les images binaires sont celles dont les pixels sont majoritairement 0 ou 255, tandis qu’une image en couleur peut avoir des pixels allant de 0 à 255.

Analyser la distribution des pixels en traçant l’histogramme des intensités d’une image est un bon moyen de mesurer l’occurrence de chaque valeur de pixel pour une image donnée. Pour une image en niveaux de gris sur 8 bits, il y a 256 valeurs d’intensité possibles. Pour comparer la distribution des pixels entre images de documents et images naturelles, vous tracerez donc deux histogrammes, un pour chaque type. Étant donné que les documents lisibles présentent de la parcimonie, la distribution des pixels dans ces images de documents devrait être majoritairement asymétrique.

Vous utiliserez le module opencv pour charger les deux images, les convertir en niveaux de gris en passant le paramètre 0 à la lecture, puis les redimensionner à la même taille.

import cv2
Propulsé par

lena_rgb = cv2.imread('lena.png')
lena_gray = cv2.cvtColor(lena_rgb,cv2.COLOR_BGR2GRAY)
Propulsé par

lena_gray.shape
Propulsé par

(512, 512)
Propulsé par

binary = cv2.imread('binary.png')
binary.shape
Propulsé par

(1394, 2190, 3)
Propulsé par

binary = cv2.resize(binary,(512,512),cv2.INTER_CUBIC)
Propulsé par

binary.shape
Propulsé par

(512, 512, 3)
Propulsé par

binary_gray = cv2.cvtColor(binary,cv2.COLOR_BGR2GRAY)
Propulsé par

binary_gray.shape
Propulsé par

(512, 512)
Propulsé par

Visualisons l’image naturelle et l’image de document.

plt.figure(figsize=[10,10])

plt.subplot(121)
plt.imshow(lena_rgb[:,:,::-1])
plt.title("Image naturelle")

plt.subplot(122)
plt.imshow(binary[:,:,::-1])
plt.title("Image de document")
plt.show()
Propulsé par

Remarque : vous utiliserez bins égal à 255, puisqu’il y a au total 255 valeurs de pixels affichables et que vous souhaitez visualiser la fréquence de chaque valeur de 0 à 255.

hist, edges = np.histogram(binary_gray,bins=range(255))
Propulsé par

plt.figure(figsize=[10,8])

plt.bar(edges[:-1], hist, width = 0.8, color='#0504aa')
plt.xlim(min(edges), max(edges))
plt.grid(axis='y', alpha=0.75)
plt.xlabel('Valeur',fontsize=15)
plt.ylabel('Fréquence',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('Fréquence',fontsize=15)
plt.title('Histogramme d\'une image de document',fontsize=15)
plt.show()
Propulsé par

hist, edges = np.histogram(lena_gray,bins=range(260))
Propulsé par

plt.figure(figsize=[10,8])

plt.bar(edges[:-1], hist, width = 0.5, color='#0504aa')
plt.xlim(min(edges), max(edges))
plt.grid(axis='y', alpha=0.75)
plt.xlabel('Pixels',fontsize=15)
plt.ylabel('Fréquence des pixels',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('Fréquence',fontsize=15)
plt.title('Histogramme d\'une image naturelle',fontsize=15)
plt.show()
Propulsé par

Sur les figures ci-dessus, vous pouvez observer que l’image naturelle couvre l’ensemble des 256 intensités avec une distribution plutôt aléatoire, tandis que l’image de document présente une distribution unimodale et est principalement asymétrique entre 0 et 255.

Conclusion

Félicitations, vous êtes arrivé au bout de ce tutoriel.

Ce tutoriel constitue une excellente introduction pour créer un histogramme avec Matplotlib à l’aide de NumPy et pandas.

Vous avez également vu comment exploiter la puissance des histogrammes pour distinguer deux domaines d’images différents : images de documents et images naturelles.

Pour aller plus loin en visualisation de données, découvrez le cours DataCamp Data Visualization with Matplotlib.

N’hésitez pas à poser vos questions sur ce tutoriel dans les commentaires ci-dessous.