Una breve introducción a matplotlib para la visualización de datos

Python tiene una amplia variedad de paquetes útiles para el aprendizaje automático y el análisis estadístico, como TensorFlow, NumPy, scikit-learn, Pandas y más. Un paquete...

Introducción

Python tiene una amplia variedad de paquetes útiles para el aprendizaje automático y el análisis estadístico como TensorFlow, NumPy, scikit -aprender, pandas y más. Un paquete que es esencial para la mayoría de los proyectos de ciencia de datos es matplotlib.

Disponible para cualquier distribución de Python, se puede instalar en Python 3 con pip. También hay otros métodos disponibles, consulte https://matplotlib.org/ para obtener más detalles.

Instalación

Si usa un sistema operativo con una terminal, el siguiente comando instalaría matplotlib con pip:

1
$ python3 -m pip install matplotlib

Importación y entorno

En un archivo de Python, queremos importar la función pyplot que nos permite interactuar con un entorno de trazado similar a MATLAB. También importamos una función de líneas que nos permite agregar líneas a los gráficos:

1
2
import matplotlib.pyplot as plt
import matplotlib.lines as mlines

Esencialmente, este entorno de trazado nos permite guardar figuras y sus atributos como variables. Estos gráficos se pueden imprimir y ver con un simple comando. Por ejemplo, podemos ver el precio de las acciones de Google: específicamente la fecha, apertura, cierre, volumen y precio de cierre ajustado (la fecha se almacena como np.datetime64) para los últimos 250 días:

1
2
3
4
5
6
7
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cbook as cbook

with cbook.get_sample_data('goog.npz') as datafile:
    price_data = np.load(datafile)['price_data'].view(np.recarray)
price_data = price_data[-250:] # get the most recent 250 trading days

Luego transformamos los datos de una manera que se hace con bastante frecuencia para series de tiempo, etc. Encontramos la diferencia, $d_i$, entre cada observación y la anterior:

$$d_i = y_i - y_{i - 1} $$

1
delta1 = np.diff(price_data.adj_close) / price_data.adj_close[:-1]

También podemos observar las transformaciones de diferentes variables, como volumen y precio de cierre:

1
2
3
# Marker size in units of points^2
volume = (15 * price_data.volume[:-2] / price_data.volume[0])**2
close = 0.003 * price_data.close[:-2] / 0.003 * price_data.open[:-2]

Trazado de un diagrama de dispersión

Para trazar realmente estos datos, puede usar las funciones subplots() de plt (matplotlib.pyplot). Por defecto, esto genera el área de la figura y los ejes de un gráfico.

Aquí haremos un diagrama de dispersión de las diferencias entre días sucesivos. Para elaborar, x es la diferencia entre el día i y el día anterior. y es la diferencia entre el día i+1 y el día anterior (i):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
fig, ax = plt.subplots()
ax.scatter(delta1[:-1], delta1[1:], c=close, s=volume, alpha=0.5)

ax.set_xlabel(r'$\Delta_i$', fontsize=15)
ax.set_ylabel(r'$\Delta_{i+1}$', fontsize=15)
ax.set_title('Volume and percent change')

ax.grid(True)
fig.tight_layout()

plt.show()

{.img-responsive}

Luego creamos etiquetas para los ejes x e y, así como un título para el gráfico. Elegimos trazar estos datos con cuadrículas y un diseño ajustado.

plt.show() nos muestra la trama.

Adición de una línea

Podemos agregar una línea a este diagrama proporcionando las coordenadas x e y como listas a una instancia de Line2D:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import matplotlib.lines as mlines

fig, ax = plt.subplots()
line = mlines.Line2D([-.15,0.25], [-.07,0.09], color='red')
ax.add_line(line)

# reusing scatterplot code
ax.scatter(delta1[:-1], delta1[1:], c=close, s=volume, alpha=0.5)

ax.set_xlabel(r'$\Delta_i$', fontsize=15)
ax.set_ylabel(r'$\Delta_{i+1}$', fontsize=15)
ax.set_title('Volume and percent change')

ax.grid(True)
fig.tight_layout()

plt.show()

{.img-responsive}

