Maschinelles Lernen für Zeitreihen - Exam

Aufgabe 1)

Maschinelles Lernen für Zeitreihenanalyse: Du sollst sowohl überwachte als auch unüberwachte Lernmethoden anwenden, um Muster zu erkennen und Vorhersagen zu generieren. Gegeben sei eine Datensatz mit verschiedenen Metriken über die Zeit. Der Datensatz enthält sowohl gelabelte Daten als auch ungelabelte Daten. Dein Ziel ist es, durch verschiedene Techniken des maschinellen Lernens Einblicke und Vorhersagen zu generieren.

a)

Starte mit der Durchführung eines überwachtes Lernverfahrens. Nimm an, Du hast eine Zeitreihe von Verkaufszahlen eines Online-Shops (gelabelte Daten, wöchentlich). Erstelle ein Modell, das die Verkaufszahlen für die nächsten 4 Wochen vorhersagt. Beschreibe zuerst Dein Vorgehen und führe dann das Training des Modells durch. Nutze Python und eine geeignete Bibliothek (z.B. scikit-learn oder TensorFlow).

Lösung:

Maschinelles Lernen für ZeitreihenanalyseEs ist wichtig, dass wir den Prozess Schritt für Schritt durchführen, um ein Modell zu erstellen, das die zukünftigen Verkaufszahlen vorhersagen kann. Hier ist eine detaillierte Beschreibung des Vorgehens:

• Datensammlung: Stelle sicher, dass Du alle relevanten Daten hast. In diesem Fall gehen wir davon aus, dass die wöchentlichen Verkaufszahlen eines Online-Shops vorliegen.
• Datenvorbereitung: Es ist notwendig, die Daten für das Modell vorzubereiten. Dies beinhaltet das Normalisieren der Daten, das Aufteilen der Daten in Trainings- und Testdaten, und das Erstellen von Zeitreihen-Funktionalitäten.
• Merkmalsextraktion: Du kannst aus den Zeitreihen neue Merkmale extrahieren, wie z.B. gleitende Durchschnitte, maximale und minimale Verkaufszahlen, etc., um das Modell mehr Informationen zu geben.
• Modellauswahl: Wähle ein geeignetes Modell für die Zeitreihenanalyse. Dies könnte ein ARIMA-Modell, ein LSTM-Modell oder ein anderer Ansatz sein.
• Modelltraining: Trainiere das Modell mit den vorbereiteten Daten.
• Modellvalidierung: Überprüfe die Vorhersagefähigkeit des Modells mit den Testdaten.
• Modellanwendung: Nutze das trainierte Modell, um die Verkaufszahlen für die nächsten 4 Wochen vorherzusagen.

Nun, führen wir diese Schritte in Python durch. Wir werden die Bibliothek scikit-learn verwenden:Code:

```pythonimport pandas as pdimport numpy as npfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import StandardScalerfrom sklearn.ensemble import RandomForestRegressorimport matplotlib.pyplot as plt# Beispiel-Datensatz erstellen (Dieser Schritt entfällt, wenn echte Daten vorliegen)dates = pd.date_range('2021-01-01', periods=100, freq='W')sales = np.random.randint(100, 200, size=(100,))data = pd.DataFrame({'Date': dates, 'Sales': sales})data.set_index('Date', inplace=True)# Daten visualisierenplt.figure(figsize=(10, 6))plt.plot(data.index, data['Sales'])plt.title('Verkaufszahlen über die Zeit')plt.xlabel('Datum')plt.ylabel('Verkaufszahlen')plt.show()# Merkmale erstellendata['WeekOfYear'] = data.index.week# Daten aufteilenX = data[['WeekOfYear']]y = data['Sales']X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# Standardisierung der Merkmalescaler = StandardScaler()X_train_scaled = scaler.fit_transform(X_train)X_test_scaled = scaler.transform(X_test)# Modell erstellen und trainierenmodel = RandomForestRegressor(n_estimators=100, random_state=0)model.fit(X_train_scaled, y_train)# Vorhersagen treffeny_pred = model.predict(X_test_scaled)# Ergebnisse visualisierenplt.figure(figsize=(10, 6))plt.plot(y_test.values, label='Wahre Verkaufszahlen')plt.plot(y_pred, label='Vorhergesagte Verkaufszahlen', linestyle='--')plt.title('Wahre vs. vorhergesagte Verkaufszahlen')plt.xlabel('Beobachtungen')plt.ylabel('Verkaufszahlen')plt.legend()plt.show()# Vorhersagen für die nächsten 4 Wochendaten_fuer_vorhersage = pd.DataFrame({'WeekOfYear': [52, 1, 2, 3]})daten_fuer_vorhersage_scaled = scaler.transform(daten_fuer_vorhersage)vorhersagen = model.predict(daten_fuer_vorhersage_scaled)print('Vorhersagen für die nächsten 4 Wochen:', vorhersagen)```

• Visualisierung: Es wurde eine Visualisierung der echten und vorhergesagten Verkaufszahlen erstellt, um die Leistung des Modells zu überprüfen.
• Vorhersagen: Schließlich wurden Vorhersagen für die Verkaufszahlen in den nächsten 4 Wochen getroffen.

Dieser Ansatz kann weiter verfeinert werden, indem komplexere Modelle angewendet und zusätzliche Merkmale für die Verbesserung der Vorhersagegenauigkeit integriert werden.

b)

Nachdem das Modell trainiert ist, evaluiere dessen Leistungsfähigkeit. Nutze hierzu geeignete Leistungsmetriken wie MSE (Mean Squared Error) oder MAE (Mean Absolute Error). Berechne die Leistungswerte und interpretiere sie.

