oracle-ads 2.12.5__py3-none-any.whl → 2.12.6__py3-none-any.whl

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

@@ -1,45 +1,35 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
 # Copyright (c) 2023, 2024 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
+import traceback
+
 import numpy as np
 import optuna
 import pandas as pd
-from joblib import Parallel, delayed
 from torch import Tensor
-from torchmetrics.regression import (
-    MeanAbsoluteError,
-    MeanAbsolutePercentageError,
-    MeanSquaredError,
-    R2Score,
-    SymmetricMeanAbsolutePercentageError,
-)
 
 from ads.common.decorator.runtime_dependency import (
     OptionalDependency,
     runtime_dependency,
 )
 from ads.opctl import logger
-
-from ..const import DEFAULT_TRIALS, ForecastOutputColumns, SupportedModels
-from ads.opctl.operator.lowcode.forecast.utils import (
-    load_pkl,
-    write_pkl,
-    _select_plot_list,
-    _label_encode_dataframe,
-)
 from ads.opctl.operator.lowcode.common.utils import (
     disable_print,
     enable_print,
-    seconds_to_datetime,
 )
-from .base_model import ForecastOperatorBaseModel
+from ads.opctl.operator.lowcode.forecast.utils import (
+    _select_plot_list,
+    load_pkl,
+    write_pkl,
+)
+
+from ..const import DEFAULT_TRIALS, SupportedModels
 from ..operator_config import ForecastOperatorConfig
+from .base_model import ForecastOperatorBaseModel
 from .forecast_datasets import ForecastDatasets, ForecastOutput
-import traceback
-
 
 # def _get_np_metrics_dict(selected_metric):
 #     metric_translation = {
@@ -62,7 +52,7 @@ import traceback
     object="NeuralProphet",
     install_from=OptionalDependency.FORECAST,
 )
-def _fit_model(data, params, additional_regressors, select_metric):
+def _fit_model(data, params, additional_regressors):
     from neuralprophet import NeuralProphet, set_log_level
 
     if logger.level > 10:
@@ -70,13 +60,12 @@ def _fit_model(data, params, additional_regressors, select_metric):
         disable_print()
 
     m = NeuralProphet(**params)
-    # m.metrics = _get_np_metrics_dict(select_metric)
     for add_reg in additional_regressors:
         m = m.add_future_regressor(name=add_reg)
     m.fit(df=data)
-    accepted_regressors_config = m.config_regressors or dict()
+    accepted_regressors_config = m.config_regressors or {}
     if hasattr(accepted_regressors_config, "regressors"):
-        accepted_regressors_config = accepted_regressors_config.regressors or dict()
+        accepted_regressors_config = accepted_regressors_config.regressors or {}
 
     enable_print()
     return m, list(accepted_regressors_config.keys())
@@ -97,11 +86,12 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
             self.loaded_trainers = load_pkl(
                 self.spec.previous_output_dir + "/trainer.pkl"
             )
-        except:
-            logger.debug("model.pkl/trainer.pkl is not present")
+        except Exception as e:
+            logger.debug(f"model.pkl/trainer.pkl is not present. Error message: {e}")
 
     def set_kwargs(self):
         # Extract the Confidence Interval Width and convert to prophet's equivalent - interval_width
