code: def plot_yearly(
      m,
      quantile,
      comp_name="yearly",
      yearly_start=0,
      quick=True,
      multiplicative=False,
      df_name="__df__",
  ):
      """Plot the yearly component of the forecast.
  
      Parameters
      ----------
          m : NeuralProphet
              Fitted model
          quantile : float
              The quantile for which the yearly seasonality is plotted
          comp_name : str
              Name of seasonality component
          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
          quick : bool
              Use quick low-level call of model
          multiplicative : bool
              Flag to set y axis as percentage
          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
  
      """
      traces = []
      line_width = 2
  
      # Compute yearly seasonality for a Jan 1 - Dec 31 sequence of dates.
      days = pd.date_range(
          start="2017-01-01", periods=365
      ) + pd.Timedelta(days=yearly_start)
      df_y = pd.DataFrame({"ds": days})
      if not isinstance(df_name, list):
          df_y["ID"] = df_name
      mean_std = False  # Indicates whether mean and std of global df shall be plotted
      if isinstance(df_name, list):
          mean_std = True
          quick = False
          df_y = pd.DataFrame()
          for i in range(m.id_list.__len__()):
              df_i = pd.DataFrame({"ds": days})
              df_i["ID"] = m.id_list[i]
              df_y = pd.concat((df_y, df_i), ignore_index=True)
      if quick:
          predicted = predict_season_from_dates(
              m,
              dates=df_y["ds"],
              name=comp_name,
              quantile=quantile,
              df_name=df_name,
          )
      else:
          predicted = m.predict_seasonal_components(
              df_y, quantile=quantile
          )[["ds", "ID", comp_name]]
  
      if mean_std:
          # If more than on ID has been provided, and no df_name has been specified: plot median and quants across all IDs
          predicted_q90 = (
              predicted[["ds", comp_name]]
              .groupby("ds")
              .apply(lambda x: x.quantile(0.9))
          )
          predicted_q10 = (
              predicted[["ds", comp_name]]
              .groupby("ds")
              .apply(lambda x: x.quantile(0.1))
          )
          predicted = (
              predicted[["ds", comp_name]]
              .groupby("ds")
              .apply(lambda x: x.mean())
          )
          predicted["ID"] = m.id_list[0]
          df_y = df_y[df_y["ID"] == m.id_list[0]]
  
      traces.append(
          go.Scatter(
              name=comp_name + " Mean" if mean_std else comp_name,
              x=df_y["ds"].dt.to_pydatetime(),
              y=predicted[comp_name],
              mode="lines",
              line=dict(color=color, width=line_width),
              fill="none",
          )
      )
      if mean_std:
          filling = "tonexty"
          traces.append(
              go.Scatter(
                  name="Quant 10%",
                  x=df_y["ds"],
                  y=predicted_q10[comp_name],
                  mode="lines",
                  line=dict(color="rgba(45, 146, 255, 0.2)", width=1),
                  fillcolor="rgba(45, 146, 255, 0.2)",
                  showlegend=True,
              )
          )
          traces.append(
              go.Scatter(
                  name="Quant 90%",
                  x=df_y["ds"],
                  y=predicted_q90[comp_name],
                  fill=filling,
                  mode="lines",
                  line=dict(color="rgba(45, 146, 255, 0.2)", width=1),
                  fillcolor="rgba(45, 146, 255, 0.2)",
                  showlegend=False,
              )
          )
  
      padded_range = get_dynamic_axis_range(
          df_y["ds"].dt.to_pydatetime(), type="dt"
      )
      xaxis = go.layout.XAxis(
          title="Day of year",
          range=padded_range,
          tickformat="%B %e",
      )
      yaxis = go.layout.YAxis(
          rangemode="normal",
          title=go.layout.yaxis.Title(text=f"Seasonality: {comp_name}"),
      )
  
      if multiplicative:
          yaxis.update(tickformat=".1%", hoverformat=".4%")
  
      return {"traces": traces, "xaxis": xaxis, "yaxis": yaxis}
  
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 6 for calling a global function with example usage: plot_yearly(m, quantile, comp_name, yearly_start, quick, multiplicative, df_name) and returns: dict