oracle-ads 2.13.1rc0__py3-none-any.whl → 2.13.2rc1__py3-none-any.whl

ads/opctl/operator/lowcode/common/utils.py

@@ -3,6 +3,7 @@
 # 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 json
 import logging
 import os
 import shutil
@@ -12,7 +13,6 @@ from typing import List, Union
 
 import fsspec
 import oracledb
-import json
 import pandas as pd
 
 from ads.common.object_storage_details import ObjectStorageDetails
@@ -142,6 +142,11 @@ def write_data(data, filename, format, storage_options=None, index=False, **kwar
     )
 
 
+def write_json(json_dict, filename, storage_options=None):
+    with fsspec.open(filename, mode="w", **storage_options) as f:
+        f.write(json.dumps(json_dict))
+
+
 def write_simple_json(data, path):
     if ObjectStorageDetails.is_oci_path(path):
         storage_options = default_signer()
@@ -265,7 +270,7 @@ def find_output_dirname(output_dir: OutputDirectory):
     while os.path.exists(unique_output_dir):
         unique_output_dir = f"{output_dir}_{counter}"
         counter += 1
-    logger.warn(
+    logger.warning(
         f"Since the output directory was not specified, the output will be saved to {unique_output_dir} directory."
     )
     return unique_output_dir

ads/opctl/operator/lowcode/forecast/model/arima.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
@@ -132,13 +132,14 @@ class ArimaOperatorModel(ForecastOperatorBaseModel):
 
             logger.debug("===========Done===========")
         except Exception as e:
-            self.errors_dict[s_id] = {
+            new_error = {
                 "model_name": self.spec.model,
                 "error": str(e),
                 "error_trace": traceback.format_exc(),
             }
-            logger.warn(f"Encountered Error: {e}. Skipping.")
-            logger.warn(traceback.format_exc())
+            self.errors_dict[s_id] = new_error
+            logger.warning(f"Encountered Error: {e}. Skipping.")
+            logger.warning(traceback.format_exc())
 
     def _build_model(self) -> pd.DataFrame:
         full_data_dict = self.datasets.get_data_by_series()
@@ -166,7 +167,7 @@ class ArimaOperatorModel(ForecastOperatorBaseModel):
             sec5_text = rc.Heading("ARIMA Model Parameters", level=2)
             blocks = [
                 rc.Html(
-                    m['model'].summary().as_html(),
+                    m["model"].summary().as_html(),
                     label=s_id if self.target_cat_col else None,
                 )
                 for i, (s_id, m) in enumerate(self.models.items())
@@ -201,11 +202,15 @@ class ArimaOperatorModel(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(
@@ -235,7 +240,7 @@ class ArimaOperatorModel(ForecastOperatorBaseModel):
                     local_explanation_section,
                 ]
             except Exception as e:
-                logger.warn(f"Failed to generate Explanations with error: {e}.")
+                logger.warning(f"Failed to generate Explanations with error: {e}.")
                 logger.debug(f"Full Traceback: {traceback.format_exc()}")
 
         model_description = rc.Text(

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

@@ -184,13 +184,18 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                     "selected_model_params": model.selected_model_params_,
                 }
             except Exception as e:
-                self.errors_dict[s_id] = {
+                new_error = {
                     "model_name": self.spec.model,
                     "error": str(e),
                     "error_trace": traceback.format_exc(),
                 }
-                logger.warn(f"Encountered Error: {e}. Skipping.")
-                logger.warn(traceback.format_exc())
+                if s_id in self.errors_dict:
+                    self.errors_dict[s_id]["model_fitting"] = new_error
+                else:
+                    self.errors_dict[s_id] = {"model_fitting": new_error}
+                logger.warning(f"Encountered Error: {e}. Skipping.")
+                logger.warning(f"self.errors_dict[s_id]: {self.errors_dict[s_id]}")
+                logger.warning(traceback.format_exc())
 
         logger.debug("===========Forecast Generated===========")
 
@@ -249,7 +254,6 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                 self.explain_model()
 
                 global_explanation_section = None
-
                 # Convert the global explanation data to a DataFrame
                 global_explanation_df = pd.DataFrame(self.global_explanation)
 
@@ -258,7 +262,9 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                 )
 
                 self.formatted_global_explanation.rename(
-                    columns={self.spec.datetime_column.name: ForecastOutputColumns.DATE},
+                    columns={
+                        self.spec.datetime_column.name: ForecastOutputColumns.DATE
+                    },
                     inplace=True,
                 )
 
@@ -313,7 +319,7 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                     local_explanation_section,
                 ]
             except Exception as e:
-                logger.warn(f"Failed to generate Explanations with error: {e}.")
+                logger.warning(f"Failed to generate Explanations with error: {e}.")
                 logger.debug(f"Full Traceback: {traceback.format_exc()}")
 
         model_description = rc.Text(
@@ -463,20 +469,44 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                         index="row", columns="Feature", values="Attribution"
                     )
                     explanations_df = explanations_df.reset_index(drop=True)
-
+                    explanations_df[ForecastOutputColumns.DATE] = (
+                        self.datasets.get_horizon_at_series(
+                            s_id=s_id
+                        )[self.spec.datetime_column.name].reset_index(drop=True)
+                    )
                     # Store the explanations in the local_explanation dictionary
                     self.local_explanation[s_id] = explanations_df
 
                     self.global_explanation[s_id] = dict(
                         zip(
-                            self.local_explanation[s_id].columns,
-                            np.nanmean((self.local_explanation[s_id]), axis=0),
+                            self.local_explanation[s_id]
+                            .drop(ForecastOutputColumns.DATE, axis=1)
+                            .columns,
+                            np.nanmean(
+                                np.abs(
+                                    self.local_explanation[s_id].drop(
+                                        ForecastOutputColumns.DATE, axis=1
+                                    )
+                                ),
+                                axis=0,
+                            ),
                         )
                     )
                 else:
                     # Fall back to the default explanation generation method
                     super().explain_model()
             except Exception as e:
+                if s_id in self.errors_dict:
+                    self.errors_dict[s_id]["explainer_error"] = str(e)
+                    self.errors_dict[s_id]["explainer_error_trace"] = (
+                        traceback.format_exc()
+                    )
+                else:
+                    self.errors_dict[s_id] = {
+                        "model_name": self.spec.model,
+                        "explainer_error": str(e),
+                        "explainer_error_trace": traceback.format_exc(),
+                    }
                 logger.warning(
                     f"Failed to generate explanations for series {s_id} with error: {e}."
                 )

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

@@ -211,8 +211,8 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
                     "error": str(e),
                     "error_trace": traceback.format_exc(),
                 }
-            logger.warn(f"Encountered Error: {e}. Skipping.")
-            logger.warn(traceback.format_exc())
+            logger.warning(f"Encountered Error: {e}. Skipping.")
+            logger.warning(traceback.format_exc())
 
         logger.debug("===========Done===========")
 
@@ -242,7 +242,7 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
                     self.models.df_wide_numeric, series=s_id
                 ),
                 self.datasets.list_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),
