Numpy Rolling - Berechnung des laufenden Durchschnitts in Python

Name

Sebastian Brandt

Published on 17.8.2023

(opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab)

Im Bereich der Datenanalyse, insbesondere bei der Arbeit mit Zeitreihendaten, ist die Fähigkeit zur Berechnung von laufenden Statistiken eine entscheidende Fertigkeit. Das wichtigste Tool dafür in Python ist die numpy-Bibliothek und speziell die Funktion numpy rolling. Mit dieser Funktion können wir verschiedene laufende Statistiken wie den laufenden Durchschnitt über unsere Daten berechnen. Aber wie funktioniert das und wie können wir es effektiv nutzen?

Numpy rolling ist eine Funktion, mit der wir eine Funktion auf ein bewegliches Fenster einer bestimmten Größe auf unsere Daten anwenden können. Dies ist besonders nützlich bei der Analyse von Zeitreihen, wo wir oft kurzfristige Schwankungen ausgleichen wollen, um die langfristigen Trends besser erkennen zu können. In diesem Artikel werden wir uns mit den Details von numpy rolling befassen, einschließlich seiner Syntax, wie man es mit verschiedenen Fenstergrößen verwendet, wie man es auf 2D-Arrays anwendet und wie man Filter damit verwendet.

Möchten Sie schnell datenvisualisierung erstellen nach Python Pandas Dataframe ohne Code?

PyGWalker ist eine Python-Bibliothek für explorative Datenanalyse mit Visualisierung. PyGWalker (opens in a new tab) kann Ihre Jupyter Notebook Datenanalyse und Datenvisualisierung vereinfachen, indem es Ihr Pandas Dataframe (und Polars Dataframe) in eine tableauähnliche Benutzeroberfläche für die visuelle Exploration umwandelt.

(opens in a new tab)

Verständnis von Numpy Rolling

Numpy rolling ist eine Funktion, die ein bewegliches Fenster auf ein Array aufträgt und eine Funktion auf die Daten in diesem Fenster anwendet. Das Fenster bewegt sich entlang des Arrays und die Funktion wird bei jedem Schritt auf das neue Fenster angewendet. Die Größe des Fensters wird vom Benutzer festgelegt und kann eine ganze Zahl sein, die kleiner oder gleich der Größe des Arrays ist.

Die Syntax für die numpy rolling Funktion lautet wie folgt:

numpy.rolling(window)

Hier ist window die Größe des beweglichen Fensters. Es handelt sich um eine ganze Zahl, die angibt, wie viele aufeinanderfolgende Elemente des Arrays in das Fenster einbezogen werden.

Zum Beispiel, wenn wir ein 1D-Array von Werten haben und den laufenden Durchschnitt mit einer Fenstergröße von 3 berechnen möchten, würden wir den folgenden Code verwenden:

import numpy as np
 
# Erzeugen eines 1D-Arrays
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
 
# Berechnen des laufenden Durchschnitts mit einer Fenstergröße von 3
rolling_mean = np.rolling(3).mean(data)
 
print(rolling_mean)

Dies gibt das folgende Array aus:

array([nan, nan, 2., 3., 4., 5., 6., 7., 8.])

Die ersten beiden Werte sind nan, da es nicht genügend vorherige Werte gibt, um ein Fenster der Größe 3 zu füllen. Der dritte Wert ist 2, da der Durchschnitt der ersten drei Werte (1, 2, 3) 2 ist und so weiter.

Vergleich von Numpy Rolling und Numpy Roll

Obwohl sich numpy rolling und numpy roll ähnlich anhören, dienen sie unterschiedlichen Zwecken. Numpy roll ist eine Funktion, die die Elemente eines Arrays entlang einer angegebenen Achse verschiebt und die Elemente am Ende des Arrays um die andere Seite des Arrays herumwickelt. Andererseits wendet numpy rolling ein bewegliches Fenster auf ein Array an und führt eine Funktion auf die Daten in diesem Fenster aus.

Zum Beispiel, wenn wir das folgende 1D-Array haben:

import numpy as np
 
# Erzeugen eines 1D-Arrays
data = np.array([1, 2, 3, 4, 5])
 
# Verwenden von numpy roll, um die Elemente um 2 Positionen nach rechts zu verschieben
rolled_data = np.roll
 
(data, 2)
 
print(rolled_data)

Dies gibt das folgende Array aus:

array([4, 5, 1, 2, 3])

Wie Sie sehen können, wurden die Elemente um zwei Positionen nach rechts verschoben, wobei die Elemente, die am Ende herausgeschoben wurden, am Anfang des Arrays wieder aufgetaucht sind.

Anwendung von Numpy Rolling auf 2D-Arrays

Numpy rolling kann auch auf 2D-Arrays angewendet werden. In diesem Fall wird das bewegliche Fenster auf jede Zeile oder Spalte des Arrays (je nach angegebener Achse) angewendet und die Funktion auf die Daten im Fenster angewendet.

