oracle-ads 2.12.11__py3-none-any.whl → 2.13.1__py3-none-any.whl

ads/opctl/operator/lowcode/forecast/model/base_model.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-# Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+# Copyright (c) 2023, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 import logging
@@ -19,6 +19,7 @@ import report_creator as rc
 from ads.common.decorator.runtime_dependency import runtime_dependency
 from ads.common.object_storage_details import ObjectStorageDetails
 from ads.opctl import logger
+from ads.opctl.operator.lowcode.common.const import DataColumns
 from ads.opctl.operator.lowcode.common.utils import (
     datetime_to_seconds,
     disable_print,
@@ -28,7 +29,6 @@ from ads.opctl.operator.lowcode.common.utils import (
     seconds_to_datetime,
     write_data,
 )
-from ads.opctl.operator.lowcode.common.const import DataColumns
 from ads.opctl.operator.lowcode.forecast.model.forecast_datasets import TestData
 from ads.opctl.operator.lowcode.forecast.utils import (
     _build_metrics_df,
@@ -49,10 +49,9 @@ from ..const import (
     SpeedAccuracyMode,
     SupportedMetrics,
     SupportedModels,
-    BACKTEST_REPORT_NAME,
 )
 from ..operator_config import ForecastOperatorConfig, ForecastOperatorSpec
-from .forecast_datasets import ForecastDatasets
+from .forecast_datasets import ForecastDatasets, ForecastResults
 
 logging.getLogger("report_creator").setLevel(logging.WARNING)
 
@@ -121,27 +120,30 @@ class ForecastOperatorBaseModel(ABC):
 
             # Generate metrics
             summary_metrics = None
-            test_data = None
+            test_data = self.datasets.test_data
             self.eval_metrics = None
 
             if self.spec.generate_report or self.spec.generate_metrics:
                 self.eval_metrics = self.generate_train_metrics()
                 if not self.target_cat_col:
-                    self.eval_metrics.rename({"Series 1": self.original_target_column},
-                                             axis=1, inplace=True)
+                    self.eval_metrics.rename(
+                        {"Series 1": self.original_target_column}, axis=1, inplace=True
+                    )
 
-                if self.spec.test_data:
+                if self.datasets.test_data is not None:
                     try:
                         (
                             self.test_eval_metrics,
-                            summary_metrics,
-                            test_data,
+                            summary_metrics
                         ) = self._test_evaluate_metrics(
                             elapsed_time=elapsed_time,
                         )
                         if not self.target_cat_col:
-                            self.test_eval_metrics.rename({"Series 1": self.original_target_column},
-                                                     axis=1, inplace=True)
+                            self.test_eval_metrics.rename(
+                                {"Series 1": self.original_target_column},
+                                axis=1,
+                                inplace=True,
+                            )
                     except Exception:
                         logger.warn("Unable to generate Test Metrics.")
                         logger.debug(f"Full Traceback: {traceback.format_exc()}")
@@ -223,17 +225,23 @@ class ForecastOperatorBaseModel(ABC):
                     rc.Block(
                         first_10_title,
                         # series_subtext,
-                        rc.Select(blocks=first_5_rows_blocks) if self.target_cat_col else first_5_rows_blocks[0],
+                        rc.Select(blocks=first_5_rows_blocks)
+                        if self.target_cat_col
+                        else first_5_rows_blocks[0],
                     ),
                     rc.Block(
                         last_10_title,
                         # series_subtext,
-                        rc.Select(blocks=last_5_rows_blocks) if self.target_cat_col else last_5_rows_blocks[0],
+                        rc.Select(blocks=last_5_rows_blocks)
+                        if self.target_cat_col
+                        else last_5_rows_blocks[0],
                     ),
                     rc.Block(
                         summary_title,
                         # series_subtext,
-                        rc.Select(blocks=data_summary_blocks) if self.target_cat_col else data_summary_blocks[0],
+                        rc.Select(blocks=data_summary_blocks)
+                        if self.target_cat_col
+                        else data_summary_blocks[0],
                     ),
                     rc.Separator(),
                 )
@@ -308,7 +316,7 @@ class ForecastOperatorBaseModel(ABC):
                         horizon=self.spec.horizon,
                         test_data=test_data,
                         ci_interval_width=self.spec.confidence_interval_width,
-                        target_category_column=self.target_cat_col
+                        target_category_column=self.target_cat_col,
                     )
                     if (
                         series_name is not None
@@ -341,17 +349,18 @@ class ForecastOperatorBaseModel(ABC):
                 )
 
             # save the report and result CSV