@@ -260,7 +260,9 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
                 )
 
             except KeyError:
-                logger.warn("Issue generating Model Parameters Table Section. Skipping")
+                logger.warning(
+                    "Issue generating Model Parameters Table Section. Skipping"
+                )
                 sec2 = rc.Text("Error generating model parameters.")
 
             section_2 = rc.Block(sec2_text, sec2)
@@ -268,7 +270,7 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
             all_sections = [section_1, section_2]
 
         if self.spec.generate_explanations:
-            logger.warn("Explanations not yet supported for the AutoTS Module")
+            logger.warning("Explanations not yet supported for the AutoTS Module")
 
         # Model Description
         model_description = rc.Text(

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

@@ -28,8 +28,8 @@ from ads.opctl.operator.lowcode.common.utils import (
     merged_category_column_name,
     seconds_to_datetime,
     write_data,
+    write_json,
 )
-from ads.opctl.operator.lowcode.forecast.model.forecast_datasets import TestData
 from ads.opctl.operator.lowcode.forecast.utils import (
     _build_metrics_df,
     _build_metrics_per_horizon,
@@ -46,6 +46,7 @@ from ..const import (
     AUTO_SELECT,
     BACKTEST_REPORT_NAME,
     SUMMARY_METRICS_HORIZON_LIMIT,
+    ForecastOutputColumns,
     SpeedAccuracyMode,
     SupportedMetrics,
     SupportedModels,
@@ -120,7 +121,7 @@ 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:
@@ -130,14 +131,12 @@ class ForecastOperatorBaseModel(ABC):
                         {"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,
-                        ) = self._test_evaluate_metrics(
-                            elapsed_time=elapsed_time,
+                        (self.test_eval_metrics, summary_metrics) = (
+                            self._test_evaluate_metrics(
+                                elapsed_time=elapsed_time,
+                            )
                         )
                         if not self.target_cat_col:
                             self.test_eval_metrics.rename(
@@ -146,7 +145,7 @@ class ForecastOperatorBaseModel(ABC):
                                 inplace=True,
                             )
                     except Exception:
-                        logger.warn("Unable to generate Test Metrics.")
+                        logger.warning("Unable to generate Test Metrics.")
                         logger.debug(f"Full Traceback: {traceback.format_exc()}")
             report_sections = []
 
@@ -156,9 +155,8 @@ class ForecastOperatorBaseModel(ABC):
                     model_description,
                     other_sections,
                 ) = self._generate_report()
-
                 header_section = rc.Block(
-                    rc.Heading("Forecast Report", level=1),
+                    rc.Heading(self.spec.report_title, level=1),
                     rc.Text(
                         f"You selected the {self.spec.model} model.\nBased on your dataset, you could have also selected any of the models: {SupportedModels.keys()}."
                     ),
@@ -361,7 +359,7 @@ class ForecastOperatorBaseModel(ABC):
     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():
@@ -370,7 +368,7 @@ class ForecastOperatorBaseModel(ABC):
                     -self.spec.horizon :
                 ]
             except KeyError as ke:
-                logger.warn(
+                logger.warning(
                     f"Error Generating Metrics: Unable to find {s_id} in the test data. Error: {ke.args}"
                 )
             y_pred = self.forecast_output.get_forecast(s_id)["forecast_value"].values[
@@ -398,7 +396,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(
             {
@@ -464,7 +462,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,
@@ -479,10 +477,11 @@ class ForecastOperatorBaseModel(ABC):
         unique_output_dir = self.spec.output_directory.url
         results = ForecastResults()
 
-        if ObjectStorageDetails.is_oci_path(unique_output_dir):
-            storage_options = default_signer()
-        else:
-            storage_options = {}
+        storage_options = (
+            default_signer()
+            if ObjectStorageDetails.is_oci_path(unique_output_dir)
+            else {}
+        )
 
         # report-creator html report
         if self.spec.generate_report:
@@ -513,12 +512,13 @@ class ForecastOperatorBaseModel(ABC):
             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,
-        )
+        if self.spec.generate_forecast_file:
+            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
@@ -532,77 +532,81 @@ class ForecastOperatorBaseModel(ABC):
                 metrics_df_formatted = metrics_df.reset_index().rename(
                     {"index": "metrics", "Series 1": metrics_col_name}, axis=1
                 )
-                write_data(
-                    data=metrics_df_formatted,
-                    filename=os.path.join(
-                        unique_output_dir, self.spec.metrics_filename
-                    ),
-                    format="csv",
-                    storage_options=storage_options,
-                    index=False,
-                )
+                if self.spec.generate_metrics_file:
+                    write_data(
+                        data=metrics_df_formatted,
+                        filename=os.path.join(
+                            unique_output_dir, self.spec.metrics_filename
+                        ),
+                        format="csv",
+                        storage_options=storage_options,
+                        index=False,
+                    )
                 results.set_metrics(metrics_df_formatted)
             else:
-                logger.warn(
+                logger.warning(
                     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_formatted,
-                        filename=os.path.join(
-                            unique_output_dir, self.spec.test_metrics_filename
-                        ),
-                        format="csv",
-                        storage_options=storage_options,
-                        index=False,
-                    )
+                    if self.spec.generate_metrics_file:
+                        write_data(
+                            data=test_metrics_df_formatted,
+                            filename=os.path.join(
+                                unique_output_dir, self.spec.test_metrics_filename
+                            ),
+                            format="csv",
+                            storage_options=storage_options,
+                            index=False,
+                        )
                     results.set_test_metrics(test_metrics_df_formatted)
                 else:
-                    logger.warn(
+                    logger.warning(
                         f"Attempted to generate the {self.spec.test_metrics_filename} file with the test metrics, however the test metrics could not be properly generated."
                     )
         # explanations csv reports
         if self.spec.generate_explanations:
             try:
-                if self.formatted_global_explanation is not None:
-                    write_data(
-                        data=self.formatted_global_explanation,
-                        filename=os.path.join(
-                            unique_output_dir, self.spec.global_explanation_filename
-                        ),
-                        format="csv",
-                        storage_options=storage_options,
-                        index=True,
-                    )
+                if not self.formatted_global_explanation.empty:
+                    if self.spec.generate_explanation_files:
+                        write_data(
+                            data=self.formatted_global_explanation,
+                            filename=os.path.join(
+                                unique_output_dir, self.spec.global_explanation_filename
+                            ),
+                            format="csv",
+                            storage_options=storage_options,
+                            index=True,
+                        )
                     results.set_global_explanations(self.formatted_global_explanation)
                 else:
-                    logger.warn(
+                    logger.warning(
                         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:
-                    write_data(
-                        data=self.formatted_local_explanation,
-                        filename=os.path.join(
-                            unique_output_dir, self.spec.local_explanation_filename
-                        ),
-                        format="csv",
-                        storage_options=storage_options,
-                        index=True,
-                    )
+                if not self.formatted_local_explanation.empty:
+                    if self.spec.generate_explanation_files:
+                        write_data(
+                            data=self.formatted_local_explanation,
+                            filename=os.path.join(
+                                unique_output_dir, self.spec.local_explanation_filename
+                            ),
+                            format="csv",
+                            storage_options=storage_options,
+                            index=True,
+                        )
                     results.set_local_explanations(self.formatted_local_explanation)
                 else:
-                    logger.warn(
+                    logger.warning(
                         f"Attempted to generate local explanations for the {self.spec.local_explanation_filename} file, but an issue occured in formatting the explanations."
                     )
             except AttributeError as e:
-                logger.warn(
+                logger.warning(
                     "Unable to generate explanations for this model type or for this dataset."
                 )
                 logger.debug(f"Got error: {e.args}")
@@ -632,15 +636,12 @@ class ForecastOperatorBaseModel(ABC):
             f"The outputs have been successfully generated and placed into the directory: {unique_output_dir}."
         )
         if self.errors_dict:
-            write_data(
-                data=pd.DataFrame.from_dict(self.errors_dict),
+            write_json(
+                json_dict=self.errors_dict,
                 filename=os.path.join(
                     unique_output_dir, self.spec.errors_dict_filename
                 ),
-                format="json",
                 storage_options=storage_options,
-                index=True,
-                indent=4,
             )
             results.set_errors_dict(self.errors_dict)
         else:
@@ -743,45 +744,62 @@ class ForecastOperatorBaseModel(ABC):
             include_horizon=False
         ).items():
             if s_id in self.models:
-                explain_predict_fn = self.get_explain_predict_fn(series_id=s_id)
-                data_trimmed = data_i.tail(
-                    max(int(len(data_i) * ratio), 5)
-                ).reset_index(drop=True)
-                data_trimmed[datetime_col_name] = data_trimmed[datetime_col_name].apply(
-                    lambda x: x.timestamp()
-                )
-
-                # Explainer fails when boolean columns are passed
-
-                _, data_trimmed_encoded = _label_encode_dataframe(
-                    data_trimmed,
-                    no_encode={datetime_col_name, self.original_target_column},
-                )
-
-                kernel_explnr = PermutationExplainer(
-                    model=explain_predict_fn, masker=data_trimmed_encoded
-                )
-                kernel_explnr_vals = kernel_explnr.shap_values(data_trimmed_encoded)
-                exp_end_time = time.time()
-                global_ex_time = global_ex_time + exp_end_time - exp_start_time
-                self.local_explainer(
-                    kernel_explnr, series_id=s_id, datetime_col_name=datetime_col_name
-                )
-                local_ex_time = local_ex_time + time.time() - exp_end_time
+                try:
+                    explain_predict_fn = self.get_explain_predict_fn(series_id=s_id)
+                    data_trimmed = data_i.tail(
+                        max(int(len(data_i) * ratio), 5)
+                    ).reset_index(drop=True)
+                    data_trimmed[datetime_col_name] = data_trimmed[
+                        datetime_col_name
+                    ].apply(lambda x: x.timestamp())
+
+                    # Explainer fails when boolean columns are passed
+
+                    _, data_trimmed_encoded = _label_encode_dataframe(
+                        data_trimmed,
+                        no_encode={datetime_col_name, self.original_target_column},
+                    )
 
-                if not len(kernel_explnr_vals):
-                    logger.warn(
-                        "No explanations generated. Ensure that additional data has been provided."
+                    kernel_explnr = PermutationExplainer(
+                        model=explain_predict_fn, masker=data_trimmed_encoded
                     )
-                else:
-                    self.global_explanation[s_id] = dict(
-                        zip(
-                            data_trimmed.columns[1:],
-                            np.average(np.absolute(kernel_explnr_vals[:, 1:]), axis=0),
-                        )
+                    kernel_explnr_vals = kernel_explnr.shap_values(data_trimmed_encoded)
+                    exp_end_time = time.time()
+                    global_ex_time = global_ex_time + exp_end_time - exp_start_time
+                    self.local_explainer(
+                        kernel_explnr,
+                        series_id=s_id,
+                        datetime_col_name=datetime_col_name,
                     )
+                    local_ex_time = local_ex_time + time.time() - exp_end_time
+
+                    if not len(kernel_explnr_vals):
+                        logger.warning(
+                            "No explanations generated. Ensure that additional data has been provided."
+                        )
+                    else:
+                        self.global_explanation[s_id] = dict(
+                            zip(
+                                data_trimmed.columns[1:],
+                                np.average(
+                                    np.absolute(kernel_explnr_vals[:, 1:]), axis=0
+                                ),
+                            )
+                        )
+                except Exception as e:
+                    if s_id in self.errors_dict:
+                        self.errors_dict[s_id]["explainer_error"] = str(e)
+                        self.errors_dict[s_id]["explainer_error_trace"] = (
+                            traceback.format_exc()
+                        )
+                    else:
+                        self.errors_dict[s_id] = {
+                            "model_name": self.spec.model,
+                            "explainer_error": str(e),
+                            "explainer_error_trace": traceback.format_exc(),
+                        }
             else:
-                logger.warn(
+                logger.warning(
                     f"Skipping explanations for {s_id}, as forecast was not generated."
                 )
 
@@ -816,6 +834,13 @@ class ForecastOperatorBaseModel(ABC):
         local_kernel_explnr_df = pd.DataFrame(
             local_kernel_explnr_vals, columns=data.columns
         )
+
+        # Add date column to local explanation DataFrame
+        local_kernel_explnr_df[ForecastOutputColumns.DATE] = (
+            self.datasets.get_horizon_at_series(
+                s_id=series_id
+            )[self.spec.datetime_column.name].reset_index(drop=True)
+        )
         self.local_explanation[series_id] = local_kernel_explnr_df
 
     def get_explain_predict_fn(self, series_id, fcst_col_name="yhat"):