TimeSeriesDataPreparationConvertor

Questa è l'API del convertitore data / ora utilizzata per fornire alcune funzionalità del convertitore data / ora all'interno di TSDP per le applicazioni da utilizzare. Esistono due casi di utilizzo per questo componente:

• Calcola i punti temporali tra un'ora di avvio e un'ora di fine specificati. In questo caso, l'ora di inizio e di fine si verificano entrambe dopo la prima osservazione nell'output del TSDP precedente.
• Calcolare i punti temporali tra un indice iniziale e un indice finale che fanno riferimento all'ultima osservazione nell'output del TSDP precedente.

Modellazione causale temporale

TCM (temporal causal modeling) si riferisce a una serie di metodi che tentano di rilevare le relazioni temporali chiave nei dati delle serie temporali utilizzando una combinazione di algoritmi di causalità e regressione Granger per la selezione delle variabili.

Codice di esempioPython :

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

Modello regressivo automatico causale temporale

I modelli autoregressivi (AR) sono creati per calcolare le previsioni fuori campione per le serie predittore che non sono serie di destinazione. Queste previsioni predittore vengono quindi utilizzate per calcolare le previsioni fuori campione per le serie di destinazione.

Modello prodotto da TemporalCausal

TemporalCausal esporta gli output:

• un file JSON che contiene informazioni sul modello TemporalCausal
• un file XML che contiene un modello a più serie

Codice di esempioPython :

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

Rilevamento valore anomalo causale temporale

Uno dei vantaggi della creazione di modelli TCM è la possibilità di rilevare valori anomali basati su modelli. Il rilevamento dei valori anomali si riferisce alla capacità di identificare i punti temporali nella serie di destinazione con valori che si allontanano troppo dai valori previsti (adattati) in base ai modelli TCM.

Analisi della causa principale causale temporale

L'analisi della causa principale si riferisce alla possibilità di esplorare il grafico causale Granger per analizzare i valori chiave / root che hanno determinato il valore anomalo in questione.

Analisi scenario causale temporale

L'analisi degli scenari fa riferimento alla capacità dei modelli TCM di "riprodurre" le ripercussioni di impostare artificialmente il valore di una serie temporale. Uno scenario è la serie di previsioni che vengono eseguite sostituendo i valori di una serie temporale root con un vettore di valori sostitutivi.

Riepilogo causale temporale

Riepilogo TCM seleziona i primi N modelli in base a una misura di qualità del modello. Esistono cinque misure di qualità del modello: errore quadratico medio (RMSE), errore percentuale quadratico medio (RMSPE), criterio di informazione bayesiano (BIC), criterio di informazione di Akaike (AIC) e R quadrato (RSQUARE). Sia N che la misura di qualità del modello possono essere impostati dall'utente.

Esplorazione serie temporali

L'esplorazione delle serie temporali esplora le caratteristiche dei dati delle serie temporali basati su alcune statistiche e test per generare informazioni preliminari sulle serie temporali prima della modellazione. Comprende non solo metodi analitici per utenti esperti (inclusi clustering di serie temporali, test root di unità e correlazioni), ma fornisce anche un processo di esplorazione automatico basato su un semplice metodo di decomposizione di serie temporali per gli utenti aziendali.

Codice di esempioPython :

from spss.ml.forecasting.timeseriesexploration import TimeSeriesExploration

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

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

Preparazione dei dati inversi per i dati delle serie temporali

Reverse Data preparation for time series data (RTSDP) fornisce una funzionalità che converte il formato compatto basato sulle righe (CRB) generato da TimeSeriesDataPreperation (TSDP) o TemporalCausalModel (TCM Score) nel formato multidimensionale appiattito (FMD).

Codice di esempioPython :

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

Argomento principale SPSS algoritmi di analisi predittiva