Zeitreihentypen (erstellt in Python)

Der erste Schritt in die Zeitreihenanalyse ist es, eine Typisierung von Zeitreihen vornehmen zu können und Grundbegriffe wie Trend, Saisonalität, Stationarität und Drift sicher zu beherschen. In diesem Beitrag werden Zeitreihen verschiedenen Typs erstellt und deren Verlauf visualisiert. Der Quellcode ist auf Lesbarkeit ausgerichtet, um die Formeln der Zeitreihen nachvollziehbar zu machen.

In [1]:
# Lade Ressourcen 
import pandas as pd
import random
import math

%matplotlib inline
In [2]:
# --- Globale Variable für die Simulationen
# Prozessgröße
n = 1000 

# Setze seed zur Reproduzierbarkeit
random.seed(42) 

# Erstelle Fehlerterm
error = [random.normalvariate(0,1) for i in range(n)] 

Random Walk mit normalverteiltem Wertezuwachs- / verlust

Ein Random Walk wird auch als stochastischer Prozess bezeichnet und ist rein zufallsbasiert. Seine Bewegung entsteht aus dem ersten Vergangenheitswert (dem ersten Lag) + Zufallszahl. In diesem Beispiel ist die Zufallszahl normalverteilt um den Mittelwert 0 mit der Standardabweichung 1.

Die explizite Multiplikation mit 1 dient lediglich zu Anschauung des sog. Unit Roots. Viele statistische Tests der Zeitreihenanalyse , wie beispielsweise der Dickey-Fuller Test, prüfen, ob ein Unit Root vorliegt – also ob der Term 1 ist und damit ein Random Walk vorliegt.

In [3]:
y = [0] * n
for i in range(1,n):
    y[i] = 1 * y[i-1] + random.normalvariate(0,1)

_ = pd.Series(y).plot(title="Random Walk mit normalverteiltem Wertezuwachs- / verlust")

Random Walk mit normalverteiltem Wertezuwachs-/ verlust + Drift

Per Definition sind Random Walks stochastische Prozesse und rein zufallsbasiert. Sie können jedoch trotzdem von einem deterministischen Trend überlagert werden. In diesem Beispiel Beträgt der Drift 0.1 – d.h. mit jedem Messwert erhöht sich der Wert des ersten Lags um den Wert 0.1. Durch den Zufallsterm random.normalvariate(0,1) ist die Zeitreihe jedoch nicht konstant steigend, sondern kann sich kurzfristig auch nach unten bewegen.

In [4]:
y = [0] * n
for i in range(1,n):
    y[i] = y[i-1] + random.normalvariate(0,1) + 0.1
    
_ = pd.Series(y).plot(title="Random Walk mit normalverteiltem Wertezuwachs-/ verlust + Drift")

Multiplikativer Prozess

Multiplikative Prozesse sind, wenn Sie über einen ausreichend langen Zeitraum beobachtet wurden, visuell einfach zu bestimmen. Sie bewegen sich mit exponentiellen Trend.

Jeder Faktor > 1 sorgt für einen exponentiellen Kurvenverlauf.

In [5]:
y = [0] * n
for i in range(1,n):
    y[i] = 1.005 * y[i-1] + random.normalvariate(0,1)
    
_ = pd.Series(y).plot(title="Multiplikativer Prozess")

Schwach stationärer Prozess

Eine zentrale Bedeutung für die Analyse von Zeitreihen hat die Eigenschaft der Stationarität. Wird der (oder bei mehreren autokorrelierenden Vergangenheitstermen die) erste Lag mit einem Faktor < 1 multipliziert, erfährt die Zeitreihe einen Druck gegen Null und bewegt sich um einen zeitlich konstanten Mittelwert. Ist ebenfalls gegeben, dass die Varianz einen zeitlich konstanten Erwartungswert hat, spricht man von stationären Prozessen.

In [6]:
y = [0] * n
for i in range(1,n):
    y[i] = 0.5 * y[i-1] + random.normalvariate(0,50)
    
_ = pd.Series(y).plot(title="Schwach stationärer Prozess")

Stark stationärer Prozess

