Utilisation de la bibliothèque de séries chronologiques

Pour commencer à utiliser la bibliothèque de séries chronologiques, importez-la dans votre notebook ou votre application Python.

Utilisez cette commande pour importer la bibliothèque de séries chronologiques :

# Import the package
import tspy

Création d'une série chronologique

Pour créer une série chronologique et utiliser les fonctions de la bibliothèque, vous devez choisir la source des données. Les sources de données prises en charge sont les suivantes :

  • Listes en mémoire
  • pandas DataFrames
  • Collections d'observations en mémoire (à l'aide de la ObservationCollection construction)
  • Lecteurs définis par l'utilisateur (à l'aide de la TimeSeriesReader construction)

L'exemple suivant montre comment extraire des données d'une liste en mémoire :

ts = tspy.time_series([5.0, 2.0, 4.0, 6.0, 6.0, 7.0])
ts

Le résultat est le suivant :

TimeStamp: 0     Value: 5.0
TimeStamp: 1     Value: 2.0
TimeStamp: 2     Value: 4.0
TimeStamp: 3     Value: 6.0
TimeStamp: 4     Value: 6.0
TimeStamp: 5     Value: 7.0

Vous pouvez également traiter plusieurs séries chronologiques simultanément à l'aide de la MultiTimeSeries construction. A MultiTimeSeries est essentiellement un dictionnaire de séries chronologiques, dans lequel chaque série chronologique possède sa propre clé unique. Les séries chronologiques ne sont pas synchronisées.

Cette MultiTimeSeries structure propose des méthodes de transformation et d'ingestion similaires à celles de la structure de série chronologique unique :

mts = tspy.multi_time_series({
	"ts1": tspy.time_series([1.0, 2.0, 3.0]),
	"ts2": tspy.time_series([5.0, 2.0, 4.0, 5.0])
})

Le résultat est le suivant :

ts2 time series
------------------------------
TimeStamp: 0     Value: 5.0
TimeStamp: 1     Value: 2.0
TimeStamp: 2     Value: 4.0
TimeStamp: 3     Value: 5.0
ts1 time series
------------------------------
TimeStamp: 0     Value: 1.0
TimeStamp: 1     Value: 2.0
TimeStamp: 2     Value: 3.0

Interpréter le temps

Par défaut, une série chronologique utilise un type long de données pour indiquer à quel moment une observation donnée a été créée; on parle alors de « marque temporelle ». Un système de référence temporelle est utilisé pour les séries chronologiques comportant des horodatages compréhensibles par l'homme. Voir « Utilisation du système de référence temporelle ».

L'exemple suivant montre comment créer une série chronologique simple dans laquelle chaque indice correspond à un jour après l'heure de début de 1990-01-01:

import datetime
granularity = datetime.timedelta(days=1)
start_time = datetime.datetime(1990, 1, 1, 0, 0, 0, 0, tzinfo=datetime.timezone.utc)

ts = tspy.time_series([5.0, 2.0, 4.0, 6.0, 6.0, 7.0], granularity=granularity, start_time=start_time)
ts

Le résultat est le suivant :

TimeStamp: 1990-01-01T00:00Z     Value: 5.0
TimeStamp: 1990-01-02T00:00Z     Value: 2.0
TimeStamp: 1990-01-03T00:00Z     Value: 4.0
TimeStamp: 1990-01-04T00:00Z     Value: 6.0
TimeStamp: 1990-01-05T00:00Z     Value: 6.0
TimeStamp: 1990-01-06T00:00Z     Value: 7.0

Effectuer des transformations simples

Les transformations sont des fonctions qui, lorsqu'on leur fournit une ou plusieurs séries chronologiques, renvoient une nouvelle série chronologique.

Par exemple, pour segmenter une série chronologique en fenêtres de size=3, en les faisant glisser de 2 enregistrements, vous pouvez utiliser la méthode suivante :

window_ts = ts.segment(3, 2)
window_ts

Le résultat est le suivant :

TimeStamp: 0     Value: original bounds: (0,2) actual bounds: (0,2) observations: [(0,5.0),(1,2.0),(2,4.0)]
TimeStamp: 2     Value: original bounds: (2,4) actual bounds: (2,4) observations: [(2,4.0),(3,6.0),(4,6.0)]

Cet exemple montre comment ajouter 1 à chaque valeur d'une série chronologique :

add_one_ts = ts.map(lambda x: x + 1)
add_one_ts

