class_docstr: State space representation of a time series process, with Kalman filter
  and smoother.
  
  Parameters
  ----------
  k_endog : {array_like, int}
      The observed time-series process :math:`y` if array like or the
      number of variables in the process if an integer.
  k_states : int
      The dimension of the unobserved state process.
  k_posdef : int, optional
      The dimension of a guaranteed positive definite covariance matrix
      describing the shocks in the measurement equation. Must be less than
      or equal to `k_states`. Default is `k_states`.
  results_class : class, optional
      Default results class to use to save filtering output. Default is
      `SmootherResults`. If specified, class must extend from
      `SmootherResults`.
  **kwargs
      Keyword arguments may be used to provide default values for state space
      matrices, for Kalman filtering options, or for Kalman smoothing
      options. See `Representation` for more details.
code: def _initialize_smoother(
      self,
      smoother_output=None,
      smooth_method=None,
      prefix=None,
      **kwargs,
  ):
      if smoother_output is None:
          smoother_output = self.smoother_output
      if smooth_method is None:
          smooth_method = self.smooth_method
  
      # Make sure we have the required Kalman filter
      (
          prefix,
          dtype,
          create_filter,
          create_statespace,
      ) = self._initialize_filter(prefix, **kwargs)
  
      # Determine if we need to (re-)create the smoother
      # (definitely need to recreate if we recreated the filter)
      create_smoother = (
          create_filter or prefix not in self._kalman_smoothers
      )
      if not create_smoother:
          kalman_smoother = self._kalman_smoothers[prefix]
  
          create_smoother = (
              kalman_smoother.kfilter
              is not self._kalman_filters[prefix]
          )
  
      # If the dtype-specific _kalman_smoother does not exist (or if we
      # need to re-create it), create it
      if create_smoother:
          # Setup the smoother
          cls = self.prefix_kalman_smoother_map[prefix]
          self._kalman_smoothers[prefix] = cls(
              self._statespaces[prefix],
              self._kalman_filters[prefix],
              smoother_output,
              smooth_method,
          )
      # Otherwise, update the smoother parameters
      else:
          self._kalman_smoothers[prefix].set_smoother_output(
              smoother_output, False
          )
          self._kalman_smoothers[prefix].set_smooth_method(
              smooth_method
          )
  
      return (
          prefix,
          dtype,
          create_smoother,
          create_filter,
          create_statespace,
      )
  
imports: import numpy
  from types import SimpleNamespace
  from statsmodels.tsa.statespace.representation import OptionWrapper
  from statsmodels.tsa.statespace.kalman_filter import KalmanFilter, FilterResults
  from statsmodels.tsa.statespace.tools import reorder_missing_matrix, reorder_missing_vector, copy_index_matrix
  from statsmodels.tsa.statespace import tools, initialization
label_desc: Use image node_id 4 for calling the KalmanSmoother obj's underlying member method code with example usage: obj._initialize_smoother(smoother_output, smooth_method, prefix) and returns: prefix,  dtype,  create_smoother,  create_filter,  create_statespace