Esempio n. 1
0
def test_pipeline():
    y = load_airline()
    y_train, y_test = temporal_train_test_split(y)

    forecaster = TransformedTargetForecaster([
        ("t1", Deseasonalizer(sp=12, model="multiplicative")),
        ("t2", Detrender(PolynomialTrendForecaster(degree=1))),
        ("forecaster", NaiveForecaster()),
    ])
    fh = np.arange(len(y_test)) + 1
    forecaster.fit(y_train, fh=fh)
    actual = forecaster.predict()

    def compute_expected_y_pred(y_train, fh):
        # fitting
        yt = y_train.copy()
        t1 = Deseasonalizer(sp=12, model="multiplicative")
        yt = t1.fit_transform(yt)
        t2 = Detrender(PolynomialTrendForecaster(degree=1))
        yt = t2.fit_transform(yt)
        forecaster = NaiveForecaster()
        forecaster.fit(yt, fh=fh)

        # predicting
        y_pred = forecaster.predict()
        y_pred = t2.inverse_transform(y_pred)
        y_pred = t1.inverse_transform(y_pred)
        return y_pred

    expected = compute_expected_y_pred(y_train, fh)
    np.testing.assert_array_equal(actual, expected)
Esempio n. 2
0
def test_pipeline():
    """Test results of TransformedTargetForecaster."""
    y = load_airline()
    y_train, y_test = temporal_train_test_split(y)

    forecaster = TransformedTargetForecaster([
        ("t1", ExponentTransformer()),
        ("t2", TabularToSeriesAdaptor(MinMaxScaler())),
        ("forecaster", NaiveForecaster()),
    ])
    fh = np.arange(len(y_test)) + 1
    forecaster.fit(y_train, fh=fh)
    actual = forecaster.predict()

    def compute_expected_y_pred(y_train, fh):
        # fitting
        yt = y_train.copy()
        t1 = ExponentTransformer()
        yt = t1.fit_transform(yt)
        t2 = TabularToSeriesAdaptor(MinMaxScaler())
        yt = t2.fit_transform(yt)
        forecaster = NaiveForecaster()
        forecaster.fit(yt, fh=fh)

        # predicting
        y_pred = forecaster.predict()
        y_pred = t2.inverse_transform(y_pred)
        y_pred = t1.inverse_transform(y_pred)
        return y_pred

    expected = compute_expected_y_pred(y_train, fh)
    np.testing.assert_array_equal(actual, expected)
Esempio n. 3
0
def learn(series_data):
    model = TransformedTargetForecaster([
        ("deseasonalise", Deseasonalizer(model="multiplicative", sp=7)),
        ("detrend", Detrender(forecaster=PolynomialTrendForecaster(degree=4))),
        ("forecast", PolynomialTrendForecaster(degree=4))
    ])
    model.fit(series_data[:-2])
    return model
Esempio n. 4
0
def test_skip_inverse_transform():
    """Test transformers with skip-inverse-transform tag in pipeline."""
    y = load_airline()
    # add nan and outlier
    y.iloc[3] = np.nan
    y.iloc[4] = y.iloc[4] * 20

    y_train, y_test = temporal_train_test_split(y)
    forecaster = TransformedTargetForecaster([
        ("t1", HampelFilter(window_length=12)),
        ("t2", Imputer(method="mean")),
        ("forecaster", NaiveForecaster()),
    ])
    fh = np.arange(len(y_test)) + 1
    forecaster.fit(y_train, fh=fh)
    y_pred = forecaster.predict()
    assert isinstance(y_pred, pd.Series)
Esempio n. 5
0
def test_nesting_pipelines():
    """Test that nesting of pipelines works."""
    from sktime.forecasting.ets import AutoETS
    from sktime.transformations.series.boxcox import LogTransformer
    from sktime.transformations.series.compose import OptionalPassthrough
    from sktime.transformations.series.detrend import Detrender
    from sktime.utils._testing.scenarios_forecasting import (
        ForecasterFitPredictUnivariateWithX, )

    pipe = ForecastingPipeline(steps=[
        ("logX", OptionalPassthrough(LogTransformer())),
        ("detrenderX", OptionalPassthrough(Detrender(forecaster=AutoETS()))),
        (
            "etsforecaster",
            TransformedTargetForecaster(steps=[
                ("log", OptionalPassthrough(LogTransformer())),
                ("autoETS", AutoETS()),
            ]),
        ),
    ])

    scenario = ForecasterFitPredictUnivariateWithX()

    scenario.run(pipe, method_sequence=["fit", "predict"])