Zum Beispiel, wenn wir ein 2D-Array von Werten haben und den laufenden Durchschnitt mit einer Fenstergröße von 3 entlang der Zeilen berechnen wollen, würden wir den folgenden Code verwenden:

import numpy as np
 
# Erzeugen eines 2D-Arrays
data = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]])
 
# Berechnen des laufenden Durchschnitts mit einer Fenstergröße von 3 entlang der Zeilen
rolling_mean = np.rolling(3, axis=1).mean(data)
 
print(rolling_mean)

Dies gibt das folgende 2D-Array aus:

array([[nan, nan,  2.,  3.,  4.],
       [nan, nan,  7.,  8.,  9.],
       [nan, nan, 12., 13., 14.]])

Die ersten beiden Werte in jeder Zeile sind nan, da es nicht genügend vorherige Werte in der Zeile gibt, um ein Fenster der Größe 3 zu füllen. Der dritte Wert in der ersten Zeile ist 2, da der Durchschnitt der ersten drei Werte in der Zeile (1, 2, 3) 2 ist und so weiter.

Verwendung von Filtern mit Numpy Rolling

Numpy rolling ermöglicht es uns auch, Filter auf die Daten im beweglichen Fenster anzuwenden. Dies kann für das Glätten der Daten oder das Entfernen von Ausreißern nützlich sein.

Zum Beispiel, wenn wir den laufenden Median (der weniger empfindlich gegenüber Ausreißern ist als der Durchschnitt) mit einer Fenstergröße von 3 berechnen möchten, würden wir den folgenden Code verwenden:

import numpy as np
 
# Erzeugen eines 1D-Arrays
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
 
# Berechnen des laufenden Medians mit einer Fenstergröße von 3
rolling_median = np.rolling(3).median(data)
 
print(rolling_median)

Dies gibt das folgende Array aus:

array([nan, nan, 2., 3., 4., 5., 6., 7., 8.])

Die ersten beiden Werte sind "nan", weil es nicht genügend vorherige Werte gibt, um ein Fenster der Größe 3 zu füllen. Der dritte Wert ist 2, weil der Median der ersten drei Werte (1, 2, 3) 2 ist, und so weiter.

Anwendung von Numpy Rolling auf Zeitreihendaten

Einer der häufigsten Anwendungsfälle für Numpy Rolling besteht in der Analyse von Zeitreihendaten. Zeitreihendaten sind eine Abfolge von Datenpunkten, die im Laufe der Zeit gesammelt wurden, in der Regel in regelmäßigen Abständen. Numpy Rolling ermöglicht es uns, rollende Statistiken über Zeitreihendaten zu berechnen und somit Einblicke in Trends und Muster zu erhalten.

Um Numpy Rolling auf Zeitreihendaten anzuwenden, müssen wir zunächst sicherstellen, dass unsere Daten richtig formatiert sind. In der Regel werden Zeitreihendaten als eindimensionales Array oder als Spalte in einem zweidimensionalen Array dargestellt, wobei jedes Element einen Datenpunkt zu einem bestimmten Zeitpunkt repräsentiert. Sobald wir unsere Zeitreihendaten im gewünschten Format haben, können wir Numpy Rolling verwenden, um rollende Statistiken zu berechnen.

Angenommen, wir haben zum Beispiel einen Zeitreihendatensatz, der die tägliche Temperatur in einer Stadt für das vergangene Jahr aufzeichnet. Wir möchten den 7-Tage-Durchschnitt der Temperatur berechnen, um tägliche Schwankungen auszugleichen und langfristige Temperaturtrends zu erkennen. So können wir es tun:

import numpy as np
 
# Angenommen, wir haben ein eindimensionales Array 'temperature' mit täglichen Temperaturwerten
# Berechnung des 7-Tage-Durchschnitts der Temperatur
rolling_avg = np.rolling(7).mean(temperature)
 
print(rolling_avg)

Das Array rolling_avg enthält die Werte des 7-Tage-Durchschnitts der Temperatur. Jeder Wert repräsentiert die Durchschnittstemperatur über ein 7-Tage-Fenster und ermöglicht es uns, den Gesamttrend der Temperatur im Laufe der Zeit zu beobachten.

Durch die Anwendung von Numpy Rolling auf Zeitreihendaten können wir wertvolle Erkenntnisse gewinnen, wie z.B. die Identifizierung von Saisonalität, die Erkennung von Anomalien oder die Vorhersage zukünftiger Trends. Es bietet ein leistungsstarkes Werkzeug zur Analyse und Verständnis von zeitabhängigen Mustern in verschiedenen Bereichen wie Finanzen, Klima, Aktienmarktanalyse und mehr.

Manipulation von Achsen mit Numpy Rolling

Numpy Rolling ermöglicht es uns nicht nur, ein gleitendes Fenster entlang der Zeilen oder Spalten eines zweidimensionalen Arrays anzuwenden, sondern bietet auch Flexibilität bei der Manipulation der Achsen. Diese Funktion ist besonders nützlich beim Arbeiten mit mehrdimensionalen Arrays und bei der Durchführung von Berechnungen über bestimmte Dimensionen hinweg.

