class_docstr: Abstract class for local forecasting models that are trained separately for each time series.
  
  Prediction is parallelized across CPU cores using joblib.Parallel.
  
  Attributes
  ----------
  allowed_local_model_args : List[str]
      Argument that can be passed to the underlying local model.
  default_n_jobs : Union[int, float]
      Default number of CPU cores used to train models. If float, this fraction of CPU cores will be used.
  default_max_ts_length : Optional[int]
      If not None, only the last ``max_ts_length`` time steps of each time series will be used to train the model.
      This significantly speeds up fitting and usually leads to no change in accuracy.
  init_time_in_seconds : int
      Time that it takes to initialize the model in seconds (e.g., because of JIT compilation by Numba).
      If time_limit is below this number, model won't be trained.
code: def _fit(
      self,
      train_data: TimeSeriesDataFrame,
      time_limit: Optional[int] = None,
      verbosity: int = 2,
      **kwargs,
  ):
      self._check_fit_params()
      set_logger_verbosity(verbosity, logger=logger)
  
      if (
          time_limit is not None
          and time_limit < self.init_time_in_seconds
      ):
          raise TimeLimitExceeded
  
      # Initialize parameters passed to each local model
      raw_local_model_args = self._get_model_params().copy()
  
      unused_local_model_args = []
      local_model_args = {}
      for key, value in raw_local_model_args.items():
          if key in self.allowed_local_model_args:
              local_model_args[key] = value
          else:
              unused_local_model_args.append(key)
  
      if len(unused_local_model_args):
          logger.warning(
              f"{self.name} ignores following hyperparameters: {unused_local_model_args}. "
              f"See the docstring of {self.name} for the list of supported hyperparameters."
          )
  
      if (
          "seasonal_period" not in local_model_args
          or local_model_args["seasonal_period"] is None
      ):
          local_model_args["seasonal_period"] = get_seasonality(
              train_data.freq
          )
      self._seasonal_period = local_model_args["seasonal_period"]
  
      self._local_model_args = self._update_local_model_args(
          local_model_args=local_model_args
      )
      self.time_limit = time_limit
      return self
  
imports: import logging
  import time
  from multiprocessing import TimeoutError, cpu_count
  from typing import Any, Dict, List, Optional, Tuple, Union
  import numpy
  import pandas
  from joblib import Parallel, delayed
  from scipy.stats import norm
  from autogluon.common.utils.log_utils import set_logger_verbosity
  from autogluon.core.utils.exceptions import TimeLimitExceeded
  from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
  from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
  from autogluon.timeseries.utils.datetime import get_seasonality
  from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
  from autogluon.timeseries.utils.warning_filters import warning_filter
label_desc: Use image node_id 2 for calling the AbstractLocalModel obj's underlying member method code with example usage: obj._fit(train_data, time_limit, verbosity) and returns: self