-            self._save_report(
+            return self._save_report(
                 report_sections=report_sections,
                 result_df=result_df,
                 metrics_df=self.eval_metrics,
                 test_metrics_df=self.test_eval_metrics,
+                test_data=test_data,
             )
 
     def _test_evaluate_metrics(self, elapsed_time=0):
         total_metrics = pd.DataFrame()
         summary_metrics = pd.DataFrame()
-        data = TestData(self.spec)
+        data = self.datasets.test_data
 
         # Generate y_pred and y_true for each series
         for s_id in self.forecast_output.list_series_ids():
@@ -388,7 +397,7 @@ class ForecastOperatorBaseModel(ABC):
             total_metrics = pd.concat([total_metrics, metrics_df], axis=1)
 
         if total_metrics.empty:
-            return total_metrics, summary_metrics, data
+            return total_metrics, summary_metrics
 
         summary_metrics = pd.DataFrame(
             {
@@ -454,7 +463,7 @@ class ForecastOperatorBaseModel(ABC):
                 ]
                 summary_metrics = summary_metrics[new_column_order]
 
-        return total_metrics, summary_metrics, data
+        return total_metrics, summary_metrics
 
     def _save_report(
         self,
@@ -462,10 +471,12 @@ class ForecastOperatorBaseModel(ABC):
         result_df: pd.DataFrame,
         metrics_df: pd.DataFrame,
         test_metrics_df: pd.DataFrame,
+        test_data: pd.DataFrame,
     ):
         """Saves resulting reports to the given folder."""
 
         unique_output_dir = self.spec.output_directory.url
+        results = ForecastResults()
 
         if ObjectStorageDetails.is_oci_path(unique_output_dir):
             storage_options = default_signer()
@@ -491,13 +502,23 @@ class ForecastOperatorBaseModel(ABC):
                         f2.write(f1.read())
 
         # forecast csv report
-        result_df = result_df if self.target_cat_col else result_df.drop(DataColumns.Series, axis=1)
+        # todo: add test data into forecast.csv
+        # if self.spec.test_data is not None:
+        #     test_data_dict = test_data.get_dict_by_series()
+        #     for series_id, test_data_values in test_data_dict.items():
+        #         result_df[DataColumns.Series] = test_data_values[]
+        result_df = (
+            result_df
+            if self.target_cat_col
+            else result_df.drop(DataColumns.Series, axis=1)
+        )
         write_data(
             data=result_df,
             filename=os.path.join(unique_output_dir, self.spec.forecast_filename),
             format="csv",
             storage_options=storage_options,
         )
+        results.set_forecast(result_df)
 
         # metrics csv report
         if self.spec.generate_metrics:
@@ -507,10 +528,11 @@ class ForecastOperatorBaseModel(ABC):
                 else "Series 1"
             )
             if metrics_df is not None:
+                metrics_df_formatted = metrics_df.reset_index().rename(
+                    {"index": "metrics", "Series 1": metrics_col_name}, axis=1
+                )
                 write_data(
-                    data=metrics_df.reset_index().rename(
-                        {"index": "metrics", "Series 1": metrics_col_name}, axis=1
-                    ),
+                    data=metrics_df_formatted,
                     filename=os.path.join(
                         unique_output_dir, self.spec.metrics_filename
                     ),
@@ -518,18 +540,20 @@ class ForecastOperatorBaseModel(ABC):
                     storage_options=storage_options,
                     index=False,
                 )
+                results.set_metrics(metrics_df_formatted)
             else:
                 logger.warn(
                     f"Attempted to generate the {self.spec.metrics_filename} file with the training metrics, however the training metrics could not be properly generated."
                 )
 
             # test_metrics csv report
-            if self.spec.test_data is not None:
+            if self.datasets.test_data is not None:
                 if test_metrics_df is not None:
+                    test_metrics_df_formatted = test_metrics_df.reset_index().rename(
+                        {"index": "metrics", "Series 1": metrics_col_name}, axis=1
+                    )
                     write_data(
-                        data=test_metrics_df.reset_index().rename(
-                            {"index": "metrics", "Series 1": metrics_col_name}, axis=1
-                        ),
+                        data=test_metrics_df_formatted,
                         filename=os.path.join(
                             unique_output_dir, self.spec.test_metrics_filename
                         ),
@@ -537,6 +561,7 @@ class ForecastOperatorBaseModel(ABC):
                         storage_options=storage_options,
                         index=False,
                     )
+                    results.set_test_metrics(test_metrics_df_formatted)
                 else:
                     logger.warn(
                         f"Attempted to generate the {self.spec.test_metrics_filename} file with the test metrics, however the test metrics could not be properly generated."
@@ -544,7 +569,7 @@ class ForecastOperatorBaseModel(ABC):
         # explanations csv reports
         if self.spec.generate_explanations:
             try:
-                if self.formatted_global_explanation is not None:
+                if not self.formatted_global_explanation.empty:
                     write_data(
                         data=self.formatted_global_explanation,
                         filename=os.path.join(
@@ -554,12 +579,13 @@ class ForecastOperatorBaseModel(ABC):
                         storage_options=storage_options,
                         index=True,
                     )
+                    results.set_global_explanations(self.formatted_global_explanation)
                 else:
                     logger.warn(
                         f"Attempted to generate global explanations for the {self.spec.global_explanation_filename} file, but an issue occured in formatting the explanations."
                     )
 
-                if self.formatted_local_explanation is not None:
+                if not self.formatted_local_explanation.empty:
                     write_data(
                         data=self.formatted_local_explanation,
                         filename=os.path.join(
@@ -569,6 +595,7 @@ class ForecastOperatorBaseModel(ABC):
                         storage_options=storage_options,
                         index=True,
                     )
+                    results.set_local_explanations(self.formatted_local_explanation)
                 else:
                     logger.warn(
                         f"Attempted to generate local explanations for the {self.spec.local_explanation_filename} file, but an issue occured in formatting the explanations."
@@ -589,10 +616,12 @@ class ForecastOperatorBaseModel(ABC):
                 index=True,
                 indent=4,
             )
+            results.set_model_parameters(self.model_parameters)
 
         # model pickle
         if self.spec.generate_model_pickle:
             self._save_model(unique_output_dir, storage_options)
+            results.set_models(self.models)
 
         logger.info(
             f"The outputs have been successfully "
@@ -612,8 +641,10 @@ class ForecastOperatorBaseModel(ABC):
                 index=True,
                 indent=4,
             )
+            results.set_errors_dict(self.errors_dict)
         else:
             logger.info("All modeling completed successfully.")
+        return results
 
     def preprocess(self, df, series_id):
         """The method that needs to be implemented on the particular model level."""
@@ -667,7 +698,10 @@ class ForecastOperatorBaseModel(ABC):
         )
 
     def _validate_automlx_explanation_mode(self):
-        if self.spec.model != SupportedModels.AutoMLX and self.spec.explanations_accuracy_mode == SpeedAccuracyMode.AUTOMLX:
+        if (
+            self.spec.model != SupportedModels.AutoMLX
+            and self.spec.explanations_accuracy_mode == SpeedAccuracyMode.AUTOMLX
+        ):
             raise ValueError(
                 "AUTOMLX explanation accuracy mode is only supported for AutoMLX models. "
                 "Please select mode other than AUTOMLX from the available explanations_accuracy_mode options"
@@ -738,14 +772,6 @@ class ForecastOperatorBaseModel(ABC):
                     logger.warn(
                         "No explanations generated. Ensure that additional data has been provided."
                     )
-                elif (
-                    self.spec.model == SupportedModels.AutoMLX
-                    and self.spec.explanations_accuracy_mode
-                    == SpeedAccuracyMode.AUTOMLX
-                ):
-                    logger.warning(
-                        "Global explanations not available for AutoMLX models with inherent explainability"
-                    )
                 else:
                     self.global_explanation[s_id] = dict(
                         zip(
@@ -794,7 +820,7 @@ class ForecastOperatorBaseModel(ABC):
     def get_explain_predict_fn(self, series_id, fcst_col_name="yhat"):
         def _custom_predict(
             data,
-            model=self.models[series_id],
+            model=self.models[series_id]["model"],
             dt_column_name=self.datasets._datetime_column_name,
         ):
             """

ads/opctl/operator/lowcode/forecast/model/forecast_datasets.py

@@ -1,8 +1,10 @@
 #!/usr/bin/env python
 
-# Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+# Copyright (c) 2023, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
+from typing import Dict, List
+
 import pandas as pd
 
 from ads.opctl import logger
@@ -21,8 +23,8 @@ from ..operator_config import ForecastOperatorConfig
 
 
 class HistoricalData(AbstractData):
-    def __init__(self, spec: dict):
-        super().__init__(spec=spec, name="historical_data")
+    def __init__(self, spec, historical_data = None):
+        super().__init__(spec=spec, name="historical_data", data=historical_data)
 
     def _ingest_data(self, spec):
         try:
@@ -50,8 +52,11 @@ class HistoricalData(AbstractData):
 
 
 class AdditionalData(AbstractData):
-    def __init__(self, spec, historical_data):
-        if spec.additional_data is not None:
+    def __init__(self, spec, historical_data, additional_data=None):
+        if additional_data is not None:
+            super().__init__(spec=spec, name="additional_data", data=additional_data)
+            self.additional_regressors = list(self.data.columns)
+        elif spec.additional_data is not None:
             super().__init__(spec=spec, name="additional_data")
             add_dates = self.data.index.get_level_values(0).unique().tolist()
             add_dates.sort()
@@ -108,14 +113,15 @@ class AdditionalData(AbstractData):
 
 
 class TestData(AbstractData):
-    def __init__(self, spec):
-        super().__init__(spec=spec, name="test_data")
+    def __init__(self, spec, test_data):
+        if test_data is not None or spec.test_data is not None:
+            super().__init__(spec=spec, name="test_data", data=test_data)
         self.dt_column_name = spec.datetime_column.name
         self.target_name = spec.target_column
 
 
 class ForecastDatasets:
-    def __init__(self, config: ForecastOperatorConfig):
+    def __init__(self, config: ForecastOperatorConfig, historical_data=None, additional_data=None, test_data=None):
         """Instantiates the DataIO instance.
 
         Properties
@@ -125,11 +131,15 @@ class ForecastDatasets:
         """
         self.historical_data: HistoricalData = None
         self.additional_data: AdditionalData = None
-
         self._horizon = config.spec.horizon
         self._datetime_column_name = config.spec.datetime_column.name
         self._target_col = config.spec.target_column
-        self._load_data(config.spec)
+        if historical_data is not None:
+            self.historical_data = HistoricalData(config.spec, historical_data)
+            self.additional_data = AdditionalData(config.spec, self.historical_data, additional_data)
+        else:
+            self._load_data(config.spec)
+        self.test_data = TestData(config.spec, test_data)
 
     def _load_data(self, spec):
         """Loads forecasting input data."""
@@ -167,7 +177,7 @@ class ForecastDatasets:
                 self.historical_data.data,
                 self.additional_data.data,
             ],
-            axis=1
+            axis=1,
         )
 
     def get_data_by_series(self, include_horizon=True):
@@ -198,7 +208,7 @@ class ForecastDatasets:
         return self.get_data_at_series(s_id)[-self._horizon :]
 
     def has_artificial_series(self):
-        return self.historical_data._data_transformer.has_artificial_series
+        return bool(self.historical_data.spec.target_category_columns)
 
     def get_earliest_timestamp(self):
         return self.historical_data.get_min_time()
@@ -249,7 +259,7 @@ class ForecastOutput:
         target_column: str,
         dt_column: str,
     ):
-        """Forecast Output contains all of the details required to generate the forecast.csv output file.
+        """Forecast Output contains all the details required to generate the forecast.csv output file.
 
         init
         -------
@@ -416,3 +426,59 @@ class ForecastOutput:
         for df in self.series_id_map.values():
             output = pd.concat([output, df])
         return output.reset_index(drop=True)
+
+
+class ForecastResults:
+    """
+    Forecast Results contains all outputs from the forecast run.
+    This class is returned to users who use the Forecast's `operate` method.
+
+    """
+
+    def set_forecast(self, df: pd.DataFrame):
+        self.forecast = df
+
+    def get_forecast(self):
+        return getattr(self, "forecast", None)
+
+    def set_metrics(self, df: pd.DataFrame):
+        self.metrics = df
+
+    def get_metrics(self):
+        return getattr(self, "metrics", None)
+
+    def set_test_metrics(self, df: pd.DataFrame):
+        self.test_metrics = df
+
+    def get_test_metrics(self):
+        return getattr(self, "test_metrics", None)
+
+    def set_local_explanations(self, df: pd.DataFrame):
+        self.local_explanations = df
+
+    def get_local_explanations(self):
+        return getattr(self, "local_explanations", None)
+
+    def set_global_explanations(self, df: pd.DataFrame):
+        self.global_explanations = df
+
+    def get_global_explanations(self):
+        return getattr(self, "global_explanations", None)
+
+    def set_model_parameters(self, df: pd.DataFrame):
+        self.model_parameters = df
+
+    def get_model_parameters(self):
+        return getattr(self, "model_parameters", None)
+
+    def set_models(self, models: List):
+        self.models = models
+
+    def get_models(self):
+        return getattr(self, "models", None)
+
+    def set_errors_dict(self, errors_dict: Dict):
+        self.errors_dict = errors_dict
+
+    def get_errors_dict(self):
+        return getattr(self, "errors_dict", None)

ads/opctl/operator/lowcode/forecast/model/neuralprophet.py

@@ -172,8 +172,10 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
                 ).values,
             )
 
-            self.models[s_id] = model
             self.trainers[s_id] = model.trainer
+            self.models[s_id] = {}
+            self.models[s_id]["model"] = model
+            self.models[s_id]["le"] = self.le[s_id]
 
             self.model_parameters[s_id] = {
                 "framework": SupportedModels.NeuralProphet,
@@ -355,7 +357,8 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
 
             sec5_text = rc.Heading("Neural Prophet Model Parameters", level=2)
             model_states = []
-            for s_id, m in self.models.items():
+            for s_id, artifacts in self.models.items():
+                m = artifacts["model"]
                 model_states.append(
                     pd.Series(
                         m.state_dict(),

ads/opctl/operator/lowcode/forecast/model/prophet.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-# Copyright (c) 2024 Oracle and/or its affiliates.
+# Copyright (c) 2024, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 import logging
@@ -43,7 +43,11 @@ def _add_unit(num, unit):
 def _fit_model(data, params, additional_regressors):
     from prophet import Prophet
 
+    monthly_seasonality = params.pop("monthly_seasonality", False)
     model = Prophet(**params)
+    if monthly_seasonality:
+        model.add_seasonality(name="monthly", period=30.5, fourier_order=5)
+        params["monthly_seasonality"] = monthly_seasonality
     for add_reg in additional_regressors:
         model.add_regressor(add_reg)
     model.fit(data)
@@ -108,7 +112,10 @@ class ProphetOperatorModel(ForecastOperatorBaseModel):
                 upper_bound=self.get_horizon(forecast["yhat_upper"]).values,
                 lower_bound=self.get_horizon(forecast["yhat_lower"]).values,
             )
-            self.models[series_id] = model
+
+            self.models[series_id] = {}
+            self.models[series_id]["model"] = model
+            self.models[series_id]["le"] = self.le[series_id]
 
             params = vars(model).copy()
             for param in ["history", "history_dates", "stan_fit"]:
@@ -252,11 +259,11 @@ class ProphetOperatorModel(ForecastOperatorBaseModel):
         all_sections = []
         if len(series_ids) > 0:
             sec1 = _select_plot_list(
-                lambda s_id: self.models[s_id].plot(
+                lambda s_id: self.models[s_id]["model"].plot(
                     self.outputs[s_id], include_legend=True
                 ),
                 series_ids=series_ids,
-                target_category_column=self.target_cat_col
+                target_category_column=self.target_cat_col,
             )
             section_1 = rc.Block(
                 rc.Heading("Forecast Overview", level=2),
@@ -267,25 +274,25 @@ class ProphetOperatorModel(ForecastOperatorBaseModel):
             )
 
             sec2 = _select_plot_list(
-                lambda s_id: self.models[s_id].plot_components(self.outputs[s_id]),
+                lambda s_id: self.models[s_id]["model"].plot_components(self.outputs[s_id]),
                 series_ids=series_ids,
-                target_category_column=self.target_cat_col
+                target_category_column=self.target_cat_col,
             )
             section_2 = rc.Block(
                 rc.Heading("Forecast Broken Down by Trend Component", level=2), sec2
             )
 
             sec3_figs = {
-                s_id: self.models[s_id].plot(self.outputs[s_id]) for s_id in series_ids
+                s_id: self.models[s_id]["model"].plot(self.outputs[s_id]) for s_id in series_ids
             }
             for s_id in series_ids:
                 add_changepoints_to_plot(
-                    sec3_figs[s_id].gca(), self.models[s_id], self.outputs[s_id]
+                    sec3_figs[s_id].gca(), self.models[s_id]["model"], self.outputs[s_id]
                 )
             sec3 = _select_plot_list(
                 lambda s_id: sec3_figs[s_id],
                 series_ids=series_ids,
-                target_category_column=self.target_cat_col
+                target_category_column=self.target_cat_col,
             )
             section_3 = rc.Block(rc.Heading("Forecast Changepoints", level=2), sec3)
 
@@ -294,12 +301,14 @@ class ProphetOperatorModel(ForecastOperatorBaseModel):
             sec5_text = rc.Heading("Prophet Model Seasonality Components", level=2)
             model_states = []
             for s_id in series_ids:
-                m = self.models[s_id]
+                m = self.models[s_id]["model"]
                 model_states.append(
                     pd.Series(
                         m.seasonalities,
                         index=pd.Index(m.seasonalities.keys(), dtype="object"),
-                        name=s_id if self.target_cat_col else self.original_target_column,
+                        name=s_id
+                        if self.target_cat_col
+                        else self.original_target_column,
                         dtype="object",
                     )
                 )
@@ -330,11 +339,15 @@ class ProphetOperatorModel(ForecastOperatorBaseModel):
                 self.formatted_local_explanation = aggregate_local_explanations
 
                 if not self.target_cat_col:
-                    self.formatted_global_explanation = self.formatted_global_explanation.rename(
-                        {"Series 1": self.original_target_column},
-                        axis=1,
+                    self.formatted_global_explanation = (
+                        self.formatted_global_explanation.rename(
+                            {"Series 1": self.original_target_column},
+                            axis=1,
+                        )
+                    )
+                    self.formatted_local_explanation.drop(
+                        "Series", axis=1, inplace=True
                     )
-                    self.formatted_local_explanation.drop("Series", axis=1, inplace=True)
 
                 # Create a markdown section for the global explainability
                 global_explanation_section = rc.Block(

ads/opctl/operator/lowcode/forecast/model_evaluator.py

@@ -91,19 +91,13 @@ class ModelEvaluator:
         output_dir = operator_config.spec.output_directory.url
         output_file_path = f'{output_dir}/back_testing/{model}/{backtest}'
         Path(output_file_path).mkdir(parents=True, exist_ok=True)
-        historical_data_url = f'{output_file_path}/historical.csv'
-        additional_data_url = f'{output_file_path}/additional.csv'
-        test_data_url = f'{output_file_path}/test.csv'
-        historical_data.to_csv(historical_data_url, index=False)
-        additional_data.to_csv(additional_data_url, index=False)
-        test_data.to_csv(test_data_url, index=False)
         backtest_op_config_draft = operator_config.to_dict()
         backtest_spec = backtest_op_config_draft["spec"]
-        backtest_spec["historical_data"]["url"] = historical_data_url
-        if backtest_spec["additional_data"]:
-            backtest_spec["additional_data"]["url"] = additional_data_url
-        backtest_spec["test_data"] = {}
-        backtest_spec["test_data"]["url"] = test_data_url
+        backtest_spec["datetime_column"]["format"] = None
+        backtest_spec.pop("test_data")
+        backtest_spec.pop("additional_data")
+        backtest_spec.pop("historical_data")
+        backtest_spec["generate_report"] = False
         backtest_spec["model"] = model
         backtest_spec['model_kwargs'] = None
         backtest_spec["output_directory"] = {"url": output_file_path}
@@ -118,19 +112,23 @@ class ModelEvaluator:
     def run_all_models(self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig):
         cut_offs, train_sets, additional_data, test_sets = self.generate_k_fold_data(datasets, operator_config)
         metrics = {}
+        date_col = operator_config.spec.datetime_column.name
         for model in self.models:
             from .model.factory import ForecastOperatorModelFactory
             metrics[model] = {}
             for i in range(len(cut_offs)):
                 try:
-                    backtest_historical_data = train_sets[i]
-                    backtest_additional_data = additional_data[i]
-                    backtest_test_data = test_sets[i]
+                    backtest_historical_data = train_sets[i].set_index([date_col, DataColumns.Series])
+                    backtest_additional_data = additional_data[i].set_index([date_col, DataColumns.Series])
+                    backtest_test_data = test_sets[i].set_index([date_col, DataColumns.Series])
                     backtest_operator_config = self.create_operator_config(operator_config, i, model,
                                                                            backtest_historical_data,
                                                                            backtest_additional_data,
                                                                            backtest_test_data)
-                    datasets = ForecastDatasets(backtest_operator_config)
+                    datasets = ForecastDatasets(backtest_operator_config,
+                                                backtest_historical_data,
+                                                backtest_additional_data,
+                                                backtest_test_data)
                     ForecastOperatorModelFactory.get_model(
                         backtest_operator_config, datasets
                     ).generate_report()

ads/opctl/operator/lowcode/forecast/schema.yaml

@@ -379,7 +379,7 @@ spec:
               required: true
             log_id:
               type: string
-              required: true
+              required: false
             auto_scaling:
               type: dict
               required: false