class_docstr: A template for :class:`~greykite.sklearn.estimator.silverkite_estimator.SilverkiteEstimator`.
  
  Takes input data and optional configuration parameters
  to customize the model. Returns a set of parameters to call
  :func:`~greykite.framework.pipeline.pipeline.forecast_pipeline`.
  
  Notes
  -----
  The attributes of a `~greykite.framework.templates.autogen.forecast_config.ForecastConfig` for
  :class:`~greykite.sklearn.estimator.silverkite_estimator.SilverkiteEstimator` are:
  
      computation_param: `ComputationParam` or None, default None
          How to compute the result. See
          :class:`~greykite.framework.templates.autogen.forecast_config.ComputationParam`.
      coverage: `float` or None, default None
          Intended coverage of the prediction bands (0.0 to 1.0).
          Same as coverage in ``forecast_pipeline``.
          You may tune how the uncertainty is computed
          via `model_components.uncertainty["uncertainty_dict"]`.
      evaluation_metric_param: `EvaluationMetricParam` or None, default None
          What metrics to evaluate. See
          :class:`~greykite.framework.templates.autogen.forecast_config.EvaluationMetricParam`.
      evaluation_period_param: `EvaluationPeriodParam` or None, default None
          How to split data for evaluation. See
          :class:`~greykite.framework.templates.autogen.forecast_config.EvaluationPeriodParam`.
      forecast_horizon: `int` or None, default None
          Number of periods to forecast into the future. Must be > 0
          If None, default is determined from input data frequency
          Same as forecast_horizon in `forecast_pipeline`
      metadata_param: `MetadataParam` or None, default None
          Information about the input data. See
          :class:`~greykite.framework.templates.autogen.forecast_config.MetadataParam`.
      model_components_param: `ModelComponentsParam` or None, default None
          Parameters to tune the model. See
          :class:`~greykite.framework.templates.autogen.forecast_config.ModelComponentsParam`.
          The fields are dictionaries with the following items.
  
          See inline comments on which values accept lists for grid search.
  
          seasonality: `dict` [`str`, `any`] or None, optional
              How to model the seasonality. A dictionary with keys corresponding to
              parameters in `~greykite.algo.forecast.silverkite.forecast_silverkite.SilverkiteForecast.forecast`.
  
              Allowed keys: ``"fs_components_df"``.
          growth: `dict` [`str`, `any`] or None, optional
              How to model the growth.
  
              Allowed keys: None. (Use ``model_components.custom["extra_pred_cols"]`` to specify
              growth terms.)
          events: `dict` [`str`, `any`] or None, optional
              How to model the holidays/events. A dictionary with keys corresponding to
              parameters in `~greykite.algo.forecast.silverkite.forecast_silverkite.SilverkiteForecast.forecast`.
  
              Allowed keys: ``"daily_event_df_dict"``.
  
              .. note::
  
                  Event names derived from ``daily_event_df_dict`` must be specified via
                  ``model_components.custom["extra_pred_cols"]`` to be included in the model.
                  This parameter has no effect on the model unless event names are passed to
                  ``extra_pred_cols``.
  
                  The function
                  `~greykite.algo.forecast.silverkite.forecast_simple_silverkite_helper.get_event_pred_cols`
                  can be used to extract all event names from ``daily_event_df_dict``.
  
          changepoints: `dict` [`str`, `any`] or None, optional
              How to model changes in trend and seasonality. A dictionary with keys corresponding to
              parameters in `~greykite.algo.forecast.silverkite.forecast_silverkite.SilverkiteForecast.forecast`.
  
              Allowed keys: "changepoints_dict", "seasonality_changepoints_dict", "changepoint_detector".
          autoregression: `dict` [`str`, `any`] or None, optional
              Specifies the autoregression configuration. Dictionary with the following optional key:
  
              ``"autoreg_dict"``: `dict` or `str` or None or a list of such values for grid search
                  If a `dict`: A dictionary with arguments for `~greykite.common.features.timeseries_lags.build_autoreg_df`.
                  That function's parameter ``value_col`` is inferred from the input of
                  current function ``self.forecast``. Other keys are:
  
                      ``"lag_dict"`` : `dict` or None
                      ``"agg_lag_dict"`` : `dict` or None
                      ``"series_na_fill_func"`` : callable
  
                  If a `str`: The string will represent a method and a dictionary will be
                  constructed using that `str`.
                  Currently only implemented method is "auto" which uses
                  `~greykite.algo.forecast.silverkite.SilverkiteForecast.__get_default_autoreg_dict`
                  to create a dictionary.
                  See more details for above parameters in
                  `~greykite.common.features.timeseries_lags.build_autoreg_df`.
  
          regressors: `dict` [`str`, `any`] or None, optional
              How to model the regressors.
  
              Allowed keys: None. (Use ``model_components.custom["extra_pred_cols"]`` to specify
              regressors.)
          lagged_regressors: `dict` [`str`, `dict`] or None, optional
              Specifies the lagged regressors configuration. Dictionary with the following optional key:
  
              ``"lagged_regressor_dict"``: `dict` or None or a list of such values for grid search
                  A dictionary with arguments for `~greykite.common.features.timeseries_lags.build_autoreg_df_multi`.
                  The keys of the dictionary are the target lagged regressor column names.
                  It can leverage the regressors included in ``df``.
                  The value of each key is either a `dict` or `str`.
                  If `dict`, it has the following keys:
  
                      ``"lag_dict"`` : `dict` or None
                      ``"agg_lag_dict"`` : `dict` or None
                      ``"series_na_fill_func"`` : callable
  
                  If `str`, it represents a method and a dictionary will be constructed using that `str`.
                  Currently the only implemented method is "auto" which uses ``SilverkiteForecast``'s
                  `~greykite.algo.forecast.silverkite.SilverkiteForecast.__get_default_lagged_regressor_dict`
                  to create a dictionary for each lagged regressor.
                  An example::
  
                      lagged_regressor_dict = {
                          "regressor1": {
                              "lag_dict": {"orders": [1, 2, 3]},
                              "agg_lag_dict": {
                                  "orders_list": [[7, 7 * 2, 7 * 3]],
                                  "interval_list": [(8, 7 * 2)]},
                              "series_na_fill_func": lambda s: s.bfill().ffill()},
                          "regressor2": "auto"}
  
                  Check the docstring of `~greykite.common.features.timeseries_lags.build_autoreg_df_multi`
                  for more details for each argument.
          uncertainty: `dict` [`str`, `any`] or None, optional
              How to model the uncertainty. A dictionary with keys corresponding to
              parameters in `~greykite.algo.forecast.silverkite.forecast_silverkite.SilverkiteForecast.forecast`.
  
              Allowed keys: ``"uncertainty_dict"``.
          custom: `dict` [`str`, `any`] or None, optional
              Custom parameters that don't fit the categories above. A dictionary with keys corresponding to
              parameters in `~greykite.algo.forecast.silverkite.forecast_silverkite.SilverkiteForecast.forecast`.
  
              Allowed keys:
                  ``"silverkite"``,
                  ``"origin_for_time_vars"``, ``"extra_pred_cols"``,
                  ``"drop_pred_cols"``, ``"explicit_pred_cols"``,
                  ``"fit_algorithm_dict"``, ``"min_admissible_value"``,
                  ``"max_admissible_value"``.
  
              .. note::
  
                  ``"extra_pred_cols"`` should contain the desired growth terms, regressor names, and event names.
  
              ``fit_algorithm_dict`` is a dictionary with ``fit_algorithm`` and ``fit_algorithm_params``
              parameters to `~greykite.algo.forecast.silverkite.forecast_silverkite.SilverkiteForecast.forecast`:
  
                      fit_algorithm_dict : `dict` or None, optional
                          How to fit the model. A dictionary with the following optional keys.
  
                          ``"fit_algorithm"`` : `str`, optional, default "linear"
                              The type of predictive model used in fitting.
  
                              See `~greykite.algo.common.ml_models.fit_model_via_design_matrix`
                              for available options and their parameters.
                          ``"fit_algorithm_params"`` : `dict` or None, optional, default None
                              Parameters passed to the requested fit_algorithm.
                              If None, uses the defaults in `~greykite.algo.common.ml_models.fit_model_via_design_matrix`.
  
          hyperparameter_override: `dict` [`str`, `any`] or None or `list` [`dict` [`str`, `any`] or None], optional
              After the above model components are used to create a hyperparameter grid, the result is
              updated by this dictionary, to create new keys or override existing ones.
              Allows for complete customization of the grid search.
  
              Keys should have format ``{named_step}__{parameter_name}`` for the named steps of the
              `sklearn.pipeline.Pipeline` returned by this function. See `sklearn.pipeline.Pipeline`.
  
              For example::
  
                  hyperparameter_override={
                      "estimator__origin_for_time_vars": 2018.0,
                      "input__response__null__impute_algorithm": "ts_interpolate",
                      "input__response__null__impute_params": {"orders": [7, 14]},
                      "input__regressors_numeric__normalize__normalize_algorithm": "RobustScaler",
                  }
  
              If a list of dictionaries, grid search will be done for each dictionary in the list.
              Each dictionary in the list override the defaults. This enables grid search
              over specific combinations of parameters to reduce the search space.
  
                  * For example, the first dictionary could define combinations of parameters for a
                    "complex" model, and the second dictionary could define combinations of parameters
                    for a "simple" model, to prevent mixed combinations of simple and complex.
                  * Or the first dictionary could grid search over fit algorithm, and the second dictionary
                    could use a single fit algorithm and grid search over seasonality.
  
              The result is passed as the ``param_distributions`` parameter
              to `sklearn.model_selection.RandomizedSearchCV`.
      model_template: `str`
          This class only accepts "SK".
code: def __init__(
      self, estimator: BaseForecastEstimator = SilverkiteEstimator()
  ):
      super().__init__(estimator=estimator)
  
imports: import dataclasses
  import functools
  from typing import Dict
  from typing import Optional
  import numpy
  import pandas
  from greykite.algo.forecast.silverkite.forecast_silverkite import SilverkiteForecast
  from greykite.common.constants import TimeFeaturesEnum
  from greykite.common.features.timeseries_lags import build_autoreg_df_multi
  from greykite.common.python_utils import dictionaries_values_to_lists
  from greykite.common.python_utils import unique_in_list
  from greykite.common.python_utils import update_dictionaries
  from greykite.common.python_utils import update_dictionary
  from greykite.framework.templates.autogen.forecast_config import ForecastConfig
  from greykite.framework.templates.autogen.forecast_config import ModelComponentsParam
  from greykite.framework.templates.base_template import BaseTemplate
  from greykite.sklearn.estimator.base_forecast_estimator import BaseForecastEstimator
  from greykite.sklearn.estimator.silverkite_estimator import SilverkiteEstimator
label_desc: Use image node_id 1 to create a new SilverkiteTemplate object from inherited base classes: BaseTemplate with example: obj = SilverkiteTemplate(estimator)