Fix encoder transformer and remove absolute index encoder

darts/models/forecasting/block_rnn_model.py

@@ -239,7 +239,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/catboost_model.py

@@ -64,7 +64,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/gradient_boosted_model.py

@@ -68,7 +68,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/linear_regression_model.py

@@ -66,7 +66,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/nbeats.py

@@ -659,7 +659,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/nhits.py

@@ -595,7 +595,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/random_forest.py

@@ -71,7 +71,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/regression_model.py

@@ -87,7 +87,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/rnn_model.py

@@ -318,7 +318,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/tcn_model.py

@@ -360,7 +360,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/tft_model.py

@@ -799,7 +799,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/torch_forecasting_model.py

@@ -187,7 +187,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/models/forecasting/transformer_model.py

@@ -448,7 +448,7 @@ def __init__(
                 add_encoders={
                     'cyclic': {'future': ['month']},
                     'datetime_attribute': {'future': ['hour', 'dayofweek']},
-                    'position': {'past': ['absolute'], 'future': ['relative']},
+                    'position': {'past': ['relative'], 'future': ['relative']},
                     'custom': {'past': [lambda idx: (idx.year - 1950) / 50]},
                     'transformer': Scaler()
                 }

darts/tests/explainability/test_shap_explainer.py

@@ -28,7 +28,7 @@ class ShapExplainerTestCase(DartsBaseTestClass):
     add_encoders = {
         "cyclic": {"past": ["month", "day"]},
         "datetime_attribute": {"future": ["hour", "dayofweek"]},
-        "position": {"past": ["absolute"], "future": ["relative"]},
+        "position": {"past": ["relative"], "future": ["relative"]},
         "custom": {"past": [lambda idx: (idx.year - 1950) / 50]},
         "transformer": Scaler(scaler),
     }
@@ -281,14 +281,14 @@ def test_explain(self):
         self.assertEqual(len(explanation), 537)
 
         # list of foregrounds: encoders have to be corrected first.
-        # results = shap_explain.explain(
-        #     foreground_series=[self.target_ts, self.target_ts[:100]],
-        #     foreground_past_covariates=[self.past_cov_ts, self.past_cov_ts[:40]],
-        #     foreground_future_covariates=[self.fut_cov_ts, self.fut_cov_ts[:40]],
-        # )
-        # ts_res = results.get_explanation(horizon=2, component="power")
-
-        # self.assertEqual(len(ts_res), 2)
+        results = shap_explain.explain(
+            foreground_series=[self.target_ts, self.target_ts[:100]],
+            foreground_past_covariates=[self.past_cov_ts, self.past_cov_ts[:40]],
+            foreground_future_covariates=[self.fut_cov_ts, self.fut_cov_ts[:40]],
+        )
+        ts_res = results.get_explanation(horizon=2, component="power")
+
+        self.assertEqual(len(ts_res), 2)
         # explain with a new foreground, minimum required. We should obtain one
         # timeseries with only one time element
         results = shap_explain.explain(
@@ -322,30 +322,30 @@ def test_explain(self):
             "0_past_cov_lag-3",
             "1_past_cov_lag-3",
             "2_past_cov_lag-3",
-            "month_sin_past_cov_lag-3",
-            "month_cos_past_cov_lag-3",
-            "day_sin_past_cov_lag-3",
-            "day_cos_past_cov_lag-3",
-            "absolute_idx_past_cov_lag-3",
-            "custom_past_cov_lag-3",
+            "darts_enc_pc_cyc_month_sin_past_cov_lag-3",
+            "darts_enc_pc_cyc_month_cos_past_cov_lag-3",
+            "darts_enc_pc_cyc_day_sin_past_cov_lag-3",
+            "darts_enc_pc_cyc_day_cos_past_cov_lag-3",
+            "darts_enc_pc_pos_relative_past_cov_lag-3",
+            "darts_enc_pc_cus_custom_past_cov_lag-3",
             "0_past_cov_lag-2",
             "1_past_cov_lag-2",
             "2_past_cov_lag-2",
-            "month_sin_past_cov_lag-2",
-            "month_cos_past_cov_lag-2",
-            "day_sin_past_cov_lag-2",
-            "day_cos_past_cov_lag-2",
-            "absolute_idx_past_cov_lag-2",
-            "custom_past_cov_lag-2",
+            "darts_enc_pc_cyc_month_sin_past_cov_lag-2",
+            "darts_enc_pc_cyc_month_cos_past_cov_lag-2",
+            "darts_enc_pc_cyc_day_sin_past_cov_lag-2",
+            "darts_enc_pc_cyc_day_cos_past_cov_lag-2",
+            "darts_enc_pc_pos_relative_past_cov_lag-2",
+            "darts_enc_pc_cus_custom_past_cov_lag-2",
             "0_past_cov_lag-1",
             "1_past_cov_lag-1",
             "2_past_cov_lag-1",
-            "month_sin_past_cov_lag-1",
-            "month_cos_past_cov_lag-1",
-            "day_sin_past_cov_lag-1",
-            "day_cos_past_cov_lag-1",
-            "absolute_idx_past_cov_lag-1",
-            "custom_past_cov_lag-1",
+            "darts_enc_pc_cyc_month_sin_past_cov_lag-1",
+            "darts_enc_pc_cyc_month_cos_past_cov_lag-1",
+            "darts_enc_pc_cyc_day_sin_past_cov_lag-1",
+            "darts_enc_pc_cyc_day_cos_past_cov_lag-1",
+            "darts_enc_pc_pos_relative_past_cov_lag-1",
+            "darts_enc_pc_cus_custom_past_cov_lag-1",
             "0_fut_cov_lag0",
             "1_fut_cov_lag0",
             "hour_fut_cov_lag0",

darts/tests/models/forecasting/test_covariate_index_generators.py

@@ -74,23 +74,23 @@ class CovariateIndexGeneratorTestCase(DartsBaseTestClass):
     def helper_test_index_types(self, ig: CovariateIndexGenerator):
         """test the index type of generated index"""
         # pd.DatetimeIndex
-        idx = ig.generate_train_series(self.target_time, self.cov_time_train)
+        idx, _ = ig.generate_train_series(self.target_time, self.cov_time_train)
         self.assertTrue(isinstance(idx, pd.DatetimeIndex))
-        idx = ig.generate_inference_series(
+        idx, _ = ig.generate_inference_series(
             self.n_short, self.target_time, self.cov_time_inf_short
         )
         self.assertTrue(isinstance(idx, pd.DatetimeIndex))
-        idx = ig.generate_train_series(self.target_time, None)
+        idx, _ = ig.generate_train_series(self.target_time, None)
         self.assertTrue(isinstance(idx, pd.DatetimeIndex))
 
         # pd.RangeIndex
-        idx = ig.generate_train_series(self.target_int, self.cov_int_train)
+        idx, _ = ig.generate_train_series(self.target_int, self.cov_int_train)
         self.assertTrue(isinstance(idx, pd.RangeIndex))
-        idx = ig.generate_inference_series(
+        idx, _ = ig.generate_inference_series(
             self.n_short, self.target_int, self.cov_int_inf_short
         )
         self.assertTrue(isinstance(idx, pd.RangeIndex))
-        idx = ig.generate_train_series(self.target_int, None)
+        idx, _ = ig.generate_train_series(self.target_int, None)
         self.assertTrue(isinstance(idx, pd.RangeIndex))
 
     def helper_test_index_generator_train(self, ig: CovariateIndexGenerator):
@@ -100,24 +100,24 @@ def helper_test_index_generator_train(self, ig: CovariateIndexGenerator):
         """
         # pd.DatetimeIndex
         # generated index must be equal to input covariate index
-        idx = ig.generate_train_series(self.target_time, self.cov_time_train)
+        idx, _ = ig.generate_train_series(self.target_time, self.cov_time_train)
         self.assertTrue(idx.equals(self.cov_time_train.time_index))
         # generated index must be equal to input covariate index
-        idx = ig.generate_train_series(self.target_time, self.cov_time_train_short)
+        idx, _ = ig.generate_train_series(self.target_time, self.cov_time_train_short)
         self.assertTrue(idx.equals(self.cov_time_train_short.time_index))
         # generated index must be equal to input target index when no covariates are defined
-        idx = ig.generate_train_series(self.target_time, None)
+        idx, _ = ig.generate_train_series(self.target_time, None)
         self.assertTrue(idx.equals(self.cov_time_train.time_index))
 
         # integer index
         # generated index must be equal to input covariate index
-        idx = ig.generate_train_series(self.target_int, self.cov_int_train)
+        idx, _ = ig.generate_train_series(self.target_int, self.cov_int_train)
         self.assertTrue(idx.equals(self.cov_int_train.time_index))
         # generated index must be equal to input covariate index
-        idx = ig.generate_train_series(self.target_time, self.cov_int_train_short)
+        idx, _ = ig.generate_train_series(self.target_time, self.cov_int_train_short)
         self.assertTrue(idx.equals(self.cov_int_train_short.time_index))
         # generated index must be equal to input target index when no covariates are defined
-        idx = ig.generate_train_series(self.target_int, None)
+        idx, _ = ig.generate_train_series(self.target_int, None)
         self.assertTrue(idx.equals(self.cov_int_train.time_index))
 
     def helper_test_index_generator_inference(self, ig, is_past=False):
@@ -134,7 +134,7 @@ def helper_test_index_generator_inference(self, ig, is_past=False):
         """
 
         # check generated inference index without passing covariates when n <= output_chunk_length
-        idx = ig.generate_inference_series(self.n_short, self.target_time, None)
+        idx, _ = ig.generate_inference_series(self.n_short, self.target_time, None)
         if is_past:
             n_out = self.input_chunk_length
             last_idx = self.target_time.end_time()
@@ -146,7 +146,7 @@ def helper_test_index_generator_inference(self, ig, is_past=False):
         self.assertTrue(idx[-1] == last_idx)
 
         # check generated inference index without passing covariates when n > output_chunk_length
-        idx = ig.generate_inference_series(self.n_long, self.target_time, None)
+        idx, _ = ig.generate_inference_series(self.n_long, self.target_time, None)
         if is_past:
             n_out = self.input_chunk_length + self.n_long - self.output_chunk_length
             last_idx = (
@@ -160,19 +160,19 @@ def helper_test_index_generator_inference(self, ig, is_past=False):
         self.assertTrue(len(idx) == n_out)
         self.assertTrue(idx[-1] == last_idx)
 
-        idx = ig.generate_inference_series(
+        idx, _ = ig.generate_inference_series(
             self.n_short, self.target_time, self.cov_time_inf_short
         )
         self.assertTrue(idx.equals(self.cov_time_inf_short.time_index))
-        idx = ig.generate_inference_series(
+        idx, _ = ig.generate_inference_series(
             self.n_long, self.target_time, self.cov_time_inf_long
         )
         self.assertTrue(idx.equals(self.cov_time_inf_long.time_index))
-        idx = ig.generate_inference_series(
+        idx, _ = ig.generate_inference_series(
             self.n_short, self.target_int, self.cov_int_inf_short
         )
         self.assertTrue(idx.equals(self.cov_int_inf_short.time_index))
-        idx = ig.generate_inference_series(
+        idx, _ = ig.generate_inference_series(
             self.n_long, self.target_int, self.cov_int_inf_long
         )
         self.assertTrue(idx.equals(self.cov_int_inf_long.time_index))