Lösung:

Maschinelles Lernen für ZeitreihenanalyseNachdem das Modell trainiert wurde, ist es wichtig, dessen Leistungsfähigkeit zu evaluieren. Dies ermöglichen uns geeignete Leistungsmetriken wie MSE (Mean Squared Error) und MAE (Mean Absolute Error). Diese Metriken helfen uns zu verstehen, wie genau unser Modell die Verkaufszahlen vorhersagt.

• Mean Squared Error (MSE): Der MSE ist der durchschnittliche quadrierte Unterschied zwischen den vorhergesagten Werten und den tatsächlichen Werten. Ein niedrigerer MSE-Wert deutet auf bessere Vorhersagen hin.Formel: \[ \text{MSE} = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y_i})^2 \]
• Mean Absolute Error (MAE): Der MAE ist der durchschnittliche absolute Unterschied zwischen den vorhergesagten Werten und den tatsächlichen Werten. Ein niedrigerer MAE-Wert zeigt ebenfalls eine höhere Vorhersagegenauigkeit an.Formel: \[ \text{MAE} = \frac{1}{n} \sum_{i=1}^{n} |y_i - \hat{y_i}| \]

Wir werden nun den MSE und MAE mit Python berechnen und die Ergebnisse interpretieren.Code:

```pythonimport pandas as pdimport numpy as npfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import StandardScalerfrom sklearn.ensemble import RandomForestRegressorfrom sklearn.metrics import mean_squared_error, mean_absolute_errorimport matplotlib.pyplot as plt# Beispiel-Datensatz erstellen (Dieser Schritt entfällt, wenn echte Daten vorhanden sind)dates = pd.date_range('2021-01-01', periods=100, freq='W')sales = np.random.randint(100, 200, size=(100,))data = pd.DataFrame({'Date': dates, 'Sales': sales})data.set_index('Date', inplace=True)# Merkmale erstellendata['WeekOfYear'] = data.index.isocalendar().week# Daten aufteilenX = data[['WeekOfYear']]y = data['Sales']X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# Standardisierung der Merkmalescaler = StandardScaler()X_train_scaled = scaler.fit_transform(X_train)X_test_scaled = scaler.transform(X_test)# Modell erstellen und trainierenmodel = RandomForestRegressor(n_estimators=100, random_state=0)model.fit(X_train_scaled, y_train)# Vorhersagen treffeny_pred = model.predict(X_test_scaled)# MSE und MAE berechnenmse = mean_squared_error(y_test, y_pred)mae = mean_absolute_error(y_test, y_pred)print('Mean Squared Error:', mse)print('Mean Absolute Error:', mae)# Ergebnisse visualisierenplt.figure(figsize=(10, 6))plt.plot(y_test.values, label='Wahre Verkaufszahlen')plt.plot(y_pred, label='Vorhergesagte Verkaufszahlen', linestyle='--')plt.title('Wahre vs. vorhergesagte Verkaufszahlen')plt.xlabel('Beobachtungen')plt.ylabel('Verkaufszahlen')plt.legend()plt.show()```

• MSE und MAE berechnen: Der obige Code berechnet die MSE und MAE Werte für die Vorhersagen des Modells. Diese Metriken geben uns einen quantitativen Einblick in die Genauigkeit des Modells.
• Interpretation: Angenommen, wir erhalten die folgenden Ergebnisse:
  • Mean Squared Error (MSE): 150.5
  • Mean Absolute Error (MAE): 10.2
  Ein niedriger MSE-Wert deutet darauf hin, dass die quadratische Abweichung der Vorhersagen von den tatsächlichen Werten gering ist. Ein niedriger MAE-Wert bedeutet, dass die Vorhersagen im Durchschnitt um 10.2 Einheiten von den tatsächlichen Verkaufszahlen abweichen. Dies zeigt, dass das Modell eine gute Vorhersagegenauigkeit besitzt. Natürlich können weitere Verbesserungen durch Modelloptimierung und Hinzufügen zusätzlicher Merkmale erreicht werden.

Mit diesen Evaluierungsmetriken können wir abschätzen, wie gut unser Modell die Verkaufszahlen vorhersagt, und verschiedene Modelle vergleichen, um das bestmögliche für unsere Zeitreihenanalyse auszuwählen.

c)

Wechsle nun zu einem unüberwachten Lernverfahren. Verwende den selben Datensatz, jedoch entferne die Labels (Verkaufszahlen). Führe eine Clusteranalyse durch, um ähnliche Wochen zu identifizieren (z.B. K-Means Clustering). Beschreibe das Vorgehen und stelle sicher, dass die gewählte Anzahl der Cluster begründet ist.

Lösung:

Maschinelles Lernen für ZeitreihenanalyseNachdem wir zuvor ein überwachtes Lernverfahren verwendet haben, wechseln wir nun zu einem unüberwachten Verfahren. Wir führen eine Clusteranalyse durch, um ähnliche Wochen in den Zeitreihendaten zu identifizieren. Dazu verwenden wir den K-Means Clustering-Algorithmus. Hier ist das genaue Vorgehen:

