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

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

@@ -54,145 +54,154 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
             target_column=self.original_target_column,
             dt_column=self.spec.datetime_column.name,
         )
-        model = self.loaded_models if self.loaded_models is not None else None
-        if model is None:
-            # Initialize the AutoTS model with specified parameters
-            model = AutoTS(
-                forecast_length=self.spec.horizon,
-                frequency=self.spec.model_kwargs.get(
-                    "frequency", "infer"
-                ),  # TODO: Use datasets.get_datetime_frequency ?
-                prediction_interval=self.spec.confidence_interval_width,
-                max_generations=self.spec.model_kwargs.get(
-                    "max_generations", AUTOTS_MAX_GENERATION
-                ),
-                no_negatives=self.spec.model_kwargs.get("no_negatives", False),
-                constraint=self.spec.model_kwargs.get("constraint", None),
-                ensemble=self.spec.model_kwargs.get("ensemble", "auto"),
-                initial_template=self.spec.model_kwargs.get(
-                    "initial_template", "General+Random"
-                ),
-                random_seed=self.spec.model_kwargs.get("random_seed", 2022),
-                holiday_country=self.spec.model_kwargs.get("holiday_country", "US"),
-                subset=self.spec.model_kwargs.get("subset", None),
-                aggfunc=self.spec.model_kwargs.get("aggfunc", "first"),
-                na_tolerance=self.spec.model_kwargs.get("na_tolerance", 1),
-                drop_most_recent=self.spec.model_kwargs.get("drop_most_recent", 0),
-                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"),
-                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"),
-                models_to_validate=self.spec.model_kwargs.get(
-                    "models_to_validate", AUTOTS_MODELS_TO_VALIDATE
-                ),
-                max_per_model_class=self.spec.model_kwargs.get(
-                    "max_per_model_class", None
-                ),
-                validation_method=self.spec.model_kwargs.get(
-                    "validation_method", "backwards"
-                ),
-                min_allowed_train_percent=self.spec.model_kwargs.get(
-                    "min_allowed_train_percent", 0.5
-                ),
-                remove_leading_zeroes=self.spec.model_kwargs.get(
-                    "remove_leading_zeroes", False
-                ),
-                prefill_na=self.spec.model_kwargs.get("prefill_na", None),
-                introduce_na=self.spec.model_kwargs.get("introduce_na", None),
-                preclean=self.spec.model_kwargs.get("preclean", None),
-                model_interrupt=self.spec.model_kwargs.get("model_interrupt", True),
-                generation_timeout=self.spec.model_kwargs.get(
-                    "generation_timeout", None
-                ),
-                current_model_file=self.spec.model_kwargs.get(
-                    "current_model_file", None
-                ),
-                verbose=-1 if logger.level > 40 else 1,
-                n_jobs=self.spec.model_kwargs.get("n_jobs", -1),
-            )
-
-        full_data_indexed = self.datasets.get_data_multi_indexed()
-
-        dates = full_data_indexed.index.get_level_values(0).unique().tolist()
-        train_idx = dates[: -self.spec.horizon]
-
-        df_train = full_data_indexed[
-            full_data_indexed.index.get_level_values(0).isin(train_idx)
-        ][[self.original_target_column]].reset_index()
-
-        # Future regressors need to be in wide format - (num_unique_dates x (num_unique_series x num_unique_cols))
-        additional_regressors = list(
-            set(full_data_indexed.columns) - {self.original_target_column}
-        )
-        if len(additional_regressors) > 1:
-            future_regressor = full_data_indexed.reset_index().pivot(
-                index=self.spec.datetime_column.name,
-                columns=ForecastOutputColumns.SERIES,
-                values=additional_regressors,
-            )
-            future_reg = future_regressor[: -self.spec.horizon]
-            regr_fcst = future_regressor[-self.spec.horizon :]
-        else:
-            future_reg = None
-            regr_fcst = None
-
-        if self.loaded_models is None:
-            model = model.fit(
-                df_train,
-                future_regressor=future_reg,
-                date_col=self.spec.datetime_column.name,
-                value_col=self.original_target_column,
-                id_col=ForecastOutputColumns.SERIES,
-            )
-            # Store the trained model and generate forecasts
-            self.models = copy.deepcopy(model)
-        else:
-            self.models = self.loaded_models
-
-        self.outputs = model.predict(future_regressor=regr_fcst)
-        logger.debug("===========Forecast Generated===========")
-
-        hist_df = model.back_forecast().forecast
-
-        params = vars(model).copy()
-        for param in [
-            "ens_copy",
-            "df_wide_numeric",
-            "future_regressor_train",
-            "initial_results",
-            "score_per_series",
-            "validation_results",
-            "validation_train_indexes",
-            "validation_test_indexes",
-            "validation_indexes",
-            "best_model",
-        ]:
-            if param in params:
-                params.pop(param)
-
-        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)
-            )
-
-            self.forecast_output.populate_series_output(
-                series_id=s_id,
-                fit_val=hist_df[s_id].values,
-                forecast_val=self.outputs.forecast[s_id].values,
-                upper_bound=self.outputs.upper_forecast[s_id].values,
-                lower_bound=self.outputs.lower_forecast[s_id].values,
+        try:
+            model = self.loaded_models if self.loaded_models is not None else None
+            if model is None:
+                # Initialize the AutoTS model with specified parameters
+                model = AutoTS(
+                    forecast_length=self.spec.horizon,
+                    frequency=self.spec.model_kwargs.get(
+                        "frequency", "infer"
+                    ),  # TODO: Use datasets.get_datetime_frequency ?
+                    prediction_interval=self.spec.confidence_interval_width,
+                    max_generations=self.spec.model_kwargs.get(
+                        "max_generations", AUTOTS_MAX_GENERATION
+                    ),
+                    no_negatives=self.spec.model_kwargs.get("no_negatives", False),
+                    constraint=self.spec.model_kwargs.get("constraint", None),
+                    ensemble=self.spec.model_kwargs.get("ensemble", "auto"),
+                    initial_template=self.spec.model_kwargs.get(
+                        "initial_template", "General+Random"
+                    ),
+                    random_seed=self.spec.model_kwargs.get("random_seed", 2022),
+                    holiday_country=self.spec.model_kwargs.get("holiday_country", "US"),
+                    subset=self.spec.model_kwargs.get("subset", None),
+                    aggfunc=self.spec.model_kwargs.get("aggfunc", "first"),
+                    na_tolerance=self.spec.model_kwargs.get("na_tolerance", 1),
+                    drop_most_recent=self.spec.model_kwargs.get("drop_most_recent", 0),
+                    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"),
+                    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"),
+                    models_to_validate=self.spec.model_kwargs.get(
+                        "models_to_validate", AUTOTS_MODELS_TO_VALIDATE
+                    ),
+                    max_per_model_class=self.spec.model_kwargs.get(
+                        "max_per_model_class", None
+                    ),
+                    validation_method=self.spec.model_kwargs.get(
+                        "validation_method", "backwards"
+                    ),
+                    min_allowed_train_percent=self.spec.model_kwargs.get(
+                        "min_allowed_train_percent", 0.5
+                    ),
+                    remove_leading_zeroes=self.spec.model_kwargs.get(
+                        "remove_leading_zeroes", False
+                    ),
+                    prefill_na=self.spec.model_kwargs.get("prefill_na", None),
+                    introduce_na=self.spec.model_kwargs.get("introduce_na", None),
+                    preclean=self.spec.model_kwargs.get("preclean", None),
+                    model_interrupt=self.spec.model_kwargs.get("model_interrupt", True),
+                    generation_timeout=self.spec.model_kwargs.get(
+                        "generation_timeout", None
+                    ),
+                    current_model_file=self.spec.model_kwargs.get(
+                        "current_model_file", None
+                    ),
+                    verbose=-1 if logger.level > 40 else 1,
+                    n_jobs=self.spec.model_kwargs.get("n_jobs", -1),
+                )
+
+            full_data_indexed = self.datasets.get_data_multi_indexed()
+
+            dates = full_data_indexed.index.get_level_values(0).unique().tolist()
+            train_idx = dates[: -self.spec.horizon]
+
+            df_train = full_data_indexed[
+                full_data_indexed.index.get_level_values(0).isin(train_idx)
+            ][[self.original_target_column]].reset_index()
+
+            # Future regressors need to be in wide format - (num_unique_dates x (num_unique_series x num_unique_cols))
+            additional_regressors = list(
+                set(full_data_indexed.columns) - {self.original_target_column}
             )
-
-            self.model_parameters[s_id] = {
-                "framework": SupportedModels.AutoTS,
-                **params,
-            }
+            if len(additional_regressors) > 1:
+                future_regressor = full_data_indexed.reset_index().pivot(
+                    index=self.spec.datetime_column.name,
+                    columns=ForecastOutputColumns.SERIES,
+                    values=additional_regressors,
+                )
+                future_reg = 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)
+                )
+
+            if self.loaded_models is None:
+                model = model.fit(
+                    df_train,
+                    future_regressor=future_reg,
+                    date_col=self.spec.datetime_column.name,
+                    value_col=self.original_target_column,
+                    id_col=ForecastOutputColumns.SERIES,
+                )
+                # Store the trained model and generate forecasts
+                self.models = copy.deepcopy(model)
+            else:
+                self.models = self.loaded_models
+
+            self.outputs = model.predict(future_regressor=regr_fcst)
+            logger.debug("===========Forecast Generated===========")
+
+            hist_df = model.back_forecast().forecast
+
+            params = vars(model).copy()
+            for param in [
+                "ens_copy",
+                "df_wide_numeric",
+                "future_regressor_train",
+                "initial_results",
+                "score_per_series",
+                "validation_results",
+                "validation_train_indexes",
+                "validation_test_indexes",
+                "validation_indexes",
+                "best_model",
+            ]:
+                if param in params:
+                    params.pop(param)
+
+            for s_id in self.datasets.list_series_ids():
+                self.forecast_output.populate_series_output(
+                    series_id=s_id,
+                    fit_val=hist_df[s_id].values,
+                    forecast_val=self.outputs.forecast[s_id].values,
+                    upper_bound=self.outputs.upper_forecast[s_id].values,
+                    lower_bound=self.outputs.lower_forecast[s_id].values,
+                )
+
+                self.model_parameters[s_id] = {
+                    "framework": SupportedModels.AutoTS,
+                    **params,
+                }
+
+        except Exception as e:
+            for s_id in self.datasets.list_series_ids():
+                self.errors_dict[s_id] = {
+                    "model_name": self.spec.model,
+                    "error": str(e),
+                }
 
         logger.debug("===========Done===========")
 