Esempio n. 6
0
    best_idx = gscv.best_index_
    assert best_idx == actual.argmin()

    best_params = gscv.best_params_
    assert best_params == param_grid[best_idx]

    # Check if best parameters are contained in best forecaster.
    best_forecaster_params = gscv.best_forecaster_.get_params()
    best_params = gscv.best_params_
    assert best_params.items() <= best_forecaster_params.items()


NAIVE = NaiveForecaster(strategy="mean")
NAIVE_GRID = {"window_length": TEST_WINDOW_LENGTHS}
PIPE = TransformedTargetForecaster([
    ("transformer", Detrender(PolynomialTrendForecaster())),
    ("forecaster", ARIMA()),
])
PIPE_GRID = {
    "transformer__forecaster__degree": [1, 2],
    "forecaster__with_intercept": [True, False],
}
CVs = [
    *[SingleWindowSplitter(fh=fh) for fh in TEST_OOS_FHS],
    SlidingWindowSplitter(fh=1, initial_window=15),
]


@pytest.mark.parametrize("forecaster, param_grid", [(NAIVE, NAIVE_GRID),
                                                    (PIPE, PIPE_GRID)])
@pytest.mark.parametrize("scoring", TEST_METRICS)
@pytest.mark.parametrize("cv", CVs)
Esempio n. 7
0
        y_test_subset = y_test.loc[
            y_pred.index
        ]  # select only time points which we predicted
        scores[i] = scoring(y_test_subset, y_pred)
    return scores


@pytest.mark.parametrize(
    "forecaster, param_dict",
    [
        (NaiveForecaster(strategy="mean"), {"window_length": TEST_WINDOW_LENGTHS}),
        # atomic estimator
        (
            TransformedTargetForecaster(
                [  # composite estimator
                    ("t", Detrender(PolynomialTrendForecaster())),
                    ("f", ReducedForecaster(LinearRegression(), scitype="regressor")),
                ]
            ),
            {
                "f__window_length": TEST_WINDOW_LENGTHS,
                "f__step_length": TEST_STEP_LENGTHS,
            },
        ),  # multiple params
    ],
)
@pytest.mark.parametrize(
    "scoring",
    [sMAPE(), make_forecasting_scorer(mean_squared_error, greater_is_better=False)],
)
@pytest.mark.parametrize(
    "cv",
Esempio n. 8
0
model = PolynomialTrendForecaster(degree=1)
transformer = Detrender(model)

yt = transformer.fit_transform(train)
trendline = model.fit(train).predict(fh=-np.arange(len(train)))

plot_ys(train, trendline, yt, labels=['series', 'trend', 'detrended'])

# ### Pipelining

# In[130]:

forecaster = TransformedTargetForecaster([
    ("deseasonalise", Deseasonalizer(model="multiplicative", sp=12)),
    ("detrend", Detrender(forecaster=PolynomialTrendForecaster(degree=1))),
    ("forecast",
     ReducedRegressionForecaster(regressor=regressor,
                                 window_length=12,
                                 strategy="recursive"))
])
forecaster.fit(train)
y_pred = forecaster.predict(fh)
plot_ys(train, test, y_pred, labels=["y_train", "y_test", "y_pred"])
smape_loss(test, y_pred)

# ## WORK IN PROGRESS

# ## Pipeline Tuning

# In[246]:

from sklearn.base import clone
Esempio n. 9
0
def make_pipeline(*estimators):
    """Helper function to make pipeline"""
    steps = [(estimator.__class__.__name__, estimator)
             for estimator in estimators]
    return TransformedTargetForecaster(steps)
Esempio n. 10
0
        y_test_subset = y_test.loc[
            y_pred.index]  # select only time points which we predicted
        scores[i] = scoring(y_test_subset, y_pred)
    return scores


@pytest.mark.parametrize(
    "forecaster, param_dict",
    [
        (NaiveForecaster(strategy="mean"), {
            "window_length": TEST_WINDOW_LENGTHS
        }),
        # atomic estimator
        (
            TransformedTargetForecaster([  # composite estimator
                ("t", Detrender(PolynomialTrendForecaster())),
                ("f", ReducedRegressionForecaster(LinearRegression()))
            ]),
            {
                "f__window_length": TEST_WINDOW_LENGTHS,
                "f__step_length": TEST_STEP_LENGTHS
            })  # multiple params
    ])
@pytest.mark.parametrize("scoring", [
    sMAPE(),
    make_forecasting_scorer(mean_squared_error, greater_is_better=False)
])
@pytest.mark.parametrize(
    "cv",
    [
        *[SingleWindowSplitter(fh=fh) for fh in TEST_OOS_FHS],
        # single split with multi-step fh