Ejemplo n.º 1
0
def fallback(mase_all, smape_all, train, test, m):
    naive = NaiveSeasonal(K=m)
    naive.fit(train)
    forecast = naive.predict(len(test))
    mase_all.append(np.vstack([
        mase_m4(train, test, forecast, m=m),
    ]))
    smape_all.append(np.vstack([
        smape_m4(test, forecast),
    ]))
Ejemplo n.º 2
0
    def test_predict_ensemble_local_models(self):
        naive = NaiveSeasonal(K=5)
        theta = Theta()
        naive_ensemble = NaiveEnsembleModel([naive, theta])
        naive_ensemble.fit(self.series1 + self.series2)
        forecast_naive_ensemble = naive_ensemble.predict(5)
        naive.fit(self.series1 + self.series2)
        theta.fit(self.series1 + self.series2)
        forecast_mean = 0.5 * naive.predict(5) + 0.5 * theta.predict(5)

        self.assertTrue(
            np.array_equal(forecast_naive_ensemble.values(),
                           forecast_mean.values()))
Ejemplo n.º 3
0
    def test_forecasting_residuals(self):
        model = NaiveSeasonal(K=1)

        # test zero residuals
        constant_ts = ct(length=20)
        residuals = model.residuals(constant_ts)
        np.testing.assert_almost_equal(residuals.univariate_values(),
                                       np.zeros(len(residuals)))

        # test constant, positive residuals
        linear_ts = lt(length=20)
        residuals = model.residuals(linear_ts)
        np.testing.assert_almost_equal(np.diff(residuals.univariate_values()),
                                       np.zeros(len(residuals) - 1))
        np.testing.assert_array_less(np.zeros(len(residuals)),
                                     residuals.univariate_values())
Ejemplo n.º 4
0
def naive2_groe(ts: TimeSeries, n: int, m: int):
    """
    Return the prediction of the naive2 baseline
    """
    # It will be better to use R functions
    ts_des = ts
    seasonOut = 1
    if m > 1:
        if check_seasonality(ts, m=int(m), max_lag=2 * m):
            _, season = extract_trend_and_seasonality(ts, m, model=ModelMode.MULTIPLICATIVE)
            ts_des = remove_from_series(ts, season, model=ModelMode.MULTIPLICATIVE)
            seasonOut = season[-m:].shift(m)
            seasonOut = seasonOut.append_values(seasonOut.values())[:n]
    naive2 = NaiveSeasonal(K=1)

    naive2.fit(ts_des)
    return naive2.predict(n) * seasonOut
Ejemplo n.º 5
0
 def test_fit_univar_ts_with_covariates_for_local_models(self):
     naive = NaiveEnsembleModel(
         [NaiveDrift(),
          NaiveSeasonal(),
          Theta(),
          ExponentialSmoothing()])
     with self.assertRaises(ValueError):
         naive.fit(self.series1, self.series2)
Ejemplo n.º 6
0
 def test_input_models_local_models(self):
     with self.assertRaises(ValueError):
         NaiveEnsembleModel([])
     with self.assertRaises(ValueError):
         NaiveEnsembleModel(
             [NaiveDrift, NaiveSeasonal, Theta, ExponentialSmoothing])
     with self.assertRaises(ValueError):
         NaiveEnsembleModel(
             [NaiveDrift(), NaiveSeasonal,
              Theta(),
              ExponentialSmoothing()])
     NaiveEnsembleModel(
         [NaiveDrift(),
          NaiveSeasonal(),
          Theta(),
          ExponentialSmoothing()])
Ejemplo n.º 7
0
 m = int(info_dataset.Frequency[cat[0] + "1"])
 for train, test in _build_tqdm_iterator(zip(ts_train, ts_test),
                                         verbose=True):
     train_des = train
     seasonOut = 1
     if m > 1:
         if check_seasonality(train, m=m, max_lag=2 * m):
             _, season = extract_trend_and_seasonality(
                 train, m, model=ModelMode.MULTIPLICATIVE)
             train_des = remove_from_series(
                 train, season, model=ModelMode.MULTIPLICATIVE)
             seasonOut = season[-m:].shift(m)
             seasonOut = seasonOut.append_values(seasonOut.values())
             seasonOut = seasonOut[:len(test)]
     naive = NaiveDrift()
     naive2 = NaiveSeasonal(K=1)
     naiveSeason = NaiveSeasonal(K=m)
     ses = ExponentialSmoothing(trend=None,
                                seasonal=None,
                                seasonal_periods=m)
     holt = ExponentialSmoothing(seasonal=None,
                                 damped=False,
                                 trend='additive',
                                 seasonal_periods=m)
     damp = ExponentialSmoothing(seasonal=None,
                                 damped=True,
                                 trend='additive',
                                 seasonal_periods=m)
     naive.fit(train)
     naive2.fit(train_des)
     naiveSeason.fit(train)
