From 2d14a8bce8e0b145e22eed5761c1ebaef09a28c6 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 28 May 2023 14:39:34 +0200 Subject: [PATCH 1/5] move static covariates handling to create_lagged_dta --- darts/explainability/shap_explainer.py | 21 ++----- darts/models/forecasting/regression_model.py | 17 +++-- darts/utils/data/tabularization.py | 65 +++++++++++++++++--- 3 files changed, 70 insertions(+), 33 deletions(-) diff --git a/darts/explainability/shap_explainer.py b/darts/explainability/shap_explainer.py index 88dfcd437f..05684b8aaf 100644 --- a/darts/explainability/shap_explainer.py +++ b/darts/explainability/shap_explainer.py @@ -702,6 +702,8 @@ def _create_regression_model_shap_X( lags_future_covariates=lags_future_covariates_list if future_covariates else None, + uses_static_covariates=self.model.uses_static_covariates, + last_static_covariates_shape=self.model._static_covariates_shape, ) # Remove sample axis: X = X[:, :, 0] @@ -720,26 +722,11 @@ def _create_regression_model_shap_X( if n_samples: X = shap.utils.sample(X, n_samples) - # We keep the creation order of the different lags/features in create_lagged_data - lags_names_list = [] - if lags_list: - for lag in lags_list: - for t_name in self.target_components: - lags_names_list.append(t_name + "_target_lag" + str(lag)) - if lags_past_covariates_list: - for lag in lags_past_covariates_list: - for t_name in self.past_covariates_components: - lags_names_list.append(t_name + "_past_cov_lag" + str(lag)) - if lags_future_covariates_list: - for lag in lags_future_covariates_list: - for t_name in self.future_covariates_components: - lags_names_list.append(t_name + "_fut_cov_lag" + str(lag)) - + # rename output columns to the matching lagged features names X = X.rename( columns={ - name: lags_names_list[idx] + name: self.model.lagged_feature_names[idx] for idx, name in enumerate(X.columns.to_list()) } ) - return X diff --git a/darts/models/forecasting/regression_model.py b/darts/models/forecasting/regression_model.py index f976d62d58..d9e8e8891b 100644 --- a/darts/models/forecasting/regression_model.py +++ b/darts/models/forecasting/regression_model.py @@ -353,7 +353,12 @@ def _create_lagged_data( lags_past_covariates = self.lags.get("past") lags_future_covariates = self.lags.get("future") - features, labels, _ = create_lagged_training_data( + ( + features, + labels, + _, + self._static_covariates_shape, + ) = create_lagged_training_data( target_series=target_series, output_chunk_length=self.output_chunk_length, past_covariates=past_covariates, @@ -361,6 +366,8 @@ def _create_lagged_data( lags=lags, lags_past_covariates=lags_past_covariates, lags_future_covariates=lags_future_covariates, + uses_static_covariates=self.uses_static_covariates, + last_static_covariates_shape=None, max_samples_per_ts=max_samples_per_ts, multi_models=self.multi_models, check_inputs=False, @@ -371,14 +378,6 @@ def _create_lagged_data( features[i] = X_i[:, :, 0] labels[i] = y_i[:, :, 0] - features, static_covariates_shape = add_static_covariates_to_lagged_data( - features, - target_series, - uses_static_covariates=self.uses_static_covariates, - last_shape=None, - ) - self._static_covariates_shape = static_covariates_shape - training_samples = np.concatenate(features, axis=0) training_labels = np.concatenate(labels, axis=0) diff --git a/darts/utils/data/tabularization.py b/darts/utils/data/tabularization.py index 5f3d336149..a6bb999f29 100644 --- a/darts/utils/data/tabularization.py +++ b/darts/utils/data/tabularization.py @@ -29,13 +29,20 @@ def create_lagged_data( lags_past_covariates: Optional[Sequence[int]] = None, lags_future_covariates: Optional[Sequence[int]] = None, output_chunk_length: int = 1, + uses_static_covariates: bool = True, + last_static_covariates_shape: Optional[Tuple[int, int]] = None, max_samples_per_ts: Optional[int] = None, multi_models: bool = True, check_inputs: bool = True, use_moving_windows: bool = True, is_training: bool = True, concatenate: bool = True, -) -> Tuple[ArrayOrArraySequence, Union[None, ArrayOrArraySequence], Sequence[pd.Index]]: +) -> Tuple[ + ArrayOrArraySequence, + Union[None, ArrayOrArraySequence], + Sequence[pd.Index], + Optional[Tuple[int, int]], +]: """ Creates the features array `X` and labels array `y` to train a lagged-variables regression model (e.g. an `sklearn` model) when `is_training = True`; alternatively, creates the features array `X` to produce a series @@ -154,6 +161,12 @@ def create_lagged_data( `lags_past_covariates`, `lags_future_covariates` values can be positive (i.e. use values *after* time `t` to predict target at time `t`), zero (i.e. use values *at* time `t` to predict target at time `t`), and/or negative (i.e. use values *before* time `t` to predict target at time `t`). + uses_static_covariates + Whether the model uses/expects static covariates. If `True`, it enforces that static covariates must + have identical shapes across all target series. + last_static_covariates_shape + Optionally, the last observed shape of the static covariates. This is ``None`` before fitting, or when + `uses_static_covariates` is ``False``. max_samples_per_ts Optionally, the maximum number of samples to be drawn for training/validation; only the most recent samples are kept. In theory, specifying a smaller `max_samples_per_ts` should reduce computation time, @@ -207,6 +220,10 @@ def create_lagged_data( gives the times of those observations formed using the `i`th `TimeSeries` object in each `Sequence`. Otherwise, if the series inputs were specified as `TimeSeries`, the only element is the times of those observations formed from the lone `TimeSeries` inputs. + last_static_covariates_shape + The last observed shape of the static covariates. This is ``None`` when `uses_static_covariates` + is ``False``. + Raises ------ @@ -288,6 +305,12 @@ def create_lagged_data( check_inputs, is_training, ) + X_i, last_static_covariates_shape = add_static_covariates_to_lagged_data( + features=X_i, + target_series=target_i, + uses_static_covariates=uses_static_covariates, + last_shape=last_static_covariates_shape, + ) X.append(X_i) y.append(y_i) times.append(times_i) @@ -298,7 +321,7 @@ def create_lagged_data( y = None elif concatenate: y = np.concatenate(y, axis=0) - return X, y, times + return X, y, times, last_static_covariates_shape def create_lagged_training_data( @@ -309,12 +332,19 @@ def create_lagged_training_data( lags: Optional[Sequence[int]] = None, lags_past_covariates: Optional[Sequence[int]] = None, lags_future_covariates: Optional[Sequence[int]] = None, + uses_static_covariates: bool = True, + last_static_covariates_shape: Optional[Tuple[int, int]] = None, max_samples_per_ts: Optional[int] = None, multi_models: bool = True, check_inputs: bool = True, use_moving_windows: bool = True, concatenate: bool = True, -) -> Tuple[ArrayOrArraySequence, Union[None, ArrayOrArraySequence], Sequence[pd.Index]]: +) -> Tuple[ + ArrayOrArraySequence, + Union[None, ArrayOrArraySequence], + Sequence[pd.Index], + Optional[Tuple[int, int]], +]: """ Creates the features array `X` and labels array `y` to train a lagged-variables regression model (e.g. an `sklearn` model); the time index values of each observation is also returned. @@ -349,6 +379,12 @@ def create_lagged_training_data( `lags_future_covariates` values can be positive (i.e. use values *after* time `t` to predict target at time `t`), zero (i.e. use values *at* time `t` to predict target at time `t`), and/or negative (i.e. use values *before* time `t` to predict target at time `t`). + uses_static_covariates + Whether the model uses/expects static covariates. If `True`, it enforces that static covariates must + have identical shapes across all target series. + last_static_covariates_shape + Optionally, the last observed shape of the static covariates. This is ``None`` before fitting, or when + `uses_static_covariates` is ``False``. max_samples_per_ts Optionally, the maximum number of samples to be drawn for training/validation; only the most recent samples are kept. In theory, specifying a smaller `max_samples_per_ts` should reduce computation time, @@ -416,6 +452,8 @@ def create_lagged_training_data( lags_past_covariates=lags_past_covariates, lags_future_covariates=lags_future_covariates, output_chunk_length=output_chunk_length, + uses_static_covariates=uses_static_covariates, + last_static_covariates_shape=last_static_covariates_shape, max_samples_per_ts=max_samples_per_ts, multi_models=multi_models, check_inputs=check_inputs, @@ -432,6 +470,8 @@ def create_lagged_prediction_data( lags: Optional[Sequence[int]] = None, lags_past_covariates: Optional[Sequence[int]] = None, lags_future_covariates: Optional[Sequence[int]] = None, + uses_static_covariates: bool = True, + last_static_covariates_shape: Optional[Tuple[int, int]] = None, max_samples_per_ts: Optional[int] = None, check_inputs: bool = True, use_moving_windows: bool = True, @@ -469,6 +509,12 @@ def create_lagged_prediction_data( `lags_future_covariates` values can be positive (i.e. use values *after* time `t` to predict target at time `t`), zero (i.e. use values *at* time `t` to predict target at time `t`), and/or negative (i.e. use values *before* time `t` to predict target at time `t`). + uses_static_covariates + Whether the model uses/expects static covariates. If `True`, it enforces that static covariates must + have identical shapes across all target series. + last_static_covariates_shape + Optionally, the last observed shape of the static covariates. This is ``None`` before fitting, or when + `uses_static_covariates` is ``False``. max_samples_per_ts Optionally, the maximum number of samples to be drawn for training/validation; only the most recent samples are kept. In theory, specifying a smaller `max_samples_per_ts` should reduce computation time, @@ -517,13 +563,15 @@ def create_lagged_prediction_data( If the provided series do not share the same type of `time_index` (e.g. `target_series` uses a pd.RangeIndex, but `future_covariates` uses a `pd.DatetimeIndex`). """ - X, _, times = create_lagged_data( + X, _, times, _ = create_lagged_data( target_series=target_series, past_covariates=past_covariates, future_covariates=future_covariates, lags=lags, lags_past_covariates=lags_past_covariates, lags_future_covariates=lags_future_covariates, + uses_static_covariates=uses_static_covariates, + last_static_covariates_shape=last_static_covariates_shape, max_samples_per_ts=max_samples_per_ts, check_inputs=check_inputs, use_moving_windows=use_moving_windows, @@ -607,12 +655,15 @@ def add_static_covariates_to_lagged_data( static_covs = ts.static_covariates.values.flatten(order="F") # we stack the static covariates to the right of lagged features # the broadcasting repeats the static covariates along axis=0 to match the number of feature rows + shape_out = ( + (len(features[idx]), len(static_covs)) + if len(features[idx].shape) == 2 + else (len(features[idx]), len(static_covs), 1) + ) features[idx] = np.hstack( [ features[idx], - np.broadcast_to( - static_covs, (len(features[idx]), len(static_covs)) - ), + np.broadcast_to(static_covs, shape_out), ] ) From f6084c19cc2d12e08426ea1171229972586daa78 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 28 May 2023 15:01:33 +0200 Subject: [PATCH 2/5] added tests for shap explainer with static covariates --- .../explainability/test_shap_explainer.py | 87 +++++++++++++++++++ darts/utils/data/tabularization.py | 2 +- 2 files changed, 88 insertions(+), 1 deletion(-) diff --git a/darts/tests/explainability/test_shap_explainer.py b/darts/tests/explainability/test_shap_explainer.py index 4c8cd2b73e..6b8399bde0 100644 --- a/darts/tests/explainability/test_shap_explainer.py +++ b/darts/tests/explainability/test_shap_explainer.py @@ -3,6 +3,7 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd +import pytest import shap import sklearn from dateutil.relativedelta import relativedelta @@ -90,6 +91,25 @@ class ShapExplainerTestCase(DartsBaseTestClass): days, np.concatenate([x_1.reshape(-1, 1), x_2.reshape(-1, 1)], axis=1) ).with_columns_renamed(["0", "1"], ["price", "power"]) + target_ts_with_static_covs = TimeSeries.from_times_and_values( + days, + x_1.reshape(-1, 1), + static_covariates=pd.DataFrame({"type": [0], "state": [1]}), + ).with_columns_renamed(["0"], ["price"]) + target_ts_with_multi_component_static_covs = TimeSeries.from_times_and_values( + days, + np.concatenate([x_1.reshape(-1, 1), x_2.reshape(-1, 1)], axis=1), + static_covariates=pd.DataFrame({"type": [0, 1], "state": [2, 3]}), + ).with_columns_renamed(["0", "1"], ["price", "power"]) + target_ts_multiple_series_with_different_static_covs = [ + TimeSeries.from_times_and_values( + days, x_1.reshape(-1, 1), static_covariates=pd.DataFrame({"type": [0]}) + ).with_columns_renamed(["0"], ["price"]), + TimeSeries.from_times_and_values( + days, x_2.reshape(-1, 1), static_covariates=pd.DataFrame({"state": [1]}) + ).with_columns_renamed(["0"], ["price"]), + ] + past_cov_ts = TimeSeries.from_times_and_values( days_past_cov, np.concatenate( @@ -670,3 +690,70 @@ def test_shap_explanation_object_validity(self): ), shap.Explanation, ) + + def test_shapley_with_static_cov(self): + ts = self.target_ts_with_static_covs + model = LightGBMModel( + lags=4, + output_chunk_length=1, + ) + model.fit( + series=ts, + ) + shap_explain = ShapExplainer(model) + + # different static covariates dimensions should raise an error + with pytest.raises(ValueError): + shap_explain.explain( + ts.with_static_covariates(ts.static_covariates["state"]) + ) + + # without static covariates should raise an error + with pytest.raises(ValueError): + shap_explain.explain(ts.with_static_covariates(None)) + + explanation_results = shap_explain.explain(ts) + assert len(explanation_results.explained_forecasts[1]["price"].columns) == ( + -(min(model.lags["target"])) + model.static_covariates.shape[1] + ) + + model.fit( + series=self.target_ts_with_multi_component_static_covs, + ) + shap_explain = ShapExplainer(model) + explanation_results = shap_explain.explain() + assert len(explanation_results.feature_values[1]) == 2 + for comp in self.target_ts_with_multi_component_static_covs.components: + comps_out = explanation_results.explained_forecasts[1][comp].columns + assert len(comps_out) == ( + -(min(model.lags["target"])) * model.input_dim["target"] + + model.input_dim["target"] * model.static_covariates.shape[1] + ) + assert comps_out[-4:].tolist() == [ + "type_statcov_target_price", + "type_statcov_target_power", + "state_statcov_target_price", + "state_statcov_target_power", + ] + + def test_shapley_multiple_series_with_different_static_covs(self): + model = LightGBMModel( + lags=4, + output_chunk_length=1, + ) + model.fit( + series=self.target_ts_multiple_series_with_different_static_covs, + ) + shap_explain = ShapExplainer( + model, + background_series=self.target_ts_multiple_series_with_different_static_covs, + ) + explanation_results = shap_explain.explain() + + self.assertTrue(len(explanation_results.feature_values) == 2) + + # model trained on multiple series will take column names of first series -> even though + # static covs have different names, the output will show the same names + for explained_forecast in explanation_results.explained_forecasts: + comps_out = explained_forecast[1]["price"].columns.tolist() + assert comps_out[-1] == "type_statcov_target_price" diff --git a/darts/utils/data/tabularization.py b/darts/utils/data/tabularization.py index a6bb999f29..74c1c65ea7 100644 --- a/darts/utils/data/tabularization.py +++ b/darts/utils/data/tabularization.py @@ -663,7 +663,7 @@ def add_static_covariates_to_lagged_data( features[idx] = np.hstack( [ features[idx], - np.broadcast_to(static_covs, shape_out), + np.broadcast_to(static_covs, shape_out[:2]).reshape(shape_out), ] ) From c7bae309c30f98f4f37f39b2432eb86c9ff755fd Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 28 May 2023 15:26:18 +0200 Subject: [PATCH 3/5] fixed bug in ShapExplainer when using selected components --- darts/explainability/explainability_result.py | 21 +++++------ darts/explainability/shap_explainer.py | 11 +++--- .../explainability/test_shap_explainer.py | 36 +++++++++++++++++++ 3 files changed, 52 insertions(+), 16 deletions(-) diff --git a/darts/explainability/explainability_result.py b/darts/explainability/explainability_result.py index 2eaf2f0948..372e5a4491 100644 --- a/darts/explainability/explainability_result.py +++ b/darts/explainability/explainability_result.py @@ -9,7 +9,6 @@ from typing import Any, Dict, Optional, Sequence, Union import shap -from numpy import integer from darts import TimeSeries from darts.logging import get_logger, raise_if, raise_if_not @@ -26,8 +25,8 @@ class ExplainabilityResult(ABC): def __init__( self, explained_forecasts: Union[ - Dict[integer, Dict[str, TimeSeries]], - Sequence[Dict[integer, Dict[str, TimeSeries]]], + Dict[int, Dict[str, TimeSeries]], + Sequence[Dict[int, Dict[str, TimeSeries]]], ], ): self.explained_forecasts = explained_forecasts @@ -61,9 +60,7 @@ def get_explanation( def _query_explainability_result( self, - attr: Union[ - Dict[integer, Dict[str, Any]], Sequence[Dict[integer, Dict[str, Any]]] - ], + attr: Union[Dict[int, Dict[str, Any]], Sequence[Dict[int, Dict[str, Any]]]], horizon: int, component: Optional[str] = None, ) -> Any: @@ -141,16 +138,16 @@ class ShapExplainabilityResult(ExplainabilityResult): def __init__( self, explained_forecasts: Union[ - Dict[integer, Dict[str, TimeSeries]], - Sequence[Dict[integer, Dict[str, TimeSeries]]], + Dict[int, Dict[str, TimeSeries]], + Sequence[Dict[int, Dict[str, TimeSeries]]], ], feature_values: Union[ - Dict[integer, Dict[str, TimeSeries]], - Sequence[Dict[integer, Dict[str, TimeSeries]]], + Dict[int, Dict[str, TimeSeries]], + Sequence[Dict[int, Dict[str, TimeSeries]]], ], shap_explanation_object: Union[ - Dict[integer, Dict[str, shap.Explanation]], - Sequence[Dict[integer, Dict[str, shap.Explanation]]], + Dict[int, Dict[str, shap.Explanation]], + Sequence[Dict[int, Dict[str, shap.Explanation]]], ], ): super().__init__(explained_forecasts) diff --git a/darts/explainability/shap_explainer.py b/darts/explainability/shap_explainer.py index 05684b8aaf..f6810c8803 100644 --- a/darts/explainability/shap_explainer.py +++ b/darts/explainability/shap_explainer.py @@ -25,7 +25,6 @@ import matplotlib.pyplot as plt import pandas as pd import shap -from numpy import integer from sklearn.multioutput import MultiOutputRegressor from darts import TimeSeries @@ -563,7 +562,7 @@ def shap_explanations( foreground_X, horizons: Optional[Sequence[int]] = None, target_components: Optional[Sequence[str]] = None, - ) -> Dict[integer, Dict[str, shap.Explanation]]: + ) -> Dict[int, Dict[str, shap.Explanation]]: """ Return a dictionary of dictionaries of shap.Explanation instances: @@ -577,7 +576,7 @@ def shap_explanations( Optionally, a list of integers representing which points/steps in the future we want to explain, starting from the first prediction step at 1. Currently, only forecasting models are supported which provide an `output_chunk_length` parameter. `horizons` must not be larger than `output_chunk_length`. - target_names + target_components Optionally, a list of strings with the target components we want to explain. """ @@ -589,7 +588,9 @@ def shap_explanations( for h in horizons: tmp_n = {} - for t_idx, t in enumerate(target_components): + for t_idx, t in enumerate(self.target_components): + if t not in target_components: + continue explainer = self.explainers[h - 1][t_idx](foreground_X) explainer.base_values = explainer.base_values.ravel() explainer.time_index = foreground_X.index @@ -601,6 +602,8 @@ def shap_explanations( for h in horizons: tmp_n = {} for t_idx, t in enumerate(target_components): + if t not in target_components: + continue if not self.single_output: tmp_t = shap.Explanation( shap_explanation_tmp.values[ diff --git a/darts/tests/explainability/test_shap_explainer.py b/darts/tests/explainability/test_shap_explainer.py index 6b8399bde0..754282faa1 100644 --- a/darts/tests/explainability/test_shap_explainer.py +++ b/darts/tests/explainability/test_shap_explainer.py @@ -1,3 +1,4 @@ +import copy from datetime import date, timedelta import matplotlib.pyplot as plt @@ -691,6 +692,41 @@ def test_shap_explanation_object_validity(self): shap.Explanation, ) + def test_shap_selected_components(self): + model = LightGBMModel( + lags=4, + lags_past_covariates=2, + lags_future_covariates=[1], + output_chunk_length=1, + ) + model.fit( + series=self.target_ts, + past_covariates=self.past_cov_ts, + future_covariates=self.fut_cov_ts, + ) + shap_explain = ShapExplainer(model) + explanation_results = shap_explain.explain() + # check that explain() with selected components gives identical results + for comp in self.target_ts.components: + explanation_comp = shap_explain.explain(target_components=[comp]) + assert explanation_comp.available_components == [comp] + assert explanation_comp.available_horizons == [1] + # explained forecasts + fc_res_tmp = copy.deepcopy(explanation_results.explained_forecasts) + fc_res_tmp[1] = {str(comp): fc_res_tmp[1][comp]} + assert explanation_comp.explained_forecasts == fc_res_tmp + + # feature values + fv_res_tmp = copy.deepcopy(explanation_results.feature_values) + fv_res_tmp[1] = {str(comp): fv_res_tmp[1][comp]} + assert explanation_comp.explained_forecasts == fc_res_tmp + + # shap objects + assert ( + len(explanation_comp.shap_explanation_object[1]) == 1 + and comp in explanation_comp.shap_explanation_object[1] + ) + def test_shapley_with_static_cov(self): ts = self.target_ts_with_static_covs model = LightGBMModel( From d8a1ef708dcfb654a3c4bf3fc630980b022d37b0 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 28 May 2023 15:57:46 +0200 Subject: [PATCH 4/5] update changelog --- CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index c311ebfc6c..fa38a0b604 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,11 +16,14 @@ but cannot always guarantee backwards compatibility. Changes that may **break co - Improvements to `EnsembleModel`: - Model creation parameter `forecasting_models` now supports a mix of `LocalForecastingModel` and `GlobalForecastingModel` (single `TimeSeries` training/inference only, due to the local models). [#1745](https://github.com/unit8co/darts/pull/1745) by [Antoine Madrona](https://github.com/madtoinou). - Future and past covariates can now be used even if `forecasting_models` have different covariates support. The covariates passed to `fit()`/`predict()` are used only by models that support it. [#1745](https://github.com/unit8co/darts/pull/1745) by [Antoine Madrona](https://github.com/madtoinou). +- Improvements to `ShapExplainer`: + - Added static covariates support to `ShapeExplainer`. [#1803](https://github.com/unit8co/darts/pull/#1803) by [Anne de Vries](https://github.com/anne-devries) and [Dennis Bader](https://github.com/dennisbader). **Fixed** - Fixed an issue not considering original component names for `TimeSeries.plot()` when providing a label prefix. [#1783](https://github.com/unit8co/darts/pull/1783) by [Simon Sudrich](https://github.com/sudrich). - Fixed an issue with `TorchForecastingModel.load_from_checkpoint()` not properly loading the loss function and metrics. [#1749](https://github.com/unit8co/darts/pull/1749) by [Antoine Madrona](https://github.com/madtoinou). - Fixed a bug when loading the weights of a `TorchForecastingModel` trained with encoders or a Likelihood. [#1744](https://github.com/unit8co/darts/pull/1744) by [Antoine Madrona](https://github.com/madtoinou). +- Fixed a bug when using selected `target_components` with `ShapExplainer. [#1803](https://github.com/unit8co/darts/pull/#1803) by [Dennis Bader](https://github.com/dennisbader). ## [0.24.0](https://github.com/unit8co/darts/tree/0.24.0) (2023-04-12) ### For users of the library: From c64b405fd3f38d91e9be340187e63a93124e145a Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 28 May 2023 16:54:41 +0200 Subject: [PATCH 5/5] fix failing unittests --- .../test_create_lagged_prediction_data.py | 46 ++++++++++- .../test_create_lagged_training_data.py | 78 ++++++++++++++----- 2 files changed, 100 insertions(+), 24 deletions(-) diff --git a/darts/tests/utils/tabularization/test_create_lagged_prediction_data.py b/darts/tests/utils/tabularization/test_create_lagged_prediction_data.py index 6893643e52..eca4cbe288 100644 --- a/darts/tests/utils/tabularization/test_create_lagged_prediction_data.py +++ b/darts/tests/utils/tabularization/test_create_lagged_prediction_data.py @@ -375,6 +375,7 @@ def test_lagged_prediction_data_equal_freq_range_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=True, ) @@ -462,6 +463,7 @@ def test_lagged_prediction_data_equal_freq_datetime_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=True, ) @@ -534,6 +536,7 @@ def test_lagged_prediction_data_unequal_freq_range_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=True, ) @@ -606,6 +609,7 @@ def test_lagged_prediction_data_unequal_freq_datetime_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=True, ) @@ -694,6 +698,7 @@ def test_lagged_prediction_data_method_consistency_range_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=True, ) @@ -705,6 +710,7 @@ def test_lagged_prediction_data_method_consistency_range_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=False, ) @@ -772,6 +778,7 @@ def test_lagged_prediction_data_method_consistency_datetime_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=True, ) @@ -783,6 +790,7 @@ def test_lagged_prediction_data_method_consistency_datetime_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=False, ) @@ -827,6 +835,7 @@ def test_lagged_prediction_data_single_lag_single_component_same_series_range_id lags=lags, lags_past_covariates=past_lags, lags_future_covariates=future_lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) # Number of observations should match number of feature times: @@ -870,6 +879,7 @@ def test_lagged_prediction_data_single_lag_single_component_same_series_datetime lags=lags, lags_past_covariates=past_lags, lags_future_covariates=future_lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) # Number of observations should match number of feature times: @@ -917,6 +927,7 @@ def test_lagged_prediction_data_extend_past_and_future_covariates_range_idx(self lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=use_moving_windows, ) @@ -978,6 +989,7 @@ def test_lagged_prediction_data_extend_past_and_future_covariates_datetime_idx( lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=use_moving_windows, ) @@ -997,7 +1009,10 @@ def test_lagged_prediction_data_single_point_range_idx(self): lag = 5 for use_moving_windows in (False, True): X, times = create_lagged_prediction_data( - target, lags=[-lag], use_moving_windows=use_moving_windows + target, + lags=[-lag], + use_moving_windows=use_moving_windows, + uses_static_covariates=False, ) self.assertTrue(np.allclose(expected_X, X)) # Should only have one sample, generated for @@ -1020,7 +1035,10 @@ def test_lagged_prediction_data_single_point_datetime_idx(self): lag = 5 for use_moving_windows in (False, True): X, times = create_lagged_prediction_data( - target, lags=[-lag], use_moving_windows=use_moving_windows + target, + lags=[-lag], + use_moving_windows=use_moving_windows, + uses_static_covariates=False, ) self.assertTrue(np.allclose(expected_X, X)) # Should only have one sample, generated for @@ -1053,6 +1071,7 @@ def test_lagged_prediction_data_zero_lags_range_idx(self): future_covariates=future, lags=[-1], lags_future_covariates=[0], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertTrue(np.allclose(expected_X, X)) @@ -1088,6 +1107,7 @@ def test_lagged_prediction_data_zero_lags_datetime_idx(self): future_covariates=future, lags=[-1], lags_future_covariates=[0], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertTrue(np.allclose(expected_X, X)) @@ -1119,6 +1139,7 @@ def test_lagged_prediction_data_positive_lags_range_idx(self): future_covariates=future, lags=[-1], lags_future_covariates=[1], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertTrue(np.allclose(expected_X, X)) @@ -1154,6 +1175,7 @@ def test_lagged_prediction_data_positive_lags_datetime_idx(self): future_covariates=future, lags=[-1], lags_future_covariates=[1], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertTrue(np.allclose(expected_X, X)) @@ -1185,6 +1207,7 @@ def test_lagged_prediction_data_sequence_inputs(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, ) self.assertTrue(np.allclose(X, expected_X)) self.assertEqual(len(times), 2) @@ -1198,6 +1221,7 @@ def test_lagged_prediction_data_sequence_inputs(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, concatenate=False, ) self.assertEqual(len(X), 2) @@ -1230,6 +1254,7 @@ def test_lagged_prediction_data_stochastic_series(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, ) self.assertTrue(np.allclose(X, expected_X)) self.assertTrue(times[0].equals(expected_times)) @@ -1252,6 +1277,7 @@ def test_lagged_prediction_data_no_shared_times_error(self): lags=lags, past_covariates=series_2, lags_past_covariates=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1264,6 +1290,7 @@ def test_lagged_prediction_data_no_shared_times_error(self): lags=lags, past_covariates=series_2, lags_past_covariates=lags, + uses_static_covariates=False, ) self.assertEqual( "Specified series do not share any common times for which features can be created.", @@ -1289,6 +1316,7 @@ def test_lagged_prediction_data_no_specified_series_lags_pairs_error(self): target_series=series, lags_future_covariates=[-1], past_covariates=series, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1306,7 +1334,9 @@ def test_lagged_prediction_data_no_lags_specified_error(self): for use_moving_windows in (False, True): with self.assertRaises(ValueError) as e: create_lagged_prediction_data( - target_series=target, use_moving_windows=use_moving_windows + target_series=target, + use_moving_windows=use_moving_windows, + uses_static_covariates=False, ) self.assertEqual( "Must specify at least one of: `lags`, `lags_past_covariates`, `lags_future_covariates`.", @@ -1326,6 +1356,7 @@ def test_lagged_prediction_data_series_too_short_error(self): create_lagged_prediction_data( target_series=series, lags=[-20, -1], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1340,6 +1371,7 @@ def test_lagged_prediction_data_series_too_short_error(self): create_lagged_prediction_data( past_covariates=series, lags_past_covariates=[-20, -1], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1369,6 +1401,7 @@ def test_lagged_prediction_data_invalid_lag_values_error(self): create_lagged_prediction_data( target_series=series, lags=[0], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1382,6 +1415,7 @@ def test_lagged_prediction_data_invalid_lag_values_error(self): create_lagged_prediction_data( past_covariates=series, lags_past_covariates=[0], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1394,6 +1428,7 @@ def test_lagged_prediction_data_invalid_lag_values_error(self): create_lagged_prediction_data( future_covariates=series, lags_future_covariates=[-1, 0, 1], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) @@ -1412,6 +1447,7 @@ def test_lagged_prediction_data_unspecified_lag_or_series_warning(self): target_series=series, lags=lags, future_covariates=series, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual(len(w), 1) @@ -1429,6 +1465,7 @@ def test_lagged_prediction_data_unspecified_lag_or_series_warning(self): target_series=series, lags=lags, lags_future_covariates=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual(len(w), 1) @@ -1449,6 +1486,7 @@ def test_lagged_prediction_data_unspecified_lag_or_series_warning(self): lags=lags, past_covariates=series, lags_future_covariates=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual(len(w), 2) @@ -1475,6 +1513,7 @@ def test_lagged_prediction_data_unspecified_lag_or_series_warning(self): target_series=series, past_covariates=series, lags_past_covariates=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual(len(w), 1) @@ -1493,6 +1532,7 @@ def test_lagged_prediction_data_unspecified_lag_or_series_warning(self): lags=lags, past_covariates=series, lags_past_covariates=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual(len(w), 1) diff --git a/darts/tests/utils/tabularization/test_create_lagged_training_data.py b/darts/tests/utils/tabularization/test_create_lagged_training_data.py index edfffc5052..31df90ae4a 100644 --- a/darts/tests/utils/tabularization/test_create_lagged_training_data.py +++ b/darts/tests/utils/tabularization/test_create_lagged_training_data.py @@ -452,7 +452,7 @@ def test_lagged_training_data_equal_freq_range_index(self): lags_is_none = [x is None for x in all_lags] if all(lags_is_none): continue - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length, past_covariates=past if lags_past else None, @@ -460,6 +460,7 @@ def test_lagged_training_data_equal_freq_range_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, multi_models=multi_models, max_samples_per_ts=max_samples_per_ts, use_moving_windows=True, @@ -558,7 +559,7 @@ def test_lagged_training_data_equal_freq_datetime_index(self): lags_is_none = [x is None for x in all_lags] if all(lags_is_none): continue - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length, past_covariates=past if lags_past else None, @@ -566,6 +567,7 @@ def test_lagged_training_data_equal_freq_datetime_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, multi_models=multi_models, max_samples_per_ts=max_samples_per_ts, use_moving_windows=True, @@ -649,7 +651,7 @@ def test_lagged_training_data_unequal_freq_range_index(self): lags_is_none = [x is None for x in all_lags] if all(lags_is_none): continue - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length, past_covariates=past if lags_past else None, @@ -657,6 +659,7 @@ def test_lagged_training_data_unequal_freq_range_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, multi_models=multi_models, max_samples_per_ts=max_samples_per_ts, use_moving_windows=False, @@ -755,7 +758,7 @@ def test_lagged_training_data_unequal_freq_datetime_index(self): lags_is_none = [x is None for x in all_lags] if all(lags_is_none): continue - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length, past_covariates=past if lags_past else None, @@ -763,6 +766,7 @@ def test_lagged_training_data_unequal_freq_datetime_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, multi_models=multi_models, max_samples_per_ts=max_samples_per_ts, use_moving_windows=False, @@ -846,7 +850,7 @@ def test_lagged_training_data_method_consistency_range_index(self): if all(lags_is_none): continue # Using moving window method: - X_mw, y_mw, times_mw = create_lagged_training_data( + X_mw, y_mw, times_mw, _ = create_lagged_training_data( target_series=target, output_chunk_length=output_chunk_length, past_covariates=past if lags_past else None, @@ -854,12 +858,13 @@ def test_lagged_training_data_method_consistency_range_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, multi_models=multi_models, use_moving_windows=True, ) # Using time intersection method: - X_ti, y_ti, times_ti = create_lagged_training_data( + X_ti, y_ti, times_ti, _ = create_lagged_training_data( target_series=target, output_chunk_length=output_chunk_length, past_covariates=past if lags_past else None, @@ -867,6 +872,7 @@ def test_lagged_training_data_method_consistency_range_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, multi_models=multi_models, use_moving_windows=False, @@ -938,7 +944,7 @@ def test_lagged_training_data_method_consistency_datetime_index(self): if all(lags_is_none): continue # Using moving window method: - X_mw, y_mw, times_mw = create_lagged_training_data( + X_mw, y_mw, times_mw, _ = create_lagged_training_data( target_series=target, output_chunk_length=output_chunk_length, past_covariates=past if lags_past else None, @@ -946,12 +952,13 @@ def test_lagged_training_data_method_consistency_datetime_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, multi_models=multi_models, use_moving_windows=True, ) # Using time intersection method: - X_ti, y_ti, times_ti = create_lagged_training_data( + X_ti, y_ti, times_ti, _ = create_lagged_training_data( target_series=target, output_chunk_length=output_chunk_length, past_covariates=past if lags_past else None, @@ -959,6 +966,7 @@ def test_lagged_training_data_method_consistency_datetime_index(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, multi_models=multi_models, use_moving_windows=False, @@ -1001,7 +1009,7 @@ def test_lagged_training_data_single_lag_single_component_same_series_range_idx( [expected_X_target, expected_X_past, expected_X_future], axis=1 ) for use_moving_windows in (False, True): - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target_series=series, output_chunk_length=output_chunk_length, past_covariates=series, @@ -1009,6 +1017,7 @@ def test_lagged_training_data_single_lag_single_component_same_series_range_idx( lags=lags, lags_past_covariates=past_lags, lags_future_covariates=future_lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) # Number of observations should match number of feature times: @@ -1051,7 +1060,7 @@ def test_lagged_training_data_single_lag_single_component_same_series_datetime_i [expected_X_target, expected_X_past, expected_X_future], axis=1 ) for use_moving_windows in (False, True): - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target_series=series, output_chunk_length=output_chunk_length, past_covariates=series, @@ -1059,6 +1068,7 @@ def test_lagged_training_data_single_lag_single_component_same_series_datetime_i lags=lags, lags_past_covariates=past_lags, lags_future_covariates=future_lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) # Number of observations should match number of feature times: @@ -1106,7 +1116,7 @@ def test_lagged_training_data_extend_past_and_future_covariates_range_idx(self): # Check correctness for both 'moving window' method # and 'time intersection' method: for use_moving_windows in (False, True): - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length=1, past_covariates=past, @@ -1114,6 +1124,7 @@ def test_lagged_training_data_extend_past_and_future_covariates_range_idx(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=use_moving_windows, ) @@ -1171,7 +1182,7 @@ def test_lagged_training_data_extend_past_and_future_covariates_datetime_idx(sel # Check correctness for both 'moving window' method # and 'time intersection' method: for use_moving_windows in (False, True): - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length=1, past_covariates=past, @@ -1179,6 +1190,7 @@ def test_lagged_training_data_extend_past_and_future_covariates_datetime_idx(sel lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, max_samples_per_ts=max_samples_per_ts, use_moving_windows=use_moving_windows, ) @@ -1202,10 +1214,11 @@ def test_lagged_training_data_single_point_range_idx(self): # Test correctness for 'moving window' and for 'time intersection' methods, as well # as for different `multi_models` values: for (use_moving_windows, multi_models) in product([False, True], [False, True]): - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length, lags=lags, + uses_static_covariates=False, multi_models=multi_models, use_moving_windows=use_moving_windows, ) @@ -1233,10 +1246,11 @@ def test_lagged_training_data_single_point_datetime_idx(self): # Test correctness for 'moving window' and for 'time intersection' methods, as well # as for different `multi_models` values: for (use_moving_windows, multi_models) in product([False, True], [False, True]): - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length, lags=lags, + uses_static_covariates=False, multi_models=multi_models, use_moving_windows=use_moving_windows, ) @@ -1269,12 +1283,13 @@ def test_lagged_training_data_zero_lags_range_idx(self): # Check correctness for 'moving windows' and 'time intersection' methods, as # well as for different `multi_models` values: for (use_moving_windows, multi_models) in product([False, True], [False, True]): - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length=1, future_covariates=future, lags=[-1], lags_future_covariates=[0], + uses_static_covariates=False, multi_models=multi_models, use_moving_windows=use_moving_windows, ) @@ -1308,12 +1323,13 @@ def test_lagged_training_data_zero_lags_datetime_idx(self): # Check correctness for 'moving windows' and 'time intersection' methods, as # well as for different `multi_models` values: for (use_moving_windows, multi_models) in product([False, True], [False, True]): - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length=1, future_covariates=future, lags=[-1], lags_future_covariates=[0], + uses_static_covariates=False, multi_models=multi_models, use_moving_windows=use_moving_windows, ) @@ -1345,12 +1361,13 @@ def test_lagged_training_data_positive_lags_range_idx(self): # Check correctness for 'moving windows' and 'time intersection' methods, as # well as for different `multi_models` values: for (use_moving_windows, multi_models) in product([False, True], [False, True]): - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length=1, future_covariates=future, lags=[-1], lags_future_covariates=[1], + uses_static_covariates=False, multi_models=multi_models, use_moving_windows=use_moving_windows, ) @@ -1384,12 +1401,13 @@ def test_lagged_training_data_positive_lags_datetime_idx(self): # Check correctness for 'moving windows' and 'time intersection' methods, as # well as for different `multi_models` values: for (use_moving_windows, multi_models) in product([False, True], [False, True]): - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length=1, future_covariates=future, lags=[-1], lags_future_covariates=[1], + uses_static_covariates=False, multi_models=multi_models, use_moving_windows=use_moving_windows, ) @@ -1423,7 +1441,7 @@ def test_lagged_training_data_sequence_inputs(self): expected_times_1 = target_1.time_index[1:] expected_times_2 = target_2.time_index[1:] # Check when `concatenate = True`: - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( (target_1, target_2), output_chunk_length=output_chunk_length, past_covariates=(past_1, past_2), @@ -1431,6 +1449,7 @@ def test_lagged_training_data_sequence_inputs(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, ) self.assertTrue(np.allclose(X, expected_X)) self.assertTrue(np.allclose(y, expected_y)) @@ -1438,7 +1457,7 @@ def test_lagged_training_data_sequence_inputs(self): self.assertTrue(times[0].equals(expected_times_1)) self.assertTrue(times[1].equals(expected_times_2)) # Check when `concatenate = False`: - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( (target_1, target_2), output_chunk_length=output_chunk_length, past_covariates=(past_1, past_2), @@ -1446,6 +1465,7 @@ def test_lagged_training_data_sequence_inputs(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, concatenate=False, ) self.assertEqual(len(X), 2) @@ -1477,7 +1497,7 @@ def test_lagged_training_data_stochastic_series(self): ) expected_y = target.all_values(copy=False)[1:, :, :] expected_times = target.time_index[1:] - X, y, times = create_lagged_training_data( + X, y, times, _ = create_lagged_training_data( target, output_chunk_length=output_chunk_length, past_covariates=past, @@ -1485,6 +1505,7 @@ def test_lagged_training_data_stochastic_series(self): lags=lags, lags_past_covariates=lags_past, lags_future_covariates=lags_future, + uses_static_covariates=False, ) self.assertTrue(np.allclose(X, expected_X)) self.assertTrue(np.allclose(y, expected_y)) @@ -1509,6 +1530,7 @@ def test_lagged_training_data_no_shared_times_error(self): lags=lags, past_covariates=series_2, lags_past_covariates=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1536,6 +1558,7 @@ def test_lagged_training_data_no_specified_series_lags_pairs_error(self): target_series=series_1, output_chunk_length=1, lags_past_covariates=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1554,6 +1577,7 @@ def test_lagged_training_data_no_specified_series_lags_pairs_error(self): output_chunk_length=1, lags_future_covariates=lags, past_covariates=series_2, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1576,6 +1600,7 @@ def test_lagged_training_data_invalid_output_chunk_length_error(self): target_series=target, output_chunk_length=0, lags=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1587,6 +1612,7 @@ def test_lagged_training_data_invalid_output_chunk_length_error(self): target_series=target, output_chunk_length=1.1, lags=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1606,6 +1632,7 @@ def test_lagged_training_data_no_lags_specified_error(self): create_lagged_training_data( target_series=target, output_chunk_length=1, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1632,6 +1659,7 @@ def test_lagged_training_data_series_too_short_error(self): target_series=series, output_chunk_length=5, lags=[-20, -10], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1649,6 +1677,7 @@ def test_lagged_training_data_series_too_short_error(self): output_chunk_length=1, past_covariates=series, lags_past_covariates=[-5, -3], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1680,6 +1709,7 @@ def test_lagged_training_data_invalid_lag_values_error(self): target_series=series, output_chunk_length=1, lags=[0], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1695,6 +1725,7 @@ def test_lagged_training_data_invalid_lag_values_error(self): output_chunk_length=1, past_covariates=series, lags_past_covariates=[0], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual( @@ -1709,6 +1740,7 @@ def test_lagged_training_data_invalid_lag_values_error(self): output_chunk_length=1, future_covariates=series, lags_future_covariates=[-1, 0, 1], + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) @@ -1734,6 +1766,7 @@ def test_lagged_training_data_unspecified_lag_or_series_warning(self): output_chunk_length=1, lags=lags, future_covariates=series, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual(len(w), 1) @@ -1752,6 +1785,7 @@ def test_lagged_training_data_unspecified_lag_or_series_warning(self): output_chunk_length=1, lags=lags, lags_future_covariates=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual(len(w), 1) @@ -1772,6 +1806,7 @@ def test_lagged_training_data_unspecified_lag_or_series_warning(self): output_chunk_length=1, past_covariates=series, lags_future_covariates=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual(len(w), 2) @@ -1799,6 +1834,7 @@ def test_lagged_training_data_unspecified_lag_or_series_warning(self): output_chunk_length=1, past_covariates=series, lags_past_covariates=lags, + uses_static_covariates=False, use_moving_windows=use_moving_windows, ) self.assertEqual(len(w), 0)