+        model_kwargs = self.spec.model_kwargs
         if self.spec.confidence_interval_width is None:
             quantiles = model_kwargs.get("quantiles", [0.05, 0.95])
             self.spec.confidence_interval_width = float(quantiles[1]) - float(
@@ -110,8 +100,6 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
         else:
             boundaries = round((1 - self.spec.confidence_interval_width) / 2, 2)
             quantiles = [boundaries, self.spec.confidence_interval_width + boundaries]
-
-        model_kwargs = self.spec.model_kwargs
         model_kwargs["quantiles"] = quantiles
         return model_kwargs
 
@@ -124,12 +112,10 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
 
             if self.loaded_models is not None and s_id in self.loaded_models:
                 model = self.loaded_models[s_id]
-                accepted_regressors_config = (
-                    model.config_regressors.regressors or dict()
-                )
+                accepted_regressors_config = model.config_regressors.regressors or {}
                 if hasattr(accepted_regressors_config, "regressors"):
                     accepted_regressors_config = (
-                        accepted_regressors_config.regressors or dict()
+                        accepted_regressors_config.regressors or {}
                     )
                 self.accepted_regressors[s_id] = list(accepted_regressors_config.keys())
                 if self.loaded_trainers is not None and s_id in self.loaded_trainers:
@@ -143,8 +129,6 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
                     data=data_i,
                     params=model_kwargs,
                     additional_regressors=self.additional_regressors,
-                    select_metric=None,
-                    # select_metric=self.spec.metric,
                 )
 
             logger.debug(
@@ -205,7 +189,6 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
                 "config_normalization": model.config_normalization,
                 "config_missing": model.config_missing,
                 "config_model": model.config_model,
-                "config_normalization": model.config_normalization,
                 "data_freq": model.data_freq,
                 "fitted": model.fitted,
                 "data_params": model.data_params,
@@ -220,19 +203,19 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
             self.errors_dict[s_id] = {
                 "model_name": self.spec.model,
                 "error": str(e),
-                "error_trace": traceback.format_exc()
+                "error_trace": traceback.format_exc(),
             }
             logger.warn(traceback.format_exc())
             raise e
 
     def _build_model(self) -> pd.DataFrame:
         full_data_dict = self.datasets.get_data_by_series()
-        self.models = dict()
-        self.trainers = dict()
-        self.outputs = dict()
-        self.errors_dict = dict()
-        self.explanations_info = dict()
-        self.accepted_regressors = dict()
+        self.models = {}
+        self.trainers = {}
+        self.outputs = {}
+        self.errors_dict = {}
+        self.explanations_info = {}
+        self.accepted_regressors = {}
         self.additional_regressors = self.datasets.get_additional_data_column_names()
         model_kwargs = self.set_kwargs()
         self.forecast_output = ForecastOutput(
@@ -282,7 +265,6 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
                     data=df_train,
                     params=params,
                     additional_regressors=self.additional_regressors,
-                    select_metric=self.spec.metric,
                 )
                 df_test = df_test[["y", "ds"] + accepted_regressors]
 
@@ -326,6 +308,8 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
     def _generate_report(self):
         import report_creator as rc
 
+        logging.getLogger("report_creator").setLevel(logging.WARNING)
+
         series_ids = self.models.keys()
         all_sections = []
         if len(series_ids) > 0:
@@ -371,7 +355,7 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
 
             sec5_text = rc.Heading("Neural Prophet Model Parameters", level=2)
             model_states = []
-            for i, (s_id, m) in enumerate(self.models.items()):
+            for s_id, m in self.models.items():
                 model_states.append(
                     pd.Series(
                         m.state_dict(),
@@ -449,7 +433,7 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
         )
 
     def explain_model(self):
-        self.local_explanation = dict()
+        self.local_explanation = {}
         global_expl = []
         rename_cols = {
             f"future_regressor_{col}": col

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

@@ -1,17 +1,23 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
 # Copyright (c) 2024 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
+import traceback
+
+import matplotlib as mpl
 import numpy as np
 import optuna
 import pandas as pd
-import logging
 from joblib import Parallel, delayed
-from ads.common.decorator.runtime_dependency import runtime_dependency
+
 from ads.opctl import logger
+from ads.opctl.operator.lowcode.common.utils import set_log_level
 from ads.opctl.operator.lowcode.forecast.operator_config import ForecastOperatorConfig
+from ads.opctl.operator.lowcode.forecast.utils import (
+    _select_plot_list,
+)
 
 from ..const import (
     DEFAULT_TRIALS,
@@ -19,23 +25,14 @@ from ..const import (
     ForecastOutputColumns,
     SupportedModels,
 )
-from ads.opctl.operator.lowcode.forecast.utils import (
-    _select_plot_list,
-    _label_encode_dataframe,
-)
-from ads.opctl.operator.lowcode.common.utils import set_log_level
 from .base_model import ForecastOperatorBaseModel
-from ..operator_config import ForecastOperatorConfig
 from .forecast_datasets import ForecastDatasets, ForecastOutput
-import traceback
-import matplotlib as mpl
-
 
 try:
     set_log_level("prophet", logger.level)
     set_log_level("cmdstanpy", logger.level)
     mpl.rcParams["figure.max_open_warning"] = 100
-except:
+except Exception:
     pass
 
 
@@ -73,9 +70,6 @@ class ProphetOperatorModel(ForecastOperatorBaseModel):
 
     def _train_model(self, i, series_id, df, model_kwargs):
         try:
-            from prophet import Prophet
-            from prophet.diagnostics import cross_validation, performance_metrics
-
             self.forecast_output.init_series_output(
                 series_id=series_id, data_at_series=df
             )
@@ -130,15 +124,15 @@ class ProphetOperatorModel(ForecastOperatorBaseModel):
             self.errors_dict[series_id] = {
                 "model_name": self.spec.model,
                 "error": str(e),
-                "error_trace": traceback.format_exc()
+                "error_trace": traceback.format_exc(),
             }
             logger.warn(f"Encountered Error: {e}. Skipping.")
             logger.warn(traceback.format_exc())
 
     def _build_model(self) -> pd.DataFrame:
         full_data_dict = self.datasets.get_data_by_series()
-        self.models = dict()
-        self.outputs = dict()
+        self.models = {}
+        self.outputs = {}
         self.additional_regressors = self.datasets.get_additional_data_column_names()
         model_kwargs = self.set_kwargs()
         self.forecast_output = ForecastOutput(
@@ -249,6 +243,8 @@ class ProphetOperatorModel(ForecastOperatorBaseModel):
         import report_creator as rc
         from prophet.plot import add_changepoints_to_plot
 
+        logging.getLogger("report_creator").setLevel(logging.WARNING)
+
         series_ids = self.models.keys()
         all_sections = []
         if len(series_ids) > 0:
@@ -351,7 +347,6 @@ class ProphetOperatorModel(ForecastOperatorBaseModel):
                 # Append the global explanation text and section to the "all_sections" list
                 all_sections = all_sections + [
                     global_explanation_section,
-                    local_explanation_text,
                     local_explanation_section,
                 ]
             except Exception as e:

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

@@ -121,23 +121,26 @@ class ModelEvaluator:
             from .model.factory import ForecastOperatorModelFactory
             metrics[model] = {}
             for i in range(len(cut_offs)):
-                backtest_historical_data = train_sets[i]
-                backtest_additional_data = additional_data[i]
-                backtest_test_data = test_sets[i]
-                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)
-                ForecastOperatorModelFactory.get_model(
-                    backtest_operator_config, datasets
-                ).generate_report()
-                test_metrics_filename = backtest_operator_config.spec.test_metrics_filename
-                metrics_df = pd.read_csv(
-                    f"{backtest_operator_config.spec.output_directory.url}/{test_metrics_filename}")
-                metrics_df["average_across_series"] = metrics_df.drop('metrics', axis=1).mean(axis=1)
-                metrics_average_dict = dict(zip(metrics_df['metrics'].str.lower(), metrics_df['average_across_series']))
-                metrics[model][i] = metrics_average_dict[operator_config.spec.metric]
+                try:
+                    backtest_historical_data = train_sets[i]
+                    backtest_additional_data = additional_data[i]
+                    backtest_test_data = test_sets[i]
+                    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)
+                    ForecastOperatorModelFactory.get_model(
+                        backtest_operator_config, datasets
+                    ).generate_report()
+                    test_metrics_filename = backtest_operator_config.spec.test_metrics_filename
+                    metrics_df = pd.read_csv(
+                        f"{backtest_operator_config.spec.output_directory.url}/{test_metrics_filename}")
+                    metrics_df["average_across_series"] = metrics_df.drop('metrics', axis=1).mean(axis=1)
+                    metrics_average_dict = dict(zip(metrics_df['metrics'].str.lower(), metrics_df['average_across_series']))
+                    metrics[model][i] = metrics_average_dict[operator_config.spec.metric]
+                except:
+                    logger.warn(f"Failed to calculate metrics for {model} and {i} backtest")
         return metrics
 
     def find_best_model(self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig):
@@ -147,10 +150,12 @@ class ModelEvaluator:
             model = SupportedModels.Prophet
             logger.error(f"Running {model} model as auto-select failed with the following error: {e.message}")
             return model
-        avg_backtests_metrics = {key: sum(value.values()) / len(value.values()) for key, value in metrics.items()}
-        best_model = min(avg_backtests_metrics, key=avg_backtests_metrics.get)
+        nonempty_metrics = {model: metric for model, metric in metrics.items() if metric != {}}
+        avg_backtests_metric = {model: sum(value.values()) / len(value.values())
+                                for model, value in nonempty_metrics.items()}
+        best_model = min(avg_backtests_metric, key=avg_backtests_metric.get)
         logger.info(f"Among models {self.models}, {best_model} model shows better performance during backtesting.")
-        backtest_stats = pd.DataFrame(metrics).rename_axis('backtest')
+        backtest_stats = pd.DataFrame(nonempty_metrics).rename_axis('backtest')
         backtest_stats.reset_index(inplace=True)
         output_dir = operator_config.spec.output_directory.url
         backtest_report_name = "backtest_stats.csv"

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

@@ -1,42 +1,41 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
 # Copyright (c) 2023, 2024 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
 import os
-import sys
-from typing import List
+from typing import Set
 
+import cloudpickle
 import fsspec
 import numpy as np
 import pandas as pd
-import cloudpickle
-import plotly.express as px
+import report_creator as rc
 from plotly import graph_objects as go
+from scipy.stats import linregress
 from sklearn.metrics import (
     explained_variance_score,
     mean_absolute_percentage_error,
     mean_squared_error,
+    r2_score,
 )
-try:
-    from scipy.stats import linregress
-except:
-    from sklearn.metrics import r2_score
 
 from ads.common.object_storage_details import ObjectStorageDetails
 from ads.dataset.label_encoder import DataFrameLabelEncoder
 from ads.opctl import logger
-
-from .const import SupportedMetrics, SupportedModels, RENDER_LIMIT
-from .errors import ForecastInputDataError, ForecastSchemaYamlError
-from .operator_config import ForecastOperatorSpec, ForecastOperatorConfig
-from ads.opctl.operator.lowcode.common.utils import merge_category_columns
 from ads.opctl.operator.lowcode.forecast.const import ForecastOutputColumns
-import report_creator as rc
+from ads.opctl.operator.lowcode.forecast.model.forecast_datasets import (
+    ForecastOutput,
+    TestData,
+)
 
+from .const import RENDER_LIMIT, SupportedMetrics
 
-def _label_encode_dataframe(df, no_encode=set()):
+logging.getLogger("report_creator").setLevel(logging.WARNING)
+
+
+def _label_encode_dataframe(df, no_encode: Set = None):
     df_to_encode = df[list(set(df.columns) - no_encode)]
     le = DataFrameLabelEncoder().fit(df_to_encode)
     return le, le.transform(df)
@@ -55,15 +54,14 @@ def smape(actual, predicted) -> float:
     denominator[zero_mask] = 1
 
     numerator = np.abs(actual - predicted)
-    default_output = np.ones_like(numerator) * np.inf
 
     abs_error = np.divide(numerator, denominator)
     return round(np.mean(abs_error) * 100, 2)
 
 
 def _build_metrics_per_horizon(
-    test_data: "TestData",
-    output: "ForecastOutput",
+    test_data: TestData,
+    output: ForecastOutput,
 ) -> pd.DataFrame:
     """
     Calculates Mean sMAPE, Median sMAPE, Mean MAPE, Median MAPE, Mean wMAPE, Median wMAPE for each horizon
@@ -173,7 +171,7 @@ def _build_metrics_per_horizon(
 
 
 def load_pkl(filepath):
-    storage_options = dict()
+    storage_options = {}
     if ObjectStorageDetails.is_oci_path(filepath):
         storage_options = default_signer()
 
@@ -195,13 +193,13 @@ def write_pkl(obj, filename, output_dir, storage_options):
 def _build_metrics_df(y_true, y_pred, series_id):
     if len(y_true) == 0 or len(y_pred) == 0:
         return pd.DataFrame()
-    metrics = dict()
+    metrics = {}
     metrics["sMAPE"] = smape(actual=y_true, predicted=y_pred)
     metrics["MAPE"] = mean_absolute_percentage_error(y_true=y_true, y_pred=y_pred)
     metrics["RMSE"] = np.sqrt(mean_squared_error(y_true=y_true, y_pred=y_pred))
     try:
         metrics["r2"] = linregress(y_true, y_pred).rvalue ** 2
-    except:
+    except Exception:
         metrics["r2"] = r2_score(y_true=y_true, y_pred=y_pred)
     metrics["Explained Variance"] = explained_variance_score(
         y_true=y_true, y_pred=y_pred
@@ -209,16 +207,13 @@ def _build_metrics_df(y_true, y_pred, series_id):
     return pd.DataFrame.from_dict(metrics, orient="index", columns=[series_id])
 
 
-def evaluate_train_metrics(output, metrics_col_name=None):
+def evaluate_train_metrics(output):
     """
     Training metrics
 
     Parameters:
     output: ForecastOutputs
 
-    metrics_col_name: str
-            Only passed in if the series column was created artifically.
-            When passed in, replaces s_id as the column name in the metrics table
     """
     total_metrics = pd.DataFrame()
     for s_id in output.list_series_ids():
@@ -263,20 +258,21 @@ def _select_plot_list(fn, series_ids):
 def _add_unit(num, unit):
     return f"{num} {unit}"
 
+
 def get_auto_select_plot(backtest_results):
     fig = go.Figure()
     columns = backtest_results.columns.tolist()
     back_test_column = "backtest"
     columns.remove(back_test_column)
-    for i, column in enumerate(columns):
-        color = 0 #int(i * 255 / len(columns))
+    for column in columns:
         fig.add_trace(
             go.Scatter(
-            x=backtest_results[back_test_column],
-            y=backtest_results[column],
-            mode="lines",
-            name=column,
-        ))
+                x=backtest_results[back_test_column],
+                y=backtest_results[column],
+                mode="lines",
+                name=column,
+            )
+        )
 
     return rc.Widget(fig)
 
@@ -384,6 +380,7 @@ def get_forecast_plots(
 
     return _select_plot_list(plot_forecast_plotly, forecast_output.list_series_ids())
 
+
 def convert_target(target: str, target_col: str):
     """
     Removes the target_column that got appended to target.

ads/opctl/operator/lowcode/pii/model/report.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
 # Copyright (c) 2023, 2024 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
 import os
 import random
 import tempfile
@@ -40,11 +40,13 @@ from ads.opctl.operator.lowcode.pii.utils import compute_rate
 
 try:
     import report_creator as rc
-except ImportError:
+except ImportError as e:
     raise ModuleNotFoundError(
         f"`report-creator` module was not found. Please run "
         f"`pip install {OptionalDependency.PII}`."
-    )
+    ) from e
+
+logging.getLogger("report_creator").setLevel(logging.WARNING)
 
 
 @dataclass(repr=True)
@@ -139,13 +141,13 @@ def make_model_card(model_name="", readme_path=""):
         fig = go.Figure(
             data=[
                 go.Table(
-                    header=dict(values=list(df.columns)),
-                    cells=dict(values=[df.Metrics, df.Values]),
+                    header={"Columns": df.columns},
+                    cells={"Metrics": df.Metrics, "Values": df.Values},
                 )
             ]
         )
         eval_res_tb = rc.Widget(data=fig, caption="Evaluation Results")
-    except:
+    except Exception:
         eval_res_tb = rc.Text("-")
         logger.warning(
             "The given readme.md doesn't have correct template for Evaluation Results."
@@ -321,7 +323,9 @@ class PIIOperatorReport:
         self.report_sections = [title_text, report_description, time_proceed, structure]
         return self
 
-    def save_report(self, report_sections=None, report_uri=None, storage_options={}):
+    def save_report(
+        self, report_sections=None, report_uri=None, storage_options: Dict = None
+    ):
         with tempfile.TemporaryDirectory() as temp_dir:
             report_local_path = os.path.join(temp_dir, "___report.html")
             disable_print()