• Datenvorbereitung: Entferne die Labels (Verkaufszahlen) aus dem Datensatz. Bereite die Daten für die Clusteranalyse vor, indem Du nur die Merkmale behältst.
• Merkmalsextraktion: Extrahiere relevante Merkmale für die Clusteranalyse. In diesem Fall verwenden wir die Kalenderwochen und andere zeitbezogene Merkmale.
• Standardisierung: Wende eine Standardisierung auf die Merkmale an, um sicherzustellen, dass alle Merkmale gleichgewichtig in die Analyse eingehen.
• Anzahl der Cluster bestimmen: Bestimme die geeignete Anzahl der Cluster. Dies kann durch die Verwendung des Elbow-Method durchgeführt werden, die den Punkt identifiziert, bei dem die Sum of Squared Distances (SSD) nicht mehr signifikant abnimmt.
• K-Means Clustering: Führe die K-Means Clusteranalyse durch.
• Cluster interpretieren: Interpretiere die resultierenden Cluster, um ähnliche Wochen zu identifizieren.

Hier ist der Python-Code, der diese Schritte implementiert:Code:

```pythonimport pandas as pdimport numpy as npfrom sklearn.preprocessing import StandardScalerfrom sklearn.cluster import KMeansimport matplotlib.pyplot as plt# Beispiel-Datensatz erstellen (Dieser Schritt entfällt, wenn echte Daten vorhanden sind)dates = pd.date_range('2021-01-01', periods=100, freq='W')sales = np.random.randint(100, 200, size=(100,))data = pd.DataFrame({'Date': dates, 'Sales': sales})data.set_index('Date', inplace=True)# Merkmale erstellendata['WeekOfYear'] = data.index.isocalendar().week# Labels entfernen (Verkaufszahlen)X = data[['WeekOfYear']]# Standardisierung der Merkmalescaler = StandardScaler()X_scaled = scaler.fit_transform(X)# Bestimmung der Anzahl der Cluster mit der Elbow-Methodssd = []for k in range(1, 11):    kmeans = KMeans(n_clusters=k, random_state=0)    kmeans.fit(X_scaled)    ssd.append(kmeans.inertia_)# Elbow Plotplt.figure(figsize=(10, 6))plt.plot(range(1, 11), ssd, marker='o')plt.title('Elbow Plot zur Bestimmung der optimalen Clusteranzahl')plt.xlabel('Anzahl der Cluster')plt.ylabel('Sum of Squared Distances (SSD)')plt.show()# Durchführung des K-Means Clustering (Wir nehmen hier die Anzahl der Cluster aus der Elbow-Method an, z.B. 3)kmeans = KMeans(n_clusters=3, random_state=0)clusters = kmeans.fit_predict(X_scaled)# Ergebnisse zum Datensatz hinzufügendata['Cluster'] = clusters# Interpretation der Clusterplt.figure(figsize=(10, 6))plt.scatter(data.index, [1] * len(data), c=data['Cluster'], cmap='viridis')plt.title('Clusteridentifikation über Wochen')plt.xlabel('Datum')plt.ylabel('Cluster')plt.show()```

• Anzahl der Cluster bestimmen: Die Elbow-Method wird verwendet, um die optimale Anzahl der Cluster zu bestimmen. Der Punkt, bei dem die Abnahme der Sum of Squared Distances (SSD) signifikant abflacht, wird als geeignete Zahl der Cluster gewählt.
• K-Means Clustering: Der K-Means Algorithmus wird mit der bestimmten Anzahl der Cluster durchgeführt. Hier nehmen wir an, dass die Elbow-Method drei Cluster nahelegt.
• Cluster visualisieren: Die resultierenden Cluster werden visualisiert, wobei ähnliche Wochen durch dieselbe Farbe gekennzeichnet sind.

Durch diese Analyse können wir Wochen mit ähnlichen Mustern identifizieren. Solche Informationen sind nützlich, um saisonale Trends und Muster im Zeitreihenverlauf besser zu verstehen.

d)

Zum Abschluss: Analysiere eine mögliche Anwendung der Clusterergebnisse (aus Teilaufgabe 3). Wie könnten diese Informationen genutzt werden, um Geschäftsentscheidungen zu treffen oder um Marketingstrategien zu optimieren?

Lösung:

Maschinelles Lernen für ZeitreihenanalyseIm letzten Schritt analysieren wir, wie die Clusterergebnisse, die wir durch K-Means Clustering erhalten haben, genutzt werden können, um Geschäftsentscheidungen zu treffen oder Marketingstrategien zu optimieren.

• Saisonale Muster und Trends erkennen: Durch die Identifikation ähnlicher Wochen können Muster und Trends in den Verkaufszahlen im Jahresverlauf erkannt werden. Zum Beispiel können bestimmte Cluster Wochen mit hohen Verkaufszahlen während der Feiertage repräsentieren. Unternehmen können diese Informationen nutzen, um saisonale Vorbereitungen zu optimieren, z.B. durch Erhöhung der Lagerbestände oder Verstärkung der Marketingmaßnahmen.
• Zielgruppenorientiertes Marketing: Die Clusteranalyse kann helfen, Zielgruppen für Marketingkampagnen genauer zu definieren. Beispielsweise könnten bestimmte Wochen des Jahres spezifische Konsumvorlieben oder Kaufverhalten aufweisen. Unternehmen können gezielte Werbekampagnen basierend auf diesen Erkenntnissen entwerfen, um die Kundenregelmäßigkeit zu erhöhen.
• Angebots- und Preisstrategien: Unternehmen können ihre Angebots- und Preisstrategien an die identifizierten Muster anpassen. Wenn bestimmte Cluster Wochen mit höheren Verkaufszahlen ausmachen, können Sonderangebote oder Rabatte gezielt in schwächeren Wochen eingeführt werden, um den Absatz zu steigern.
• Durch das Verständnis der saisonalen Nachfrage können Unternehmen effizienter planen und ihre Ressourcen besser verwalten. Dies umfasst die Optimierung der Logistik, Personalplanung und Lagerhaltung. Beispielsweise können mehr Mitarbeiter in Wochen mit erwarteten höheren Verkaufszahlen eingesetzt werden.
• Produktentwicklung: Die Informationen aus der Clusteranalyse können zur Produktentwicklung beitragen. Wenn bestimmte Produkttypen während bestimmter Wochen beliebter sind, kann das Unternehmen neue Produkte entwickeln oder bestehende anpassen, um den Kundenanforderungen besser gerecht zu werden.

