SPSS Predictive Analytics-Prognosen mit Datenaufbereitung für Zeitreihendaten in Notebooks

TimeSeriesDataPreparationConvertor

Diese Konverter-API für Datum/Uhrzeit wird verwendet, um einige Funktionen des TSDP-Konverters für Datum/Uhrzeit zur Verwendung durch Anwendungen bereitzustellen. Es gibt zwei Anwendungsfälle für diese Komponente:

• Berechnen Sie die Zeitpunkte zwischen einer angegebenen Startzeit und einer angegebenen Endzeit. In diesem Fall können Start- und Endzeit nach der ersten Beobachtung in der vorherigen TSDP-Ausgabe liegen.
• Berechnen Sie die Zeitpunkte zwischen einem Startindex und einem Endindex durch Verweisen auf die letzte Beobachtung in der vorherigen TSDP-Ausgabe.

Temporale kausale Modellierung

Als temporale kausale Modellierung (Temporal Causal Modeling, TCM) wird eine Suite von Methoden bezeichnet, die versuchen, wichtige temporale Beziehungen in Zeitreihendaten zu erkennen, indem sie eine Kombination aus Granger-Kausalität und Regressionsalgorithmen für die Variablenauswahl verwenden.

Python-Beispielcode:

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()

Temporales kausales autoregressives Modell

Modelle mit Autoregression (AR) sind dafür konzipiert, Vorhersagen außerhalb der Stichproben für Prädiktorreihen zu berechnen, die keine Zielreihen sind. Diese Prädiktorvorhersagen werden dann zum Berechnen von Out-of-sample-Vorhersagen für die Zielzeitreihen verwendet.

Temporal-kausal erzeugtes Modell

TemporalCausal exportiert Ausgaben:

• eine JSON-Datei, die TemporalCausal-Modellinformationen enthält
• eine XML-Datei, die ein Modell mit mehreren Zeitreihen enthält

Python-Beispielcode:

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()

Temporale kausale Ausreißererkennung

Einer der Vorteile der Erstellung von TCM-Modellen ist die Fähigkeit, modellbasierte Ausreißer zu erkennen. Als Ausreißererkennung wird die Funktionalität bezeichnet, mit der die Zeitpunkte in der Zielzeitreihe ermittelt werden, deren Werte zu weit von ihren erwarteten (angepassten) Werten auf der Basis der TCM-Modelle abweichen.

Temporale kausale Ursachenanalyse

Als Ursachenanalyse wird eine Funktionalität zum Untersuchen des Granger-Kausalitätsdiagramms bezeichnet, mit der die wichtigsten/ursächlichen Werte analysiert werden, die zum jeweiligen Ausreißer geführt haben.

Temporale kausale Szenarioanalyse

Die Szenarioanalyse verweist auf eine Funktion der TCM-Modelle, die Auswirkungen der künstlichen Festlegung des Werts einer Zeitreihe 'auszuspielen'. Ein Szenario ist die Gruppe der Vorhersagen, die ausgeführt werden, indem die Werte einer Stammzeitreihe durch einen Vektor von Ersatzwerten ersetzt werden.

Temporale kausale Zusammenfassung

Die TCM-Zusammenfassung wählt die oberen N Modelle auf der Basis eines Modellqualitätsmaßes aus. Es gibt fünf Modellqualitätmaße: Wurzel der mittleren Fehlerquadratsumme (Root Mean Squared Error, RMSE), Wurzel der mittleren Fehlerquadratsumme (Prozent) (Root Mean Squared Percentage Error - RMSPE), Bayes-Informationskriterium (Bayesian Information Criterion - BIC), Akaike-Informationskriterium (Akaike Information Criterion - AIC) und R-Quadrat (R squared - RSQUARE). Sowohl N als auch das Modellqualitätsmaß können vom Benutzer festgelegt werden.

Zeitreihenuntersuchung

Die Zeitreihenexploration untersucht die Merkmale von Zeitreihendaten auf der Basis von Statistiken und Tests zum Generieren von vorläufigen Einblicken in die Zeitreihe vor der Modellierung. Sie deckt nicht nur Analysemethoden für erfahrene Benutzer ab (einschließlich Zeitreihen-Clustering, Einheitenstammtest und Korrelationen), sondern stellt auch einen automatischen Explorationsprozess bereit, der auf einer einfachen Zeitreihen-Dekompositionsmethode für Geschäftsbenutzer basiert.

Python-Beispielcode:

from spss.ml.forecasting.timeseriesexploration import TimeSeriesExploration

tse = TimeSeriesExploration(). \
    setAutoExploration(True). \
    setClustering(True)

tseModel = tse.fit(data)
predictions = tseModel.transform(data)
predictions.show()

Regressive Datenaufbereitung für Zeitreihendaten

Die umgekehrte Datenaufbereitung für Zeitreihendaten (Reverse Time Series Data Preparation, RTSDP) bietet Funktionen, die das von TSDP (Time Series Data Preperation) oder TCM (Temporal Causal Model) generierte Format CRB (Compact Row Based) zurück in das vereinfachte mehrdimensionale Format (Flattened Multi-Dimensional, FMD) umwandelt.

Python-Beispielcode:

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()

Übergeordnetes Thema: SPSS Vorhersageanalysealgorithmen