@@ -213,29 +222,30 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
             - ci_col_names (list): A list of column names for confidence intervals.
         """
         import datapane as dp
-
-        # 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),
-            self.datasets.list_series_ids(),
-        )
-
-        # Section 2: AutoTS Model Parameters
-        sec2_text = dp.Text(f"## AutoTS Model Parameters")
-        try:
-            sec2 = dp.Code(
-                code=yaml.dump(list(self.models.best_model.T.to_dict().values())[0]),
-                language="yaml",
+        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),
+                self.datasets.list_series_ids(),
+            )
+
+            # Section 2: AutoTS Model Parameters
+            sec2_text = dp.Text(f"## AutoTS Model Parameters")
+            try:
+                sec2 = dp.Code(
+                    code=yaml.dump(list(self.models.best_model.T.to_dict().values())[0]),
+                    language="yaml",
+                )
 
-        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]
+            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]
 
         if self.spec.generate_explanations:
             logger.warn(f"Explanations not yet supported for the AutoTS Module")
@@ -266,9 +276,17 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
         r2	-4.60E-06
         Explained Variance	0.002177087
         """
-        mapes = pd.DataFrame(self.models.best_model_per_series_mape()).T
-        scores = pd.DataFrame(
-            self.models.best_model_per_series_score(), columns=["AutoTS Score"]
-        ).T
-        df = pd.concat([mapes, scores])
+        df = pd.DataFrame()
+        try:
+            mapes = pd.DataFrame(self.models.best_model_per_series_mape()).T
+            scores = pd.DataFrame(
+                self.models.best_model_per_series_score(), columns=["AutoTS Score"]
+            ).T
+            df = pd.concat([mapes, scores])
+        except Exception as e:
+            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

@@ -88,7 +88,7 @@ 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."""
@@ -270,17 +270,20 @@ class ForecastOperatorBaseModel(ABC):
                     sec9 = dp.DataTable(self.eval_metrics)
                     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]
+
+                forecast_plots = []
+                if len(self.forecast_output.list_series_ids()) > 0:
+                    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")
@@ -557,13 +560,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 +654,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)
+            if s_id in self.models:
 
-            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)
+                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 +713,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

@@ -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:
@@ -310,56 +310,56 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
 
     def _generate_report(self):
         import datapane as dp
-
+        series_ids = self.models.keys()
         all_sections = []
+        if len(series_ids) > 0:
+            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=series_ids,
+                )
+                all_sections = all_sections + [sec1_text, sec1]
+            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_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=series_ids,
+                )
+                all_sections = all_sections + [sec2_text, sec2]
+            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_text = dp.Text(f"## Forecast Parameter Plots")
+                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)
+                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,
+                    )
+                )
+            all_model_states = pd.concat(model_states, axis=1)
+            sec5 = dp.DataTable(all_model_states)
 
-        all_sections = all_sections + [sec5_text, sec5]
+            all_sections = all_sections + [sec5_text, sec5]
 
         if self.spec.generate_explanations:
             try: