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 __init__(
      self,
      freq: Optional[str] = None,
      prediction_length: int = 1,
      path: Optional[str] = None,
      name: Optional[str] = None,
      eval_metric: str = None,
      hyperparameters: Dict[str, Any] = None,
      **kwargs,  # noqa
  ):
      if hyperparameters is None:
          hyperparameters = {}
      else:
          hyperparameters = hyperparameters.copy()
      # TODO: Replace with 'num_cpus' argument passed to fit (after predictor API is changed)
      n_jobs = hyperparameters.pop("n_jobs", self.default_n_jobs)
      if isinstance(n_jobs, float) and 0 < n_jobs <= 1:
          self.n_jobs = max(int(cpu_count() * n_jobs), 1)
      elif isinstance(n_jobs, int):
          self.n_jobs = n_jobs
      else:
          raise ValueError(
              f"n_jobs must be a float between 0 and 1 or an integer (received n_jobs = {n_jobs})"
          )
      # Default values, potentially overridden inside _fit()
      self.use_fallback_model = hyperparameters.pop(
          "use_fallback_model", True
      )
      self.max_ts_length = hyperparameters.pop(
          "max_ts_length", self.default_max_ts_length
      )
  
      super().__init__(
          path=path,
          freq=freq,
          prediction_length=prediction_length,
          name=name,
          eval_metric=eval_metric,
          hyperparameters=hyperparameters,
          **kwargs,
      )
  
      self._local_model_args: Dict[str, Any] = None
      self._seasonal_period: Optional[int] = None
      self.time_limit: Optional[float] = None
  
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 1 to create a new AbstractLocalModel object from inherited base classes: AbstractTimeSeriesModel with example: obj = AbstractLocalModel(freq, prediction_length, path, name, eval_metric, hyperparameters)