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

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
+        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,38 +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_text = dp.Text(f"## Forecasted Data Overlaying Historical")
-                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]
-                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")
+                forecast_plots = []
+                if len(self.forecast_output.list_series_ids()) > 0:
+                    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,
+                            forecast_sec,
+                        ]  # series_subtext,
+                    else:
+                        forecast_plots = [forecast_text, forecast_sec]
+
+                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
@@ -418,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)
 
@@ -427,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)
@@ -557,13 +546,14 @@ class ForecastOperatorBaseModel(ABC):
         )
         if self.errors_dict:
             write_data(
-                data=pd.DataFrame(self.errors_dict.items(), columns=["model", "error"]),
+                data=pd.DataFrame.from_dict(self.errors_dict),
                 filename=os.path.join(
                     unique_output_dir, self.spec.errors_dict_filename
                 ),
-                format="csv",
+                format="json",
                 storage_options=storage_options,
                 index=True,
+                indent=4,
             )
         else:
             logger.info(f"All modeling completed successfully.")
@@ -650,38 +640,47 @@ class ForecastOperatorBaseModel(ABC):
         for s_id, data_i in self.datasets.get_data_by_series(
             include_horizon=False
         ).items():
-            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()
-            )
-
-            kernel_explnr = PermutationExplainer(
-                model=explain_predict_fn, masker=data_trimmed
-            )
-            kernel_explnr_vals = kernel_explnr.shap_values(data_trimmed)
+            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()
+                )
 
-            exp_end_time = time.time()
-            global_ex_time = global_ex_time + exp_end_time - exp_start_time
+                # Explainer fails when boolean columns are passed
 
-            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
+                _, 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(
-                    f"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.warn(
+                        f"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),
+                        )
                     )
