Reducción de Muestreo de Datos Utilizando Matplotlib

Introducción

En este laboratorio, aprenderemos a reducir la resolución de datos utilizando Matplotlib en Python. La reducción de la resolución es el proceso de reducir la tasa de muestreo o el tamaño de muestra de una señal. Utilizaremos una clase que reducirá la resolución de los datos y los recomputará cuando se amplíe.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje su retroalimentación después de la sesión y resolveremos el problema para usted de inmediato.

Importando bibliotecas

Comenzaremos importando las bibliotecas necesarias. Para esta tarea, utilizaremos las bibliotecas Matplotlib y NumPy.

import matplotlib.pyplot as plt
import numpy as np

Definiendo la clase

Definiremos una clase DataDisplayDownsampler que reducirá la resolución de los datos y los recomputará cuando se amplíe. El constructor de la clase tomará los parámetros de entrada xdata e ydata. Estableceremos el número máximo de puntos en 50 y calcularemos el delta de xdata.

class DataDisplayDownsampler:
    def __init__(self, xdata, ydata):
        self.origYData = ydata
        self.origXData = xdata
        self.max_points = 50
        self.delta = xdata[-1] - xdata[0]

Reduciendo la resolución de los datos

Definiremos un método downsample que reducirá la resolución de los datos. El método tomará xstart y xend como parámetros de entrada. Obtendremos los puntos en el rango de vista y dilataremos la máscara en uno para capturar los puntos justo fuera del rango de vista y no truncar la línea. Determinaremos cuántos puntos eliminar y aplicaremos la máscara a los datos. Finalmente, reduciremos la resolución de los datos y devolveremos xdata e ydata.

def downsample(self, xstart, xend):
    ## get the points in the view range
    mask = (self.origXData > xstart) & (self.origXData < xend)
    ## dilate the mask by one to catch the points just outside
    ## of the view range to not truncate the line
    mask = np.convolve([1, 1, 1], mask, mode='same').astype(bool)
    ## sort out how many points to drop
    ratio = max(np.sum(mask) // self.max_points, 1)

    ## mask data
    xdata = self.origXData[mask]
    ydata = self.origYData[mask]

    ## downsample data
    xdata = xdata[::ratio]
    ydata = ydata[::ratio]

    print(f"using {len(ydata)} of {np.sum(mask)} visible points")

    return xdata, ydata

Actualizando los datos

Definiremos un método update que actualizará los datos. El método tomará el ax (eje) como parámetro de entrada. Actualizaremos la línea obteniendo el límite de vista y comprobando si el ancho del límite de vista es diferente de delta. Si el ancho del límite de vista es diferente de delta, actualizaremos delta y obtendremos xstart y xend. Luego estableceremos los datos en los datos con resolución reducida y dibujaremos el estado inactivo.

def update(self, ax):
    ## Update the line
    lims = ax.viewLim
    if abs(lims.width - self.delta) > 1e-8:
        self.delta = lims.width
        xstart, xend = lims.intervalx
        self.line.set_data(*self.downsample(xstart, xend))
        ax.figure.canvas.draw_idle()

Creando la señal

Crearemos una señal utilizando NumPy. Crearemos una matriz xdata utilizando la función linspace con start = 16, stop = 365 y num = (365 - 16)*4. Crearemos una matriz ydata utilizando las funciones sin y cos.

xdata = np.linspace(16, 365, (365-16)*4)
ydata = np.sin(2*np.pi*xdata/153) + np.cos(2*np.pi*xdata/127)

Creando la gráfica

Crearemos una gráfica utilizando Matplotlib. Crearemos una instancia d de la clase DataDisplayDownsampler utilizando xdata e ydata. Crearemos una figura y un eje utilizando la función subplots. Conectaremos la línea y estableceremos la autoscala en False. Conectaremos para cambiar los límites de vista, estableceremos el límite x y mostraremos la gráfica.

d = DataDisplayDownsampler(xdata, ydata)
fig, ax = plt.subplots()
d.line, = ax.plot(xdata, ydata, 'o-')
ax.set_autoscale_on(False)
ax.callbacks.connect('xlim_changed', d.update)
ax.set_xlim(16, 365)
plt.show()

Resumen

En este laboratorio, aprendimos cómo reducir la resolución de los datos utilizando Matplotlib en Python. Utilizamos una clase que reduce la resolución de los datos y los vuelve a calcular cuando se hace un zoom. Creamos una señal utilizando NumPy y creamos una gráfica utilizando Matplotlib. Conectamos para cambiar los límites de vista y establecimos el límite x.