oracle-ads 2.11.7__py3-none-any.whl → 2.11.9__py3-none-any.whl

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

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*--
 import traceback
 
-# Copyright (c) 2023 Oracle and/or its affiliates.
+# 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 pandas as pd
@@ -52,7 +52,6 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
         ] = self.spec.preprocessing or model_kwargs_cleaned.get("preprocessing", True)
         return model_kwargs_cleaned, time_budget
 
-
     def preprocess(self, data, series_id=None):  # TODO: re-use self.le for explanations
         _, df_encoded = _label_encode_dataframe(
             data,
@@ -77,8 +76,13 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
     def _build_model(self) -> pd.DataFrame:
         from automlx import init
         import logging
+
         try:
-            init(engine="ray", engine_opts={"ray_setup": {"_temp_dir": "/tmp/ray-temp"}}, loglevel=logging.CRITICAL)
+            init(
+                engine="ray",
+                engine_opts={"ray_setup": {"_temp_dir": "/tmp/ray-temp"}},
+                loglevel=logging.CRITICAL,
+            )
         except Exception as e:
             logger.info("Ray already initialized")
 
@@ -167,12 +171,6 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
 
         return self.forecast_output.get_forecast_long()
 
-    @runtime_dependency(
-        module="datapane",
-        err_msg=(
-            "Please run `pip3 install datapane` to install the required dependencies for report generation."
-        ),
-    )
     def _generate_report(self):
         """
         Generate the report for the automlx model.
@@ -183,25 +181,20 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
 
         Returns
         -------
-            - model_description (datapane.Text): A Text component containing the description of the automlx model.
-            - other_sections (List[Union[datapane.Text, datapane.Blocks]]): A list of Text and Blocks components representing various sections of the report.
+            - model_description (report-creator.Text): A Text component containing the description of the automlx model.
+            - other_sections (List[Union[report-creator.Text, report-creator.Block]]): A list of Text and Blocks components representing various sections of the report.
             - forecast_col_name (str): The name of the forecasted column.
             - train_metrics (bool): A boolean value indicating whether to include train metrics in the report.
             - ds_column_series (pd.Series): The pd.Series object representing the datetime column of the dataset.
             - ds_forecast_col (pd.Series): The pd.Series object representing the forecasted column.
             - ci_col_names (List[str]): A list of column names for the confidence interval in the report.
         """
-        import datapane as dp
+        import report_creator as rc
 
         """The method that needs to be implemented on the particular model level."""
-        selected_models_text = dp.Text(
-            f"## Selected Models Overview \n "
-            "The following tables provide information regarding the "
-            "chosen model for each series and the corresponding parameters of the models."
-        )
         selected_models = dict()
         models = self.models
-        all_sections = []
+        other_sections = []
 
         if len(self.models) > 0:
             for i, (s_id, m) in enumerate(models.items()):
@@ -214,39 +207,42 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                 selected_models.items(), columns=["series_id", "best_selected_model"]
             )
             selected_df = selected_models_df["best_selected_model"].apply(pd.Series)
