code: def __init__(
      self,
      path_context: str,
      label: str,
      feature_generator: PipelineFeatureGenerator,
      ignored_columns: list = None,
      label_count_threshold=10,
      problem_type=None,
      quantile_levels=None,
      eval_metric=None,
      positive_class=None,
      cache_data=True,
      is_trainer_present=False,
      random_state=0,
      sample_weight=None,
      weight_evaluation=False,
      groups=None,
  ):
      super().__init__(
          path_context=path_context, random_state=random_state
      )
      self.label = label
      self.ignored_columns = ignored_columns
      if self.ignored_columns is None:
          self.ignored_columns = []
      self.threshold = label_count_threshold
      self.problem_type = problem_type
      self.eval_metric = get_metric(
          eval_metric, self.problem_type, "eval_metric"
      )
  
      if self.problem_type == QUANTILE and quantile_levels is None:
          raise ValueError(
              "if `problem_type='quantile'`, `quantile_levels` has to be specified"
          )
      if isinstance(quantile_levels, float):
          quantile_levels = [quantile_levels]
      if isinstance(quantile_levels, Iterable):
          for quantile in quantile_levels:
              if quantile <= 0.0 or quantile >= 1.0:
                  raise ValueError(
                      "quantile values have to be non-negative and less than 1.0 (0.0 < q < 1.0). "
                      "For example, 0.95 quantile = 95 percentile"
                  )
          quantile_levels = np.sort(np.array(quantile_levels))
      self.quantile_levels = quantile_levels
  
      self.cache_data = cache_data
      if not self.cache_data:
          logger.log(
              30,
              "Warning: `cache_data=False` will disable or limit advanced functionality after training such as feature importance calculations. It is recommended to set `cache_data=True` unless you explicitly wish to not have the data saved to disk.",
          )
      self.is_trainer_present = is_trainer_present
  
      self.cleaner = None
      self.label_cleaner: LabelCleaner = None
      self.feature_generator: PipelineFeatureGenerator = (
          feature_generator
      )
  
      self._original_features = None
      self._pre_X_rows = None
      self._post_X_rows = None
      self._positive_class = positive_class
      self.sample_weight = sample_weight
      self.weight_evaluation = weight_evaluation
      self.groups = groups
      if sample_weight is not None and not isinstance(
          sample_weight, str
      ):
          raise ValueError(
              "sample_weight must be a string indicating the name of the column that contains sample weights. If you have a vector of sample weights, first add these as an extra column to your data."
          )
      if weight_evaluation and sample_weight is None:
          raise ValueError(
              "Must specify sample_weight column if you specify weight_evaluation=True"
          )
      if groups is not None and not isinstance(groups, str):
          raise ValueError(
              "groups must be a string indicating the name of the column that contains the split groups. If you have a vector of split groups, first add these as an extra column to your data."
          )
  
imports: from __future__ import annotations
  import copy
  import json
  import logging
  import time
  from collections.abc import Iterable
  from typing import List, Union
  import numpy
  import pandas
  from pandas import DataFrame, Series
  from sklearn.metrics import classification_report
  from autogluon.core.constants import AUTO_WEIGHT, BALANCE_WEIGHT, BINARY, MULTICLASS, QUANTILE, REGRESSION
  from autogluon.core.data.label_cleaner import LabelCleaner, LabelCleanerMulticlassToBinary
  from autogluon.core.learner import AbstractLearner
  from autogluon.core.metrics import Scorer, confusion_matrix, get_metric
  from autogluon.core.models.greedy_ensemble.ensemble_selection import EnsembleSelection
  from autogluon.core.utils import augment_rare_classes, compute_weighted_metric, extract_column, get_leaderboard_pareto_frontier, get_pred_from_proba, get_pred_from_proba_df, infer_problem_type
  from autogluon.features.generators import PipelineFeatureGenerator
label_desc: Use image node_id 1 to create a new AbstractTabularLearner object from inherited base classes: AbstractLearner with example: obj = AbstractTabularLearner(path_context, label, feature_generator, ignored_columns, label_count_threshold, problem_type, quantile_levels, eval_metric, positive_class, cache_data, is_trainer_present, random_state, sample_weight, weight_evaluation, groups)