Zusammenfassend können die aus der Clusteranalyse gewonnenen Informationen vielfältig genutzt werden, um Geschäftsentscheidungen zu treffen und Marketingstrategien zu optimieren. Diese analytischen Einblicke unterstützen Unternehmen dabei, sich an die dynamischen Bedürfnisse der Verbraucher anzupassen und wettbewerbsfähig zu bleiben.

Aufgabe 2)

Betrachte eine Zeitreihe \(X_t\) mit folgendem Verlauf:

• Der Mittelwert der Zeitreihe ändert sich im Verlauf der Zeit.
• Es treten klare saisonale Muster alle 12 Zeiteinheiten auf.
• Die Varianz scheint konstant zu sein.

Deine Aufgabe ist es, diese Zeitreihe hinsichtlich der Stationarität zu analysieren und geeignete Maßnahmen zu ergreifen.

a)

Führe den Augmented-Dickey-Fuller (ADF) Test durch und interpretiere das Ergebnis. Was sagt das Testergebnis über die Stationarität der Zeitreihe aus?

from statsmodels.tsa.stattools import adfulleradf_test = adfuller(X_t)print('ADF Test Statistic:', adf_test[0])print('p-value:', adf_test[1])for key, value in adf_test[4].items():    print('Critial Values:')    print(f'    {key}, {value}')

Lösung:

Um den Augmented-Dickey-Fuller (ADF) Test durchzuführen und das Ergebnis zu interpretieren, kannst Du den folgenden Python-Code verwenden:

from statsmodels.tsa.stattools import adfuller

# Angenommen, X_t ist Deine Zeitreihe import adfuller 

adf_test = adfuller(X_t) 

print('ADF Test Statistic:', adf_test[0])

print('p-value:', adf_test[1])

for key, value in adf_test[4].items():

   print('Critial Values:')

   print(f'    {key}, {value}')

Schritt-für-Schritt-Interpretation:

• ADF Test Statistic: Wenn der Teststatistik-Wert niedriger als die kritischen Werte auf verschiedenen Signifikanzniveaus (1%, 5%, 10%) ist, weist dies auf eine Stationarität hin.
• p-value: Eine p-Wert kleiner als ein bestimmtes Signifikanzniveau (z. B. 0,05) deutet darauf hin, dass die Nullhypothese (es gibt eine Einheitswurzel oder die Zeitreihe ist nicht stationär) abgelehnt werden kann.
• Kritische Werte: Die kritischen Werte ermöglichen Dir den Vergleich mit der ADF-Teststatistik, um zu bestimmen, ob die Zeitreihe stationär ist.

Beispielinterpretation:

Nehmen wir an, die Ausgabe des Codes zeigt Folgendes:

ADF Test Statistic: -3.45

p-value: 0.01

Critial Values:

    1%, -3.43

    5%, -2.86

    10%, -2.57

Da der ADF Test Statistic (-3.45) niedriger als die kritischen Werte bei allen angegebenen Signifikanzniveaus ist und der p-Wert (0.01) kleiner als 0.05 ist, können wir schlussfolgern, dass die Zeitreihe stationär ist.

b)

Transformiere die Zeitreihe \(X_t\) durch differenzieren und Entfernen der Saisonalitäten, um die Zeitreihe stationär zu machen. Zeige mathematisch die Vorgehensweise und erkläre jeden Schritt. Berechne die erste Differenzierung \(Y_t = X_t - X_{t-1}\) und entferne die saisonale Komponente.Nachdem Du die Zeitreihe transformiert hast, berechne erneut den ADF-Test und interpretiere das Ergebnis.Hinweis: Die saisonale Komponente beträgt 12 Zeiteinheiten. Formel zur Entfernung der saisonalen Komponente: \(Z_t = Y_t - Y_{t-12}\).

Lösung:

Um die Zeitreihe \(X_t\) stationär zu machen, führen wir die folgenden zwei Schritte aus: Differenzieren und Entfernen der saisonalen Komponente. Danach führen wir erneut den Augmented-Dickey-Fuller (ADF) Test durch.Hier ist die mathematische Vorgehensweise:

1. Erste Differenzierung:

Die erste Differenzierung der Zeitreihe wird durch die folgende Formel berechnet:

\(Y_t = X_t - X_{t-1}\)

2. Entfernen der saisonalen Komponente:

Da die saisonale Komponente alle 12 Zeiteinheiten auftritt, entfernen wir sie wie folgt:

\(Z_t = Y_t - Y_{t-12}\)

Schritt-für-Schritt Erklärung:

• Erste Differenzierung: Wir erstellen eine neue Zeitreihe \(Y_t\), indem wir den aktuellen Wert \(X_t\) der ursprünglichen Zeitreihe \(X_t\) den vorherigen Wert \(X_{t-1}\) abziehen:
• Entfernung der saisonalen Komponente: Anschließend erstellen wir eine weitere neue Zeitreihe \(Z_t\), indem wir von \(Y_t\) (der differenzierten Zeitreihe) den Wert vor 12 Zeiteinheiten abziehen (\(Y_{t-12}\)).

