Zeitreihendaten mit NumPy

Zeitreihendaten sind einzigartig, da sie sequenziell voneinander abhängen. Dies liegt daran, dass die Daten im Laufe der Zeit in konsistenten Intervallen erfasst werden, beispielsweise jährlich, täglich oder sogar stündlich.

Zeitreihendaten sind für viele Analysen wichtig, da sie Muster für geschäftliche Fragen wie Datenprognosen, Anomalieerkennung, Trendanalysen und mehr darstellen können.

In Python können Sie versuchen, den Zeitreihendatensatz mit NumPy zu analysieren. NumPy ist ein leistungsstarkes Paket für numerische und statistische Berechnungen, kann aber auf Zeitreihendaten erweitert werden.

Wie das geht, probieren wir es aus.

Zuerst müssen wir NumPy in unserer Python-Umgebung installieren. Sie können das mit dem folgenden Code tun, falls Sie das noch nicht getan haben.

Als nächstes versuchen wir, Zeitreihendaten mit NumPy zu initiieren. Wie bereits erwähnt, haben Zeitreihendaten sequentielle und zeitliche Eigenschaften, daher würden wir versuchen, sie mit NumPy zu erstellen.

import numpy as np

dates = np.array(('2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04', '2023-01-05'), dtype="datetime64")
dates

Output>>
array(('2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04',
       '2023-01-05'), dtype="datetime64(D)")

Wie Sie im obigen Code sehen können, setzen wir die Datenzeitreihe in NumPy mit dem dtype Parameter. Ohne sie würden die Daten als Zeichenfolgendaten betrachtet, jetzt jedoch als Zeitreihendaten.

Wir können die NumPy-Zeitreihendaten erstellen, ohne sie einzeln zu schreiben. Dazu können wir eine bestimmte Methode von NumPy verwenden.

date_range = np.arange('2023-01-01', '2025-01-01', dtype="datetime64(M)")
date_range

Output>>
array(('2023-01', '2023-02', '2023-03', '2023-04', '2023-05', '2023-06',
       '2023-07', '2023-08', '2023-09', '2023-10', '2023-11', '2023-12',
       '2024-01', '2024-02', '2024-03', '2024-04', '2024-05', '2024-06',
       '2024-07', '2024-08', '2024-09', '2024-10', '2024-11', '2024-12'),
      dtype="datetime64(M)")

Wir erstellen monatliche Daten von 2023 bis 2024, wobei die Daten jedes Monats die Werte darstellen.

Danach können wir versuchen, die Daten basierend auf der NumPy-Datums-/Uhrzeitreihe zu analysieren. Wir können beispielsweise Zufallsdaten mit einem Datumsbereich erstellen, der unserem Datumsbereich entspricht.

information = np.random.randn(len(date_range)) * 10 + 100

Output>>
array((128.85379394,  92.17272879,  81.73341807,  97.68879621,
       116.26500413,  89.83992529,  93.74247891, 115.50965063,
        88.05478692, 106.24013365,  92.84193254,  96.70640287,
        93.67819695, 106.1624716 ,  97.64298602, 115.69882628,
       110.88460629,  97.10538592,  98.57359395, 122.08098289,
       104.55571757, 100.74572336,  98.02508889, 106.47247489))

Mit der Zufallsmethode in NumPy können wir Zufallswerte generieren, um Zeitreihenanalysen zu simulieren.

Beispielsweise können wir versuchen, mit NumPy mithilfe des folgenden Codes eine gleitende Durchschnittsanalyse durchzuführen.

def moving_average(information, window):
    return np.convolve(information, np.ones(window), 'legitimate') / window

ma_12 = moving_average(information, 12)
ma_12

Output>>
array(( 99.97075433,  97.03945458,  98.20526648,  99.53106381,
       101.03189965, 100.58353316, 101.18898821, 101.59158114,
       102.13919216, 103.51426971, 103.05640219, 103.48833188,
       104.30217122))

Der gleitende Durchschnitt ist eine einfache Zeitreihenanalyse, bei der wir den Mittelwert der Teilmengennummer der Reihe berechnen. Im obigen Beispiel verwenden wir Fenster 12 als Teilmenge. Das bedeutet, dass wir die ersten 12 der Reihe als Teilmenge nehmen und ihre Mittelwerte ermitteln. Dann verschiebt sich die Teilmenge um eins und wir nehmen die nächste mittlere Teilmenge.

Die erste Teilmenge ist additionally diese Teilmenge, bei der wir den Mittelwert nehmen:

(128.85379394,  92.17272879,  81.73341807,  97.68879621,
       116.26500413,  89.83992529,  93.74247891, 115.50965063,
        88.05478692, 106.24013365,  92.84193254,  96.70640287)

In der nächsten Teilmenge verschieben wir das Fenster um eins:

(92.17272879,  81.73341807,  97.68879621,
       116.26500413,  89.83992529,  93.74247891, 115.50965063,
        88.05478692, 106.24013365,  92.84193254,  96.70640287,
        93.67819695)

