code: def plot_parameters(
      m,
      plot_configuration,
      quantile=0.5,
      weekly_start=0,
      yearly_start=0,
      figsize=(700, 210),
      df_name=None,
      forecast_in_focus=None,
      resampler_active=False,
      plotly_static=False,
  ):
      """Plot the parameters that the model is composed of, visually.
  
      Parameters
      ----------
          m : NeuralProphet
              Fitted model
          plot_configuration: dict
              dict of configured parameters to plot
          quantile : float
              The quantile for which the model parameters are to be plotted
          weekly_start : int
              Specifying the start day of the weekly seasonality plot
  
              Options
                  * (default) ``weekly_start = 0``: starts the week on Sunday
                  * ``weekly_start = 1``: shifts by 1 day to Monday, and so on
          yearly_start : int
              Specifying the start day of the yearly seasonality plot.
  
              Options
                  * (default) ``yearly_start = 0``: starts the year on Jan 1
                  * ``yearly_start = 1``: shifts by 1 day to Jan 2, and so on
          figsize : tuple
              Width, height in inches.
  
              Note
              ----
              Default value is set to ``None`` ->  automatic ``figsize = (700, 210 * npanel)``
          df_name : str
              Name of dataframe to refer to data params from original keys of train dataframes
  
              Note
              ----
              Only used for local normalization in global modeling
          forecast_in_focus: int
              optinal, i-th step ahead forecast to plot
  
              Note
              ----
              None (default): plot self.highlight_forecast_step_n by default
          resampler_active : bool
              Flag whether to activate the plotly-resampler
          plotly_static: bool
              Flag whether to generate a static svg image
  
      Returns:
          Plotly figure
      """
      if resampler_active:
          register_plotly_resampler(mode="auto")
      else:
          unregister_plotly_resampler()
      compnents_to_plot = plot_configuration["components_list"]
      additive_future_regressors = plot_configuration[
          "additive_future_regressors"
      ]
      additive_events = plot_configuration["additive_events"]
      multiplicative_future_regressors = plot_configuration[
          "multiplicative_future_regressors"
      ]
      multiplicative_events = plot_configuration[
          "multiplicative_events"
      ]
      lagged_scalar_regressors = plot_configuration[
          "lagged_scalar_regressors"
      ]
  
      npanel = len(compnents_to_plot)
      figsize = figsize if figsize else (700, 210 * npanel)
  
      # Create Plotly subplot figure and add the components to it
      fig = make_subplots(npanel, cols=1, print_grid=False)
      fig.update_layout(
          go.Layout(
              showlegend=False,
              width=figsize[0],
              height=figsize[1] * npanel,
              **layout_args,
          )
      )
  
      for i, comp in enumerate(compnents_to_plot):
          is_multiplicative = False
          plot_name = comp["plot_name"].lower()
          if plot_name.startswith("trend"):
              if "change" in plot_name:
                  trace_object = plot_trend_change(
                      m,
                      quantile=quantile,
                      plot_name=comp["plot_name"],
                      df_name=df_name,
                  )
              else:
                  trace_object = plot_trend(
                      m,
                      quantile=quantile,
                      plot_name=comp["plot_name"],
                      df_name=df_name,
                  )
  
          elif plot_name.startswith("seasonality"):
              name = comp["comp_name"]
              if m.config_seasonality.mode == "multiplicative":
                  is_multiplicative = True
              if (
                  name.lower() == "weekly"
                  or m.config_seasonality.periods[name].period == 7
              ):
                  trace_object = plot_weekly(
                      m=m,
                      quantile=quantile,
                      weekly_start=weekly_start,
                      comp_name=name,
                      multiplicative=is_multiplicative,
                      df_name=df_name,
                  )
              elif (
                  name.lower() == "yearly"
                  or m.config_seasonality.periods[name].period == 365.25
              ):
                  trace_object = plot_yearly(
                      m=m,
                      quantile=quantile,
                      yearly_start=yearly_start,
                      comp_name=name,
                      multiplicative=is_multiplicative,
                      df_name=df_name,
                  )
              elif (
                  name.lower() == "daily"
                  or m.config_seasonality.periods[name].period == 1
              ):
                  trace_object = plot_daily(
                      m=m,
                      quantile=quantile,
                      comp_name=name,
                      multiplicative=is_multiplicative,
                      df_name=df_name,
                  )
              else:
                  trace_object = plot_custom_season(
                      m=m,
                      quantile=quantile,
                      comp_name=name,
                      multiplicative=is_multiplicative,
                      df_name=df_name,
                  )
          elif plot_name == "lagged weights":
              trace_object = plot_lagged_weights(
                  weights=comp["weights"],
                  comp_name=comp["comp_name"],
                  focus=comp["focus"],
              )
          else:
              if plot_name == "additive future regressor":
                  weights = additive_future_regressors
              elif plot_name == "multiplicative future regressor":
                  is_multiplicative = True
                  weights = multiplicative_future_regressors
              elif plot_name == "lagged scalar regressor":
                  weights = lagged_scalar_regressors
              elif plot_name == "additive event":
                  weights = additive_events
              elif plot_name == "multiplicative event":
                  is_multiplicative = True
                  weights = multiplicative_events
              trace_object = plot_scalar_weights(
                  weights=weights,
                  plot_name=comp["plot_name"],
                  focus=forecast_in_focus,
                  multiplicative=is_multiplicative,
              )
  
          if i == 0:
              xaxis = fig["layout"]["xaxis"]
              yaxis = fig["layout"]["yaxis"]
          else:
              xaxis = fig["layout"][f"xaxis{i + 1}"]
              yaxis = fig["layout"][f"yaxis{i + 1}"]
  
          xaxis.update(trace_object["xaxis"])
          yaxis.update(trace_object["yaxis"])
          xaxis.update(**xaxis_args)
          yaxis.update(**yaxis_args)
          for trace in trace_object["traces"]:
              fig.add_trace(
                  trace, row=i + 1, col=1
              )  # adapt var name to plotly-resampler
          unregister_plotly_resampler()
      return fig
  
file_path: neural_prophet/neuralprophet/plot_model_parameters_plotly.py
imports: import datetime
  import logging
  import numpy
  import pandas
  from neuralprophet.plot_utils import predict_one_season, predict_season_from_dates
label_desc: Use image node_id 10 for calling a global function with example usage: plot_parameters(m, plot_configuration, quantile, weekly_start, yearly_start, figsize, df_name, forecast_in_focus, resampler_active, plotly_static) and returns: fig