Transformieren

Transformationen sind Funktionen, die auf eine Zeitreihe angewendet werden, was zu einer weiteren Zeitreihe führt. Die Zeitreihenbibliothek unterstützt verschiedene Typen von Transformationen, einschließlich bereitgestellter Transformationen (mithilfe von from tspy.functions import transformers) sowie benutzerdefinierter Transformationen.

Im folgenden Beispiel werden einige bereitgestellte Transformationen dargestellt:

#Interpolation
>>> ts = tspy.time_series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
>>> periodicity = 2
>>> interp = interpolators.nearest(0.0)
>>> interp_ts = ts.resample(periodicity, interp)
>>> interp_ts.print()
TimeStamp: 0     Value: 1.0
TimeStamp: 2     Value: 3.0
TimeStamp: 4     Value: 5.0

#Fillna
>>> shift_ts = ts.shift(2)
    print("shifted ts to add nulls")
    print(shift_ts)
    print("\nfilled ts to make nulls 0s")
    null_filled_ts = shift_ts.fillna(interpolators.fill(0.0))
    print(null_filled_ts)

shifted ts to add nulls
TimeStamp: 0     Value: null
TimeStamp: 1     Value: null
TimeStamp: 2     Value: 1.0
TimeStamp: 3     Value: 2.0
TimeStamp: 4     Value: 3.0
TimeStamp: 5     Value: 4.0

filled ts to make nulls 0s
TimeStamp: 0     Value: 0.0
TimeStamp: 1     Value: 0.0
TimeStamp: 2     Value: 1.0
TimeStamp: 3     Value: 2.0
TimeStamp: 4     Value: 3.0
TimeStamp: 5     Value: 4.0

# Additive White Gaussian Noise (AWGN)
>>> noise_ts = ts.transform(transformers.awgn(mean=0.0,sd=.03))
>>> print(noise_ts)
TimeStamp: 0     Value: 0.9962378841388397
TimeStamp: 1     Value: 1.9681980879378596
TimeStamp: 2     Value: 3.0289374962174405
TimeStamp: 3     Value: 3.990728648807705
TimeStamp: 4     Value: 4.935338359740761

TimeStamp: 5     Value: 6.03395072999318

Segmentierung

Unter Segmentierung oder Fenstertechnik versteht man den Prozess der Aufteilung einer Zeitreihe in mehrere Segmente. Die Zeitreihenbibliothek unterstützt verschiedene Formen der Segmentierung und ermöglicht zudem die Erstellung von benutzerdefinierten Segmenten.

• Fensterbasierte Segmentierung

  Diese Art der Segmentierung einer Zeitreihe basiert auf vom Benutzer angegebenen Segmentgrößen. Die Segmente können datensatzbasiert oder zeitbasiert sein. Es gibt Optionen, mit denen ie auf rollenden Fenstern sowie auf gleitenden Fenstern basierende Segmente erstellt werden können.

  >>> import tspy
  >>> ts_orig = tspy.builder()
    .add(tspy.observation(1,1.0))
    .add(tspy.observation(2,2.0))
    .add(tspy.observation(6,6.0))
    .result().to_time_series()
  >>> ts_orig
  timestamp: 1     Value: 1.0
  timestamp: 2     Value: 2.0
  timestamp: 6     Value: 6.0
  
  >>> ts = ts_orig.segment_by_time(3,1)
  >>> ts
  timestamp: 1     Value: original bounds: (1,3) actual bounds: (1,2) observations: [(1,1.0),(2,2.0)]
  timestamp: 2     Value: original bounds: (2,4) actual bounds: (2,2) observations: [(2,2.0)]
  timestamp: 3     Value: this segment is empty
  timestamp: 4     Value: original bounds: (4,6) actual bounds: (6,6) observations: [(6,6.0)]
  

