La préparation des données de séries temporelles (TSDP) permet de convertir les données temporelles brutes (dans un format multidimensionnel à plat, qui inclut les données basées sur les colonnes et les données transactionnelles (basées sur les événements)) en données de séries temporelles standard (dans un format compact basé sur les lignes) qui sont requises par les méthodes d'analyse de séries temporelles ultérieures.
L'objectif principal de TSDP est de générer des séries temporelles en fonction de la combinaison de chaque valeur unique dans les champs de dimension avec des champs de métrique. De plus, elle trie les données en se basant sur l'horodatage, extrait les métadonnées des variables d'heure, transforme les séries temporelles avec une autre granularité temporelle (intervalle) en appliquant une fonction d'agrégation ou de distribution, vérifie la qualité des données et gère les valeurs manquantes si nécessaire.
Exemple de code Python :
from spss.ml.forecasting.timeseriesdatapreparation import TimeSeriesDataPreparation
tsdp = TimeSeriesDataPreparation(). \
setMetricFieldList(["Demand"]). \
setDateTimeField("Date"). \
setEncodeSeriesID(True). \
setInputTimeInterval("MONTH"). \
setOutTimeInterval("MONTH"). \
setQualityScoreThreshold(0.0). \
setConstSeriesThreshold(0.0)
tsdpOut = tsdp.transform(data)
TimeSeriesDataPreparationConvertor
Il s'agit de l'API convertisseur de date / heure utilisée pour fournir certaines fonctionnalités du convertisseur de date / heure à l'intérieur de TSDP pour les applications à utiliser. Il existe deux cas d'utilisation pour ce composant :
- Calculer les points temporels entre une heure de début et une heure de fin spécifiées. Dans ce cas, les heures de début et de fin interviennent toutes deux après la première observation dans la sortie précédente de TSDP.
- Calculer les points temporels entre un index de début et un index de fin faisant référence à la dernière observation dans la sortie précédente de TSDP.
Modélisation causale temporelle
La modélisation causale temporelle (TCM) fait référence à une suite de méthodes qui tentent de découvrir les relations temporelles clés dans les données de séries temporelles à l'aide d'une combinaison d'algorithmes de causalité et de régression Granger pour la sélection de variables.
Exemple de code Python :
from spss.ml.forecasting.timeseriesdatapreparation import TimeSeriesDataPreparation
from spss.ml.common.wrapper import LocalContainerManager
from spss.ml.forecasting.temporalcausal import TemporalCausal
from spss.ml.forecasting.params.predictor import MaxLag, MaxNumberOfPredictor, Predictor
from spss.ml.forecasting.params.temporal import FieldNameList, FieldSettings, Forecast, Fit
from spss.ml.forecasting.reversetimeseriesdatapreparation import ReverseTimeSeriesDataPreparation
tsdp = TimeSeriesDataPreparation().setDimFieldList(["Demension1", "Demension2"]). \
setMetricFieldList(["m1", "m2", "m3", "m4"]). \
setDateTimeField("date"). \
setEncodeSeriesID(True). \
setInputTimeInterval("MONTH"). \
setOutTimeInterval("MONTH")
tsdpOutput = tsdp.transform(changedDF)
lcm = LocalContainerManager()
lcm.exportContainers("TSDP", tsdp.containers)
estimator = TemporalCausal(lcm). \
setInputContainerKeys(["TSDP"]). \
setTargetPredictorList([Predictor(
targetList=[["", "", ""]],
predictorCandidateList=[["", "", ""]])]). \
setMaxNumPredictor(MaxNumberOfPredictor(False, 4)). \
setMaxLag(MaxLag("SETTING", 5)). \
setTolerance(1e-6)
tcmModel = estimator.fit(tsdpOutput)
transformer = tcmModel.setDataEncoded(True). \
setCILevel(0.95). \
setOutTargetValues(False). \
setTargets(FieldSettings(fieldNameList=FieldNameList(seriesIDList=[["da1", "db1", "m1"]]))). \
setReestimate(False). \
setForecast(Forecast(outForecast=True, forecastSpan=5, outCI=True)). \
setFit(Fit(outFit=True, outCI=True, outResidual=True))
predictions = transformer.transform(tsdpOutput)
rtsdp = ReverseTimeSeriesDataPreparation(lcm). \
setInputContainerKeys(["TSDP"]). \
setDeriveFutureIndicatorField(True)
rtsdpOutput = rtsdp.transform(predictions)
rtsdpOutput.show()
Modèle autorégressif causal temporel
Les modèles autorégressifs (AR) sont construits pour calculer des prévisions hors échantillon pour des séries prédicteurs qui ne sont pas des séries cibles. Ces prévisions de prédicteur sont ensuite utilisées pour calculer des prévisions hors échantillon pour les séries cibles.
Modèle produit par TemporalCausal
TemporalCausal exporte les sorties suivantes :
- un fichier JSON contenant des informations sur le modèle TemporalCausal,
- un fichier XML qui contient le modèle multisérie.
Exemple de code Python :
from spss.ml.common.wrapper import LocalContainerManager
from spss.ml.forecasting.temporalcausal import TemporalCausal, TemporalCausalAutoRegressiveModel
from spss.ml.forecasting.params.predictor import MaxLag, MaxNumberOfPredictor, Predictor
from spss.ml.forecasting.params.temporal import FieldNameList, FieldSettingsAr, ForecastAr
lcm = LocalContainerManager()
arEstimator = TemporalCausal(lcm). \
setInputContainerKeys([tsdp.uid]). \
setTargetPredictorList([Predictor(
targetList = [["da1", "db1", "m2"]],
predictorCandidateList = [["da1", "db1", "m1"],
["da1", "db2", "m1"],
["da1", "db2", "m2"],
["da1", "db3", "m1"],
["da1", "db3", "m2"],
["da1", "db3", "m3"]])]). \
setMaxNumPredictor(MaxNumberOfPredictor(False, 5)). \
setMaxLag(MaxLag("SETTING", 5))
arEstimator.fit(df)
tcmAr = TemporalCausalAutoRegressiveModel(lcm).\
setInputContainerKeys([arEstimator.uid]).\
setDataEncoded(True).\
setOutTargetValues(True). \
setTargets(FieldSettingsAr(FieldNameList(
seriesIDList=[["da1", "db1", "m1"],
["da1", "db2", "m2"],
["da1", "db3", "m3"]]))).\
setForecast(ForecastAr(forecastSpan = 5))
scored = tcmAr.transform(df)
scored.show()
Détection causale temporelle des valeurs extrêmes
L'un des avantages de la génération de modèles TCM est la capacité de détecter les valeurs extrêmes basées sur des modèles. La détection des valeurs extrêmes fait référence à la fonction permettant d'identifier les points temporels dans les séries cibles par des valeurs qui s'écartent trop des valeurs attendues (adaptées) basées sur les modèles TCM.
Analyse causale temporelle de la cause première
L'analyse de la cause première fait référence à la capacité d'explorer le graphique causal de Granger afin d'analyser les valeurs clés/racines qui ont donné lieu à la valeur extrême en question.
Analyse causale temporelle du scénario
L'analyse de scénarios fait référence à une capacité des modèles TCM à "jouer" les répercussions de la fixation artificielle de la valeur d'une série temporelle. Un scénario correspond à l'ensemble des prévisions qui sont effectuées en remplaçant les valeurs d'une série temporelle racine par un vecteur de valeurs de substitution.
Récapitulatif causal temporel
Le récapitulatif TCM sélectionne les N premiers modèles en fonction d'une mesure de qualité du modèle. Il existe cinq mesures de qualité d'un modèle : l'erreur quadratique moyenne racine (RMSE), le pourcentage d'erreur quadratique moyenne racine (RMSPE), le critère d'information bayésien (BIC), le critère d'information d'Akaike (AIC) et R au carré (RSQUARE). N et la mesure de qualité du modèle peuvent être définis par l'utilisateur.
Exploration des séries temporelles
L'exploration des séries temporelles permet d'explorer les caractéristiques des données de séries temporelles en fonction de certaines statistiques et de certains tests afin de générer des informations préliminaires sur la série temporelle avant sa modélisation. Elle couvre non seulement les méthodes d'analyse destinées aux utilisateurs experts (notamment le regroupement des séries temporelles, les tests de racine unitaire et les corrélations), mais fournit également un processus d'exploration automatique basé sur une méthode simple de décomposition des séries temporelles destinée aux professionnels.
Exemple de code Python :
from spss.ml.forecasting.timeseriesexploration import TimeSeriesExploration
tse = TimeSeriesExploration(). \
setAutoExploration(True). \
setClustering(True)
tseModel = tse.fit(data)
predictions = tseModel.transform(data)
predictions.show()
Préparation des données inverse pour les données de séries temporelles
La préparation de données inversées pour les données de série temporelle (RTSDP) fournit des fonctionnalités qui permettent de convertir le format de ligne compacte (CRB) généré par TimeSeriesDataPreperation (TSDP) ou TemporalCausalModel (Score TCM) au format multidimensionnel (FMD) aplati.
Exemple de code Python :
from spss.ml.common.wrapper import LocalContainerManager
from spss.ml.forecasting.params.temporal import GroupType
from spss.ml.forecasting.reversetimeseriesdatapreparation import ReverseTimeSeriesDataPreparation
from spss.ml.forecasting.timeseriesdatapreparation import TimeSeriesDataPreparation
manager = LocalContainerManager()
tsdp = TimeSeriesDataPreparation(manager). \
setDimFieldList(["Dimension1", "Dimension2", "Dimension3"]). \
setMetricFieldList(
["Metric1", "Metric2", "Metric3", "Metric4", "Metric5", "Metric6", "Metric7", "Metric8", "Metric9", "Metric10"]). \
setDateTimeField("TimeStamp"). \
setEncodeSeriesID(False). \
setInputTimeInterval("WEEK"). \
setOutTimeInterval("WEEK"). \
setMissingImputeType("LINEAR_INTERP"). \
setQualityScoreThreshold(0.0). \
setConstSeriesThreshold(0.0). \
setGroupType(
GroupType([("Metric1", "MEAN"), ("Metric2", "SUM"), ("Metric3", "MODE"), ("Metric4", "MIN"), ("Metric5", "MAX")]))
tsdpOut = tsdp.transform(changedDF)
rtsdp = ReverseTimeSeriesDataPreparation(manager). \
setInputContainerKeys([tsdp.uid]). \
setDeriveFutureIndicatorField(True)
rtdspOut = rtsdp.transform(tsdpOut)
import com.ibm.spss.ml.forecasting.traditional.TimeSeriesForecastingModelReEstimate
val tsdp = TimeSeriesDataPreparation().
setDimFieldList(Array("da", "db")).
setMetricFieldList(Array("metric")).
setDateTimeField("date").
setEncodeSeriesID(false).
setInputTimeInterval("MONTH").
setOutTimeInterval("MONTH")
val lcm = LocalContainerManager()
lcm.exportContainers("k", tsdp.containers)
val reestimate = TimeSeriesForecastingModelReEstimate(lcm).
setForecast(ForecastEs(outForecast = true, forecastSpan = 4, outCI = true)).
setFitSettings(Fit(outFit = true, outCI = true, outResidual = true)).
setOutInputData(true).
setInputContainerKeys(Seq("k"))
val rtsdp = ReverseTimeSeriesDataPreparation(tsdp.manager).
setInputContainerKeys(List(tsdp.uid)).
setDeriveFutureIndicatorField(true)
val pipeline = new Pipeline().setStages(Array(tsdp, reestimate, rtsdp))
val scored = pipeline.fit(data).transform(data)
scored.show()
Rubrique parent: SPSS