Ejemplo n.º 8
0
    (ExponentialSmoothing(), 5.6),
    (ARIMA(12, 2, 1), 10),
    (ARIMA(1, 1, 1), 40),
    (StatsForecastAutoARIMA(period=12), 4.8),
    (Croston(version="classic"), 34),
    (Croston(version="tsb", alpha_d=0.1, alpha_p=0.1), 34),
    (Theta(), 11.3),
    (Theta(1), 20.2),
    (Theta(-1), 9.8),
    (FourTheta(1), 20.2),
    (FourTheta(-1), 9.8),
    (FourTheta(trend_mode=TrendMode.EXPONENTIAL), 5.5),
    (FourTheta(model_mode=ModelMode.MULTIPLICATIVE), 11.4),
    (FourTheta(season_mode=SeasonalityMode.ADDITIVE), 14.2),
    (FFT(trend="poly"), 11.4),
    (NaiveSeasonal(), 32.4),
    (KalmanForecaster(dim_x=3), 17.0),
]

if TORCH_AVAILABLE:
    models += [
        (LinearRegressionModel(lags=12), 11.0),
        (RandomForest(lags=12, n_estimators=200, max_depth=3), 15.5),
    ]

# forecasting models with exogenous variables support
multivariate_models = [
    (VARIMA(1, 0, 0), 55.6),
    (VARIMA(1, 1, 1), 57.0),
    (KalmanForecaster(dim_x=30), 30.0),
]
Ejemplo n.º 9
0
        smape_all = []
        m = int(info_dataset.Frequency[freq[0] + '1'])
        for train, test in _build_tqdm_iterator(zip(ts_train, ts_test), verbose=True):
            # remove seasonality
            train_des = train
            seasonOut = 1
            season = constant_timeseries(length=len(train), freq=train.freq_str, start_ts=train.start_time())
            if m > 1:
                if check_seasonality(train, m=m, max_lag=2 * m):
                    pass
                    _, season = extract_trend_and_seasonality(train, m, model=ModelMode.MULTIPLICATIVE)
                    train_des = remove_from_series(train, season, model=ModelMode.MULTIPLICATIVE)
                    seasonOut = season[-m:].shift(m)
                    seasonOut = seasonOut.append_values(seasonOut.values())[:len(test)]
            # model selection
            naiveSeason = NaiveSeasonal(K=m)
            naive2 = NaiveSeasonal(K=1)
            ses = ExponentialSmoothing(trend=None, seasonal=None, seasonal_periods=m)
            holt = ExponentialSmoothing(seasonal=None, damped=False, trend='additive', seasonal_periods=m)
            damp = ExponentialSmoothing(seasonal=None, damped=True, trend='additive', seasonal_periods=m)

            fourtheta = FourTheta.select_best_model(train, [1, 2, 3], m)
            theta = Theta(theta=0, season_mode=SeasonalityMode.MULTIPLICATIVE, seasonality_period=m)

            models_simple = [naiveSeason, theta, fourtheta]
            models_des = [naive2, ses, holt, damp]

            # Linear Regression (with constraints)

            def train_pred(id_start=None, id_end=None):
                for m in models_simple:
Ejemplo n.º 10
0
 def get_local_models(self):
     return [NaiveDrift(), NaiveSeasonal(5), NaiveSeasonal(10)]
Ejemplo n.º 11
0
 def test_call_predict_local_models(self):
     naive_ensemble = NaiveEnsembleModel([NaiveSeasonal(), Theta()])
     with self.assertRaises(Exception):
         naive_ensemble.predict(5)
     naive_ensemble.fit(self.series1)
     naive_ensemble.predict(5)
Ejemplo n.º 12
0
            seasonOut = 1
            season = constant_timeseries(length=len(train),
                                         freq=train.freq_str(),
                                         start_ts=train.start_time())
            if m > 1:
                if check_seasonality(train, m=m, max_lag=2 * m):
                    pass
                    _, season = extract_trend_and_seasonality(
                        train, m, model=ModelMode.MULTIPLICATIVE)
                    train_des = remove_from_series(
                        train, season, model=ModelMode.MULTIPLICATIVE)
                    seasonOut = season[-m:].shift(m)
                    seasonOut = seasonOut.append_values(
                        seasonOut.values())[:len(test)]
            # model selection
            naiveSeason = NaiveSeasonal(K=m)
            naive2 = NaiveSeasonal(K=1)
            ses = ExponentialSmoothing(trend=None,
                                       seasonal=None,
                                       seasonal_periods=m)
            holt = ExponentialSmoothing(seasonal=None,
                                        damped=False,
                                        trend='additive',
                                        seasonal_periods=m)
            damp = ExponentialSmoothing(seasonal=None,
                                        damped=True,
                                        trend='additive',
                                        seasonal_periods=m)

            fourtheta = FourTheta.select_best_model(train, [1, 2, 3], m)
            theta = Theta(theta=0,