Trazado de histogramas {#trazado de histogramas}

Para trazar un histograma, seguimos un proceso similar y usamos la función hist() de pyplot. Generaremos 10000 puntos de datos aleatorios, x, con una media de 100 y una desviación estándar de 15.

La función hist toma los datos, x, el número de contenedores y otros argumentos como density, que normaliza los datos a una densidad de probabilidad, o alpha, que establece la transparencia del histograma.

También usaremos la biblioteca mlab para agregar una línea que represente una función de densidad normal con la misma media y desviación estándar:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt

mu, sigma = 100, 15
x = mu + sigma*np.random.randn(10000)

# the histogram of the data
n, bins, patches = plt.hist(x, 30, density=1, facecolor='blue', alpha=0.75)

# add a 'best fit' line
y = mlab.normpdf( bins, mu, sigma)
l = plt.plot(bins, y, 'r--', linewidth=4)

plt.xlabel('IQ')
plt.ylabel('Probability')
plt.title(r'$\mathrm{Histogram\ of\ IQ:}\ \mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)

plt.show()

{.img-responsive}

Gráficos de barras

Si bien los histogramas nos ayudaron con las densidades visuales, los gráficos de barras nos ayudan a ver los recuentos de datos. Para trazar un gráfico de barras con matplotlib, usamos la función bar(). Esto toma los recuentos y las etiquetas de datos como x e y, junto con otros argumentos.

Como ejemplo, podríamos ver una muestra de la cantidad de programadores que usan diferentes lenguajes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import numpy as np
import matplotlib.pyplot as plt
 
objects = ('Python', 'C++', 'Java', 'Perl', 'Scala', 'Lisp')
y_pos = np.arange(len(objects))
performance = [10,8,6,4,2,1]
 
plt.bar(y_pos, performance, align='center', alpha=0.5)
plt.xticks(y_pos, objects)
plt.ylabel('Usage')
plt.title('Programming language usage')
 
plt.show()

{.img-responsive}

Trazado de imágenes {#trazado de imágenes}

El análisis de imágenes es muy común en Python. No es sorprendente que podamos usar matplotlib para ver imágenes. Usamos la biblioteca cv2 para leer imágenes.

El resumen de la función read_image() se encuentra a continuación:

  • lee el archivo de imagen
  • divide los canales de color
  • los cambia a RGB
  • cambia el tamaño de la imagen
  • devuelve una matriz de valores RGB

El resto del código se lee en las primeras cinco imágenes de gatos y perros de los datos utilizados en una CNN de reconocimiento de imágenes. Las imágenes están concatenadas e impresas en el mismo eje:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import matplotlib.pyplot as plt
import numpy as np
import os, cv2

cwd = os.getcwd()
TRAIN_DIR = cwd + '/data/train/'

ROWS = 256
COLS = 256
CHANNELS = 3

train_images = [TRAIN_DIR+i for i in os.listdir(TRAIN_DIR)] # use this for full dataset
train_dogs =   [TRAIN_DIR+i for i in os.listdir(TRAIN_DIR) if 'dog' in i]
train_cats =   [TRAIN_DIR+i for i in os.listdir(TRAIN_DIR) if 'cat' in i]

def read_image(file_path):
    img = cv2.imread(file_path, cv2.IMREAD_COLOR) #cv2.IMREAD_GRAYSCALE
    b,g,r = cv2.split(img)
    img2 = cv2.merge([r,g,b])
    return cv2.resize(img2, (ROWS, COLS), interpolation=cv2.INTER_CUBIC)

for a in range(0,5):
    cat = read_image(train_cats[a])
    dog = read_image(train_dogs[a])
    pair = np.concatenate((cat, dog), axis=1)
    plt.figure(figsize=(10,5))
    plt.imshow(pair)
    plt.show()

{.img-responsive}

{.img-responsive}

{.img-responsive}

{.img-responsive}

{.img-responsive}

Conclusión

En esta publicación, vimos una breve introducción sobre cómo usar matplotlib para trazar datos en diagramas de dispersión, histogramas y gráficos de barras. También agregamos líneas a estas parcelas. Finalmente, vimos cómo leer imágenes usando la biblioteca cv2 y usamos matplotlib para trazar las imágenes.