Le résultat est le suivant :

TimeStamp: 0     Value: 6.0
TimeStamp: 1     Value: 3.0
TimeStamp: 2     Value: 5.0
TimeStamp: 3     Value: 7.0
TimeStamp: 4     Value: 7.0
TimeStamp: 5     Value: 8.0

Vous pouvez également effectuer une jointure gauche temporelle sur une série chronologique, par exemple ts avec une autre série chronologique ts2 :

ts2 = tspy.time_series([1.0, 2.0, 3.0])
joined_ts = ts.left_join(ts2)
joined_ts

Le résultat est le suivant :

TimeStamp: 0     Value: [5.0, 1.0]
TimeStamp: 1     Value: [2.0, 2.0]
TimeStamp: 2     Value: [4.0, 3.0]
TimeStamp: 3     Value: [6.0, null]
TimeStamp: 4     Value: [6.0, null]
TimeStamp: 5     Value: [7.0, null]

Utilisation des transformateurs

Le package « transformers » propose une large gamme de transformateurs intégrés. Importez le paquet pour utiliser les fonctions de transformation fournies :

from tspy.builders.functions import transformers

Une fois le package ajouté, vous pouvez transformer les données d'une série chronologique à l'aide de la transform méthode.

Par exemple, pour calculer la différence d'une série chronologique :

ts_diff = ts.transform(transformers.difference())

Voici le résultat :

TimeStamp: 1     Value: -3.0
TimeStamp: 2     Value: 2.0
TimeStamp: 3     Value: 2.0
TimeStamp: 4     Value: 0.0
TimeStamp: 5     Value: 1.0

Utilisation des réducteurs

Tout comme avec le package `transformers`, vous pouvez réduire une série chronologique à l'aide des méthodes fournies par le package `reducers`. Vous pouvez importer le package « reducers » comme suit :

from tspy.builders.functions import reducers

Une fois le package importé, utilisez la reduce méthode pour calculer la moyenne d'une série chronologique, par exemple :

avg = ts.reduce(reducers.average())
avg

Cela donne :

5.0

Les réducteurs possèdent une propriété particulière qui leur permet d'être utilisés conjointement avec des transformations de segmentation (somme horaire, moyenne sur la fenêtre précédant la survenue d'une erreur, etc.). Comme la sortie d'un segmentation + reducer est une série chronologique, on utilise la transform méthode.

Par exemple, pour diviser le données en fenêtres de taille 3 et calculer la moyenne de chaque fenêtre, utilisez :

avg_windows_ts = ts.segment(3).transform(reducers.average())

Il en résulte :

imeStamp: 0     Value: 3.6666666666666665
TimeStamp: 1     Value: 4.0
TimeStamp: 2     Value: 5.333333333333333
TimeStamp: 3     Value: 6.333333333333333

Représentation graphique de séries chronologiques

L'évaluation paresseuse est utilisée lors de la représentation graphique d'une série chronologique. Lorsque vous tracez une série chronologique, vous pouvez effectuer l'une des opérations suivantes :

  • Récupérer les observations de la série chronologique, ce qui renvoie un BoundTimeSeries
  • Réduire la série chronologique à une valeur ou à un ensemble de valeurs
  • Effectuer des opérations d'enregistrement ou d'impression

Par exemple, pour récupérer toutes les valeurs d'une série chronologique :

observations = ts.materialize()
observations

Il en résulte :

[(0,5.0),(1,2.0),(2,4.0),(3,6.0),(4,6.0),(5,7.0)]

Pour extraire une plage d'une série chronologique, utilisez :

observations = ts[1:3] # same as ts.materialize(1, 3)
observations

Voici le résultat :

[(1,2.0),(2,4.0),(3,6.0)]

Notez qu'une série chronologique est optimisée pour les requêtes par plage si elle présente un caractère périodique.

L'application de la fonction describe à une série chronologique donnée permet également de tracer un graphique de cette série :

describe_obj = ts.describe()
describe_obj

Le résultat est le suivant :

min inter-arrival-time: 1
max inter-arrival-time: 1
mean inter-arrival-time: 1.0
top: 6.0
unique: 5
frequency: 2
first: TimeStamp: 0     Value: 5.0
last: TimeStamp: 5     Value: 7.0
count: 6
mean:5.0
std:1.632993161855452
min:2.0
max:7.0
25%:3.5
50%:5.5
75%:6.25

En savoir plus