Reamostrar Dados com Matplotlib - Tutorial de Downsampling em Python

Introdução

Neste laboratório, aprenderemos como reduzir a taxa de amostragem de dados usando Matplotlib em Python. Downsampling (redução da taxa de amostragem) é o processo de reduzir a taxa de amostragem ou o tamanho da amostra de um sinal. Usaremos uma classe que fará o downsample dos dados e recalculará quando houver zoom.

Dicas para a VM

Após a inicialização da VM, clique no canto superior esquerdo para mudar para a aba Notebook e acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão, e resolveremos o problema prontamente para você.

Importando bibliotecas

Começaremos importando as bibliotecas necessárias. Usaremos as bibliotecas Matplotlib e NumPy para esta tarefa.

import matplotlib.pyplot as plt
import numpy as np

Definindo a classe

Definiremos uma classe DataDisplayDownsampler que fará o downsample dos dados e recalculará quando houver zoom. O construtor da classe receberá xdata e ydata como parâmetros de entrada. Definiremos o número máximo de pontos como 50 e calcularemos o 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]

Downsampling de dados

Definiremos um método downsample que fará o downsample dos dados. O método receberá xstart e xend como parâmetros de entrada. Obteremos os pontos no intervalo de visualização e dilataremos a máscara em um para capturar os pontos logo fora do intervalo de visualização, a fim de não truncar a linha. Decidiremos quantos pontos descartar e mascarar os dados. Finalmente, faremos o downsample dos dados e retornaremos 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

Atualizando os dados

Definiremos um método update que atualizará os dados. O método receberá ax (eixo) como um parâmetro de entrada. Atualizaremos a linha obtendo o limite de visualização e verificando se a largura do limite de visualização é diferente de delta. Se a largura do limite de visualização for diferente de delta, atualizaremos o delta e obteremos xstart e xend. Em seguida, definiremos os dados para os dados com downsample e desenharemos o idle.

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

Criando o sinal

Criaremos um sinal usando NumPy. Criaremos um array xdata usando a função linspace com start=16, stop=365 e num= (365-16)*4. Criaremos um array ydata usando as funções sin e cos.

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

Criando o gráfico

Criaremos um gráfico usando Matplotlib. Criaremos uma instância d da classe DataDisplayDownsampler usando xdata e ydata. Criaremos uma figura e um eixo usando a função subplots. Conectaremos a linha e definiremos autoscale como False. Conectaremos para mudar os limites de visualização, definiremos o limite x e mostraremos o gráfico.

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

Resumo

Neste laboratório, aprendemos como fazer downsampling de dados usando Matplotlib em Python. Usamos uma classe que faz downsampling dos dados e recalcula quando há zoom. Criamos um sinal usando NumPy e criamos um gráfico usando Matplotlib. Conectamos para mudar os limites de visualização e definimos o limite x.

Reamostragem de Dados Usando Matplotlib