Konwersator TimeSeriesDataPreparation

Jest to interfejs API konwertora daty/czasu, który jest używany do udostępniania niektórych funkcji konwersatora daty/godziny w programie TSDP dla aplikacji, które mają być używane. Istnieją dwa przypadki użycia dla tego komponentu:

• Oblicz punkty czasu między określonym czasem rozpoczęcia i zakończenia. W tym przypadku czas rozpoczęcia i zakończenia występuje po pierwszej obserwacji w poprzednim wyjściu TSDP.
• Należy obliczyć punkty czasu między indeksem początkowym i indeksem końcowym, które odnoszą się do ostatniej obserwacji w poprzednim wyjściu TSDP.

Modelowanie przyczynowe szeregów czasowych

Modelowanie przyczynowe szeregów czasowych (TCM) odnosi się do zestawu metod, które próbują wykryć kluczowe relacje czasowe w danych szeregów czasowych za pomocą kombinacji przyczynowości i algorytmów regresji Grangera do wyboru zmiennych.

Kod przykładowyPython :

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

Model regresywny przyczynowy przyczynowy szeregów czasowych

Modele autoregresyjne (AR) są budowane w celu obliczenia prognoz dla serii predyktorów, które nie są seriami docelowymi. Te prognozy predyktorów są następnie używane do obliczenia prognoz dla serii docelowej z próbką.

Model utworzony przez TemporalCausal

TemporalCausal eksportuje dane wyjściowe:

• Plik JSON zawierający informacje o modelu TemporalCausal .
• plik XML, który zawiera model z wieloma seriami

Kod przykładowyPython :

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

Wykrywanie odstających szeregów czasowych przyczynowych

Jedną z zalet budowania modeli TCM jest możliwość wykrywania odstających modeli opartych na modelu. Wykrywanie wartości odstających odnosi się do możliwości identyfikowania punktów czasowych w seriach docelowych z wartościami, które są zbyt dalekie od oczekiwanych (dopasowanych) wartości w oparciu o modele TCM.

Analiza podstawowej przyczyny przyczynowej przyczynowej

Analiza podstawowej przyczyny odnosi się do możliwości eksplorowania wykresu przyczynowego Grangera w celu przeanalizowania wartości klucz/użytkownika root, których wynikiem było dane odstające.

Analiza scenariusza przyczynowego szeregów czasowych

Analiza scenariuszy odnosi się do możliwości modeli TCM do "play-out" reperkusji sztucznie ustawiających wartość szeregu czasowego. Scenariusz to zestaw prognoz, które są wykonywane przez podstawienie wartości głównego szeregu czasowego przez wektor wartości zastępczych.

Podsumowanie przyczynowe szeregów czasowych

TCM Summary wybiera pierwsze N modeli w oparciu o jedną miarę jakości modelu. Istnieje pięć miar jakości modelu: Błąd średniej kwadratowej średniej (RMSE), Błąd wartości procentowej średniej kwadratowej (RMSPE), Bayesowskie kryterium informacyjne (BIC), Kryterium informacyjne Akaike (AIC) i kwadrat R kwadrat (RSQUARE). Zarówno N, jak i model miary jakości mogą być ustawione przez użytkownika.

Eksplorowanie szeregów czasowych

Eksploracja szeregów czasowych eksploruje charakterystykę danych szeregów czasowych w oparciu o niektóre statystyki i testy w celu wygenerowania wstępnych spostrzeżeń na temat szeregów czasowych przed modelowaniem. Obejmuje ona nie tylko metody analityczne dla użytkowników zaawansowanych (w tym grupowanie szeregów czasowych, test główny jednostki oraz korelacje), ale także zapewnia automatyczny proces eksploracji oparty na prostej metodzie dekompozycji szeregów czasowych dla użytkowników biznesowych.

Kod przykładowyPython :

from spss.ml.forecasting.timeseriesexploration import TimeSeriesExploration

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

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

Przygotowanie danych z odwrotnego okresu dla danych szeregów czasowych

Funkcja odwrotnego przygotowania danych dla danych szeregów czasowych (RTSDP) zapewnia funkcjonalność, która przekształca format CRB wygenerowany przez model TimeSeriesDataPreperation (TSDP) lub TemporalCausal(TCM Score) z powrotem do formatu FMD (spłaszczonego wielowymiarowego).

Kod przykładowyPython :

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

Temat nadrzędny: Algorytmy analizy predykcyjnejSPSS