Rééchantillonnage des données à l'aide de Matplotlib

Introduction

Dans ce laboratoire, nous allons apprendre à réduire l'échantillonnage des données à l'aide de Matplotlib en Python. Le rééchantillonnage est le processus consistant à réduire la fréquence d'échantillonnage ou la taille d'échantillonnage d'un signal. Nous utiliserons une classe qui réduira l'échantillonnage des données et recomputera lorsque le zoom est effectué.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du carnet Jupyter.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques

Nous allons commencer par importer les bibliothèques nécessaires. Nous utiliserons les bibliothèques Matplotlib et NumPy pour cette tâche.

import matplotlib.pyplot as plt
import numpy as np

Définition de la classe

Nous allons définir une classe DataDisplayDownsampler qui réduira l'échantillonnage des données et recomputera lorsque le zoom est effectué. Le constructeur de la classe prendra les données x et y comme paramètres d'entrée. Nous définirons le nombre maximum de points à 50 et calculerons le delta des données x.

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

Rééchantillonnage des données

Nous allons définir une méthode downsample qui réduira l'échantillonnage des données. La méthode prendra xstart et xend comme paramètres d'entrée. Nous obtiendrons les points dans la plage d'affichage et dilaterons le masque de un pour capturer les points juste en dehors de la plage d'affichage afin de ne pas tronquer la ligne. Nous déterminerons combien de points doivent être éliminés et nous masquerons les données. Enfin, nous réduirons l'échantillonnage des données et renverrons les données x et y.

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

Mise à jour des données

Nous allons définir une méthode update qui mettra à jour les données. La méthode prendra ax (axe) comme paramètre d'entrée. Nous mettrons à jour la ligne en obtenant la limite d'affichage et en vérifiant si la largeur de la limite d'affichage est différente de delta. Si la largeur de la limite d'affichage est différente de delta, nous mettrons à jour delta et obtiendrons xstart et xend. Nous définirons ensuite les données sur les données rééchantillonnées et dessinerons l'état inactif.

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

Création du signal

Nous allons créer un signal à l'aide de NumPy. Nous allons créer un tableau xdata à l'aide de la fonction linspace avec start = 16, stop = 365 et num=(365 - 16)*4. Nous allons créer un tableau ydata à l'aide des fonctions sin et cos.

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

Création du tracé

Nous allons créer un tracé à l'aide de Matplotlib. Nous allons créer une instance d de la classe DataDisplayDownsampler en utilisant xdata et ydata. Nous allons créer une figure et un axe à l'aide de la fonction subplots. Nous allons connecter la ligne et définir l'auto-échelle sur False. Nous allons connecter pour changer les limites d'affichage, définir la limite x et afficher le tracé.

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

Sommaire

Dans ce laboratoire, nous avons appris à réduire l'échantillonnage des données à l'aide de Matplotlib en Python. Nous avons utilisé une classe qui réduit l'échantillonnage des données et le recalcul lorsqu'on zoom. Nous avons créé un signal à l'aide de NumPy et un tracé à l'aide de Matplotlib. Nous avons connecté pour changer les limites d'affichage et défini la limite x.