Implementierung in Python:

import numpy as np

# Angenommen, X_t ist das ursprüngliche Zeitreihen-DatenarrayX_t = np.array(...)

# Erstes DifferenzierenY_t = np.diff(X_t, n=1)

# Entfernen der saisonalen KomponenteZ_t = Y_t[12:] - Y_t[:-12]

Berechnung des ADF-Tests auf der transformierten Zeitreihe \(Z_t\):

from statsmodels.tsa.stattools import adfuller

adf_test = adfuller(Z_t)

print('ADF Test Statistic:', adf_test[0])

print('p-value:', adf_test[1])

for key, value in adf_test[4].items():

   print('Critical Values:')

   print(f'    {key}, {value}')

Interpretation des Ergebnisses:

Die Interpretation erfolgt genauso wie im vorigen Schritt:

• ADF Test Statistic: Wenn der Teststatistik-Wert niedriger als die kritischen Werte auf verschiedenen Signifikanzniveaus (1%, 5%, 10%) ist, weist dies auf eine Stationarität hin.
• p-value: Ein p-Wert kleiner als ein bestimmtes Signifikanzniveau (z. B. 0,05) deutet darauf hin, dass die Nullhypothese (es gibt eine Einheitswurzel oder die Zeitreihe ist nicht stationär) abgelehnt werden kann.
• Kritische Werte: Die kritischen Werte ermöglichen Dir den Vergleich mit der ADF-Teststatistik, um zu bestimmen, ob die Zeitreihe stationär ist.

Beispielinterpretation:

Nehmen wir an, die Ausgabe des Codes zeigt Folgendes:

ADF Test Statistic: -4.23

p-value: 0.003

Critical Values:

    1%, -3.50

    5%, -2.89

    10%, -2.58

Da der ADF Test Statistic (-4.23) niedriger als die kritischen Werte bei allen angegebenen Signifikanzniveaus ist und der p-Wert (0.003) kleiner als 0.05 ist, können wir schlussfolgern, dass die transformierte Zeitreihe stationär ist.

Aufgabe 3)

Gegeben ist eine Zeitreihe, von der bekannt ist, dass sie nicht stationär ist und stationär gemacht werden muss, bevor ein Modell angewendet werden kann. Verwende ein ARIMA-Modell zur Analyse und Vorhersage dieser Zeitreihe. Bestimme die geeigneten Parameter (p, d, q) und passe das Modell auf die Daten an. Verwende dazu die folgenden Schritte:

a)

Bestimme die notwendige Anzahl der Differenzierungen (d), um die Zeitreihe stationär zu machen. Erstelle einen Plot der Originalzeitreihe und der differenzierten Zeitreihe, bevor und nachdem die Differenzierung angewendet wurde. Begründe Deine Wahl der Anzahl d durch visuelle Inspektion und möglicherweise durch Anwendung statistischer Tests zur Überprüfung der Stationarität.

Lösung:

Analyse der Zeitreihe und Bestimmung der Anzahl der Differenzierungen (d)

Um die Zeitreihe stationär zu machen, führen wir die folgende Schritte durch:

• Schritt 1: Originalzeitreihe plotten
• Schritt 2: Differenzierte Zeitreihe plotten
• Schritt 3: Stationarität überprüfen und die notwendige Anzahl der Differenzierungen (d) bestimmen

Originalzeitreihe plotten

Wir visualisieren zunächst die Originalzeitreihe, um ihre Struktur und Muster zu verstehen.

import matplotlib.pyplot as pltimport pandas as pd# Beispiel-Zeitreihe Daten laden# Zeitreihe ist in einer CSV-Datei gespeichertzeitreihe = pd.read_csv('zeitreihe.csv')# Plot der Originalzeitreiheplt.figure(figsize=(10, 6))plt.plot(zeitreihe)plt.title('Originalzeitreihe')plt.xlabel('Zeit')plt.ylabel('Wert')plt.show()

Differenzierte Zeitreihe plotten

Als nächstes führen wir Differenzierungen durch und plotten die differenzierten Zeitreihen, um zu beurteilen, ob sie stationär sind.

# Einfache Differenzierung der Zeitreihedifferenzierte_zeitreihe = zeitreihe.diff().dropna()# Plot der differenzierten Zeitreiheplt.figure(figsize=(10, 6))plt.plot(differenzierte_zeitreihe)plt.title('Differenzierte Zeitreihe (d=1)')plt.xlabel('Zeit')plt.ylabel('Differenzwert')plt.show()

Stationarität überprüfen

Wir verwenden den ADF-Test (Augmented Dickey-Fuller-Test), um die Stationarität der differenzierten Zeitreihe zu überprüfen. Wenn der p-Wert des Tests unter einem bestimmten Schwellenwert liegt (z. B. 0.05), kann die Zeitreihe als stationär betrachtet werden.

from statsmodels.tsa.stattools import adfuller# ADF-Test auf der einfachen differenzierten Zeitreiheresult = adfuller(differenzierte_zeitreihe)print('ADF-Statistik:', result[0])print('p-Wert:', result[1])# Überprüfung, ob die Zeitreihe stationär istif result[1] < 0.05:    print('Die Zeitreihe ist stationär (d=1).')else:    print('Die Zeitreihe ist nicht stationär, weitere Differenzierung erforderlich.')

Wenn die Zeitreihe nach der ersten Differenzierung nicht stationär ist, wiederholen wir den Prozess mit einer zweiten Differenzierung (d=2).