-            selected_models_section = dp.Blocks(
-                "### Best Selected Model", dp.DataTable(selected_df)
+            selected_models_section = rc.Block(
+                rc.Heading("Selected Models Overview", level=2),
+                rc.Text(
+                    "The following tables provide information regarding the "
+                    "chosen model for each series and the corresponding parameters of the models."
+                ),
+                rc.DataTable(selected_df, index=True),
             )
 
-            all_sections = [selected_models_text, selected_models_section]
+            other_sections = [selected_models_section]
 
         if self.spec.generate_explanations:
             try:
                 # If the key is present, call the "explain_model" method
                 self.explain_model()
 
-                # Create a markdown text block for the global explanation section
-                global_explanation_text = dp.Text(
-                    f"## Global Explanation of Models \n "
-                    "The following tables provide the feature attribution for the global explainability."
-                )
-
                 # Convert the global explanation data to a DataFrame
                 global_explanation_df = pd.DataFrame(self.global_explanation)
 
                 self.formatted_global_explanation = (
-                        global_explanation_df / global_explanation_df.sum(axis=0) * 100
+                    global_explanation_df / global_explanation_df.sum(axis=0) * 100
                 )
                 self.formatted_global_explanation = (
                     self.formatted_global_explanation.rename(
-                        {self.spec.datetime_column.name: ForecastOutputColumns.DATE}, axis=1
+                        {self.spec.datetime_column.name: ForecastOutputColumns.DATE},
+                        axis=1,
                     )
                 )
 
                 # Create a markdown section for the global explainability
-                global_explanation_section = dp.Blocks(
-                    "### Global Explainability ",
-                    dp.DataTable(self.formatted_global_explanation),
+                global_explanation_section = rc.Block(
+                    rc.Heading("Global Explanation of Models", level=2),
+                    rc.Text(
+                        "The following tables provide the feature attribution for the global explainability."
+                    ),
+                    rc.DataTable(self.formatted_global_explanation, index=True),
                 )
 
                 aggregate_local_explanations = pd.DataFrame()
@@ -258,34 +254,32 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                     )
                 self.formatted_local_explanation = aggregate_local_explanations
 
-                local_explanation_text = dp.Text(f"## Local Explanation of Models \n ")
                 blocks = [
-                    dp.DataTable(
+                    rc.DataTable(
                         local_ex_df.div(local_ex_df.abs().sum(axis=1), axis=0) * 100,
                         label=s_id,
+                        index=True,
                     )
                     for s_id, local_ex_df in self.local_explanation.items()
                 ]
-                local_explanation_section = (
-                    dp.Select(blocks=blocks) if len(blocks) > 1 else blocks[0]
+                local_explanation_section = rc.Block(
+                    rc.Heading("Local Explanation of Models", level=2),
+                    rc.Select(blocks=blocks),
                 )
 
-                # Append the global explanation text and section to the "all_sections" list
-                all_sections = all_sections + [
-                    global_explanation_text,
+                # Append the global explanation text and section to the "other_sections" list
+                other_sections = other_sections + [
                     global_explanation_section,
-                    local_explanation_text,
                     local_explanation_section,
                 ]
             except Exception as e:
                 logger.warn(f"Failed to generate Explanations with error: {e}.")
                 logger.debug(f"Full Traceback: {traceback.format_exc()}")
 
-        model_description = dp.Text(
+        model_description = rc.Text(
             "The AutoMLx model automatically preprocesses, selects and engineers "
             "high-quality features in your dataset, which are then provided for further processing."
         )
-        other_sections = all_sections
 
         return (
             model_description,

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*--
 
-# Copyright (c) 2023 Oracle and/or its affiliates.
+# 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 copy
@@ -82,13 +82,19 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
                     drop_data_older_than_periods=self.spec.model_kwargs.get(
                         "drop_data_older_than_periods", None
                     ),
-                    model_list=self.spec.model_kwargs.get("model_list", "fast_parallel"),
-                    transformer_list=self.spec.model_kwargs.get("transformer_list", "auto"),
+                    model_list=self.spec.model_kwargs.get(
+                        "model_list", "fast_parallel"
+                    ),
+                    transformer_list=self.spec.model_kwargs.get(
+                        "transformer_list", "auto"
+                    ),
                     transformer_max_depth=self.spec.model_kwargs.get(
                         "transformer_max_depth", 6
                     ),
                     models_mode=self.spec.model_kwargs.get("models_mode", "random"),
-                    num_validations=self.spec.model_kwargs.get("num_validations", "auto"),
+                    num_validations=self.spec.model_kwargs.get(
+                        "num_validations", "auto"
+                    ),
                     models_to_validate=self.spec.model_kwargs.get(
                         "models_to_validate", AUTOTS_MODELS_TO_VALIDATE
                     ),
@@ -138,14 +144,15 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
                     values=additional_regressors,
                 )
                 future_reg = future_regressor[: -self.spec.horizon]
-                regr_fcst = future_regressor[-self.spec.horizon:]
+                regr_fcst = future_regressor[-self.spec.horizon :]
             else:
                 future_reg = None
                 regr_fcst = None
 
             for s_id in self.datasets.list_series_ids():
                 self.forecast_output.init_series_output(
-                    series_id=s_id, data_at_series=self.datasets.get_data_at_series(s_id)
+                    series_id=s_id,
+                    data_at_series=self.datasets.get_data_at_series(s_id),
                 )
 
             if self.loaded_models is None:
@@ -213,7 +220,7 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
 
         Returns:
             tuple: A tuple containing the following elements:
-            - model_description (dp.Text): A text object containing the description of the AutoTS model.
+            - model_description (rc.Text): A text object containing the description of the AutoTS model.
             - other_sections (list): A list of sections to be included in the report.
             - forecast_col_name (str): The name of the forecast column.
             - train_metrics (bool): A boolean indicating whether to include train metrics.
@@ -221,37 +228,48 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
             - ds_forecast_col (pd.Index): A pandas Index containing the forecast column values.
             - ci_col_names (list): A list of column names for confidence intervals.
         """
-        import datapane as dp
+        import report_creator as rc
+
         all_sections = []
         if self.models:
             # Section 1: Forecast Overview
-            sec1_text = dp.Text(
-                "## Forecast Overview \n"
-                "These plots show your forecast in the context of historical data."
-            )
-            sec_1 = _select_plot_list(
-                lambda s_id: self.outputs.plot(self.models.df_wide_numeric, series=s_id),
+
+            sec_1_plots = _select_plot_list(
+                lambda s_id: self.outputs.plot(
+                    self.models.df_wide_numeric, series=s_id
+                ),
                 self.datasets.list_series_ids(),
             )
+            section_1 = rc.Block(
+                rc.Heading("Forecast Overview", level=2),
+                rc.Text(
+                    "These plots show your forecast in the context of historical data."
+                ),
+                sec_1_plots,
+            )
 
             # Section 2: AutoTS Model Parameters
-            sec2_text = dp.Text(f"## AutoTS Model Parameters")
+            sec2_text = rc.Heading("AutoTS Model Parameters", level=2)
             try:
-                sec2 = dp.Code(
-                    code=yaml.dump(list(self.models.best_model.T.to_dict().values())[0]),
-                    language="yaml",
+                sec2 = rc.Yaml(
+                    yaml.dump(list(self.models.best_model.T.to_dict().values())[0]),
                 )
 
             except KeyError as ke:
-                logger.warn(f"Issue generating Model Parameters Table Section. Skipping")
-                sec2 = dp.Text(f"Error generating model parameters.")
-            all_sections = [sec1_text, sec_1, sec2_text, sec2]
+                logger.warn(
+                    f"Issue generating Model Parameters Table Section. Skipping"
+                )
+                sec2 = rc.Text("Error generating model parameters.")
+
+            section_2 = rc.Block(sec2_text, sec2)
+
+            all_sections = [sec_1_plots, section_2]
 
         if self.spec.generate_explanations:
             logger.warn(f"Explanations not yet supported for the AutoTS Module")
 
         # Model Description
-        model_description = dp.Text(
+        model_description = rc.Text(
             "AutoTS is a time series package for Python designed for rapidly deploying high-accuracy forecasts at scale. "
             "In 2023, AutoTS has won in the M6 forecasting competition, "
             "delivering the highest performance investment decisions across 12 months of stock market forecasting."
@@ -284,9 +302,7 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
             ).T
             df = pd.concat([mapes, scores])
         except Exception as e:
-            logger.debug(
-                f"Failed to generate training metrics"
-            )
+            logger.debug(f"Failed to generate training metrics")
             logger.debug(f"Received Error Statement: {e}")
 
         return df

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*--
 
-# Copyright (c) 2023 Oracle and/or its affiliates.
+# 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 json
@@ -88,7 +88,9 @@ class ForecastOperatorBaseModel(ABC):
         self.formatted_local_explanation = None
 
         self.forecast_col_name = "yhat"
-        self.perform_tuning = (self.spec.tuning != None) and (self.spec.tuning.n_trials != None)
+        self.perform_tuning = (self.spec.tuning != None) and (
+            self.spec.tuning.n_trials != None
+        )
 
     def generate_report(self):
         """Generates the forecasting report."""
@@ -100,7 +102,7 @@ class ForecastOperatorBaseModel(ABC):
             warnings.simplefilter(action="ignore", category=UserWarning)
             warnings.simplefilter(action="ignore", category=RuntimeWarning)
             warnings.simplefilter(action="ignore", category=ConvergenceWarning)
-            import datapane as dp
+            import report_creator as rc
 
             # load models if given
             if self.spec.previous_output_dir is not None:
@@ -140,69 +142,58 @@ class ForecastOperatorBaseModel(ABC):
                     other_sections,
                 ) = self._generate_report()
 
-                title_text = dp.Text("# Forecast Report")
-
-                md_columns = " * ".join(
-                    [f"{s_id} \n" for s_id in self.datasets.list_series_ids()]
-                )
-
-                header_section = dp.Blocks(
-                    blocks=[
-                        dp.Text(f"You selected the **`{self.spec.model}`** model."),
-                        model_description,
-                        dp.Text(
-                            "Based on your dataset, you could have also selected "
-                            f"any of the models: `{'`, `'.join(SupportedModels.keys())}`."
+                header_section = rc.Block(
+                    rc.Heading("Forecast Report", level=1),
+                    rc.Text(
+                        f"You selected the {self.spec.model} model.\n{model_description}\nBased on your dataset, you could have also selected any of the models: {SupportedModels.keys()}."
+                    ),
+                    rc.Group(
+                        rc.Metric(
+                            heading="Analysis was completed in ",
+                            value=human_time_friendly(elapsed_time),
                         ),
-                        dp.Group(
-                            dp.BigNumber(
-                                heading="Analysis was completed in ",
-                                value=human_time_friendly(elapsed_time),
-                            ),
-                            dp.BigNumber(
-                                heading="Starting time index",
-                                value=self.datasets.get_earliest_timestamp().strftime(
-                                    "%B %d, %Y"
-                                ),
+                        rc.Metric(
+                            heading="Starting time index",
+                            value=self.datasets.get_earliest_timestamp().strftime(
+                                "%B %d, %Y"
                             ),
-                            dp.BigNumber(
-                                heading="Ending time index",
-                                value=self.datasets.get_latest_timestamp().strftime(
-                                    "%B %d, %Y"
-                                ),
-                            ),
-                            dp.BigNumber(
-                                heading="Num series",
-                                value=len(self.datasets.list_series_ids()),
+                        ),
+                        rc.Metric(
+                            heading="Ending time index",
+                            value=self.datasets.get_latest_timestamp().strftime(
+                                "%B %d, %Y"
                             ),
-                            columns=4,
                         ),
-                    ]
+                        rc.Metric(
+                            heading="Num series",
+                            value=len(self.datasets.list_series_ids()),
+                        ),
+                    ),
                 )
 
-                first_10_rows_blocks = [
-                    dp.DataTable(
-                        df.head(10),
-                        caption="Start",
+                first_5_rows_blocks = [
+                    rc.DataTable(
+                        df.head(5),
                         label=s_id,
+                        index=True,
                     )
                     for s_id, df in self.full_data_dict.items()
                 ]
 
-                last_10_rows_blocks = [
-                    dp.DataTable(
-                        df.tail(10),
-                        caption="End",
+                last_5_rows_blocks = [
+                    rc.DataTable(
+                        df.tail(5),
                         label=s_id,
+                        index=True,
                     )
                     for s_id, df in self.full_data_dict.items()
                 ]
 
                 data_summary_blocks = [
-                    dp.DataTable(
+                    rc.DataTable(
                         df.describe(),
-                        caption="Summary Statistics",
                         label=s_id,
+                        index=True,
                     )
                     for s_id, df in self.full_data_dict.items()
                 ]
@@ -210,44 +201,33 @@ class ForecastOperatorBaseModel(ABC):
                 series_name = merged_category_column_name(
                     self.spec.target_category_columns
                 )
-                series_subtext = dp.Text(f"Indexed by {series_name}")
-                first_10_title = dp.Text("### First 10 Rows of Data")
-                last_10_title = dp.Text("### Last 10 Rows of Data")
-                summary_title = dp.Text("### Data Summary Statistics")
-
-                if series_name is not None and len(self.datasets.list_series_ids()) > 1:
-                    data_summary_sec = dp.Blocks(
-                        blocks=[
-                            first_10_title,
-                            series_subtext,
-                            dp.Select(blocks=first_10_rows_blocks),
-                            last_10_title,
-                            series_subtext,
-                            dp.Select(blocks=last_10_rows_blocks),
-                            summary_title,
-                            series_subtext,
-                            dp.Select(blocks=data_summary_blocks),
-                            dp.Text("----"),
-                        ]
-                    )
-                else:
-                    data_summary_sec = dp.Blocks(
-                        blocks=[
-                            first_10_title,
-                            first_10_rows_blocks[0],
-                            last_10_title,
-                            last_10_rows_blocks[0],
-                            summary_title,
-                            data_summary_blocks[0],
-                            dp.Text("----"),
-                        ]
-                    )
+                # series_subtext = rc.Text(f"Indexed by {series_name}")
+                first_10_title = rc.Heading("First 5 Rows of Data", level=3)
+                last_10_title = rc.Heading("Last 5 Rows of Data", level=3)
+                summary_title = rc.Heading("Data Summary Statistics", level=3)
+
+                data_summary_sec = rc.Block(
+                    rc.Block(
+                        first_10_title,
+                        # series_subtext,
+                        rc.Select(blocks=first_5_rows_blocks),
+                    ),
+                    rc.Block(
+                        last_10_title,
+                        # series_subtext,
+                        rc.Select(blocks=last_5_rows_blocks),
+                    ),
+                    rc.Block(
+                        summary_title,
+                        # series_subtext,
+                        rc.Select(blocks=data_summary_blocks),
+                    ),
+                    rc.Separator(),
+                )
 
-                summary = dp.Group(
-                    blocks=[
-                        header_section,
-                        data_summary_sec,
-                    ]
+                summary = rc.Block(
+                    header_section,
+                    data_summary_sec,
                 )
 
                 test_metrics_sections = []
@@ -255,41 +235,47 @@ class ForecastOperatorBaseModel(ABC):
                     self.test_eval_metrics is not None
                     and not self.test_eval_metrics.empty
                 ):
-                    sec7_text = dp.Text(f"## Test Data Evaluation Metrics")
-                    sec7 = dp.DataTable(self.test_eval_metrics)
+                    sec7_text = rc.Heading("Test Data Evaluation Metrics", level=2)
+                    sec7 = rc.DataTable(self.test_eval_metrics, index=True)
                     test_metrics_sections = test_metrics_sections + [sec7_text, sec7]
 
                 if summary_metrics is not None and not summary_metrics.empty:
-                    sec8_text = dp.Text(f"## Test Data Summary Metrics")
-                    sec8 = dp.DataTable(summary_metrics)
+                    sec8_text = rc.Heading("Test Data Summary Metrics", level=2)
+                    sec8 = rc.DataTable(summary_metrics, index=True)
                     test_metrics_sections = test_metrics_sections + [sec8_text, sec8]
 
                 train_metrics_sections = []
                 if self.eval_metrics is not None and not self.eval_metrics.empty:
-                    sec9_text = dp.Text(f"## Training Data Metrics")
-                    sec9 = dp.DataTable(self.eval_metrics)
+                    sec9_text = rc.Heading("Training Data Metrics", level=2)
+                    sec9 = rc.DataTable(self.eval_metrics, index=True)
                     train_metrics_sections = [sec9_text, sec9]
 
-
                 forecast_plots = []
                 if len(self.forecast_output.list_series_ids()) > 0:
-                    forecast_text = dp.Text(f"## Forecasted Data Overlaying Historical")
+                    forecast_text = rc.Heading(
+                        "Forecasted Data Overlaying Historical", level=2
+                    )
                     forecast_sec = get_forecast_plots(
                         self.forecast_output,
                         horizon=self.spec.horizon,
                         test_data=test_data,
                         ci_interval_width=self.spec.confidence_interval_width,
                     )
-                    if series_name is not None and len(self.datasets.list_series_ids()) > 1:
-                        forecast_plots = [forecast_text, series_subtext, forecast_sec]
+                    if (
+                        series_name is not None
+                        and len(self.datasets.list_series_ids()) > 1
+                    ):
+                        forecast_plots = [
+                            forecast_text,
+                            forecast_sec,
+                        ]  # series_subtext,
                     else:
                         forecast_plots = [forecast_text, forecast_sec]
 
-                yaml_appendix_title = dp.Text(f"## Reference: YAML File")
-                yaml_appendix = dp.Code(code=self.config.to_yaml(), language="yaml")
+                yaml_appendix_title = rc.Heading("Reference: YAML File", level=2)
+                yaml_appendix = rc.Yaml(self.config.to_dict())
                 report_sections = (
-                    [title_text]
-                    + [summary]
+                    [summary]
                     + forecast_plots
                     + other_sections
                     + test_metrics_sections
@@ -421,7 +407,7 @@ class ForecastOperatorBaseModel(ABC):
         test_metrics_df: pd.DataFrame,
     ):
         """Saves resulting reports to the given folder."""
-        import datapane as dp
+        import report_creator as rc
 
         unique_output_dir = find_output_dirname(self.spec.output_directory)
 
@@ -430,13 +416,13 @@ class ForecastOperatorBaseModel(ABC):
         else:
             storage_options = dict()
 
-        # datapane html report
+        # report-creator html report
         if self.spec.generate_report:
-            # datapane html report
             with tempfile.TemporaryDirectory() as temp_dir:
                 report_local_path = os.path.join(temp_dir, "___report.html")
                 disable_print()
-                dp.save_report(report_sections, report_local_path)
+                with rc.ReportCreator("My Report") as report:
+                    report.save(rc.Block(*report_sections), report_local_path)
                 enable_print()
 
                 report_path = os.path.join(unique_output_dir, self.spec.report_filename)
@@ -655,11 +641,10 @@ 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 = 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()
                 )
@@ -667,7 +652,8 @@ class ForecastOperatorBaseModel(ABC):
                 # Explainer fails when boolean columns are passed
 
                 _, data_trimmed_encoded = _label_encode_dataframe(
-                    data_trimmed, no_encode={datetime_col_name, self.original_target_column}
+                    data_trimmed,
+                    no_encode={datetime_col_name, self.original_target_column},
                 )
 
                 kernel_explnr = PermutationExplainer(