Istogrammi in Matplotlib

Introduzione

Secondo Wikipedia, un istogramma è una rappresentazione grafica accurata della distribuzione di dati numerici. È una stima della distribuzione di probabilità di una variabile continua (variabile quantitativa) ed è stato introdotto per la prima volta da Karl Pearson. È un tipo di grafico a barre. Per costruire un istogramma, il primo passo è “suddividere in bin” l’intervallo di valori — cioè dividere l’intero intervallo di valori in una serie di intervalli — e poi contare quanti valori ricadono in ciascun intervallo. I bin sono di solito specificati come intervalli consecutivi e non sovrapposti di una variabile. I bin (intervalli) devono essere adiacenti e sono spesso (ma non necessariamente) di uguale ampiezza.

Oltre ai dati numerici, gli istogrammi possono essere usati anche per visualizzare la distribuzione delle immagini, dato che le immagini non sono altro che una combinazione di elementi dell’immagine (pixel) compresi tra $0$ e $255$. L’asse x dell’istogramma indica il numero di bin mentre l’asse y rappresenta la frequenza di un determinato bin. Il numero di bin è un parametro che può variare in base a come vuoi visualizzare la distribuzione dei tuoi dati.

Per esempio: poniamo che tu voglia tracciare un istogramma di un’immagine RGB con valori dei pixel compresi tra $0$ e $255$. Il numero massimo di bin che questa immagine può avere è $255$. Se imposti l’asse x (numero di bin) a $255$, allora l’asse y indicherà la frequenza di ciascun pixel in quell’immagine.

Gli istogrammi sono concettualmente simili ai grafici a bar; diamo un’occhiata a un esempio illustrativo di istogramma:

Un istogramma è uno strumento eccellente per visualizzare e comprendere la distribuzione probabilistica di dati numerici o di immagini, ed è intuitivamente compreso da quasi tutti. Python offre molte opzioni diverse per costruire e tracciare istogrammi. Python ha alcune librerie integrate per creare grafici, e una di queste è matplotlib.

Nella lezione di oggi userai principalmente matplotlib per creare e visualizzare istogrammi su vari tipi di dataset.

Quindi, senza ulteriori indugi, iniziamo.

Tracciare un istogramma con NumPy e Matplotlib

import numpy as np

Per la riproducibilità, userai la funzione seed di numPy, che fornirà lo stesso output a ogni esecuzione.

Tracerai l’istogramma di una distribuzione gaussiana (normale), con media $0$ e deviazione standard $1$.

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

np_hist[:10]

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

Verifichiamo la media e la deviazione standard della distribuzione sopra.

np_hist.mean(),np_hist.std()

(-0.016772157343909157, 1.0458427194167)

Successivamente userai la funzione histogram di numPy, che restituirà hist e bin_edges.

hist,bin_edges = np.histogram(np_hist)

hist

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

bin_edges

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

Ora tracciamo l’istogramma usando la funzione plt.bar di matplotlib, dove il tuo asse x e asse y saranno rispettivamente bin_edges e hist.

