class_docstr: Class to hold results from fitting an DynamicFactor model.
  
  Parameters
  ----------
  model : DynamicFactor instance
      The fitted model instance
  
  Attributes
  ----------
  specification : dictionary
      Dictionary including all attributes from the DynamicFactor model
      instance.
  coefficient_matrices_var : ndarray
      Array containing autoregressive lag polynomial coefficient matrices,
      ordered from lowest degree to highest.
  
  See Also
  --------
  statsmodels.tsa.statespace.kalman_filter.FilterResults
  statsmodels.tsa.statespace.mlemodel.MLEResults
class_docstr_tok: ["Class","to","hold","results","from","fitting","an","DynamicFactor","model",".","Parameters","--","--","--","--","--","model",":","DynamicFactor","instance","The","fitted","model","instance","Attributes","--","--","--","--","--","specification",":","dictionary","Dictionary","including","all","attributes","from","the","DynamicFactor","model","instance",".","coefficient_matrices_var",":","ndarray","Array","containing","autoregressive","lag","polynomial","coefficient","matrices",",","ordered","from","lowest","degree","to","highest",".","See","Also","--","--","--","--","statsmodels.tsa.statespace.kalman_filter.FilterResults","statsmodels.tsa.statespace.mlemodel.MLEResults"]
code: def summary(self, alpha=0.05, start=None, separate_params=True):
      from statsmodels.iolib.summary import summary_params
  
      spec = self.specification
  
      # Create the model name
      model_name = []
      if spec.k_factors > 0:
          if spec.factor_order > 0:
              model_type = "DynamicFactor(factors=%d, order=%d)" % (
                  spec.k_factors,
                  spec.factor_order,
              )
          else:
              model_type = "StaticFactor(factors=%d)" % spec.k_factors
  
          model_name.append(model_type)
          if spec.k_exog > 0:
              model_name.append("%d regressors" % spec.k_exog)
      else:
          model_name.append("SUR(%d regressors)" % spec.k_exog)
  
      if spec.error_order > 0:
          error_type = "VAR" if spec.error_var else "AR"
          model_name.append(
              "%s(%d) errors" % (error_type, spec.error_order)
          )
  
      summary = super().summary(
          alpha=alpha,
          start=start,
          model_name=model_name,
          display_params=not separate_params,
      )
  
      if separate_params:
          indices = np.arange(len(self.params))
  
          def make_table(self, mask, title, strip_end=True):
              res = (
                  self,
                  self.params[mask],
                  self.bse[mask],
                  self.zvalues[mask],
                  self.pvalues[mask],
                  self.conf_int(alpha)[mask],
              )
  
              param_names = [
                  ".".join(name.split(".")[:-1]) if strip_end else name
                  for name in np.array(self.data.param_names)[
                      mask
                  ].tolist()
              ]
  
              return summary_params(
                  res,
                  yname=None,
                  xname=param_names,
                  alpha=alpha,
                  use_t=False,
                  title=title,
              )
  
          k_endog = self.model.k_endog
          k_exog = self.model.k_exog
          k_factors = self.model.k_factors
          factor_order = self.model.factor_order
          _factor_order = self.model._factor_order
          _error_order = self.model._error_order
  
          # Add parameter tables for each endogenous variable
          loading_indices = indices[self.model._params_loadings]
          loading_masks = []
          exog_indices = indices[self.model._params_exog]
          exog_masks = []
          for i in range(k_endog):
              # 1. Factor loadings
              # Recall these are in the form:
              # 'loading.f1.y1', 'loading.f2.y1', 'loading.f1.y2', ...
  
              loading_mask = loading_indices[
                  i * k_factors : (i + 1) * k_factors
              ]
              loading_masks.append(loading_mask)
  
              # 2. Exog
              # Recall these are in the form:
              # beta.x1.y1, beta.x2.y1, beta.x1.y2, ...
              exog_mask = exog_indices[i * k_exog : (i + 1) * k_exog]
              exog_masks.append(exog_mask)
  
              # Create the table
              mask = np.concatenate([loading_mask, exog_mask])
              title = (
                  "Results for equation %s" % self.model.endog_names[i]
              )
              table = make_table(self, mask, title)
              summary.tables.append(table)
  
          # Add parameter tables for each factor
          factor_indices = indices[self.model._params_factor_transition]
          factor_masks = []
          if factor_order > 0:
              for i in range(k_factors):
                  start = i * _factor_order
                  factor_mask = factor_indices[
                      start : start + _factor_order
                  ]
                  factor_masks.append(factor_mask)
  
                  # Create the table
                  title = "Results for factor equation f%d" % (i + 1)
                  table = make_table(self, factor_mask, title)
                  summary.tables.append(table)
  
          # Add parameter tables for error transitions
          error_masks = []
          if spec.error_order > 0:
              error_indices = indices[
                  self.model._params_error_transition
              ]
              for i in range(k_endog):
                  if spec.error_var:
                      start = i * _error_order
                      end = (i + 1) * _error_order
                  else:
                      start = i * spec.error_order
                      end = (i + 1) * spec.error_order
  
                  error_mask = error_indices[start:end]
                  error_masks.append(error_mask)
  
                  # Create the table
                  title = (
                      "Results for error equation e(%s)"
                      % self.model.endog_names[i]
                  )
                  table = make_table(self, error_mask, title)
                  summary.tables.append(table)
  
          # Error covariance terms
          error_cov_mask = indices[self.model._params_error_cov]
          table = make_table(
              self,
              error_cov_mask,
              "Error covariance matrix",
              strip_end=False,
          )
          summary.tables.append(table)
  
          # Add a table for all other parameters
          masks = []
          for m in (
              loading_masks,
              exog_masks,
              factor_masks,
              error_masks,
              [error_cov_mask],
          ):
              m = np.array(m).flatten()
              if len(m) > 0:
                  masks.append(m)
          masks = np.concatenate(masks)
          inverse_mask = np.array(
              list(set(indices).difference(set(masks)))
          )
          if len(inverse_mask) > 0:
              table = make_table(
                  self,
                  inverse_mask,
                  "Other parameters",
                  strip_end=False,
              )
              summary.tables.append(table)
  
      return summary
  
imports: import numpy
  from .mlemodel import MLEModel, MLEResults, MLEResultsWrapper
  from .tools import is_invertible, prepare_exog, constrain_stationary_univariate, unconstrain_stationary_univariate, constrain_stationary_multivariate, unconstrain_stationary_multivariate
  from statsmodels.multivariate.pca import PCA
  from statsmodels.regression.linear_model import OLS
  from statsmodels.tsa.vector_ar.var_model import VAR
  from statsmodels.tsa.arima.model import ARIMA
  from statsmodels.tools.tools import Bunch
  from statsmodels.tools.data import _is_using_pandas
  from statsmodels.tsa.tsatools import lagmat
  from statsmodels.tools.decorators import cache_readonly
  import statsmodels.base.wrapper
  from statsmodels.compat.pandas import Appender
label_desc: Use image node_id 5 for calling the DynamicFactorResults obj's underlying member method code with example usage: obj.summary(alpha, start, separate_params) and returns: summary, summary_params