class_docstr: Inherits time series methods from TSM class.
  
  **** DYNAMIC REGRESSION MODEL ****
  
  Parameters
  ----------
  
  formula : string
      patsy string describing the regression
  
  data : pd.DataFrame
      Field to specify the data that will be used
docstr: Plots the fit of the model
  
  Parameters
  ----------
  intervals : Boolean
      Whether to plot 95% confidence interval of states
  
  Returns
  ----------
  None (plots data and the fit)
docstr_tok: ["Plots","the","fit","of","the","model","Parameters","--","--","--","--","--","intervals",":","Boolean","Whether","to","plot","95","%","confidence","interval","of","states","Returns","--","--","--","--","--","None","(","plots","data","and","the","fit",")"]
code: def plot_fit(self, intervals=False, **kwargs):
      """Plots the fit of the model
  
      Parameters
      ----------
      intervals : Boolean
          Whether to plot 95% confidence interval of states
  
      Returns
      ----------
      None (plots data and the fit)
      """
      import matplotlib.pyplot as plt
      import seaborn as sns
  
      figsize = kwargs.get("figsize", (10, 7))
      series_type = kwargs.get("series_type", "Smoothed")
  
      if self.latent_variables.estimated is False:
          raise Exception("No latent variables estimated!")
      else:
          date_index = copy.deepcopy(self.index)
          date_index = date_index[: self.y.shape[0] + 1]
  
          if series_type == "Smoothed":
              mu, V = self.smoothed_state(
                  self.data, self.latent_variables.get_z_values()
              )
          elif series_type == "Filtered":
              mu, V, _, _, _ = self._model(
                  self.data, self.latent_variables.get_z_values()
              )
          else:
              mu, V = self.smoothed_state(
                  self.data, self.latent_variables.get_z_values()
              )
  
          # Create smoothed/filtered aggregate series
          _, Z, _, _, _ = self._ss_matrices(
              self.latent_variables.get_z_values()
          )
          smoothed_series = np.zeros(self.y.shape[0])
  
          for t in range(0, self.y.shape[0]):
              smoothed_series[t] = np.dot(Z[t], mu[:, t])
  
          plt.figure(figsize=figsize)
  
          plt.subplot(self.z_no + 1, 1, 1)
          plt.title(self.y_name + " Raw and " + series_type)
          plt.plot(date_index, self.data, label="Data")
          plt.plot(
              date_index, smoothed_series, label=series_type, c="black"
          )
          plt.legend(loc=2)
  
          for coef in range(0, self.z_no - 1):
              V_coef = V[0][coef][:-1]
              plt.subplot(self.z_no + 1, 1, 2 + coef)
              plt.title("Beta " + self.X_names[coef])
  
              if intervals == True:
                  alpha = [
                      0.15 * i / float(100) for i in range(50, 12, -2)
                  ]
                  plt.fill_between(
                      date_index[5:],
                      mu[coef, 0 : mu.shape[1] - 1][5:]
                      + 1.98 * np.sqrt(V_coef[5:]),
                      mu[coef, 0 : mu.shape[1] - 1][5:]
                      - 1.98 * np.sqrt(V_coef[5:]),
                      alpha=0.15,
                      label="95% C.I.",
                  )
              plt.plot(
                  date_index,
                  mu[coef, 0 : mu.shape[1] - 1],
                  label="Data",
              )
              plt.legend(loc=2)
  
          plt.subplot(self.z_no + 1, 1, self.z_no + 1)
          plt.title("Measurement Error")
          plt.plot(
              date_index, self.data - smoothed_series, label="Irregular"
          )
          plt.legend(loc=2)
  
          plt.show()
  
imports: import copy
  import sys
  import numpy
  import pandas
  import scipy.stats
  from patsy import dmatrices, dmatrix, demo_data
  from ..None import families
  from ..None import tsm
  from ..None import data_check
  from .kalman import *
label_desc: Use image node_id 9 for calling the DynReg obj's underlying member method code with example usage: obj.plot_fit(intervals) without return types