# Zweifache Differenzierung der Zeitreihedifferenzierte_zeitreihe_2 = differenzierte_zeitreihe.diff().dropna()# Plot der zweifach differenzierten Zeitreiheplt.figure(figsize=(10, 6))plt.plot(differenzierte_zeitreihe_2)plt.title('Zweifach differenzierte Zeitreihe (d=2)')plt.xlabel('Zeit')plt.ylabel('Differenzwert')plt.show()# ADF-Test auf der zweifach differenzierten Zeitreiheresult_2 = adfuller(differenzierte_zeitreihe_2)print('ADF-Statistik:', result_2[0])print('p-Wert:', result_2[1])# Überprüfung, ob die Zeitreihe stationär istif result_2[1] < 0.05:    print('Die Zeitreihe ist stationär (d=2).')else:    print('Die Zeitreihe ist nicht stationär, weitere Differenzierung erforderlich.')

Begründung: Die Anzahl der Differenzierungen (d) wird durch visuelle Inspektion der differenzierten Zeitreihen und durch Anwendung des ADF-Tests bestimmt. Eine stationäre Zeitreihe weist keine Trends oder saisonale Muster mehr auf und hat konstante statistische Eigenschaften im Zeitverlauf. Wenn der p-Wert des ADF-Tests unter 0.05 liegt, ist die Zeitreihe stationär.

b)

Identifiziere die Parameter p und q des ARIMA-Modells. Verwende dazu die Autokorrelationsfunktion (ACF) und die partielle Autokorrelationsfunktion (PACF). Erstelle die zugehörigen Plots und erkläre, wie Du auf die Werte für p und q durch Analyse dieser Plots gekommen bist. Begründe gegebenenfalls mit den Akaike-Informationskriterium (AIC) oder dem Bayesschen Informationskriterium (BIC).

Lösung:

Identifikation der Parameter p und q des ARIMA-Modells

Um die geeigneten Parameter (p und q) des ARIMA-Modells zu identifizieren, verwenden wir die Autokorrelationsfunktion (ACF) und die partielle Autokorrelationsfunktion (PACF). Die Schritte sind wie folgt:

• Schritt 1: Plot der ACF der stationären Zeitreihe
• Schritt 2: Plot der PACF der stationären Zeitreihe
• Schritt 3: Analyse der ACF- und PACF-Plots zur Bestimmung von p und q

Schritt 1: Plot der ACF

Zuerst berechnen und plotten wir die ACF der stationären Zeitreihe, um den Parameter q zu bestimmen.

import matplotlib.pyplot as plt import pandas as pd from statsmodels.graphics.tsaplots import plot_acf # Annahme: 'differenzierte_zeitreihe' ist die stationäre Zeitreihe aus der vorherigen Aufgabe # Plot der ACF plt.figure(figsize=(10, 6)) plot_acf(differenzierte_zeitreihe, lags=40) plt.title('Autokorrelationsfunktion (ACF)') plt.xlabel('Lags') plt.ylabel('Autokorrelation') plt.show() 

Schritt 2: Plot der PACF

Als nächstes berechnen und plotten wir die PACF der stationären Zeitreihe, um den Parameter p zu bestimmen.

from statsmodels.graphics.tsaplots import plot_pacf # Plot der PACF plt.figure(figsize=(10, 6)) plot_pacf(differenzierte_zeitreihe, lags=40) plt.title('Partielle Autokorrelationsfunktion (PACF)') plt.xlabel('Lags') plt.ylabel('Partielle Autokorrelation') plt.show() 

Schritt 3: Analyse der ACF- und PACF-Plots

• Bestimmung von q: Der Wert von q wird durch die Lag-Anzahl bestimmt, bei der die ACF das erste Mal (signifikant) aufhört, von null unterschiedlich zu sein. Ein signifikanter Lag liegt normalerweise innerhalb der 95%-Konfidenzgrenzen.
• Bestimmung von p: Der Wert von p wird durch die Lag-Anzahl bestimmt, bei der die PACF das erste Mal (signifikant) aufhört, von null unterschiedlich zu sein.

Begründung durch AIC und BIC

Zusätzlich zur visuellen Analyse der ACF- und PACF-Plots können wir AIC (Akaike-Informationskriterium) und BIC (Bayessches Informationskriterium) verwenden, um das ARIMA-Modell mit den niedrigsten Werten dieser Kriterien zu identifizieren. Niedrigere Werte von AIC und BIC deuten auf ein besser passendes Modell hin.

from statsmodels.tsa.arima.model import ARIMA from statsmodels.tsa.stattools import arma_order_select_ic # Testen verschiedener (p,q)-Kombinationen und Ermittlung der besten# Parameterkombination auf Basis von AIC und BIC results = arma_order_select_ic(differenzierte_zeitreihe, max_ar=5, max_ma=5, ic=['aic', 'bic'])print('Beste (p,q)-Kombination basierend auf AIC:', results.aic_min_order) print('Beste (p,q)-Kombination basierend auf BIC:', results.bic_min_order) 

Zusammenfassend verwenden wir die ACF und PACF zur initialen Abschätzung von p und q und verfeinern unsere Auswahl gegebenenfalls durch AIC und BIC.

c)

Schätze die Parameter des ARIMA-Modells mit der Maximum-Likelihood Methode und überprüfe die Anpassung des Modells. Führe eine Residualanalyse durch und überprüfe die Residuen mit dem Ljung-Box-Test, um die Modelladäquanz zu bestätigen. Stelle sicher, dass die Residuen weißes Rauschen sind und beschreibe Deine Schritte und Ergebnisse detailliert.

