Fix/comp lags feat order

darts/models/forecasting/regression_model.py

@@ -1032,24 +1032,16 @@ def predict(
                     )
                 # component-wise lags
                 if "target" in self.component_lags:
-                    tmp_X = [
-                        series_matrix[
-                            :,
-                            [lag - (shift + last_step_shift) for lag in comp_lags],
-                            comp_i,
-                        ]
-                        for comp_i, (comp, comp_lags) in enumerate(
-                            self.component_lags["target"].items()
-                        )
-                    ]
-                    # values are grouped by component
-                    np_X.append(
-                        np.concatenate(tmp_X, axis=1).reshape(
-                            len(series) * num_samples, -1
-                        )
+                    tmp_X = self._extract_component_lags_autoregression(
+                        cov_type="target",
+                        values_matrix=series_matrix,
+                        shift=shift,
+                        last_step_shift=last_step_shift,
+                        t_pred=t_pred,
                     )
+                    np_X.append(tmp_X.reshape(len(series) * num_samples, -1))
+                # shared lags
                 else:
-                    # values are grouped by lags
                     np_X.append(
                         series_matrix[
                             :,
@@ -1064,21 +1056,15 @@ def predict(
                 if cov_type in covariate_matrices:
                     # component-wise lags
                     if cov_type in self.component_lags:
-                        tmp_X = [
-                            covariate_matrices[cov_type][
-                                :,
-                                np.array(comp_lags) - self.lags[cov_type][0] + t_pred,
-                                comp_i,
-                            ]
-                            for comp_i, (comp, comp_lags) in enumerate(
-                                self.component_lags[cov_type].items()
-                            )
-                        ]
-                        np_X.append(
-                            np.concatenate(tmp_X, axis=1).reshape(
-                                len(series) * num_samples, -1
-                            )
+                        tmp_X = self._extract_component_lags_autoregression(
+                            cov_type=cov_type,
+                            values_matrix=covariate_matrices[cov_type],
+                            shift=shift,
+                            last_step_shift=last_step_shift,
+                            t_pred=t_pred,
                         )
+                        np_X.append(tmp_X.reshape(len(series) * num_samples, -1))
+                    # shared lags
                     else:
                         np_X.append(
                             covariate_matrices[cov_type][
@@ -1149,6 +1135,44 @@ def _predict_and_sample(
         k = x.shape[0]
         return prediction.reshape(k, self.pred_dim, -1)
 
+    def _extract_component_lags_autoregression(
+        self,
+        cov_type: str,
+        values_matrix: np.ndarray,
+        shift: int,
+        last_step_shift: int,
+        t_pred: int,
+    ) -> np.ndarray:
+        """Extract, concatenate and reorder component-wise lags to obtain a features order
+        identical to tabularization.
+        """
+        # prepare index to reorder features by lags across components
+        comp_lags_reordered = np.concatenate(
+            [
+                np.array(comp_lags, dtype=int)
+                for comp_lags in self.component_lags[cov_type].values()
+            ]
+        ).argsort()
+
+        # convert relative lags to absolute
+        if cov_type == "target":
+            lags_shift = -shift - last_step_shift
+        else:
+            lags_shift = -self.lags[cov_type][0] + t_pred
+
+        # extract features
+        tmp_X = [
+            values_matrix[
+                :,
+                np.array(comp_lags) + lags_shift,
+                comp_i,
+            ]
+            for comp_i, comp_lags in enumerate(self.component_lags[cov_type].values())
+        ]
+
+        # concatenate on features dimension and reorder
+        return np.concatenate(tmp_X, axis=1)[:, comp_lags_reordered]
+
     @property
     def lagged_feature_names(self) -> Optional[List[str]]:
         """The lagged feature names the model has been trained on.

darts/tests/models/forecasting/test_regression_models.py

@@ -1990,7 +1990,7 @@ def test_component_specific_lags(self, config):
         )
 
         # n > output_chunk_length
-        model.predict(
+        pred = model.predict(
             7,
             series=series[0] if multiple_series else None,
             past_covariates=(
@@ -2004,6 +2004,11 @@ def test_component_specific_lags(self, config):
                 else None
             ),
         )
+        # check that lagged features are properly extracted during auto-regression
+        if multivar_target:
+            np.testing.assert_array_almost_equal(
+                tg.sine_timeseries(length=27)[-7:].values(), pred["sine"].values()
+            )
 
     @pytest.mark.parametrize(
         "config",