Das ist, was die np.convolve tut, als würde die Methode verschieben und summieren die Serie Teilmenge so viel wie die np.ones Array-Nummer. Wir verwenden die gültige Possibility nur, um den Betrag zurückzugeben, der ohne Auffüllen berechnet werden kann.

Dennoch werden gleitende Durchschnitte häufig zur Analyse von Zeitreihendaten verwendet, um das zugrunde liegende Muster zu erkennen und als Signale, beispielsweise für Kauf/Verkauf im Finanzbereich.

Apropos Muster: Wir können die Trenddaten in Zeitreihen mit NumPy simulieren. Der Development ist eine langfristige und anhaltende Richtungsbewegung in den Daten. Im Grunde ist es die allgemeine Richtung, in der die Zeitreihendaten verlaufen würden.

pattern = np.polyfit(np.arange(len(information)), information, 1)
pattern

Output>>
array(( 0.20421765, 99.78795983))

Was oben passiert, ist, dass wir eine lineare Gerade an unsere obigen Daten anpassen. Aus dem Ergebnis erhalten wir die Steigung der Linie (erste Zahl) und den Achsenabschnitt (zweite Zahl). Die Steigung stellt dar, wie stark sich die Daten professional Schritt oder zeitliche Werte im Durchschnitt ändern, während der Achsenabschnitt die Datenrichtung angibt (positiv bedeutet nach oben und negativ bedeutet nach unten).

Wir können auch trendbereinigte Daten haben, additionally die Komponenten, nachdem wir den Development aus der Zeitreihe entfernt haben. Dieser Datentyp wird häufig verwendet, um Fluktuationsmuster in den Trenddaten und Anomalien zu erkennen.

detrended = information - (pattern(0) * np.arange(len(information)) + pattern(1))
detrended

Output>>
array(( 29.06583411,  -7.81944869, -18.46297706,  -2.71181657,
        15.66017371, -10.96912278,  -7.2707868 ,  14.29216727,
       -13.36691409,   4.61421499,  -8.98820376,  -5.32795108,
        -8.56037465,   3.71968235,  -5.00402087,  12.84760174,
         7.8291641 ,  -6.15427392,  -4.89028352,  18.41288776,
         0.6834048 ,  -3.33080706,  -6.25565918,   1.98750918))

Die Daten ohne ihren Development werden in der Ausgabe oben angezeigt. In einer realen Anwendung würden wir sie analysieren, um zu sehen, welche zu stark vom allgemeinen Muster abweichen.

Wir können auch versuchen, die Saisonalität anhand der uns vorliegenden Zeitreihendaten zu analysieren. Saisonalität bezeichnet regelmäßige und vorhersehbare Muster, die in bestimmten Zeitabständen auftreten, beispielsweise alle 3 Monate, alle 6 Monate usw. Saisonalität wird normalerweise durch externe Faktoren wie Feiertage, Wetter, Veranstaltungen usw. beeinflusst.

seasonality = np.imply(information.reshape(-1, 12), axis=0)
seasonal_component = np.tile(seasonality, len(information)//12 + 1)(:len(information))

Output>>
array((111.26599544,  99.16760019,  89.68820205, 106.69381124,
       113.57480521,  93.4726556 ,  96.15803643, 118.79531676,
        96.30525224, 103.4929285 ,  95.43351072, 101.58943888,
       111.26599544,  99.16760019,  89.68820205, 106.69381124,
       113.57480521,  93.4726556 ,  96.15803643, 118.79531676,
        96.30525224, 103.4929285 ,  95.43351072, 101.58943888))

Im obigen Code berechnen wir den Durchschnitt für jeden Monat und erweitern dann die Daten, um sie seiner Länge anzupassen. Am Ende erhalten wir den Durchschnitt für jeden Monat im Zweijahresintervall und können versuchen, die Daten zu analysieren, um festzustellen, ob es nennenswerte Saisonalität gibt.

Das sind alle grundlegenden Methoden, die wir mit NumPy für Zeitreihendaten und -analysen durchführen können. Es gibt viele erweiterte Methoden, aber die oben genannten sind die grundlegenden Methoden, die wir durchführen können.

Abschluss

Die Zeitreihendaten sind ein einzigartiger Datensatz, da sie sequenziell dargestellt werden und zeitliche Eigenschaften haben. Mit NumPy können wir die Zeitreihendaten festlegen, während wir grundlegende Zeitreihenanalysen wie gleitende Durchschnitte, Trendanalysen und Saisonalitätsanalysen durchführen. Daten, während wir grundlegende Zeitreihenanalysen wie gleitende Durchschnitte, Trendanalysen und Saisonalitätsanalysen durchführen.

Cornellius Yudha Wijaya ist Information Science Assistant Supervisor und Datenautor. Während seiner Vollzeitbeschäftigung bei Allianz Indonesien teilt er gerne Python- und Datentipps über soziale Medien und in den Medien. Cornellius schreibt über eine Vielzahl von KI- und maschinellen Lernthemen.

Zeitreihendaten mit NumPy