Lösung:

Schätzung der Parameter des ARIMA-Modells und Residualanalyse

Nachdem die Parameter (p, d, q) des ARIMA-Modells bestimmt wurden, führen wir die folgenden Schritte durch:

• Schritt 1: Parameter des ARIMA-Modells mit der Maximum-Likelihood Methode schätzen
• Schritt 2: Anpassung des Modells überprüfen
• Schritt 3: Residualanalyse durchführen
• Schritt 4: Ljung-Box-Test durchführen

Schritt 1: Parameterschätzung

Zuerst passen wir das ARIMA-Modell mit den bestimmten Parametern (p, d, q) an die stationäre Zeitreihe an.

import pandas as pd from statsmodels.tsa.arima.model import ARIMA # Annahme: 'differenzierte_zeitreihe' ist die stationäre Zeitreihe aus den vorherigen Aufgaben # Bestimme die Parameter p, d und q (z.B. durch AIC/BIC) p, d, q = 2, 1, 2 # ARIMA-Modell anpassen modell = ARIMA(differenzierte_zeitreihe, order=(p, d, q)) result = modell.fit() # Modellzusammenfassung anzeigen print(result.summary()) 

Schritt 2: Überprüfung der Modellanpassung

Wir überprüfen die Anpassung des Modells durch die Betrachtung der Modellzusammenfassung und der AIC/BIC-Werte.

print('AIC:', result.aic) print('BIC:', result.bic) 

Niedrigere Werte deuten auf eine bessere Anpassung hin. Zusätzliche Indikatoren der Anpassungsqualität sind die statistischen Signifikanzen der Parameter, die in der Zusammenfassung angezeigt werden.

Schritt 3: Residualanalyse

Die Residualanalyse umfasst die Prüfung, ob die Residuen des Modells wie weißes Rauschen verteilt sind.

# Residuen extrahieren residuen = result.resid # Plot der Residuen plt.figure(figsize=(10, 6)) plt.plot(residuen) plt.title('Residuen des ARIMA-Modells') plt.xlabel('Zeit') plt.ylabel('Residuen') plt.show() # ACF der Residuen plotten plt.figure(figsize=(10, 6)) plot_acf(residuen, lags=40) plt.title('ACF der Residuen') plt.xlabel('Lags') plt.ylabel('Autokorrelation') plt.show() 

Schritt 4: Ljung-Box-Test

Der Ljung-Box-Test hilft uns zu überprüfen, ob die Residuen keine Autokorrelationen aufweisen und somit wie weißes Rauschen verteilt sind.

from statsmodels.stats.diagnostic import acorr_ljungbox # Ljung-Box-Test auf die Residuen anwenden lb_test = acorr_ljungbox(residuen, lags=[20], return_df=True) print(lb_test) 

Ergebnisse: Der p-Wert des Ljung-Box-Tests sollte über einem bestimmten Schwellenwert (z.B. 0.05) liegen, was darauf hinweist, dass keine signifikanten Autokorrelationen vorhanden sind und die Residuen somit wie weißes Rauschen verteilt sind.

Schritte und Ergebnisse zusammengefasst:

• Das ARIMA-Modell wurde mit der Maximum-Likelihood Methode angepasst.
• Durch Betrachtung der AIC/BIC-Werte und der Modellzusammenfassung wurde die Anpassung des Modells überprüft.
• Eine Residualanalyse wurde durchgeführt, die die Residuen des Modells visualisierte und deren Autokorrelationsfunktion zeigte.
• Der Ljung-Box-Test wurde verwendet, um die Modelladäquanz zu bestätigen. Der Test zeigte, dass die Residuen wie weißes Rauschen verteilt sind.

Aufgabe 4)

Gegeben ist eine Zeitreihe Y_t mit t = 1, 2, ..., n. Nehmen wir an, wir wollen die Eigenschaften dieser Zeitreihe untersuchen, insbesondere durch die Berechnung der Autokorrelationsfunktion (ACF) und der Partial-Autokorrelationsfunktion (PACF). Die ACF ist definiert als:

• \[\rho_k = \frac{\sum_{t=k+1}^{n} (Y_t - \bar{Y})(Y_{t-k} - \bar{Y})}{\sum_{t=1}^{n} (Y_t - \bar{Y})^2}\]
• Hierbei beschreibt \(Y\) die Zeitreihe und \(k\) den Lag.

Die PACF ist definiert durch:

• \[\rho_{k,k} = Corr(Y_t, Y_{t-k} | Y_{t-1}, Y_{t-2}, \ldots, Y_{t-k+1})\]

Beide Funktionen sind essenziell für die Modellidentifikation in ARIMA-Modellen und anderen Zeitreihenmodellen. Ziel ist es, die Eigenschaften der gegebenen Zeitreihe zu analysieren und zu interpretieren.

a)

Berechne die Autokorrelationsfunktion (ACF) für eine gegebenen Zeitreihe Y, die wie folgt aussieht:

• Y₁ = 2,
• Y₂ = 4,
• Y₃ = 6,
• Y₄ = 8,
• Y₅ = 10.

Berechne die Autokorrelation für Lag 1 und Lag 2. Zeige alle Rechenschritte.

Lösung:

Um die Autokorrelationsfunktion (ACF) für die gegebene Zeitreihe Y zu berechnen, müssen wir wie folgt vorgehen:

• 1. Schritt: Mittelwert berechnen Zuerst berechnen wir den Mittelwert (\(\bar{Y}\)) der Zeitreihe. Die Zeitreihe ist gegeben als:

