code: def test_forecast_pipeline_rolling_evaluation_silverkite():
      """Checks the output rolling evaluation with Silverkite template"""
      data = generate_df_with_reg_for_tests(
          freq="1D",
          periods=20 * 7,  # short-term: 20 weeks of data
          remove_extra_cols=True,
          mask_test_actuals=True,
      )
      regressor_cols = ["regressor1", "regressor2", "regressor_categ"]
      keep_cols = [TIME_COL, VALUE_COL] + regressor_cols
      df = data["df"][keep_cols]
  
      coverage = 0.1
      hyperparameter_grid = {
          "estimator__origin_for_time_vars": [
              None
          ],  # inferred from training data
          "estimator__fs_components_df": [
              pd.DataFrame(
                  {
                      "name": ["tow"],
                      "period": [7.0],
                      "order": [3],
                      "seas_names": ["weekly"],
                  }
              )
          ],
          "estimator__extra_pred_cols": [
              regressor_cols,
              regressor_cols + ["ct_sqrt"],
          ],  # two cases: no growth term and single growth term
          "estimator__fit_algorithm_dict": [
              {"fit_algorithm": "linear"}
          ],
      }
      pipeline_params = mock_pipeline(
          df=df,
          time_col=TIME_COL,
          value_col=VALUE_COL,
          date_format=None,  # not recommended, but possible to specify
          freq=None,
          regressor_cols=regressor_cols,
          estimator=SilverkiteEstimator(),
          hyperparameter_grid=hyperparameter_grid,
          hyperparameter_budget=1,
          n_jobs=1,
          forecast_horizon=2 * 7,
          coverage=coverage,
          test_horizon=2 * 7,
          periods_between_train_test=2 * 7,
          agg_periods=7,
          agg_func=np.mean,
          score_func=mean_absolute_error,  # callable score_func
          null_model_params=None,
          cv_horizon=1 * 7,
          cv_expanding_window=True,
          cv_min_train_periods=8 * 7,
          cv_periods_between_splits=7,
          cv_periods_between_train_test=3 * 7,
          cv_max_splits=2,
      )
      tscv = RollingTimeSeriesSplit(
          forecast_horizon=2 * 7,
          min_train_periods=10 * 7,
          expanding_window=True,
          use_most_recent_splits=True,
          periods_between_splits=2 * 7,
          periods_between_train_test=2 * 7,
          max_splits=3,
      )
      rolling_evaluation = forecast_pipeline_rolling_evaluation(
          pipeline_params=pipeline_params, tscv=tscv
      )
  
      expected_splits_n = tscv.max_splits
      assert len(rolling_evaluation.keys()) == expected_splits_n
      assert set(rolling_evaluation.keys()) == {
          "split_0",
          "split_1",
          "split_2",
      }
  
      time_col = pipeline_params["time_col"]
      for split_num, (train, test) in enumerate(tscv.split(X=df)):
          split_output = rolling_evaluation[f"split_{split_num}"]
          assert (
              round(split_output["runtime_sec"], 3)
              == split_output["runtime_sec"]
          )
  
          pipeline_result = split_output["pipeline_result"]
  
          # Checks every split uses all the available data for training
          ts = pipeline_result.timeseries
          train_end_date = df.iloc[train[-1]][time_col]
          assert ts.train_end_date == train_end_date
  
          assert pipeline_result.backtest is None
  
          # Checks every split has forecast for train+test periods passed by tscv
          forecast = pipeline_result.forecast
          assert (
              forecast.df.shape[0]
              == ts.fit_df.shape[0]
              + tscv.periods_between_train_test
              + tscv.forecast_horizon
          )
  
imports: import sys
  import numpy
  import pandas
  import pytest
  from sklearn.metrics import mean_absolute_error
  from greykite.common.constants import TIME_COL
  from greykite.common.constants import VALUE_COL
  from greykite.common.evaluation import EvaluationMetricEnum
  from greykite.common.python_utils import assert_equal
  from greykite.common.testing_utils import generate_df_for_tests
  from greykite.common.testing_utils import generate_df_with_reg_for_tests
  from greykite.framework.benchmark.benchmark_class_helper import forecast_pipeline_rolling_evaluation
  from greykite.framework.pipeline.pipeline import forecast_pipeline
  from greykite.framework.utils.framework_testing_utils import mock_pipeline
  from greykite.framework.utils.result_summary import summarize_grid_search_results
  from greykite.sklearn.cross_validation import RollingTimeSeriesSplit
  from greykite.sklearn.estimator.prophet_estimator import ProphetEstimator
  from greykite.sklearn.estimator.silverkite_estimator import SilverkiteEstimator
label_desc: Use image node_id 2 for calling a global function with example usage: test_forecast_pipeline_rolling_evaluation_silverkite() without return types