code: def plot_parameters(
      m,
      plot_configuration,
      quantile=0.5,
      weekly_start=0,
      yearly_start=0,
      figsize=None,
      df_name=None,
      forecast_in_focus=None,
  ):
      """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 = (10, 3 * 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
  
      Returns
      -------
          matplotlib.pyplot.figure
              Figure showing the NeuralProphet parameters
  
      Examples
      --------
      Base usage of :meth:`plot_parameters`
  
      >>> from neuralprophet import NeuralProphet
      >>> m = NeuralProphet()
      >>> metrics = m.fit(df, freq="D")
      >>> future = m.make_future_dataframe(df=df, periods=365)
      >>> forecast = m.predict(df=future)
      >>> m.plot_parameters()
  
      """
      components_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"
      ]
      overwriting_unknown_data_normalization = plot_configuration[
          "overwriting_unknown_data_normalization"
      ]
  
      npanel = len(components_to_plot)
      figsize = figsize if figsize else (10, 3 * npanel)
      fig, axes = plt.subplots(
          npanel, 1, facecolor="w", figsize=figsize
      )
      if npanel == 1:
          axes = [axes]
      multiplicative_axes = []
      for ax, comp in zip(axes, components_to_plot):
          plot_name = comp["plot_name"].lower()
          if plot_name.startswith("trend"):
              if "change" in plot_name:
                  plot_trend_change(
                      m=m,
                      quantile=quantile,
                      ax=ax,
                      plot_name=comp["plot_name"],
                      df_name=df_name,
                  )
              else:
                  plot_trend(
                      m=m,
                      quantile=quantile,
                      ax=ax,
                      plot_name=comp["plot_name"],
                      df_name=df_name,
                  )
          elif plot_name.startswith("seasonality"):
              name = comp["comp_name"]
              if m.config_seasonality.mode == "multiplicative":
                  multiplicative_axes.append(ax)
              if (
                  name.lower() == "weekly"
                  or m.config_seasonality.periods[name].period == 7
              ):
                  plot_weekly(
                      m=m,
                      quantile=quantile,
                      ax=ax,
                      weekly_start=weekly_start,
                      comp_name=name,
                      df_name=df_name,
                  )
              elif (
                  name.lower() == "yearly"
                  or m.config_seasonality.periods[name].period == 365.25
              ):
                  plot_yearly(
                      m=m,
                      quantile=quantile,
                      ax=ax,
                      yearly_start=yearly_start,
                      comp_name=name,
                      df_name=df_name,
                  )
              elif (
                  name.lower() == "daily"
                  or m.config_seasonality.periods[name].period == 1
              ):
                  plot_daily(
                      m=m,
                      quantile=quantile,
                      ax=ax,
                      comp_name=name,
                      df_name=df_name,
                  )
              else:
                  plot_custom_season(
                      m=m,
                      quantile=quantile,
                      ax=ax,
                      comp_name=name,
                      df_name=df_name,
                  )
          elif plot_name == "lagged weights":
              plot_lagged_weights(
                  weights=comp["weights"],
                  comp_name=comp["comp_name"],
                  focus=comp["focus"],
                  ax=ax,
              )
          else:
              if plot_name == "additive future regressor":
                  weights = additive_future_regressors
              elif plot_name == "multiplicative future regressor":
                  multiplicative_axes.append(ax)
                  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":
                  multiplicative_axes.append(ax)
                  weights = multiplicative_events
              plot_scalar_weights(
                  weights=weights,
                  plot_name=comp["plot_name"],
                  focus=forecast_in_focus,
                  ax=ax,
              )
      fig = fig.tight_layout()
      # Reset multiplicative axes labels after tight_layout adjustment
      for ax in multiplicative_axes:
          ax = set_y_as_percent(ax)
      if overwriting_unknown_data_normalization:
          # if overwriting_unknown_data_normalization is True, we get back to the initial False state
          m.config_normalization.unknown_data_normalization = False
  
      return fig
  
file_path: neural_prophet/neuralprophet/plot_model_parameters_matplotlib.py
imports: import datetime
  import logging
  import numpy
  import pandas
  from neuralprophet.plot_utils import predict_one_season, predict_season_from_dates, set_y_as_percent
label_desc: Use image node_id 1 for calling a global function with example usage: plot_parameters(m, plot_configuration, quantile, weekly_start, yearly_start, figsize, df_name, forecast_in_focus) and returns: fig