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

ads/llm/serializers/runnable_parallel.py

@@ -1,3 +1,9 @@
+#!/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/
+
 from langchain.schema.runnable import RunnableParallel
 from langchain.load.dump import dumpd
 from langchain.load.load import load
@@ -10,7 +16,7 @@ class RunnableParallelSerializer:
 
     @staticmethod
     def load(config: dict, **kwargs):
-        steps = config["kwargs"]["steps"]
+        steps = config.get("kwargs", dict()).get("steps", dict())
         steps = {k: load(v, **kwargs) for k, v in steps.items()}
         return RunnableParallel(**steps)
 

ads/opctl/operator/lowcode/anomaly/README.md

@@ -35,7 +35,7 @@ All generated configurations should be ready to use without the need for any add
 To run anomaly detection locally, create and activate a new conda environment (`ads-anomaly`). Install all the required libraries listed in the `environment.yaml` file.
 
 ```yaml
-- datapane
+- report-creator
 - cerberus
 - oracle-automlx==23.4.1
 - oracle-automlx[classic]==23.4.1

ads/opctl/operator/lowcode/anomaly/environment.yaml

@@ -5,7 +5,7 @@ dependencies:
   - python=3.8
   - pip
   - pip:
-      - datapane
+      - report-creator
       - cerberus
       - oracle-automlx==23.4.1
       - oracle-automlx[classic]==23.4.1

ads/opctl/operator/lowcode/anomaly/model/automlx.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 pandas as pd
@@ -27,8 +27,13 @@ class AutoMLXOperatorModel(AnomalyOperatorBaseModel):
     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")
         date_column = self.spec.datetime_column.name
@@ -68,21 +73,21 @@ class AutoMLXOperatorModel(AnomalyOperatorBaseModel):
         return anomaly_output
 
     def _generate_report(self):
-        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."
-        )
-        all_sections = [selected_models_text]
+        other_sections = [
+            rc.Heading("Selected Models Overview", level=2),
+            rc.Text(
+                "The following tables provide information regarding the chosen model."
+            ),
+        ]
 
-        model_description = dp.Text(
+        model_description = rc.Text(
             "The automlx model automatically pre-processes, selects and engineers "
             "high-quality features in your dataset, which then given to an automatically "
             "chosen and optimized machine learning model.."
         )
-        other_sections = all_sections
 
         return (
             model_description,

ads/opctl/operator/lowcode/anomaly/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 pandas as pd
@@ -81,21 +81,20 @@ class AutoTSOperatorModel(AnomalyOperatorBaseModel):
         return anomaly_output
 
     def _generate_report(self):
-        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."
-        )
-        all_sections = [selected_models_text]
-
-        model_description = dp.Text(
+        other_sections = [
+            rc.Heading("Selected Models Overview", level=2),
+            rc.Text(
+                "The following tables provide information regarding the chosen model."
+            ),
+        ]
+        model_description = rc.Text(
             "The automlx model automatically pre-processes, selects and engineers "
             "high-quality features in your dataset, which then given to an automatically "
             "chosen and optimized machine learning model.."
         )
-        other_sections = all_sections
 
         return (
             model_description,

ads/opctl/operator/lowcode/anomaly/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 os
@@ -57,7 +57,7 @@ class AnomalyOperatorBaseModel(ABC):
 
     def generate_report(self):
         """Generates the report."""
-        import datapane as dp
+        import report_creator as rc
         import matplotlib.pyplot as plt
 
         start_time = time.time()
@@ -79,12 +79,10 @@ class AnomalyOperatorBaseModel(ABC):
                 anomaly_output, test_data, elapsed_time
             )
         table_blocks = [
-            dp.DataTable(df, label=col)
+            rc.DataTable(df, label=col, index=True)
             for col, df in self.datasets.full_data_dict.items()
         ]
-        data_table = (
-            dp.Select(blocks=table_blocks) if len(table_blocks) > 1 else table_blocks[0]
-        )
+        data_table = rc.Select(blocks=table_blocks)
         date_column = self.spec.datetime_column.name
 
         blocks = []
@@ -106,44 +104,42 @@ class AnomalyOperatorBaseModel(ABC):
                 plt.xlabel(date_column)
                 plt.ylabel(col)
                 plt.title(f"`{col}` with reference to anomalies")
-                figure_blocks.append(ax)
-            blocks.append(dp.Group(blocks=figure_blocks, label=target))
-        plots = dp.Select(blocks=blocks) if len(blocks) > 1 else blocks[0]
+                figure_blocks.append(rc.Widget(ax))
+            blocks.append(rc.Group(*figure_blocks, label=target))
+        plots = rc.Select(blocks)
 
         report_sections = []
-        title_text = dp.Text("# Anomaly Detection Report")
-
-        yaml_appendix_title = dp.Text(f"## Reference: YAML File")
-        yaml_appendix = dp.Code(code=self.config.to_yaml(), language="yaml")
-        summary = dp.Blocks(
-            blocks=[
-                dp.Group(
-                    dp.Text(f"You selected the **`{self.spec.model}`** model."),
-                    dp.Text(
-                        "Based on your dataset, you could have also selected "
-                        f"any of the models: `{'`, `'.join(SupportedModels.keys())}`."
-                    ),
-                    dp.BigNumber(
-                        heading="Analysis was completed in ",
-                        value=human_time_friendly(elapsed_time),
-                    ),
-                    label="Summary",
-                )
-            ]
+        title_text = rc.Heading("Anomaly Detection Report", level=1)
+
+        yaml_appendix_title = rc.Heading("Reference: YAML File", level=2)
+        yaml_appendix = rc.Yaml(self.config.to_dict())
+        summary = rc.Block(
+            rc.Group(
+                rc.Text(f"You selected the **`{self.spec.model}`** model."),
+                rc.Text(
+                    "Based on your dataset, you could have also selected "
+                    f"any of the models: `{'`, `'.join(SupportedModels.keys())}`."
+                ),
+                rc.Metric(
+                    heading="Analysis was completed in ",
+                    value=human_time_friendly(elapsed_time),
+                ),
+                label="Summary",
+            )
         )
-        sec_text = dp.Text(f"## Train Evaluation Metrics")
-        sec = dp.DataTable(self._evaluation_metrics(anomaly_output))
+        sec_text = rc.Heading("Train Evaluation Metrics", level=2)
+        sec = rc.DataTable(self._evaluation_metrics(anomaly_output), index=True)
         evaluation_metrics_sec = [sec_text, sec]
 
         test_metrics_sections = []
         if total_metrics is not None and not total_metrics.empty:
-            sec_text = dp.Text(f"## Test Data Evaluation Metrics")
-            sec = dp.DataTable(total_metrics)
+            sec_text = rc.Heading("Test Data Evaluation Metrics", level=2)
+            sec = rc.DataTable(total_metrics, index=True)
             test_metrics_sections = test_metrics_sections + [sec_text, sec]
 
         if summary_metrics is not None and not summary_metrics.empty:
-            sec_text = dp.Text(f"## Test Data Summary Metrics")
-            sec = dp.DataTable(summary_metrics)
+            sec_text = rc.Heading("Test Data Summary Metrics", level=2)
+            sec = rc.DataTable(summary_metrics, index=True)
             test_metrics_sections = test_metrics_sections + [sec_text, sec]
 
         report_sections = (
@@ -248,7 +244,7 @@ class AnomalyOperatorBaseModel(ABC):
         test_metrics: 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)
 
@@ -257,11 +253,12 @@ class AnomalyOperatorBaseModel(ABC):
         else:
             storage_options = dict()
 
-        # datapane html report
+        # report-creator 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()
             with open(report_local_path) as f1:
                 with fsspec.open(

ads/opctl/operator/lowcode/anomaly/model/tods.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 importlib
@@ -97,16 +97,16 @@
 #         return anomaly_output
 
 #     def _generate_report(self):
-#         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(
+#         selected_models_text = rc.Text(
 #             f"## Selected Models Overview \n "
 #             "The following tables provide information regarding the chosen model."
 #         )
 #         all_sections = [selected_models_text]
 
-#         model_description = dp.Text(
+#         model_description = rc.Text(
 #             "The tods model is a full-stack automated machine learning system for outlier detection "
 #             "on univariate / multivariate time-series data. It provides exhaustive modules for building "
 #             "machine learning-based outlier detection systems and wide range of algorithms."

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

@@ -323,7 +323,7 @@ spec:
             missing_value_imputation:
               type: boolean
               required: false
-              default: true
+              default: false
 
     generate_report:
       type: boolean

ads/opctl/operator/lowcode/forecast/README.md

@@ -35,7 +35,7 @@ To run forecasting locally, create and activate a new conda environment (`ads-fo
 - neuralprophet
 - pmdarima
 - statsmodels
