class_docstr: Inherits time series methods from TSM class.
  
  **** GENERALIZED AUTOREGRESSIVE SCORE E(X)OGENOUS VARIABLE (GASX) MODELS ****
  
  Parameters
  ----------
  data : pd.DataFrame or np.array
      Field to specify the time series data that will be used.
  
  formula : string
      patsy string describing the regression
  
  ar : int
      Field to specify how many AR lags the model will have.
  
  sc : int
      Field to specify how many score lags terms the model will have.
  
  integ : int (default : 0)
      Specifies how many time to difference the time series.
  
  dist : str
      Which distribution to use
code: def __init__(self, data, formula, ar, sc, family, integ=0):
      # Initialize TSM object
      super(GASX, self).__init__("GASX")
  
      self.ar = ar
      self.sc = sc
      self.integ = integ
      self.z_no = self.ar + self.sc
      self.max_lag = max(self.ar, self.sc)
      self._z_hide = (
          0  # Whether to cutoff variance latent variables from results
      )
      self.supported_methods = ["MLE", "PML", "Laplace", "M-H", "BBVI"]
      self.default_method = "MLE"
      self.multivariate_model = False
  
      # Format the data
      self.is_pandas = True  # This is compulsory for this model type
      self.data_original = data.copy()
      self.formula = formula
      self.y, self.X = dmatrices(formula, data)
      self.y_name = self.y.design_info.describe()
      self.X_names = self.X.design_info.describe().split(" + ")
      self.y = self.y.astype(np.float)
      self.X = self.X.astype(np.float)
      self.param_no = self.X.shape[1]
      self.data_name = self.y_name
      self.y = np.array([self.y]).ravel()
      self.data = self.y.copy()
      self.X = np.array([self.X])[0]
      self.index = data.index
  
      # Difference data
      for order in range(0, self.integ):
          self.y = np.diff(self.y)
          self.data = np.diff(self.data)
          self.data_name = "Differenced " + self.data_name
  
      self.data_length = self.data.shape[0]
      self._create_model_matrices()
      self._create_latent_variables()
  
      self.family = family
  
      (
          self.model_name2,
          self.link,
          self.scale,
          self.shape,
          self.skewness,
          self.mean_transform,
          self.cythonized,
      ) = self.family.setup()
  
      # Identify whether model has cythonized backend - then choose update type
      if self.cythonized is True:
          self._model = self._cythonized_model
          self._mb_model = self._cythonized_mb_model
          if self.family.gradient_only is True:
              self.recursion = self.family.gradientx_recursion()
          else:
              self.recursion = self.family.newtonx_recursion()
      else:
          self._model = self._uncythonized_model
          self._mb_model = self._uncythonized_mb_model
  
      self.model_name = (
          self.model_name2
          + " GAS X("
          + str(self.ar)
          + ","
          + str(self.integ)
          + ","
          + str(self.sc)
          + ")"
      )
  
      # Build any remaining latent variables that are specific to the family chosen
      for no, i in enumerate(self.family.build_latent_variables()):
          self.latent_variables.add_z(i[0], i[1], i[2])
          self.latent_variables.z_list[
              no + self.ar + self.sc + self.X.shape[1]
          ].start = i[3]
  
      self.family_z_no = len(self.family.build_latent_variables())
      self.latent_variables.z_list[0].start = self.mean_transform(
          np.mean(self.data)
      )
      self.z_no = len(self.latent_variables.z_list)
  
imports: import sys
  import numpy
  import pandas
  import scipy.stats
  import scipy.special
  from patsy import dmatrices, dmatrix, demo_data
  from ..None import families
  from ..None import tsm
  from ..None import data_check
  from .gas_core_recursions import gasx_recursion
label_desc: Use image node_id 1 to create a new GASX object from inherited base classes: tsm with example: obj = GASX(data, formula, ar, sc, family, integ)