class_docstr: Stores predicted and actual values.
  Provides functionality to evaluate a forecast:
  
      - plots true against actual with prediction bands.
      - evaluates model performance.
  
  Input should be one of two kinds of forecast results:
  
      - model fit to train data, forecast on test set (actuals available).
      - model fit to all data, forecast on future dates (actuals not available).
  
  The input ``df`` is a concatenation of fitted and forecasted values.
  
  Attributes
  ----------
  df : `pandas.DataFrame`
      Timestamp, predicted, and actual values.
  time_col : `str`
      Column in ``df`` with timestamp (default "ts").
  actual_col : `str`
      Column in ``df`` with actual values (default "y").
  predicted_col : `str`
      Column in ``df`` with predicted values (default "forecast").
  predicted_lower_col : `str` or None
      Column in ``df`` with predicted lower bound (default "forecast_lower", optional).
  predicted_upper_col : `str` or None
      Column in ``df`` with predicted upper bound (default "forecast_upper", optional).
  null_model_predicted_col : `str` or None
      Column in ``df`` with predicted value of null model (default "forecast_null", optional).
  ylabel : `str`
      Unit of measurement (default "y")
  train_end_date : `str` or `datetime` or None, default None
      End date for train period. If `None`, assumes all data were used for training.
  test_start_date : `str` or `datetime` or None, default None
      Start date of test period. If `None`, set to the ``time_col`` value immediately after
      ``train_end_date``. This assumes that all data not used in training were used for testing.
  forecast_horizon : `int` or None, default None
      Number of periods forecasted into the future. Must be > 0.
  coverage : `float` or None
      Intended coverage of the prediction bands (0.0 to 1.0).
  r2_loss_function : `function`
      Loss function to calculate ``cst.R2_null_model_score``, with signature
      ``loss_func(y_true, y_pred)`` (default mean_squared_error)
  estimator : An instance of an estimator that implements `greykite.models.base_forecast_estimator.BaseForecastEstimator`.
      The fitted estimator, the last step in the forecast pipeline.
  relative_error_tolerance : `float` or None, default None
      Threshold to compute the ``Outside Tolerance`` metric,
      defined as the fraction of forecasted values whose relative
      error is strictly greater than ``relative_error_tolerance``.
      For example, 0.05 allows for 5% relative error.
      If `None`, the metric is not computed.
  df_train : `pandas.DataFrame`
      Subset of ``df`` where ``df[time_col]`` <= ``train_end_date``.
  df_test : `pandas.DataFrame`
      Subset of ``df`` where ``df[time_col]`` > ``train_end_date``.
  train_evaluation : `dict` [`str`, `float`]
      Evaluation metrics on training set.
  test_evaluation : `dict` [`str`, `float`]
      Evaluation metrics on test set (if actual values provided after train_end_date).
  test_na_count : `int`
      Count of NA values in test data.
docstr: Computes various evaluation metrics for the forecast.
  
  :param data: pd.DataFrame
      with columns according to self.__init__ (e.g. subset of self.df)
  :return: dictionary with evaluation metrics
docstr_tok: ["Computes","various","evaluation","metrics","for","the","forecast",".",":","param","data",":","pd.DataFrame","with","columns","according","to","self.__init__","(","e.g",".","subset","of","self.df",")",":","return",":","dictionary","with","evaluation","metrics"]
code: def __evaluation_metrics(self, data):
      """Computes various evaluation metrics for the forecast.
  
      :param data: pd.DataFrame
          with columns according to self.__init__ (e.g. subset of self.df)
      :return: dictionary with evaluation metrics
      """
      metrics = calc_pred_err(
          data[self.actual_col], data[self.predicted_col]
      )
      if self.relative_error_tolerance is not None:
          metrics[cst.FRACTION_OUTSIDE_TOLERANCE] = partial(
              fraction_outside_tolerance,
              rtol=self.relative_error_tolerance,
          )(
              y_true=data[self.actual_col],
              y_pred=data[self.predicted_col],
          )
      else:
          metrics[cst.FRACTION_OUTSIDE_TOLERANCE] = None
  
      for metric in [
          cst.R2_null_model_score,
          cst.PREDICTION_BAND_WIDTH,
          cst.PREDICTION_BAND_COVERAGE,
          cst.LOWER_BAND_COVERAGE,
          cst.UPPER_BAND_COVERAGE,
          cst.COVERAGE_VS_INTENDED_DIFF,
      ]:
          metrics.update({metric: None})
  
      # evaluates cst.R2_null_model_score if null model is available
      if self.null_model_predicted_col is not None:
          metrics.update(
              {
                  cst.R2_null_model_score: r2_null_model_score(
                      data[self.actual_col],
                      data[self.predicted_col],
                      y_pred_null=data[self.null_model_predicted_col],
                      loss_func=self.r2_loss_function,
                  )
              }
          )
  
      # evaluates prediction bands if available
      if (
          self.predicted_lower_col is not None
          and self.predicted_upper_col is not None
      ):
          result = calc_pred_coverage(
              data[self.actual_col],
              data[self.predicted_col],
              data[self.predicted_lower_col],
              data[self.predicted_upper_col],
              self.coverage,
          )
          metrics.update(result)
      return metrics
  
imports: from functools import partial
  import pandas
  from sklearn.metrics import mean_squared_error
  from greykite.common import constants
  from greykite.common.evaluation import ElementwiseEvaluationMetricEnum
  from greykite.common.evaluation import EvaluationMetricEnum
  from greykite.common.evaluation import add_finite_filter_to_scorer
  from greykite.common.evaluation import calc_pred_coverage
  from greykite.common.evaluation import calc_pred_err
  from greykite.common.evaluation import fraction_outside_tolerance
  from greykite.common.evaluation import r2_null_model_score
  from greykite.common.python_utils import apply_func_to_columns
  from greykite.common.time_properties import infer_freq
  from greykite.common.viz.timeseries_plotting import add_groupby_column
  from greykite.common.viz.timeseries_plotting import flexible_grouping_evaluation
  from greykite.common.viz.timeseries_plotting import grouping_evaluation
  from greykite.common.viz.timeseries_plotting import plot_forecast_vs_actual
  from greykite.common.viz.timeseries_plotting import plot_multivariate
  from greykite.common.viz.timeseries_plotting import plot_univariate
  from greykite.framework.input.univariate_time_series import UnivariateTimeSeries
label_desc: Use image node_id 2 for calling the UnivariateForecast obj's underlying member method code with example usage: obj.__evaluation_metrics(data) and returns: metrics