code: def estimate(self):
      from . import Keras_Models as tskeras
      from . import Scikit_Models as tsscikit
      from . import Intermittent_Models as interm
  
      logger = tsutil.get_pyaf_logger()
      mARList = {}
      lNeedExogenous = False
      for trend in self.mTrendList:
          for cycle in self.mCycleList[trend]:
              cycle_residue = cycle.getCycleResidueName()
              if self.mOptions.mDebug:
                  self.check_not_nan(
                      self.mCycleFrame[cycle_residue], cycle_residue
                  )
              self.mARList[cycle_residue] = []
              if self.mOptions.mActiveAutoRegressions["NoAR"]:
                  self.mARList[cycle_residue] = [cZeroAR(cycle_residue)]
              lLags = self.mCycleFrame[cycle_residue].shape[0] // 4
              if lLags >= self.mOptions.mMaxAROrder:
                  lLags = self.mOptions.mMaxAROrder
              if (self.mCycleFrame[cycle_residue].shape[0] > 12) and (
                  self.mCycleFrame[cycle_residue].std() > 0.00001
              ):
                  if self.mOptions.mActiveAutoRegressions["AR"]:
                      lAR = tsscikit.cAutoRegressiveModel(
                          cycle_residue, lLags
                      )
                      self.mARList[cycle_residue] = self.mARList[
                          cycle_residue
                      ] + [lAR]
                  if self.mOptions.mActiveAutoRegressions["ARX"] and (
                      self.mExogenousInfo is not None
                  ):
                      lARX = tsscikit.cAutoRegressiveModel(
                          cycle_residue, lLags, self.mExogenousInfo
                      )
                      self.mARList[cycle_residue] = self.mARList[
                          cycle_residue
                      ] + [lARX]
                      lNeedExogenous = True
                  if self.mOptions.mActiveAutoRegressions["LSTM"]:
                      if self.mOptions.canBuildKerasModel("LSTM"):
                          lLSTM = tskeras.cLSTM_Model(
                              cycle_residue, lLags, self.mExogenousInfo
                          )
                          self.mARList[cycle_residue] = self.mARList[
                              cycle_residue
                          ] + [lLSTM]
                      else:
                          logger.debug(
                              "SKIPPING_MODEL_WITH_KERAS '" + "LSTM"
                          )
  
                  if self.mOptions.mActiveAutoRegressions["MLP"]:
                      if self.mOptions.canBuildKerasModel("MLP"):
                          lMLP = tskeras.cMLP_Model(
                              cycle_residue, lLags, self.mExogenousInfo
                          )
                          self.mARList[cycle_residue] = self.mARList[
                              cycle_residue
                          ] + [lMLP]
                      else:
                          logger.debug(
                              "SKIPPING_MODEL_WITH_KERAS '" + "MLP"
                          )
  
                  if self.mOptions.mActiveAutoRegressions["SVR"]:
                      lSVR = tsscikit.cSVR_Model(cycle_residue, lLags)
                      self.mARList[cycle_residue] = self.mARList[
                          cycle_residue
                      ] + [lSVR]
                  if self.mOptions.mActiveAutoRegressions["SVRX"] and (
                      self.mExogenousInfo is not None
                  ):
                      lSVRX = tsscikit.cSVR_Model(
                          cycle_residue, lLags, self.mExogenousInfo
                      )
                      self.mARList[cycle_residue] = self.mARList[
                          cycle_residue
                      ] + [lSVRX]
                      lNeedExogenous = True
                  if self.mOptions.mActiveAutoRegressions["XGB"]:
                      lXGB = tsscikit.cXGBoost_Model(
                          cycle_residue, lLags
                      )
                      self.mARList[cycle_residue] = self.mARList[
                          cycle_residue
                      ] + [lXGB]
                  if self.mOptions.mActiveAutoRegressions["XGBX"] and (
                      self.mExogenousInfo is not None
                  ):
                      lXGBX = tsscikit.cXGBoost_Model(
                          cycle_residue, lLags, self.mExogenousInfo
                      )
                      self.mARList[cycle_residue] = self.mARList[
                          cycle_residue
                      ] + [lXGBX]
                      lNeedExogenous = True
                  if self.mOptions.mActiveAutoRegressions["CROSTON"]:
                      lIsSignalIntermittent = (
                          interm.is_signal_intermittent(
                              self.mCycleFrame[cycle_residue],
                              self.mOptions,
                          )
                      )
                      if lIsSignalIntermittent:
                          lCroston = interm.cCroston_Model(
                              cycle_residue, lLags
                          )
                          self.mARList[cycle_residue] = self.mARList[
                              cycle_residue
                          ] + [lCroston]
              if len(self.mARList[cycle_residue]) == 0:
                  self.mARList[cycle_residue] = [cZeroAR(cycle_residue)]
  
      if lNeedExogenous:
          if self.mOptions.mDebugProfile:
              logger.info(
                  "AR_MODEL_ADD_EXOGENOUS '"
                  + str(self.mCycleFrame.shape[0])
                  + " "
                  + str(len(self.mExogenousInfo.mEncodedExogenous))
              )
          self.mCycleFrame = self.mExogenousInfo.transformDataset(
              self.mCycleFrame
          )
  
      for cycle_residue in self.mARList.keys():
          self.estimate_ar_models_for_cycle(cycle_residue)
          for autoreg in self.mARList[cycle_residue]:
              autoreg.mARFrame = pd.DataFrame()
          del self.mARFrame
  
imports: import pandas
  import numpy
  from .None import Time
  from .None import Perf
  from .None import Plots
  from .None import Utils
  import time
label_desc: Use image node_id 9 for calling the cAutoRegressiveEstimator obj's underlying member method code with example usage: obj.estimate() without return types