Animierter 3D-Zufallswalk in Matplotlib

Einführung

In diesem Lab werden wir lernen, wie man mithilfe der Matplotlib-Bibliothek in Python einen animierten 3D-Zufallswalk-Graphen erstellt. Wir werden einen 3D-Graphen erstellen und einen Zufallswalk mit 40 Teilchen simulieren, die sich zufällig im 3D-Raum bewegen.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Importieren der erforderlichen Bibliotheken

Wir beginnen mit dem Importieren der erforderlichen Bibliotheken. Wir werden numpy verwenden, um Zufallszahlen zu generieren, und matplotlib, um den Graphen zu erstellen.

import matplotlib.pyplot as plt
import numpy as np
import matplotlib.animation as animation

Definieren der Zufallswalk-Funktion

Wir definieren eine Funktion, die einen Zufallswalk mit einer angegebenen Anzahl von Schritten und einer maximalen Schrittgröße generiert. Die Funktion nimmt zwei Eingaben entgegen: num_steps ist die Gesamtzahl der Schritte im Zufallswalk und max_step ist die maximale Größe jedes Schritts. Wir verwenden numpy.random, um Zufallszahlen für die Schritte zu generieren, und numpy.cumsum, um die kumulative Summe der Schritte zu berechnen, um die Endposition zu erhalten.

def random_walk(num_steps, max_step=0.05):
    """Return a 3D random walk as (num_steps, 3) array."""
    start_pos = np.random.random(3)
    steps = np.random.uniform(-max_step, max_step, size=(num_steps, 3))
    walk = start_pos + np.cumsum(steps, axis=0)
    return walk

Definieren der Update-Funktion

Wir definieren eine Funktion, die den Graphen für jedes Frame der Animation aktualisiert. Die Funktion nimmt drei Eingaben entgegen: num ist die aktuelle Frame-Nummer, walks ist eine Liste aller Zufallswalks und lines ist eine Liste aller Linien im Graphen. Für jede Linie und jeden Zufallswalk aktualisieren wir die Daten für die x-, y- und z-Koordinaten der Linie bis zur aktuellen Frame-Nummer. Wir verwenden line.set_data() und line.set_3d_properties(), um die x-y- und z-Koordinaten jeweils zu aktualisieren.

def update_lines(num, walks, lines):
    for line, walk in zip(lines, walks):
        ## NOTE: there is no.set_data() for 3 dim data...
        line.set_data(walk[:num, :2].T)
        line.set_3d_properties(walk[:num, 2])
    return lines

Generieren von Zufallswalks

Wir generieren 40 Zufallswalks mit jeweils 30 Schritten mithilfe der zuvor definierten Funktion random_walk(). Wir speichern alle Zufallswalks in einer Liste namens walks.

## Data: 40 random walks as (num_steps, 3) arrays
num_steps = 30
walks = [random_walk(num_steps) for index in range(40)]

Erstellen eines 3D-Graphen

Wir erstellen einen 3D-Graphen mit matplotlib. Wir fügen für jeden Zufallswalk eine leere Linie zum Graphen hinzu. Wir setzen die Grenzen für die x-, y- und z-Achsen auf den Bereich zwischen 0 und 1.

## Attaching 3D axis to the figure
fig = plt.figure()
ax = fig.add_subplot(projection="3d")

## Create lines initially without data
lines = [ax.plot([], [], [])[0] for _ in walks]

## Setting the axes properties
ax.set(xlim3d=(0, 1), xlabel='X')
ax.set(ylim3d=(0, 1), ylabel='Y')
ax.set(zlim3d=(0, 1), zlabel='Z')

Erstellen einer Animation

Wir erstellen eine Animation mit der Klasse FuncAnimation aus matplotlib.animation. Wir übergeben das Figure-Objekt, die Update-Funktion, die Gesamtzahl der Frames (die der Anzahl der Schritte in den Zufallswalks entspricht), die Liste aller Zufallswalks und die Liste aller Linien als Argumente an den FuncAnimation-Konstruktor.

## Creating the Animation object
ani = animation.FuncAnimation(
    fig, update_lines, num_steps, fargs=(walks, lines), interval=100)

Anzeigen der Animation

Schließlich zeigen wir die Animation mit plt.show().

plt.show()

Zusammenfassung

Wir haben gelernt, wie man mithilfe der Matplotlib-Bibliothek in Python einen animierten 3D-Zufallswalk-Graphen erstellt. Wir haben Zufallswalks generiert und den Graphen für jedes Frame der Animation aktualisiert. Diese Technik kann verwendet werden, um die Bewegung von Teilchen, Diffusion und andere stochastische Prozesse im dreidimensionalen Raum zu visualisieren.