Pour commencer à travailler avec la bibliothèque de séries temporelles, importez la bibliothèque dans votre bloc-notes ou votre application Python.
Utilisez cette commande pour importer la bibliothèque de séries temporelles:
# Import the package
import tspy
Création d'une série temporelle
Pour créer une série temporelle et utiliser les fonctions de bibliothèque, vous devez choisir la source de données. Les sources de données prises en charge sont les suivantes :
- Listes en mémoire
- DataFrames pandas
- Collections d'observations en mémoire (à l'aide de la construction
ObservationCollection) - Lecteurs définis par l'utilisateur (à l'aide de la construction
TimeSeriesReader)
L'exemple suivant illustre l'ingestion de données à partir d'une liste en mémoire :
ts = tspy.time_series([5.0, 2.0, 4.0, 6.0, 6.0, 7.0])
ts
La sortie se présente comme suit :
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 utiliser plusieurs séries temporelles en même temps à l'aide de la construction MultiTimeSeries. Un MultiTimeSeries est essentiellement un dictionnaire de séries temporelles, où chaque série temporelle possède sa propre clé unique. Les séries temporelles ne sont pas alignées dans le temps.
La construction MultiTimeSeries fournit des méthodes similaires pour la transformation et l'ingestion en tant que construction de série temporelle 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])
})
La sortie se présente comme suit :
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étation du temps
Par défaut, une série temporelle utilise un type de données long pour indiquer quand une observation donnée a été créée (jauge de temps). Un système de référence temporel est utilisé pour les séries temporelles qui utilisent des horodatages interprétables par les humains. Voir Utilisation du système de référence de temps.
L'exemple suivant montre comment créer une série temporelle simple où chaque index indique un jour après l'heure de début 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
La sortie se présente comme suit :
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
Exécution de transformations simples
Les transformations sont des fonctions qui, à partir d'une ou de plusieurs séries temporelles, renvoient une nouvelle série temporelle.
Par exemple, pour segmentez une série temporelle dans des fenêtres où chaque fenêtre est size=3, glissant par 2 enregistrements, vous pouvez utiliser la méthode suivante :
window_ts = ts.segment(3, 2)
window_ts
La sortie se présente comme suit :
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 l'ajout de la valeur 1 à chaque valeur d'une série temporelle :
add_one_ts = ts.map(lambda x: x + 1)
add_one_ts
La sortie se présente comme suit :
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 quitter temporairement une série temporelle, par exemple, ts avec une autre série temporelle ts2 :
ts2 = tspy.time_series([1.0, 2.0, 3.0])
joined_ts = ts.left_join(ts2)
joined_ts
La sortie se présente comme suit :
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 de transformateurs
Une suite riche de transformateurs intégrés est fournie dans le package de transformateurs. Importez le package pour utiliser les fonctions de transformateur fournies :
from tspy.builders.functions import transformers
Une fois que vous avez ajouté le package, vous pouvez transformer des données dans une série temporelle à l'aide de la méthode transform.
Par exemple, pour calculer une différence sur une série temporelle :
ts_diff = ts.transform(transformers.difference())
La sortie est la suivante :
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 de réducteurs
Comme pour le package de transformateurs, vous pouvez réduire une série temporelle à l'aide des méthodes fournies par le package de réducteurs. Vous pouvez importer le package des réducteurs comme suit :
from tspy.builders.functions import reducers
Après avoir importé le package, utilisez la méthode reduce pour obtenir la moyenne sur une série temporelle, par exemple :
avg = ts.reduce(reducers.average())
avg
La sortie générée est la suivante :
5.0
Les réducteurs possèdent une propriété spéciale qui leur permet d'être utilisés avec des transformations de segmentation (somme horaire, moyenne dans la fenêtre avant une erreur, etc.). Comme la sortie d'une segmentation + reducer est une série temporelle, la méthode transform est utilisée.
Par exemple, pour segmenter une série temporelle en fenêtres de taille trois et obtenir la moyenne de chaque fenêtre, utilisez :
avg_windows_ts = ts.segment(3).transform(reducers.average())
Résultat :
imeStamp: 0 Value: 3.6666666666666665
TimeStamp: 1 Value: 4.0
TimeStamp: 2 Value: 5.333333333333333
TimeStamp: 3 Value: 6.333333333333333
Représentation d'une série temporelle
L'évaluation paresseuse est utilisée lors de la représentation graphique d'une série temporelle. Lorsque vous représentez une série temporelle, vous pouvez effectuer l'une des opérations suivantes :
- Collectez les observations de la série temporelle, qui renvoie un
BoundTimeSeries - Réduire la série temporelle en une valeur ou une collection de valeurs
- Effectuer des opérations de sauvegarde ou d'impression
Par exemple, pour collecter et renvoyer toutes les valeurs d'une série temporelle :
observations = ts.materialize()
observations
Résultat :
[(0,5.0),(1,2.0),(2,4.0),(3,6.0),(4,6.0),(5,7.0)]
Pour collecter une plage d'une série temporelle, utilisez :
observations = ts[1:3] # same as ts.materialize(1, 3)
observations
La sortie est la suivante :
[(1,2.0),(2,4.0),(3,6.0)]
Notez qu'une série temporelle est optimisée pour les requêtes de plage si la série temporelle est de nature périodique.
À l'aide de describe sur une série temporelle en cours, il s'agit également de graphiques de la série temporelle :
describe_obj = ts.describe()
describe_obj
La sortie est la suivante :
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
- Fonctionnalités essentielles des séries temporelles
- Fonctions de série temporelle
- Évaluation retardée des séries temporelles
- Utilisation du système de référence de temps
tspyDocumentation du kit SDK Python
Rubrique parent: Analyse des séries temporelles