def test_gscv_fit(forecaster, param_dict, cv, scoring): param_grid = ParameterGrid(param_dict) y = load_airline() gscv = ForecastingGridSearchCV( forecaster, param_grid=param_dict, cv=cv, scoring=scoring ) gscv.fit(y) # check scores gscv_scores = gscv.cv_results_[f"mean_test_{scoring.name}"] expected_scores = compute_expected_gscv_scores( forecaster, cv, param_grid, y, scoring ) np.testing.assert_array_equal(gscv_scores, expected_scores) # check best parameters assert gscv.best_params_ == param_grid[gscv_scores.argmin()] # check best forecaster is the one with best parameters assert { key: value for key, value in gscv.best_forecaster_.get_params().items() if key in gscv.best_params_.keys() } == gscv.best_params_
def test_multiplex_with_grid_search(): """Test MultiplexForecaster perfromas as expected with ForecastingGridSearchCV. Because the typical use case of MultiplexForecaster is to use it with the ForecastingGridSearchCV forecaster - here we simply test that the best "selected_forecaster" for MultiplexForecaster found using ForecastingGridSearchCV is the same forecaster we would find if we evaluated all the forecasters in MultiplexForecaster independently. """ y = load_shampoo_sales() forecasters = [ ("ets", AutoETS()), ("naive", NaiveForecaster()), ] multiplex_forecaster = MultiplexForecaster(forecasters=forecasters) forecaster_names = [name for name, _ in forecasters] cv = ExpandingWindowSplitter(start_with_window=True, step_length=12) gscv = ForecastingGridSearchCV( cv=cv, param_grid={"selected_forecaster": forecaster_names}, forecaster=multiplex_forecaster, ) gscv.fit(y) gscv_best_name = gscv.best_forecaster_.selected_forecaster best_name = _score_forecasters(forecasters, cv, y) assert gscv_best_name == best_name
def test_gscv(forecaster, param_grid, cv, scoring): y, X = load_longley() gscv = ForecastingGridSearchCV(forecaster, param_grid=param_grid, cv=cv, scoring=scoring) gscv.fit(y, X) param_grid = ParameterGrid(param_grid) _check_cv(forecaster, gscv, cv, param_grid, y, X, scoring)
forecaster = ExponentialSmoothing() # In[39]: forecaster_param_grid = { 'trend': ['add', 'mul'], 'seasonal': ['add', 'mul'], 'sp': [12] } # In[40]: cv = SlidingWindowSplitter(initial_window=int(len(train) * 0.5)) gscv = ForecastingGridSearchCV(forecaster, cv=cv, param_grid=forecaster_param_grid) gscv.fit(train) y_pred = gscv.predict(fh) # In[43]: gscv.best_params_ # In[42]: plot_ys(train, test, y_pred, labels=["y_train", "y_test", "y_pred"]) smape_loss(test, y_pred) # ### Tune Forecaster & Reduced Regressor
def genforecast(data): from sktime.forecasting.model_selection import temporal_train_test_split import numpy as np import math y_train, y_test = temporal_train_test_split(data) fh = np.arange(1, len(y_test) + 1) testct = len(y_test) from sktime.forecasting.naive import NaiveForecaster forecaster = NaiveForecaster(strategy="drift") forecaster.fit(y_train) y_pred_naive = forecaster.predict(fh) from sktime.performance_metrics.forecasting import smape_loss naive_acc = round(smape_loss(y_pred_naive, y_test), 4) #full model dev and forecast next 5 days forecaster.fit(data) futurewin = np.arange(1, 6) # 5 day in future prediction fut_pred = forecaster.predict(futurewin) min_naive = round(min(fut_pred), 2) max_naive = round(max(fut_pred), 2) from sktime.forecasting.trend import PolynomialTrendForecaster forecaster = PolynomialTrendForecaster(degree=1) forecaster.fit(y_train) y_pred_poly = forecaster.predict(fh) from sktime.performance_metrics.forecasting import smape_loss poly_acc = round(smape_loss(y_pred_poly, y_test), 4) #full model dev and forecast next 5 days forecaster.fit(data) futurewin = np.arange(1, 6) # 5 day in future prediction fut_pred = forecaster.predict(futurewin) min_poly = round(min(fut_pred), 2) max_poly = round(max(fut_pred), 2) from sktime.forecasting.compose import EnsembleForecaster from sktime.forecasting.exp_smoothing import ExponentialSmoothing sp1 = math.floor(len(y_test) / 4) sp2 = min(sp1, 12) spval = max(2, sp2) forecaster = EnsembleForecaster([ ("ses", ExponentialSmoothing(seasonal="multiplicative", sp=spval)), ("holt", ExponentialSmoothing(trend="add", damped=False, seasonal="multiplicative", sp=spval)), ("damped", ExponentialSmoothing(trend="add", damped=True, seasonal="multiplicative", sp=spval)) ]) forecaster.fit(y_train) y_pred_ensem = forecaster.predict(fh) ensem_acc = round(smape_loss(y_test, y_pred_ensem), 4) #full model dev and forecast next 5 days forecaster.fit(data) futurewin = np.arange(1, 6) # 5 day in future prediction fut_pred = forecaster.predict(futurewin) min_ensem = round(min(fut_pred), 2) max_ensem = round(max(fut_pred), 2) from sklearn.neighbors import KNeighborsRegressor regressor = KNeighborsRegressor(n_neighbors=1) from sktime.forecasting.compose import ReducedRegressionForecaster forecaster = ReducedRegressionForecaster(regressor=regressor, window_length=15, strategy="recursive") param_grid = {"window_length": [5, 10, 15]} from sktime.forecasting.model_selection import SlidingWindowSplitter from sktime.forecasting.model_selection import ForecastingGridSearchCV # we fit the forecaster on the initial window, and then use temporal cross-validation to find the optimal parameter cv = SlidingWindowSplitter(initial_window=int(len(y_train) * 0.5)) gscv = ForecastingGridSearchCV(forecaster, cv=cv, param_grid=param_grid) gscv.fit(y_train) y_pred_redreg = gscv.predict(fh) redreg_acc = round(smape_loss(y_test, y_pred_redreg), 4) #full model dev and forecast next 5 days gscv.fit(data) futurewin = np.arange(1, 6) # 5 day in future prediction fut_pred = gscv.predict(futurewin) min_redreg = round(min(fut_pred), 2) max_redreg = round(max(fut_pred), 2) return min_naive, max_naive, min_poly, max_poly, min_ensem, max_ensem, min_redreg, max_redreg, y_test, testct, y_pred_naive, naive_acc, y_pred_poly, poly_acc, y_pred_ensem, ensem_acc, y_pred_redreg, redreg_acc
print("Arima with Seas.\t", mape_arima_seas) series_log = series.apply(np.log) plot_series(series_log) fh = ForecastingHorizon(series[-25:].index, is_relative=False) y_train, y_test = temporal_train_test_split(series.iloc[train_[0]:test_[0] + 1], test_size=1) y_predA, y_confA = ForecastingGridSearchCV( ARIMA(), SlidingWindowSplitter(window_length=48, start_with_window=True, initial_window=48), { 'order': [(p, d, q)] }, n_jobs=-1).fit(series).predict(fh, return_pred_int=True) y_predAS, y_confAS = ForecastingGridSearchCV( ARIMA(), SlidingWindowSplitter(window_length=48, start_with_window=True, initial_window=48), { 'order': [(p, d, q)], 'seasonal_order': [(P, D, Q, S)] }, n_jobs=-1).fit(series).predict(fh, return_pred_int=True) y_predN = ForecastingGridSearchCV(NaiveForecaster(),
st.pyplot() st.write("smape_loss(y_test, y_pred):", smape_loss(y_test, y_pred)) st.write(''' * Tuning In the `ReducedRegressionForecaster`, both the `window_length` and `strategy arguments` are hyper-parameters which we may want to optimise. ''') from sktime.forecasting.model_selection import ForecastingGridSearchCV forecaster = ReducedRegressionForecaster(regressor=regressor, window_length=15, strategy="recursive") param_grid = {"window_length": [5, 10, 15]} cv = SlidingWindowSplitter(initial_window=int(len(y_train) * 0.5)) gscv = ForecastingGridSearchCV(forecaster, cv=cv, param_grid=param_grid) gscv.fit(y_train) y_pred = gscv.predict(fh) plot_ys(y_train, y_test, y_pred, labels=["y_train", "y_test", "y_pred"]) st.pyplot() st.write("smape_loss(y_test, y_pred):", smape_loss(y_test, y_pred)) st.write("gscv.best_params_:", gscv.best_params_) st.write(''' * Detrending 请注意,到目前为止,上述减少方法并未考虑任何季节或趋势,但我们可以轻松地指定首先对数据进行趋势去除的管道。 sktime提供了一个通用的去趋势器,它是一个使用任何预测器并返回预测器预测值的样本内残差的转换器。 例如,要删除时间序列的线性趋势,我们可以写成 ''')