• Ankerbasierte Segmentierung

  Die ankerbasierte Segmentierung ist eine sehr wichtige Art der Segmentierung, bei der ein Segment durch Verankerung an einem bestimmten Lambda erstellt wird, bei dem es sich um einen einfachen Wert handeln kann. Ein Beispiel ist die Überprüfung von Ereignissen vor dem Auftreten eines 500-Fehlers oder die Untersuchung von Werten nach der Beobachtung einer Unregelmäßigkeit. Zu den Varianten der ankerbasierten Segmentierung gehört die Bereitstellung eines Bereichs mit mehreren Markierungen.

  >>> import tspy
  >>> ts_orig = tspy.time_series([1.0, 2.0, 3.0, 4.0, 5.0])
  >>> ts_orig
  timestamp: 0     Value: 1.0
  timestamp: 1     Value: 2.0
  timestamp: 2     Value: 3.0
  timestamp: 3     Value: 4.0
  timestamp: 4     Value: 5.0
  
  >>> ts = ts_orig.segment_by_anchor(lambda x: x % 2 == 0, 1, 2)
  >>> ts
  timestamp: 1     Value: original bounds: (0,3) actual bounds: (0,3) observations: [(0,1.0),(1,2.0),(2,3.0),(3,4.0)]
  timestamp: 3     Value: original bounds: (2,5) actual bounds: (2,4) observations: [(2,3.0),(3,4.0),(4,5.0)]
  

• Segmenter

  Es gibt mehrere spezialisierte Segmentierungsroutinen, die ohne Vorbereitungspaket bereitgestellt werden, indem das Paket segmenters(mit from tspy.functions import segmenters) importiert wird. Ein Beispiel ist ein Segmenter, der die Regression zur Segmentierung einer Zeitreihe verwendet:

  >>> ts = tspy.time_series([1.0,2.0,3.0,4.0,5.0,2.0,1.0,-1.0,50.0,53.0,56.0])
  >>> max_error = .5
  >>> skip = 1
  >>> reg_sts = ts.to_segments(segmenters.regression(max_error,skip,use_relative=True))
  >>> reg_sts
  
  timestamp: 0     Value:   range: (0, 4)   outliers: {}
  timestamp: 5     Value:   range: (5, 7)   outliers: {}
  timestamp: 8     Value:   range: (8, 10)   outliers: {}
  

Reducer

Ein Reducer ist eine Funktion, die auf die Werte in einer Gruppe von Zeitreihen angewendet wird, um einen einzelnen Wert zu erzeugen. Die Zeitreihenfunktionen reducerähneln dem von Hadoop/Spark verwendeten Reducer-Konzept. Dieser einzelne Wert kann eine Sammlung sein, ist jedoch allgemeiner ein einzelnes Objekt. Ein Beispiel für eine Reducerfunktion ist die Berechnung des Durchschnitts der Werte in einer Zeitreihe.

Es werden mehrere reducer-Funktionen unterstützt, darunter:

• Abstandsreducer

  Abstandsreducer sind eine Klasse von Reducern, mit denen der Abstand zwischen zwei Zeitreihen berechnet wird. Die Bibliothek unterstützt numerische und kategorische Abstandsfunktionen bei Sequenzen. Dazu gehören Zeitnormierungs-Abstandsmessungen wie Itakura-Parallelogramm, Sakoe-Chiba Band, nicht beschränktes DTW und nicht zeitnormierte DTW-Beschränkungen. Verteilungsabstände wie ungarischer Abstand und Earth-Mover-Abstand sind ebenfalls verfügbar.

  Für kategoriale Zeitreihenabstandsmessungen können Sie die Damerau Levenshtein- und Jaro-Winkler-Abstandsmaße verwenden.

  >>> from tspy.functions import *
  >>> ts = tspy.time_series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
  >>> ts2 = ts.transform(transformers.awgn(sd=.3))
  >>> dtw_distance = ts.reduce(ts2,reducers.dtw(lambda obs1, obs2: abs(obs1.value - obs2.value)))
  >>> print(dtw_distance)
  1.8557981638880405
  

