code: def train(self, iInputDS, iTime, iSignal, iHorizon, iTransformation):
      logger = tsutil.get_pyaf_logger()
  
      start_time = time.time()
      self.setParams(
          iInputDS,
          iTime,
          iSignal,
          iHorizon,
          iTransformation,
          self.mExogenousData,
      )
  
      self.run_gc()
  
      # estimate time info
      # assert(self.mTimeInfo.mSignalFrame.shape[0] == iInputDS.shape[0])
      self.mSplit.estimate()
      self.mTimeInfo.estimate()
  
      exog_start_time = time.time()
      if self.mExogenousInfo is not None:
          self.mExogenousInfo.fit()
          if self.mOptions.mDebugProfile:
              logger.info(
                  "EXOGENOUS_ENCODING_TIME_IN_SECONDS "
                  + str(self.mSignal)
                  + " "
                  + str(time.time() - exog_start_time)
              )
  
      # estimate the trend
  
      lTrendEstimator = tstr.cTrendEstimator()
      lTrendEstimator.mSignalFrame = self.mSignalFrame
      lTrendEstimator.mTimeInfo = self.mTimeInfo
      lTrendEstimator.mSplit = self.mSplit
      lTrendEstimator.mOptions = self.mOptions
  
      trend_start_time = time.time()
      lTrendEstimator.estimateTrend()
      # lTrendEstimator.plotTrend();
      if self.mOptions.mDebugProfile:
          logger.info(
              "TREND_TIME_IN_SECONDS "
              + str(self.mSignal)
              + " "
              + str(time.time() - trend_start_time)
          )
  
      # estimate cycles
      cycle_start_time = time.time()
  
      lCycleEstimator = tscy.cCycleEstimator()
      lCycleEstimator.mTrendFrame = lTrendEstimator.mTrendFrame
      lCycleEstimator.mTrendList = lTrendEstimator.mTrendList
  
      del lTrendEstimator
      self.run_gc()
  
      lCycleEstimator.mTimeInfo = self.mTimeInfo
      lCycleEstimator.mSplit = self.mSplit
      lCycleEstimator.mOptions = self.mOptions
  
      lCycleEstimator.estimateAllCycles()
      # if(self.mOptions.mDebugCycles):
      # lCycleEstimator.plotCycles();
      if self.mOptions.mDebugProfile:
          logger.info(
              "CYCLE_TIME_IN_SECONDS "
              + str(self.mSignal)
              + " "
              + str(str(time.time() - cycle_start_time))
          )
  
      # autoregressive
      ar_start_time = time.time()
      lAREstimator = tsar.cAutoRegressiveEstimator()
      lAREstimator.mCycleFrame = lCycleEstimator.mCycleFrame
      lAREstimator.mTrendList = lCycleEstimator.mTrendList
      lAREstimator.mCycleList = lCycleEstimator.mCycleList
  
      del lCycleEstimator
      self.run_gc()
  
      lAREstimator.mTimeInfo = self.mTimeInfo
      lAREstimator.mSplit = self.mSplit
      lAREstimator.mExogenousInfo = self.mExogenousInfo
      lAREstimator.mOptions = self.mOptions
      lAREstimator.estimate()
      # lAREstimator.plotAR();
      if self.mOptions.mDebugProfile:
          logger.info(
              "AUTOREG_TIME_IN_SECONDS "
              + str(self.mSignal)
              + " "
              + str(str(time.time() - ar_start_time))
          )
      # forecast perfs
  
      perf_start_time = time.time()
      lModels = {}
      for trend in lAREstimator.mTrendList:
          for cycle in lAREstimator.mCycleList[trend]:
              cycle_residue = cycle.getCycleResidueName()
              for autoreg in lAREstimator.mARList[cycle_residue]:
                  lModel = tsmodel.cTimeSeriesModel(
                      self.mTransformation, trend, cycle, autoreg
                  )
                  lModels[lModel.mOutName] = lModel
  
      del lAREstimator
      self.updatePerfsForAllModels(lModels)
  
      if self.mOptions.mDebugProfile:
          logger.info(
              "PERF_TIME_IN_SECONDS "
              + str(self.mSignal)
              + " "
              + str(len(lModels))
              + " "
              + str(str(time.time() - perf_start_time))
          )
  
      if self.mOptions.mDebugProfile:
          logger.info(
              "TRAINING_TIME_IN_SECONDS "
              + str(self.mSignal)
              + " "
              + str(time.time() - start_time)
          )
      self.run_gc()
  
imports: import pandas
  import numpy
  import traceback
  import dill
  from pathos.multiprocessing import ProcessingPool
  import time
  import threading
  from .None import Time
  from .None import Exogenous
  from .None import MissingData
  from .None import Signal_Transformation
  from .None import Perf
  from .None import SignalDecomposition_Trend
  from .None import SignalDecomposition_Cycle
  from .None import SignalDecomposition_AR
  from .None import Options
  from .None import TimeSeriesModel
  from .None import TimeSeries_Cutting
  from .None import Utils
  import copy
label_desc: Use image node_id 8 for calling the cSignalDecompositionOneTransform obj's underlying member method code with example usage: obj.train(iInputDS, iTime, iSignal, iHorizon, iTransformation) without return types