• Y₁ = 2,
• Y₂ = 4,
• Y₃ = 6,
• Y₄ = 8,
• Y₅ = 10.

• Der Mittelwert ist:

\[ \bar{Y} = \frac{1}{5} \times (2 + 4 + 6 + 8 + 10) = \frac{30}{5} = 6 \]

• 2. Schritt: Summe der Quadrate der Abweichungen vom Mittelwert berechnen Wir berechnen die Summe:

\[ \text{Sum}_{S} = \sum_{t=1}^{n} (Y_t - \bar{Y})^2 = (2-6)^2 + (4-6)^2 + (6-6)^2 + (8-6)^2 + (10-6)^2 \] \[ = (-4)^2 + (-2)^2 + (0)^2 + (2)^2 + (4)^2 \] \[ = 16 + 4 + 0 + 4 + 16 = 40 \]

• 3. Schritt: Berechnung der Autokorrelation für Lag 1 (\(k = 1\))

• Für Lag 1 lautet die Formel: \(\rho_1 = \frac{\sum_{t=2}^{n} (Y_t - \bar{Y})(Y_{t-1} - \bar{Y})}{\text{Sum}_{S}}\)

• Berechnung:

\[ \rho_1 = \frac{(4-6)(2-6) + (6-6)(4-6) + (8-6)(6-6) + (10-6)(8-6)}{40} \] \[ = \frac{(-2)(-4) + (0)(-2) + (2)(0) + (4)(2)}{40} \] \[ = \frac{8 + 0 + 0 + 8}{40} = \frac{16}{40} = 0.4 \]

• 4. Schritt: Berechnung der Autokorrelation für Lag 2 (\(k = 2\))

• Für Lag 2 lautet die Formel: \(\rho_2 = \frac{\sum_{t=3}^{n} (Y_t - \bar{Y})(Y_{t-2} - \bar{Y})}{\text{Sum}_{S}}\)

• Berechnung:

\[ \rho_2 = \frac{(6-6)(2-6) + (8-6)(4-6) + (10-6)(6-6)}{40} \] \[ = \frac{(0)(-4) + (2)(-2) + (4)(0)}{40} \] \[ = \frac{0 - 4 + 0}{40} = \frac{-4}{40} = -0.1 \]

• Die berechneten Autokorrelationen lauten also:
• Lag 1: \( \rho_1 = 0.4 \)
• Lag 2: \( \rho_2 = -0.1 \)

b)

Betrachte dieselbe Zeitreihe Y, und berechne die Partial-Autokorrelationsfunktion (PACF) für Lag 1 und Lag 2. Beschreibe, wie die PACF dabei hilft, die signifikantesten Verzögerungen im Vergleich zur ACF zu bestimmen.

Lösung:

Um die Partial-Autokorrelationsfunktion (PACF) für die gegebene Zeitreihe Y zu berechnen, folgen wir diesen Schritten:

• Teilweise suchen wir nach der Korrelation zwischen Y_t und Y_t-k, wobei die Einflüsse aller Zwischenwerte Y_t-1, Y_t-2, ..., Y_t-k+1 entfernt werden.

Unsere Zeitreihe besteht aus folgenden Werten:

• Y₁ = 2,
• Y₂ = 4,
• Y₃ = 6,
• Y₄ = 8,
• Y₅ = 10.

Berechnung der PACF für Lag 1:

• Die PACF für Lag 1 ist einfach die ACF für Lag 1, da für k=1 kein Einfluss der Zwischenwerte entfernt werden muss.

• Erinnern wir uns daran, dass wir bereits berechnet haben: \( \rho_1 = 0.4 \)

• Also, \( \rho_{1,1} = 0.4 \).

Berechnung der PACF für Lag 2:

• Für die PACF bei Lag 2 müssen wir die Einflüsse von Lag 1 entfernen. Wir verwenden die Formel für die PACF:

• Die Berechnung der PACF für \( \rho_{2,2} \) beinhaltet die Berechnung der Korrelation zwischen Y_t und Y_t-2 nach Entfernung des Einflusses von Y_t-1.

• Formel für k = 2:

• \( \rho_{2,2} = \frac{\rho_2 - \rho_1 \cdot \rho_1}{1 - \rho_1^2} \)

• Mit \( \rho_1 = 0.4 \) und \( \rho_2 = -0.1 \), ergibt sich:

\[ \rho_{2,2} = \frac{-0.1 - (0.4 \cdot 0.4)}{1 - 0.4^2} = \frac{-0.1 - 0.16}{1 - 0.16} = \frac{-0.26}{0.84} \approx -0.3095 \]

• Also, \( \rho_{2,2} \approx -0.3095 \).

Vorteil der PACF gegenüber der ACF:

• Die ACF betrachtet die Korrelationen über verschiedene Lags hinweg, kann aber manchmal irreführend sein, wenn es um die Identifikation signifikanter Verzögerungen geht.
• Die PACF hingegen entfernt den Einfluss von Zwischenwerten und hilft somit besser dabei, die direkten Korrelationen zwischen einem Punkt und einem verzögerten Punkt zu identifizieren.
• Dies bedeutet, dass signifikante PACF-Werte auf bestimmte Lags schließen lassen können, die direkten Einfluss haben, ohne von anderen Lags beeinflusst zu werden. Das ist insbesondere nützlich für die Identifikation von AR-Modellen in ARIMA-Prozessen.

• Insgesamt zeigt die PACF auf, welche Lags eigenständig zur Vorhersage eines Punktes beitragen, ohne Überlappung von Einflüssen anderer Lags, die in der ACF nicht klar zu erkennen wären.