• Mathematische Reducer

  Für numerische Zeitreihen werden einige praktische mathematische Reducer bereitgestellt. Dazu gehören grundlegende Reducer wie Durchschnitt, Summe, Standardabweichung und Momente. Entropie, Kurtosis, FFT und ihre Varianten, verschiedene Korrelationen und Histogramme gehören ebenfalls dazu. Ein praktischer Basiszusammenfassungs-Reducer ist die Funktion describe, die Basisinformationen zur Zeitreihe bereitstellt.

  >>> from tspy.functions import *
  >>> ts = tspy.time_series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
  >>> ts2 = ts.transform(transformers.awgn(sd=.3))
  >>> corr = ts.reduce(ts2, reducers.correlation())
  >>> print(corr)
  0.9938941942380525
  
  >>> adf = ts.reduce(reducers.adf())
  >>> print(adf)
  pValue: -3.45
  satisfies test: false
  
  >>> ts2 = ts.transform(transformers.awgn(sd=.3))
  >>> granger = ts.reduce(ts2, reducers.granger(1))
  >>> print(granger) #f_stat, p_value, R2
  -1.7123613937876463,-3.874412217575385,1.0
  

• Ein weiterer grundlegender Reducer, der für ein erstes Verständnis der Zeitreihe sehr nützlich ist, ist der Beschreibungsreducer. Im Folgenden wird dieser Reducer veranschaulicht:

  >>> desc = ts.describe()
  >>> print(desc)
  min inter-arrival-time: 1
  max inter-arrival-time: 1
  mean inter-arrival-time: 1.0
  top: null
  unique: 6
  frequency: 1
  first: TimeStamp: 0     Value: 1.0
  last: TimeStamp: 5     Value: 6.0
  count: 6
  mean:3.5
  std:1.707825127659933
  min:1.0
  max:6.0
  25%:1.75
  50%:3.5
  75%:5.25
  

Temporale Joins

Die Bibliothek enthält Funktionen für temporale Joins oder das Verknüpfen von Zeitreihen auf Basis ihrer Zeitmarken. Die Joinfunktionen ähneln denen in einer Datenbank, einschließlich linke Joins, rechte Joins, Outer Joins, Inner Joins, linke Outer Joins, rechte Outer Joins usw. Die folgenden Beispielcodes zeigen einige dieser Joinfunktionen:

# Create a collection of observations (materialized TimeSeries)
observations_left = tspy.observations(tspy.observation(1, 0.0), tspy.observation(3, 1.0), tspy.observation(8, 3.0), tspy.observation(9, 2.5))
observations_right = tspy.observations(tspy.observation(2, 2.0), tspy.observation(3, 1.5), tspy.observation(7, 4.0), tspy.observation(9, 5.5), tspy.observation(10, 4.5))

# Build TimeSeries from Observations
ts_left = observations_left.to_time_series()
ts_right = observations_right.to_time_series()

# Perform full join
ts_full = ts_left.full_join(ts_right)
print(ts_full)

TimeStamp: 1     Value: [0.0, null]
TimeStamp: 2     Value: [null, 2.0]
TimeStamp: 3     Value: [1.0, 1.5]
TimeStamp: 7     Value: [null, 4.0]
TimeStamp: 8     Value: [3.0, null]
TimeStamp: 9     Value: [2.5, 5.5]
TimeStamp: 10     Value: [null, 4.5]

# Perform left align with interpolation
ts_left_aligned, ts_right_aligned = ts_left.left_align(ts_right, interpolators.nearest(0.0))

print("left ts result")
print(ts_left_aligned)
print("right ts result")
print(ts_right_aligned)

left ts result
TimeStamp: 1     Value: 0.0
TimeStamp: 3     Value: 1.0
TimeStamp: 8     Value: 3.0
TimeStamp: 9     Value: 2.5
right ts result
TimeStamp: 1     Value: 0.0
TimeStamp: 3     Value: 1.5
TimeStamp: 8     Value: 4.0
TimeStamp: 9     Value: 5.5

