code: def plot_cross_validation_metric(
      df_cv,
      metric,
      rolling_window=0.1,
      ax=None,
      figsize=(10, 6),
      color="b",
      point_color="gray",
  ):
      """Plot a performance metric vs. forecast horizon from cross validation.
  
      Cross validation produces a collection of out-of-sample model predictions
      that can be compared to actual values, at a range of different horizons
      (distance from the cutoff). This computes a specified performance metric
      for each prediction, and aggregated over a rolling window with horizon.
  
      This uses prophet.diagnostics.performance_metrics to compute the metrics.
      Valid values of metric are 'mse', 'rmse', 'mae', 'mape', and 'coverage'.
  
      rolling_window is the proportion of data included in the rolling window of
      aggregation. The default value of 0.1 means 10% of data are included in the
      aggregation for computing the metric.
  
      As a concrete example, if metric='mse', then this plot will show the
      squared error for each cross validation prediction, along with the MSE
      averaged over rolling windows of 10% of the data.
  
      Parameters
      ----------
      df_cv: The output from prophet.diagnostics.cross_validation.
      metric: Metric name, one of ['mse', 'rmse', 'mae', 'mape', 'coverage'].
      rolling_window: Proportion of data to use for rolling average of metric.
          In [0, 1]. Defaults to 0.1.
      ax: Optional matplotlib axis on which to plot. If not given, a new figure
          will be created.
      figsize: Optional tuple width, height in inches.
      color: Optional color for plot and error points, useful when plotting
          multiple model performances on one axis for comparison.
  
      Returns
      -------
      a matplotlib figure.
      """
      if ax is None:
          fig = plt.figure(facecolor="w", figsize=figsize)
          ax = fig.add_subplot(111)
      else:
          fig = ax.get_figure()
      # Get the metric at the level of individual predictions, and with the rolling window.
      df_none = performance_metrics(
          df_cv, metrics=[metric], rolling_window=-1
      )
      df_h = performance_metrics(
          df_cv, metrics=[metric], rolling_window=rolling_window
      )
  
      # Some work because matplotlib does not handle timedelta
      # Target ~10 ticks.
      tick_w = max(df_none["horizon"].astype("timedelta64[ns]")) / 10.0
      # Find the largest time resolution that has <1 unit per bin.
      dts = ["D", "h", "m", "s", "ms", "us", "ns"]
      dt_names = [
          "days",
          "hours",
          "minutes",
          "seconds",
          "milliseconds",
          "microseconds",
          "nanoseconds",
      ]
      dt_conversions = [
          24 * 60 * 60 * 10**9,
          60 * 60 * 10**9,
          60 * 10**9,
          10**9,
          10**6,
          10**3,
          1.0,
      ]
      for i, dt in enumerate(dts):
          if np.timedelta64(1, dt) < np.timedelta64(tick_w, "ns"):
              break
  
      x_plt = df_none["horizon"].astype("timedelta64[ns]").view(
          np.int64
      ) / float(dt_conversions[i])
      x_plt_h = df_h["horizon"].astype("timedelta64[ns]").view(
          np.int64
      ) / float(dt_conversions[i])
  
      ax.plot(x_plt, df_none[metric], ".", alpha=0.1, c=point_color)
      ax.plot(x_plt_h, df_h[metric], "-", c=color)
      ax.grid(True)
  
      ax.set_xlabel("Horizon ({})".format(dt_names[i]))
      ax.set_ylabel(metric)
      return fig
  
imports: from __future__ import absolute_import, division, print_function
  import logging
  import numpy
  import pandas
  from prophet.diagnostics import performance_metrics
label_desc: Use image node_id 10 for calling a global function with example usage: plot_cross_validation_metric(df_cv, metric, rolling_window, ax, figsize, color, point_color) and returns: fig