Introduction
Dans ce laboratoire, vous allez apprendre à utiliser la bibliothèque multiprocessing et Matplotlib pour tracer des données générées à partir d'un processus séparé. Nous allons créer deux classes - ProcessPlotter et NBPlot - pour gérer respectivement le tracé et la génération de données. La classe NBPlot générera des données aléatoires et les enverra à la classe ProcessPlotter via un tube, qui tracerra ensuite les données en temps réel.
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 Notebook pour accéder à Jupyter Notebook pour la pratique.
Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.
Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous réglerons rapidement le problème pour vous.
Importation des bibliothèques
Nous commençons par importer les bibliothèques nécessaires. Nous utiliserons multiprocessing pour gérer les processus séparés, time pour le délai de temps, numpy pour générer des données aléatoires et matplotlib pour le tracé.
import multiprocessing as mp
import time
import numpy as np
import matplotlib.pyplot as plt
Définir la classe ProcessPlotter
La classe ProcessPlotter gérera le tracé des données envoyées par le tube. Elle vérifiera continuellement le tube pour de nouvelles données et les tracera en temps réel.
class ProcessPlotter:
def __init__(self):
self.x = []
self.y = []
def terminate(self):
plt.close('all')
def call_back(self):
while self.pipe.poll():
command = self.pipe.recv()
if command is None:
self.terminate()
return False
else:
self.x.append(command[0])
self.y.append(command[1])
self.ax.plot(self.x, self.y, 'ro')
self.fig.canvas.draw()
return True
def __call__(self, pipe):
print('starting plotter...')
self.pipe = pipe
self.fig, self.ax = plt.subplots()
timer = self.fig.canvas.new_timer(interval=1000)
timer.add_callback(self.call_back)
timer.start()
print('...done')
plt.show()
Définir la classe NBPlot
La classe NBPlot générera des données aléatoires et les enverra à la classe ProcessPlotter via un tube.
class NBPlot:
def __init__(self):
self.plot_pipe, plotter_pipe = mp.Pipe()
self.plotter = ProcessPlotter()
self.plot_process = mp.Process(
target=self.plotter, args=(plotter_pipe,), daemon=True)
self.plot_process.start()
def plot(self, finished=False):
send = self.plot_pipe.send
if finished:
send(None)
else:
data = np.random.random(2)
send(data)
Créer une instance de NBPlot et envoyer des données à ProcessPlotter
Créez une instance de la classe NBPlot et envoyez des données aléatoires à la classe ProcessPlotter. Nous enverrons 10 ensembles de données, avec un délai de 0,5 seconde entre chaque ensemble.
def main():
pl = NBPlot()
for _ in range(10):
pl.plot()
time.sleep(0.5)
pl.plot(finished=True)
if __name__ == '__main__':
if plt.get_backend() == "MacOSX":
mp.set_start_method("forkserver")
main()
Résumé
Dans ce laboratoire, nous avons appris à utiliser la bibliothèque multiprocessing et Matplotlib pour tracer des données générées à partir d'un processus séparé. Nous avons créé deux classes - ProcessPlotter et NBPlot - pour gérer respectivement le tracé et la génération de données. La classe NBPlot a généré des données aléatoires et les a envoyées à la classe ProcessPlotter via un tube, qui a ensuite tracé les données en temps réel.