Prognosen

Eine wichtige Funktionalität, die von der Zeitreihenbibliothek bereitgestellt wird, ist die Vorhersage. Die Bibliothek umfasst Funktionen für einfache und komplexe Vorhersagemodelle, darunter ARIMA-, Exponential-, Holt-Winters- und BATS-Modelle. Das folgende Beispiel zeigt die Funktion zum Erstellen eines Holt-Winters-Modells:

import random

model = tspy.forecasters.hws(samples_per_season=samples_per_season, initial_training_seasons=initial_training_seasons)

for i in range(100):
    timestamp = i
    value = random.randint(1,10) * 1.0
    model.update_model(timestamp, value)

print(model)

Forecasting Model
  Algorithm: HWSAdditive=5 (aLevel=0.001, bSlope=0.001, gSeas=0.001) level=6.087789839896166, slope=0.018901997884893912, seasonal(amp,per,avg)=(1.411203455586738,5, 0,-0.0037471500727535465)

#Is model init-ed
if model.is_initialized():
    print(model.forecast_at(120))

6.334135728495107

ts = tspy.time_series([float(i) for i in range(10)])

print(ts)

TimeStamp: 0     Value: 0.0
TimeStamp: 1     Value: 1.0
TimeStamp: 2     Value: 2.0
TimeStamp: 3     Value: 3.0
TimeStamp: 4     Value: 4.0
TimeStamp: 5     Value: 5.0
TimeStamp: 6     Value: 6.0
TimeStamp: 7     Value: 7.0
TimeStamp: 8     Value: 8.0
TimeStamp: 9     Value: 9.0

num_predictions = 5
model = tspy.forecasters.auto(8)
confidence = .99

predictions = ts.forecast(num_predictions, model, confidence=confidence)

print(predictions.to_time_series())

TimeStamp: 10     Value: {value=10.0, lower_bound=10.0, upper_bound=10.0, error=0.0}
TimeStamp: 11     Value: {value=10.997862810553725, lower_bound=9.934621260488143, upper_bound=12.061104360619307, error=0.41277640121597475}
TimeStamp: 12     Value: {value=11.996821082897318, lower_bound=10.704895525154571, upper_bound=13.288746640640065, error=0.5015571318964149}
TimeStamp: 13     Value: {value=12.995779355240911, lower_bound=11.50957896664928, upper_bound=14.481979743832543, error=0.5769793776877866}
TimeStamp: 14     Value: {value=13.994737627584504, lower_bound=12.33653268707341, upper_bound=15.652942568095598, error=0.6437557559526337}

print(predictions.to_time_series().to_df())

timestamp      value  lower_bound  upper_bound     error
0         10  10.000000    10.000000    10.000000  0.000000
1         11  10.997863     9.934621    12.061104  0.412776
2         12  11.996821    10.704896    13.288747  0.501557
3         13  12.995779    11.509579    14.481980  0.576979
4         14  13.994738    12.336533    15.652943  0.643756

Zeitreihen-SQL

Die Zeitreihenbibliothek ist nahtlos in Apache Spark integriert. Durch die Verwendung neuer Datentypen in Spark Catalyst können Sie mit Apache Spark horizontal skalierende SQL-Operationen für Zeitreihen durchführen. Dies ermöglicht Ihnen die einfache Nutzung von Zeitreihenerweiterungen in IBM Analytics Engine oder in Lösungen, die IBM Analytics Engine enthalten, wie die watsonx.ai Studio Spark-Umgebungen.

SQL-Erweiterungen decken die meisten Aspekte der Zeitreihenfunktionen ab, einschließlich Segmentierung, Transformation, Reduzierung, Vorhersage und Ein-/Ausgabe. Siehe Zeitreihendaten analysieren.

Weitere Informationen

Informationen zur Verwendung von tspyPython SDK finden Sie in der tspyPython SDK-Dokumentation.

Übergeordnetes Thema: Zeitreihenanalyse