import matplotlib.pyplot as plt
%matplotlib inline

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('Value',fontsize=15)
plt.ylabel('Frequency',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('Frequency',fontsize=15)
plt.title('Normal Distribution Histogram',fontsize=15)
plt.show()

Arrotondiamo i bin_edges a interi.

bin_edges = np.round(bin_edges,0)

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('Value',fontsize=15)
plt.ylabel('Frequency',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('Frequency',fontsize=15)
plt.title('Normal Distribution Histogram',fontsize=15)
plt.show()

Adesso il grafico sembra molto meglio, non trovi?

Per capire hist e bin_edges, vediamo un esempio:

Definirai un array con valori arbitrari e definirai i bin con un intervallo di $5$.

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

hist

array([0, 2, 4, 1])

Nell’output sopra, hist indica che ci sono $0$ elementi nel bin $0$, $2$ nel bin $1$, $4$ nel bin $3$, $1$ nel bin $4$.

bin_edges

array([0, 1, 2, 3, 4])

Allo stesso modo, l’output di bin_edges sopra significa che il bin $0$ è nell’intervallo $[0,1)$, il bin $1$ nell’intervallo $[1,2)$, il bin $2$ nell’intervallo $[2,3)$, il bin $3$ nell’intervallo $[3,4)$.

Tracciare un istogramma usando solo Matplotlib

Tracciare un istogramma con matplotlib è un gioco da ragazzi. Ti basta usare la funzione plt.hist() di matplotlib e passare i dati insieme al numero di bin e ad alcuni parametri opzionali.

In plt.hist(), passando bins='auto' ottieni il numero di bin “ideale”. L’idea è selezionare un’ampiezza dei bin che generi la rappresentazione più fedele dei tuoi dati.

Tutto qui. Quindi, tracciamo l’istogramma della normal_distribution che hai costruito con 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('Value',fontsize=15)
plt.ylabel('Frequency',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('Frequency',fontsize=15)
plt.title('Normal Distribution Histogram',fontsize=15)
plt.show()

Tracciare due istogrammi insieme

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])

Tracciare l’istogramma dei dati Iris con Pandas

Userai sklearn per caricare un dataset chiamato iris. In sklearn, c’è una libreria chiamata datasets in cui trovi il dataset Iris che può essere caricato al volo. Quindi, carichiamo rapidamente il dataset iris.

from sklearn.datasets import load_iris
import pandas as pd

data = load_iris().data

names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width']

Successivamente, creerai il dataframe del dataset iris.

dataset = pd.DataFrame(data,columns=names)

dataset.head()

dataset.columns[0]

'sepal-length'

Infine, userai la funzione integrata di pandas .hist() che tracerà gli istogrammi per tutte le feature presenti nel dataset.

Non è fantastico?

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

La petal-length, petal-width e sepal-length mostrano una distribuzione unimodale, mentre la sepal-width riflette una curva gaussiana. Tutte queste sono analisi utili perché puoi poi pensare di usare un algoritmo che funzioni bene con questo tipo di distribuzione.

Tracciare l’istogramma con 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()

<Figure size 720x720 with 0 Axes>

Tracciare l’istogramma di immagini binarie e RGB

Nell’ultima parte del tutorial, visualizzerai due immagini di domini diversi: immagini binarie (documento) e immagini naturali. Le immagini binarie sono quelle i cui valori di pixel sono per lo più $0$ o $255$, mentre un’immagine a canali di colore può avere un valore di pixel compreso ovunque tra $0$ e $255$.

Analizzare la distribuzione dei pixel tracciando un istogramma dei valori d’intensità di un’immagine è il modo giusto per misurare l’occorrenza di ogni pixel per una data immagine. Per un’immagine in scala di grigi a 8 bit, ci sono 256 possibili valori di intensità. Pertanto, per studiare la differenza tra le immagini di documento e quelle naturali nel dominio della distribuzione dei pixel, traccerai due istogrammi ciascuno per l’immagine di documento e per l’immagine naturale. Considerando che i documenti leggibili hanno una certa sparseness, la distribuzione dei pixel in queste immagini di documento dovrebbe essere per lo più asimmetrica.

Userai il modulo opencv per caricare le due immagini, convertirle in scala di grigi passando il parametro $0$ durante la lettura e infine ridimensionarle alla stessa dimensione.

import cv2

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

lena_gray.shape

(512, 512)

binary = cv2.imread('binary.png')
binary.shape

(1394, 2190, 3)

binary = cv2.resize(binary,(512,512),cv2.INTER_CUBIC)

binary.shape

(512, 512, 3)

binary_gray = cv2.cvtColor(binary,cv2.COLOR_BGR2GRAY)

binary_gray.shape

(512, 512)

Visualizziamo sia l’immagine naturale sia quella di documento.

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

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

plt.subplot(122)
plt.imshow(binary[:,:,::-1])
plt.title("Document Image")
plt.show()

Nota: userai bins pari a $255$, dato che in un’immagine ci sono in totale $255$ pixel e vuoi visualizzare la frequenza di ogni valore di pixel dell’immagine compreso tra $0$ e $255$.

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

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('Value',fontsize=15)
plt.ylabel('Frequency',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('Frequency',fontsize=15)
plt.title('Document Image Histogram',fontsize=15)
plt.show()

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

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('Frequency of Pixels',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('Frequency',fontsize=15)
plt.title('Natural Image Histogram',fontsize=15)
plt.show()

Dalle figure sopra, puoi osservare che l’immagine naturale è distribuita su tutte le 256 intensità con una distribuzione casuale, mentre l’immagine di documento mostra una distribuzione unimodale ed è per lo più asimmetrica tra i valori di pixel da $0$ a $255$.

Conclusione

Congratulazioni per aver terminato il tutorial.

Questo tutorial è stato un buon punto di partenza per capire come creare un istogramma usando matplotlib con l’aiuto di numpy e pandas.

Hai anche imparato come sfruttare la potenza degli istogrammi per distinguere tra due diversi domini di immagini, ovvero immagine di documento e immagine naturale.

Se vuoi saperne di più sulle tecniche di visualizzazione dei dati, valuta di seguire il corso di DataCamp Data Visualization with Matplotlib.

Per qualsiasi domanda relativa a questo tutorial, sentiti libero di scriverla nei commenti qui sotto.