Le système de référence temporel (TRS) est un système local, régional ou mondial permettant d'identifier le temps.
Un système de référence temporel définit une projection spécifique pour un mappage bidirectionnel entre un horodatage et sa représentation numérique. Un exemple courant connu de la plupart des utilisateurs est l'heure UTC, qui mappe un horodatage, par exemple, le 1er janvier 2019, à minuit (GMT), à un entier 64 bits (1546300800000), qui capture le nombre de millisecondes écoulées depuis le 1er janvier 1970. En général, la valeur d'horodatage est plus facilement lisible par l'homme, tandis que la représentation numérique convient mieux au traitement machine.
Dans la bibliothèque de séries temporelles, une série temporelle peut être associée à un système de référence temporel (TRS). Un tel système est composé des éléments suivants :
- Une graduation temporelle qui capture la granularité temporelle (par exemple, 1 minute)
- Heure et date de début qui capturent une heure de début, par exemple
1 Jan 2019, 12 midnight US Eastern Daylight Savings time (EDT). Un horodatage est mappé à une représentation numérique en calculant le nombre de graduations temporelles écoulées depuis la date et l'heure de début. Une représentation numérique est mise à l'échelle en fonction de la granularité et décalée de l'heure de début lorsqu'elle est mappée à un horodatage.
Notez que cette projection bidirectionnelle peut entraîner une perte de temps. Par exemple, si la granularité temporelle réelle d'une série temporelle est exprimée en secondes, le mappage en aval et en amont des horodatages 09:00:01 et 09:00:02 (à lire en tant que hh:mm:ss) à une granularité d'une minute entraînerait les horodatages 09:00:00 et 09:00:00 respectivement. Dans cet exemple, une série temporelle, dont la granularité est en secondes, est mappée à des minutes et, par conséquent, le mappage inverse perd des informations. Toutefois, si la granularité mappée est supérieure à la granularité de la série temporelle d'entrée (plus précisément, si la granularité de la série temporelle est un multiple intégral de la granularité mappée), la projection bidirectionnelle est garantie sans perte. Par exemple, le mappage d'une série temporelle, dont la granularité est en minutes, en secondes et sa projection inverse en minutes, génère une reconstruction sans perte des horodatages.
Définition de TRS
Lors de la création d'une série temporelle, cette dernière est associée à un système de référence temporel (TRS) (ou Aucun si aucun système de référence temporel n'est spécifié). Si le système de référence temporel (TRS) a pour valeur Aucun, les valeurs numériques ne peuvent pas être mappées à des horodatages. Notez qu'un système de référence temporel (TRS) ne peut être défini sur une série temporelle qu'au moment de sa construction. En effet, de par sa conception, une série temporelle est un objet immuable. Cette immutabilité est utile si la bibliothèque est utilisée dans un environnement à unités d'exécutions multiples ou dans des environnements informatiques en réseau, tels qu'Apache Spark. Un système de référence temporel (TRS) ne peut être défini qu'au moment de sa construction, mais il peut être modifié à l'aide de la méthode with_trs, comme décrit dans la section qui suit. La méthode with_trs génère une nouvelle série temporelle et n'a donc aucun impact sur l'immutabilité.
Soit une série temporelle simple créée à partir d'une liste en mémoire :
values = [1.0, 2.0, 4.0]
x = tspy.time_series(values)
x
Le résultat est le suivant :
TimeStamp: 0 Value: 1.0
TimeStamp: 1 Value: 2.0
TimeStamp: 2 Value: 4.0
Lors de la construction, la série temporelle peut être associée à un système de référence temporel (TRS). L'association d'un système de référence temporel (TRS) à une série temporelle permet à ses horodatages numériques de correspondre aux graduations temporelles et décalages horaires/fuseaux horaires. L'exemple suivant montre 1 minute and 1 Jan 2019, 12 midnight (GMT) :
zdt = datetime.datetime(2019,1,1,0,0,0,0,tzinfo=datetime.timezone.utc)
x_trs = tspy.time_series(data, granularity=datetime.timedelta(minutes=1), start_time=zdt)
x_trs
Le résultat est le suivant :
TimeStamp: 2019-01-01T00:00Z Value: 1.0
TimeStamp: 2019-01-01T00:01Z Value: 2.0
TimeStamp: 2019-01-01T00:02Z Value: 4.0
Voici un autre exemple où les horodatages numériques sont réinterprétés avec une durée d'une heure et un décalage/fuseau horaire sous la forme 1 Jan 2019, 12 midnight US Eastern Daylight Savings time (EDT).
tz_edt = datetime.timezone.edt
zdt = datetime.datetime(2019,1,1,0,0,0,0,tzinfo=tz_edt)
x_trs = tspy.time_series(data, granularity=datetime.timedelta(hours=1), start_time=zdt)
x_trs
Le résultat est le suivant :
TimeStamp: 2019-01-01T00:00-04:00 Value: 1.0
TimeStamp: 2019-01-01T00:01-04:00 Value: 2.0
TimeStamp: 2019-01-01T00:02-04:00 Value: 4.0
Notez que les horodatages indiquent maintenant un décalage de -4 heures par rapport à l'heure GMT (fuseau horaire EDT) et capturent des graduations temporelles d'une heure. Notez également que la définition d'un système de référence temporel (TRS) ne modifie PAS les horodatages numériques ; elle ne spécifie qu'un mode d'interprétation des horodatages numériques.
x_trs.print(human_readable=False)
Le résultat est le suivant :
TimeStamp: 0 Value: 1.0
TimeStamp: 1 Value: 2.0
TimeStamp: 2 Value: 4.0
Modification de TRS
Vous pouvez modifier le TRS associé à une série temporelle à l'aide de la fonction with_trs. Notez que cette fonction génère une exception si la série temporelle d'entrée n'est pas associée à un système de référence temporel (TRS) (si la valeur de TRS est définie sur Aucun). L'utilisation de with_trs modifie les horodatages numériques.
L'exemple de code suivant affiche TRS défini au moment des constructions sans utiliser with_trs :
# 1546300800 is the epoch time in seconds for 1 Jan 2019, 12 midnight GMT
zdt1 = datetime.datetime(1970,1,1,0,0,0,0,tzinfo=datetime.timezone.utc)
y = tspy.observations.of(tspy.observation(1546300800, 1.0),tspy.observation(1546300860, 2.0), tspy.observation(1546300920,
4.0)).to_time_series(granularity=datetime.timedelta(seconds=1), start_time=zdt1)
y.print()
y.print(human_readable=False)
Le résultat est le suivant :
TimeStamp: 2019-01-01T00:00Z Value: 1.0
TimeStamp: 2019-01-01T00:01Z Value: 2.0
TimeStamp: 2019-01-01T00:02Z Value: 4.0
# TRS has been set during construction time - no changes to numeric timestamps
TimeStamp: 1546300800 Value: 1.0
TimeStamp: 1546300860 Value: 2.0
TimeStamp: 1546300920 Value: 4.0
L'exemple suivant montre comment appliquer with_trs pour modifier granularity à une minute et conserver le décalage d'heure d'origine (1 janvier 1970, 12 heures GMT) :
y_minutely_1970 = y.with_trs(granularity=datetime.timedelta(minutes=1), start_time=zdt1)
y_minutely_1970.print()
y_minutely_1970.print(human_readable=False)
Le résultat est le suivant :
TimeStamp: 2019-01-01T00:00Z Value: 1.0
TimeStamp: 2019-01-01T00:01Z Value: 2.0
TimeStamp: 2019-01-01T00:02Z Value: 4.0
# numeric timestamps have changed to number of elapsed minutes since 1 Jan 1970, 12 midnight GMT
TimeStamp: 25771680 Value: 1.0
TimeStamp: 25771681 Value: 2.0
TimeStamp: 25771682 Value: 4.0
Maintenant, appliquez with_trs pour changer granularity à une minute et le décalage au 1er janvier 2019, 12 heures GMT :
zdt2 = datetime.datetime(2019,1,1,0,0,0,0,tzinfo=datetime.timezone.utc)
y_minutely = y.with_trs(granularity=datetime.timedelta(minutes=1), start_time=zdt2)
y_minutely.print()
y_minutely.print(human_readable=False)
Le résultat est le suivant :
TimeStamp: 2019-01-01T00:00Z Value: 1.0
TimeStamp: 2019-01-01T00:01Z Value: 2.0
TimeStamp: 2019-01-01T00:02Z Value: 4.0
# numeric timestamps are now minutes elapsed since 1 Jan 2019, 12 midnight GMT
TimeStamp: 0 Value: 1.0
TimeStamp: 1 Value: 2.0
TimeStamp: 2 Value: 4.0
Pour mieux comprendre son impact sur le post-traitement, examinons les points suivants. Notez que materialize sur les horodatages numériques fonctionne sur les horodatages sous-jacents associés à la série temporelle.
print(y.materialize(0,2))
print(y_minutely_1970.materialize(0,2))
print(y_minutely.materialize(0,2))
Le résultat est le suivant :
# numeric timestamps in y are in the range 1546300800, 1546300920 and thus y.materialize(0,2) is empty
[]
# numeric timestamps in y_minutely_1970 are in the range 25771680, 25771682 and thus y_minutely_1970.materialize(0,2) is empty
[]
# numeric timestamps in y_minutely are in the range 0, 2
[(0,1.0),(1,2.0),(2,4.0)]
La méthode materialize peut également être appliquée aux objets date et heure. Cela génère une exception si la série temporelle sous-jacente n'est pas associée à un système de référence temporel (TRS) (si la valeur de TRS est définie sur Aucun). En supposant que la série temporelle sous-jacente possède un système de référence temporel (TRS), les objets datetime sont mappés à une plage numérique à l'aide du système de référence temporel.
# Jan 1 2019, 12 midnight GMT
dt_beg = datetime.datetime(2019,1,1,0,0,0,0,tzinfo=datetime.timezone.utc)
# Jan 1 2019, 12:02 AM GMT
dt_end = datetime.datetime(2019,1,1,0,2,0,0,tzinfo=datetime.timezone.utc)
print(y.materialize(dt_beg, dt_end))
print(y_minutely_1970.materialize(dt_beg, dt_end))
print(y_minutely.materialize(dt_beg, dt_end))
# materialize on y in UTC millis
[(1546300800,1.0),(1546300860,2.0), (1546300920,4.0)]
# materialize on y_minutely_1970 in UTC minutes
[(25771680,1.0),(25771681,2.0),(25771682,4.0)]
# materialize on y_minutely in minutes offset by 1 Jan 2019, 12 midnight
[(0,1.0),(1,2.0),(2,4.0)]
Horodatages en double
La modification du système de référence temporel (TRS) peut générer des horodatages en double. L'exemple suivant modifie la granularité en une heure, ce qui entraîne des horodatages en double. La bibliothèque de séries temporelles gère les horodatages en double de manière transparente et fournit des combinateurs pratiques pour réduire les valeurs associées aux horodatages en double en une même valeur (par exemple, en calculant une moyenne des valeurs regroupées par horodatages en double).
y_hourly = y_minutely.with_trs(granularity=datetime.timedelta(hours=1), start_time=zdt2)
print(y_minutely)
print(y_minutely.materialize(0,2))
print(y_hourly)
print(y_hourly.materialize(0,0))
Le résultat est le suivant :
# y_minutely - minutely time series
TimeStamp: 2019-01-01T00:00Z Value: 1.0
TimeStamp: 2019-01-01T00:01Z Value: 2.0
TimeStamp: 2019-01-01T00:02Z Value: 4.0
# y_minutely has numeric timestamps 0, 1 and 2
[(0,1.0),(1,2.0),(2,4.0)]
# y_hourly - hourly time series has duplicate timestamps
TimeStamp: 2019-01-01T00:00Z Value: 1.0
TimeStamp: 2019-01-01T00:00Z Value: 2.0
TimeStamp: 2019-01-01T00:00Z Value: 4.0
# y_hourly has numeric timestamps of all 0
[(0,1.0),(0,2.0),(0,4.0)]
Les horodatages en double peuvent être éventuellement combinés comme suit :
y_hourly_averaged = y_hourly.transform(transformers.combine_duplicate_granularity(lambda x: sum(x)/len(x))
print(y_hourly_averaged.materialize(0,0))
Le résultat est le suivant :
# values corresponding to the duplicate numeric timestamp 0 have been combined using average
# average = (1+2+4)/3 = 2.33
[(0,2.33)]
En savoir plus
Pour utiliser le kit SDK tspy Python, voir la documentation du kit SDK tspy Python.
Rubrique parent: Analyse des séries temporelles