Stationäre Prozesse lassen sich in schwach bzw. stark stationär unterscheiden. Beiden gemeinsam sind die zeitlich konstanten Erwartungswerte für Mittelwert und Varianz. Schwach stationäre Prozesse weisen dabei Autokorrelationen auf. Stark stationäre Prozesse sind hingegen völlig Zufallsbasiert und verfügen über keinerlei innere Abhängigkeitsstrukturen.

Stark stationäre Prozesse werden auch als Weißes Rauschen bezeichnet.

In [7]:
y = [0] * n
for i in range(1,n):
    y[i] = random.normalvariate(0,50)
    
_ = pd.Series(y).plot(title="Stark stationärer Prozess")

Deterministischer (trendstationärer) Prozess

Ein deterministischer Prozess bewegt sich mit fortschreitenden Zeit in die Richtung des Trends. Anders als bei einem stochastischen Prozess, bei dem die Vergangenheitswerte (die sog. Lags) den Wert zum Zeitpunkt t0 bestimmen, ist es bei einem deterministischen Prozess die Zeit selbst, die den Wert bestimmt.

Oszilliert der Verlauf mit zeitlich konstanter Varianz um den Trendverlauf, spricht man von einem trendstationären Prozess.

In [8]:
y = [0] * n
for i in range(1,n):
    y[i] = 0.2 * i + random.normalvariate(0,50)
    
_ = pd.Series(y).plot(title="Deterministischer (trendstationärer) Prozess")

Stationärer Prozess mit Autokorrelationen im ersten und zweiten Lag

Stationäre Prozesse können innere Abhängigkeiten zu einem oder mehreren Vergangenheitswerten aufweisen. Hier bestehen Autokorrelationen im ersten und zweiten Lag.

In [9]:
y = [0] * n
for i in range(1,n):
    y[i] = 0.8 * y[i-1] + 0.1 * y[i-2] + random.normalvariate(0,1)

_ = pd.Series(y).plot(title="Stationärer Prozess mit 2 Autokorrelationen")

Trendstationärer Prozess mit additiver saisonaler Komponente

Saisonalitäten bezeichnen wiederkehrende Muster in Zeitreihen. Hier wird eine Zeitreihe mit einer Saisonalität der Frequenz 12 erstellt. Wir können uns also vorstellen, das diese Saisonalität die Durchschnittstemperatur der Monate im Jahr bezeichnet.

Die hier erstellte Zeitreihe enthält außerdem einen Trend, den wir bspw. (und mit etwas Fantasie) als Klimaerwärmung interpretieren können – jede Zeiteinheit erhöht den Temperaturwert um den Faktor 0.1.

In [10]:
y = [0] * 120
saison = [2,4,6,8,10,20,20,10,8,6,4,2] * 12
for i in range(0,120):
    y[i] = 0.1 * i + saison[i] + random.normalvariate(0,2)

_ = pd.Series(y).plot(title="Additive saisonale Komponente")

Trendstationärer Prozesses mit multiplikativer saisonaler Komponente

Wird die Saisonalität mit jedem Zyklus kleiner oder größer, handelt es sich eine multiplikative Saisonalität. Bei der Zerlegung (Dekomposition) von Zeitreihen in Trend, Error und Saisonalität wird in der Regel die Information benötigt, welchen Typs die saisonale Komponente ist. In Python kann die Dekomposition bspw. mit dem Modul statsmodels durchgeführt werden. Dort existiert die Methode seasonal_decompose mit dem Parameter model (=’additive|multiplicative’).

In [11]:
y = [0] * 120
saison = [2,4,6,8,10,20,20,10,8,6,4,2] * 12
for i in range(0,120):
    y[i] = math.sqrt(i) * saison[i] + random.normalvariate(0,20)

_ = pd.Series(y).plot(title="Multiplikative saisonale Komponente")

Instationäre Varianz

Verändert sich der Erwartungswert der Varianz über den zeitlichen Verlauf, liegt keine Stationarität vor – auch wenn der Mittelwert (= Erwartungswert) konstant ist.

In [12]:
y1 = [random.normalvariate(0,1) for i in range(0,100)] 
y2 = [random.normalvariate(0,5) for i in range(0,100)] 
y3 = [random.normalvariate(0,10) for i in range(0,100)] 

y = y1+y2+y3

_ = pd.Series(y).plot(title="Instationäre Varianz")

1 thought on “Zeitreihentypen (erstellt in Python)

Leave a Comment