Angenommen, wir haben zum Beispiel ein dreidimensionales Array, das monatliche Temperaturmessungen an verschiedenen Orten und Zeitperioden repräsentiert. Wir möchten den gleitenden Durchschnitt der Temperatur für jeden Ort entlang der Zeitachse berechnen. So können wir das mit Numpy Rolling erreichen:

import numpy as np
 
# Angenommen, wir haben ein dreidimensionales Array 'temperature' mit der Form (num_locations, num_time_periods, num_months)
# Berechnung des gleitenden Durchschnitts der Temperatur entlang der Zeitachse
rolling_avg = np.rolling(3, axis=1).mean(temperature)
 
print(rolling_avg)

In diesem Beispiel geben wir axis=1 an, um anzugeben, dass wir das gleitende Fenster entlang der Zeitachse anwenden möchten. Das resultierende Array rolling_avg enthält die Werte des gleitenden Durchschnitts der Temperatur für jeden Ort und behält dabei die ursprüngliche Form des Arrays bei.

Durch die Manipulation von Achsen mit Numpy Rolling können wir rollende Berechnungen über bestimmte Dimensionen hinweg durchführen und somit sinnvolle Informationen aus mehrdimensionalen Daten analysieren und extrahieren.

Optimierung von Numpy Rolling für die Datenanalyse

Bei der Arbeit mit großen Datensätzen oder bei komplexen Berechnungen mit Numpy Rolling ist die Optimierung entscheidend, um eine effiziente Berechnung und eine Reduzierung der Verarbeitungszeit zu gewährleisten. Hier sind einige Tipps zur Optimierung von Numpy Rolling für die Datenanalyse:

1. Geben Sie den dtype an: Beim Erstellen von Arrays oder beim Laden von Daten in Numpy sollten Sie den geeigneten Datentyp (dtype) angeben. Die Verwendung des richtigen Datentyps spart nicht nur Speicherplatz, sondern verbessert auch die Rechengeschwindigkeit.

2. Verwenden Sie die Fenstergröße sinnvoll: Passen Sie die Fenstergröße entsprechend Ihren Daten und Analyseanforderungen an. Eine kleinere Fenstergröße bietet detailliertere Einblicke, kann jedoch auf Störungen empfindlich reagieren, während eine größere Fenstergröße Schwankungen ausgleicht, jedoch kurzfristige Muster übersehen kann.

3. Nutzen Sie vektorisierte Operationen: Numpy ist für vektorisierte Operationen ausgelegt,

   die die Leistung erheblich verbessern können. Versuchen Sie statt Schleifen oder iterativen Berechnungen Ihre Berechnungen mit den integrierten Funktionen und Operationen von Numpy zu formulieren.

4. Berücksichtigen Sie Parallelisierung: Wenn Ihr System paralleles Rechnen unterstützt, erkunden Sie Optionen zur Parallelisierung Ihrer Numpy Rolling-Berechnungen. Die Parallelisierung ermöglicht es, die Berechnung auf mehrere Kerne oder Prozessoren zu verteilen und so die Verarbeitungszeit für große Datensätze zu reduzieren.

Durch die Beachtung dieser Optimierungstechniken können Sie die Leistung Ihrer Numpy Rolling-Berechnungen verbessern und das volle Potenzial der Datenanalyse ausschöpfen.

FAQs

Hier sind einige häufig gestellte Fragen zu Numpy Rolling:

1. Was ist Numpy Rolling? Numpy Rolling ist eine Funktion in der Numpy-Bibliothek, die es uns ermöglicht, rollende Statistiken auf Arrays zu berechnen. Es wendet ein gleitendes Fenster auf die Daten an und führt eine angegebene Funktion auf den fensterbasierten Daten aus. Dies ist besonders nützlich für die Zeitreihenanalyse und das Glätten von Datenfluktuationen.

2. Wie berechnet man rollende Statistiken mit Numpy? Um rollende Statistiken mit Numpy zu berechnen, können Sie die Funktion numpy.rolling() verwenden und die Fenstergröße und die gewünschte Funktion (z.B. Mittelwert, Median) angeben, die auf die Daten im Fenster angewendet werden soll. Die Funktion iteriert über das Array und wendet die angegebene Funktion auf jedes Datenfenster an.

3. Wie lautet die Syntax für die Numpy-Rolling-Funktion? Die Syntax für die Numpy-Rolling-Funktion lautet numpy.rolling(window, axis=0), wobei window die Größe des gleitenden Fensters angibt und axis (optional) die Achse festlegt, entlang derer die Rollenoperation erfolgen soll. Die Funktion liefert ein Objekt für das gleitende Fenster zurück, das verwendet werden kann, um verschiedene Funktionen wie Mittelwert, Median usw. anzuwenden.