-- datapane
+- report-creator
 - cerberus
 - sktime
 - optuna==3.1.0

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

@@ -10,12 +10,12 @@ dependencies:
       - neuralprophet
       - pmdarima
       - statsmodels
-      - datapane
+      - report-creator
       - cerberus
       - sktime
       - shap
       - autots[additional]
-      - optuna==3.1.0
-      - oracle-automlx==23.4.1
-      - oracle-automlx[forecasting]==23.4.1
+      - optuna
+      - oracle-automlx>=23.4.1
+      - oracle-automlx[forecasting]>=23.4.1
       - fire

ads/opctl/operator/lowcode/forecast/model/arima.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 pandas as pd
@@ -66,7 +66,7 @@ class ArimaOperatorModel(ForecastOperatorBaseModel):
             target = self.original_target_column
             self.forecast_output.init_series_output(series_id=s_id, data_at_series=df)
             # If trend is constant, remove constant columns
-            if 'trend' not in model_kwargs or model_kwargs['trend'] == 'c':
+            if "trend" not in model_kwargs or model_kwargs["trend"] == "c":
                 self.constant_cols[s_id] = df.columns[df.nunique() == 1]
                 df = df.drop(columns=self.constant_cols[s_id])
 
@@ -147,29 +147,25 @@ class ArimaOperatorModel(ForecastOperatorBaseModel):
 
     def _generate_report(self):
         """The method that needs to be implemented on the particular model level."""
-        import datapane as dp
+        import report_creator as rc
+
         all_sections = []
         if len(self.models) > 0:
-            sec5_text = dp.Text(f"## ARIMA Model Parameters")
+            sec5_text = rc.Heading("ARIMA Model Parameters", level=2)
             blocks = [
-                dp.HTML(
+                rc.Html(
                     m.summary().as_html(),
                     label=s_id,
                 )
                 for i, (s_id, m) in enumerate(self.models.items())
             ]
-            sec5 = dp.Select(blocks=blocks) if len(blocks) > 1 else blocks[0]
+            sec5 = rc.Select(blocks=blocks)
             all_sections = [sec5_text, sec5]
 
         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)
@@ -185,9 +181,12 @@ class ArimaOperatorModel(ForecastOperatorBaseModel):
                 )
 
                 # 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()
@@ -199,30 +198,29 @@ class ArimaOperatorModel(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,
                     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(
             "An autoregressive integrated moving average, or ARIMA, is a statistical "
             "analysis model that uses time series data to either better understand the "
             "data set or to predict future trends. A statistical model is autoregressive if "

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,