Zeitreihendaten sind eine Folge von Beobachtungen, die in regelmäßigen Zeitintervallen aufgezeichnet werden und häufig in verschiedenen Bereichen wie Finanzen, Wirtschaft und Ingenieurwesen verwendet werden. Jedoch, Zeitreihendaten können häufig Rauschen, Ausreißer, fehlende Werte und andere Anomalien enthalten, die sich auf die Analyse und Interpretation der Daten auswirken können. Daher ist die Bereinigung der Daten ein entscheidender Schritt im Zeitreihenanalyseprozess, der normalerweise vor dem Coaching der meisten gängigen Modelle erforderlich ist, z Exponentielle Glättung, VARoder ARMA Modelle.
Dieser Artikel bietet einen umfassenden Überblick über die Schritte zur Bereinigung von Zeitreihendaten. Diese Schritte lauten in der logischen Reihenfolge, in der sie normalerweise ausgeführt würden:
- Behandeln Sie fehlende Werte
- Development entfernen
- Saisonalität entfernen
- Überprüfen Sie den Stillstand und stellen Sie ihn ggf. nonetheless
- Normalisieren Sie die Daten
- Ausreißer entfernen
- Glätten Sie die Daten
Der Artikel enthält auch eine allgemeine Richtlinie für Bereinigen von Zeitreihendaten und heben Sie hervor, wie wichtig es ist, einen geeigneten Ansatz zur Bereinigung von Zeitreihendaten zu verwenden. Bitte beachten Sie, dass Sie je nach Ihren Daten einige Schritte überspringen oder ändern oder andere hinzufügen müssen.
Wir werden einen Datensatz von verwenden Kaggle das sammelt die Werte der monatliche Bierproduktion in Australien von 1956 bis 1995.
Der erste Schritt nach dem Import der Daten ist deren Überprüfung. Wir können damit beginnen, den Kopf (oberste 5 Datenzeilen) des Datensatzes zu überprüfen.
# Import required libraries
import pandas as pd
import numpy as np# Learn dataset file
df = pd.read_csv("/monthly-beer-production-in-austr.csv")
# Examine information sorts
print(df.dtypes)
# Present the highest 5 rows of the dataset
df.head()
Uns fallen zwei Dinge auf:
- Das Datum hat nicht den richtigen Datentyp, es muss einer sein Terminzeit.
- Der Index ist nicht das Datum des Datenrahmens, und dies ist eine wichtige Anforderung, wenn wir mit Zeitreihendaten arbeiten.
Der nächste Schritt wäre additionally die Umrechnung des Datums in Terminzeit und legen Sie es als Index fest.
# Convert the month column to datetime
df['Month'] = pd.to_datetime(df['Month'], format='%Y-%m')# Set the date because the index
df = df.set_index('Month')
# Convert the dataframe to sequence
df_beer = df['Monthly beer production']
Sobald dies erledigt ist, können wir es grafisch darstellen:
# Import required libraries
import matplotlib.pyplot as plt# Plot information
df_beer.plot(figsize=(14,6))
plt.xlabel('Date')
plt.ylabel('Month-to-month beer manufacturing')
plt.grid()
plt.present()
Versuchen wir, die Hauptanliegen der Daten zusammenzufassen, indem wir einen kurzen Blick auf die vorherige Darstellung werfen:
- Es ist instationär
- Es scheint eine zu geben saisonale Komponente
- Es gibt einen Development und eine zunehmende Varianz
- Es sieht so aus, als gäbe es einige Ausreißer
Dies sind einige der Probleme, die wir im Datenbereinigungsprozess angehen müssen.
Behandeln Sie fehlende Werte
Wir müssen prüfen, ob Werte fehlen oder nicht.
# Examine for lacking values
df.isna().sum()
Diesmal haben wir Glück, es fehlen keine Werte.
Wenn wir das hätten, könnten wir es mit folgenden Methoden bewältigen:
- Anrechnung: Diese Methoden ergänzen die fehlenden Werte durch geschätzte Werte. Einige beliebte Imputationsmethoden umfassen die Imputation konstanter Werte, die Mittelwert-, Median- oder Modusimputation sowie die Vorwärts- oder Rückwärtsfüllung.
- Interpolation: Diese Methoden verwenden mathematische Funktionen, um fehlende Werte basierend auf den Werten der umgebenden Beobachtungen zu schätzen. Die beliebtesten sind die lineare Interpolation, die Polynominterpolation und die Spline-Interpolation.
- Prädiktive Modellierung: Vorhersagemodellierungsmethoden verwenden statistische oder maschinelle Lernalgorithmen, um ein Modell zu erstellen, um fehlende Werte basierend auf den Werten anderer Variablen vorherzusagen. Zu den beliebten Vorhersagemodellierungsmethoden gehören Okay-Nearest Neighbors, Regression, Entscheidungsbäume, Random Forests und neuronale Netze.
Es ist wichtig, basierend auf den spezifischen Merkmalen und Anforderungen der Daten eine geeignete Methode zum Umgang mit fehlenden Werten auszuwählen. In einigen Fällen kann eine Kombination verschiedener Methoden erforderlich sein, um die besten Ergebnisse zu erzielen. Im Folgenden zeigen wir, wie wir die fehlenden Werte mit einigen der zuvor beschriebenen Methoden entfernen würden:
# Imputation of fixed worth
df_beer = df_beer.fillna(0)# Imply imputation
df_beer = df_beer.fillna(df_beer.imply())
# Backward-fill imputation (or final statement carried ahead)
df_beer = df_beer.bfill()
# Linear interpolation
df_beer = df_beer.interpolate(technique='linear')
Dies ist aber, wie bereits erwähnt, bei den aktuellen Daten nicht notwendig.
Development entfernen
Die meisten Modelle, wie z ARIMAerfordern stationäre Daten. Stationarität wird erreicht, wenn Daten einen konstanten Mittelwert, eine konstante Varianz und eine konstante Kovarianz aufweisen.
Der erste Schritt dazu besteht darin, den Development zu beseitigen. Der Development kann mit verschiedenen Methoden entfernt werden. Schauen Sie sich unten die häufigsten an:
- Differenzierung: Subtrahieren der Beobachtungen aus einem früheren Zeitraum, um den Mittelwert der Reihe über die Zeit zu stabilisieren.
- Zersetzung: Zerlegen der Zeitreihe in ihre Development-, Saison- und Restkomponenten und Entfernen der Trendkomponente.
- Gleitende Mittelwerte: Berechnen des Durchschnitts der Beobachtungen über eine feste Anzahl von Zeiträumen und Subtrahieren dieses Werts von jeder Beobachtung.
- Polynomanpassung: Anpassen einer Polynomkurve an die Zeitreihendaten und Subtrahieren dieser von der Originalreihe, um den Development zu entfernen.
- Trendfilter: Verwenden von Filtern wie dem Hodrick-Prescott- oder Kalman-Filter, um die Trendkomponente zu entfernen.
- Protokolltransformationen: Logarithmieren der Zeitreihendaten, um das Ausmaß des Developments zu verringern und die Varianz der Reihe zu stabilisieren.
- Field-Cox-Transformationen: Transformieren der Zeitreihendaten mithilfe einer Potenztransformation, um die Varianz zu stabilisieren und den Development linear zu machen.
Abhängig von den spezifischen Anforderungen und Eigenschaften der Daten kann eine Technik besser geeignet sein als eine andere. In manchen Fällen ist mehr als eine Methode erforderlich.
Für unser Beispiel zeigen wir das erste, das eines der am häufigsten verwendeten ist. Nachdem wir die erste Differenz der Daten ermittelt haben, müssen wir die erste Zeile unserer Daten entfernen. Dies liegt daran, dass wir die Differenz des ersten Components nicht ermitteln können, da vorher kein anderer Wert vorhanden ist. Daher erscheint es als NaN (Keine Zahl) und kann einfach gelöscht werden.
# Take the primary distinction of the info to take away the pattern
df_beer = df_beer.diff()# Drop the primary NaN worth coming from taking the distinction
df_beer = df_beer.dropna()
# Plot the info to see the result
df_beer.plot(figsize=(15,5))
plt.xlabel('Date')
plt.ylabel('Beer manufacturing improve price')
plt.grid()
plt.present()
Wir beobachten, dass der Mittelwert nun ungefähr konstant um Null herum liegt. Es gibt jedoch noch ein weiteres Downside zu lösen: das nicht konstante oder zunehmende Varianz.
Wir könnten einige der zuvor gesehenen Transformationen nutzen. Wir werden jedoch stattdessen einen intuitiven Ansatz verwenden. Um der im Laufe der Jahre kontinuierlich zunehmenden Varianz Rechnung zu tragen, könnten wir für jedes Jahr eine konsistente Varianz erzwingen. Mal sehen, wie wir dies in Python erreichen können.
# Calculate annually's variance (equal to plain deviation)
annual_variance = df_beer.groupby(df_beer.index.yr).std()
mapped_annual_variance = df_beer.index.map(
lambda x: annual_variance.loc[x.year])# Standardize annually's variance
df_beer = df_beer / mapped_annual_variance
# Plot end result
df_beer.plot(figsize=(15,5))
plt.xlabel('Date')
plt.ylabel('Standardized beer manufacturing price')
plt.grid()
plt.present()
Endlich können wir erkennen, dass unsere Daten eine konstante Varianz und einen konstanten Mittelwert aufweisen. Wir sind der Stationarität nun einen Schritt näher gekommen!
Sie können auf das Notizbuch in unserem Repository zugreifen Github.