+            else:
+                logger.warn(
+                    f"Skipping explanations for {s_id}, as forecast was not generated."
                 )
 
         logger.info(
@@ -700,9 +699,14 @@ class ForecastOperatorBaseModel(ABC):
             kernel_explainer: The kernel explainer object to use for generating explanations.
         """
         data = self.datasets.get_horizon_at_series(s_id=series_id)
-
+        # columns that were dropped in train_model in arima, should be dropped here as well
         data[datetime_col_name] = datetime_to_seconds(data[datetime_col_name])
         data = data.reset_index(drop=True)
+
+        # Explainer fails when boolean columns are passed
+        _, data = _label_encode_dataframe(
+            data, no_encode={datetime_col_name, self.original_target_column}
+        )
         # Generate local SHAP values using the kernel explainer
         local_kernel_explnr_vals = kernel_explainer.shap_values(data)
 

ads/opctl/operator/lowcode/forecast/model/neuralprophet.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 numpy as np
@@ -41,20 +41,20 @@ from .forecast_datasets import ForecastDatasets, ForecastOutput
 import traceback
 
 
-def _get_np_metrics_dict(selected_metric):
-    metric_translation = {
-        "mape": MeanAbsolutePercentageError,
-        "smape": SymmetricMeanAbsolutePercentageError,
-        "mae": MeanAbsoluteError,
-        "r2": R2Score,
-        "rmse": MeanSquaredError,
-    }
-    if selected_metric not in metric_translation.keys():
-        logger.warn(
-            f"Could not find the metric: {selected_metric} in torchmetrics. Defaulting to MAE and RMSE"
-        )
-        return {"MAE": MeanAbsoluteError(), "RMSE": MeanSquaredError()}
-    return {selected_metric: metric_translation[selected_metric]()}
+# def _get_np_metrics_dict(selected_metric):
+#     metric_translation = {
+#         "mape": MeanAbsolutePercentageError,
+#         "smape": SymmetricMeanAbsolutePercentageError,
+#         "mae": MeanAbsoluteError,
+#         "r2": R2Score,
+#         "rmse": MeanSquaredError,
+#     }
+#     if selected_metric not in metric_translation.keys():
+#         logger.warn(
+#             f"Could not find the metric: {selected_metric} in torchmetrics. Defaulting to MAE and RMSE"
+#         )
+#         return {"MAE": MeanAbsoluteError(), "RMSE": MeanSquaredError()}
+#     return {selected_metric: metric_translation[selected_metric]()}
 
 
 @runtime_dependency(
@@ -70,7 +70,7 @@ def _fit_model(data, params, additional_regressors, select_metric):
         disable_print()
 
     m = NeuralProphet(**params)
-    m.metrics = _get_np_metrics_dict(select_metric)
+    # 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)
@@ -120,11 +120,11 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
             data = self.preprocess(df, s_id)
             data_i = self.drop_horizon(data)
 
-            if self.loaded_models is not None:
+            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 or dict()
                 self.accepted_regressors[s_id] = list(accepted_regressors_config.keys())
-                if self.loaded_trainers is not None:
+                if self.loaded_trainers is not None and s_id in self.loaded_trainers:
                     model.trainer = self.loaded_trainers[s_id]
             else:
                 if self.perform_tuning:
@@ -135,7 +135,8 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
                     data=data_i,
                     params=model_kwargs,
                     additional_regressors=self.additional_regressors,
-                    select_metric=self.spec.metric,
+                    select_metric=None,
+                    # select_metric=self.spec.metric,
                 )
 
             logger.debug(
@@ -209,6 +210,7 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
             logger.debug("===========Done===========")
         except Exception as e:
             self.errors_dict[s_id] = {"model_name": self.spec.model, "error": str(e)}
+            raise e
 
     def _build_model(self) -> pd.DataFrame:
         full_data_dict = self.datasets.get_data_by_series()
@@ -309,92 +311,96 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
         return selected_params
 
     def _generate_report(self):
-        import datapane as dp
+        import report_creator as rc
 
+        series_ids = self.models.keys()
         all_sections = []
+        if len(series_ids) > 0:
+            try:
+                sec1 = _select_plot_list(
+                    lambda s_id: self.models[s_id].plot(self.outputs[s_id]),
+                    series_ids=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."
+                    ),
+                    sec1,
+                )
+                all_sections = all_sections + [section_1]
+            except Exception as e:
+                logger.debug(f"Failed to plot with exception: {e.args}")
 
-        try:
-            sec1_text = dp.Text(
-                "## Forecast Overview \nThese plots show your "
-                "forecast in the context of historical data."
-            )
-            sec1 = _select_plot_list(
-                lambda s_id: self.models[s_id].plot(self.outputs[s_id]),
-                series_ids=self.datasets.list_series_ids(),
-            )
-            all_sections = all_sections + [sec1_text, sec1]
-        except Exception as e:
-            logger.debug(f"Failed to plot with exception: {e.args}")
-
-        try:
-            sec2_text = dp.Text(f"## Forecast Broken Down by Trend Component")
-            sec2 = _select_plot_list(
-                lambda s_id: self.models[s_id].plot_components(self.outputs[s_id]),
-                series_ids=self.datasets.list_series_ids(),
-            )
-            all_sections = all_sections + [sec2_text, sec2]
-        except Exception as e:
-            logger.debug(f"Failed to plot with exception: {e.args}")
+            try:
+                sec2 = _select_plot_list(
+                    lambda s_id: self.models[s_id].plot_components(self.outputs[s_id]),
+                    series_ids=series_ids,
+                )
+                section_2 = rc.Block(
+                    rc.Heading("Forecast Broken Down by Trend Component", level=2), sec2
+                )
+                all_sections = all_sections + [section_2]
+            except Exception as e:
+                logger.debug(f"Failed to plot with exception: {e.args}")
 
-        try:
-            sec3_text = dp.Text(f"## Forecast Parameter Plots")
-            sec3 = _select_plot_list(
-                lambda s_id: self.models[s_id].plot_parameters(),
-                series_ids=self.datasets.list_series_ids(),
-            )
-            all_sections = all_sections + [sec3_text, sec3]
-        except Exception as e:
-            logger.debug(f"Failed to plot with exception: {e.args}")
-
-        sec5_text = dp.Text(f"## Neural Prophet Model Parameters")
-        model_states = []
-        for i, (s_id, m) in enumerate(self.models.items()):
-            model_states.append(
-                pd.Series(
-                    m.state_dict(),
-                    index=m.state_dict().keys(),
-                    name=s_id,
+            try:
+                sec3 = _select_plot_list(
+                    lambda s_id: self.models[s_id].plot_parameters(),
+                    series_ids=series_ids,
                 )
-            )
-        all_model_states = pd.concat(model_states, axis=1)
-        sec5 = dp.DataTable(all_model_states)
+                section_3 = rc.Block(
+                    rc.Heading("Forecast Parameter Plots", level=2), sec3
+                )
+                all_sections = all_sections + [section_3]
+            except Exception as e:
+                logger.debug(f"Failed to plot with exception: {e.args}")
+
+            sec5_text = rc.Heading("Neural Prophet Model Parameters", level=2)
+            model_states = []
+            for i, (s_id, m) in enumerate(self.models.items()):
+                model_states.append(
+                    pd.Series(
+                        m.state_dict(),
+                        index=m.state_dict().keys(),
+                        name=s_id,
+                    )
+                )
+            all_model_states = pd.concat(model_states, axis=1)
+            sec5 = rc.DataTable(all_model_states, index=True)
 
-        all_sections = all_sections + [sec5_text, sec5]
+            all_sections = 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."
-                )
-
                 # 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 Explainability", level=2),
+                    rc.Text(
+                        "The following tables provide the feature attribution for the global explainability."
+                    ),
+                    rc.DataTable(self.formatted_global_explanation, index=True),
                 )
 
-                local_explanation_text = dp.Text(f"## Local Explanation of Models \n ")
                 blocks = [
-                    dp.DataTable(
+                    rc.DataTable(
                         local_ex_df.drop("Series", axis=1),
                         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:
@@ -402,7 +408,7 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
                 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(
             "NeuralProphet is an easy to learn framework for interpretable time "
             "series forecasting. NeuralProphet is built on PyTorch and combines "
             "Neural Network and traditional time-series algorithms, inspired by "