code: def score_debug(
      self,
      X: DataFrame,
      y=None,
      extra_info=False,
      compute_oracle=False,
      extra_metrics=None,
      decision_threshold=None,
      skip_score=False,
      refit_full=None,
      set_refit_score_to_parent=False,
      display=False,
  ):
      leaderboard_df = self.leaderboard(
          extra_info=extra_info,
          refit_full=refit_full,
          set_refit_score_to_parent=set_refit_score_to_parent,
          display=display,
      )
      if extra_metrics is None:
          extra_metrics = []
      if y is None:
          error_if_missing = extra_metrics or not skip_score
          X, y = self.extract_label(
              X, error_if_missing=error_if_missing
          )
      w = None
      if self.weight_evaluation:
          X, w = extract_column(X, self.sample_weight)
  
      X = self.transform_features(X)
      if y is not None:
          self._validate_class_labels(y)
          y_internal = self.label_cleaner.transform(y)
          y_internal = y_internal.fillna(-1)
      else:
          y_internal = None
  
      trainer = self.load_trainer()
      scores = {}
      leaderboard_models = set(leaderboard_df["model"].tolist())
      all_trained_models = trainer.get_model_names()
      all_trained_models = [
          m for m in all_trained_models if m in leaderboard_models
      ]
      all_trained_models_can_infer = trainer.get_model_names(
          models=all_trained_models, can_infer=True
      )
      all_trained_models_original = all_trained_models.copy()
      (
          model_pred_proba_dict,
          pred_time_test_marginal,
      ) = trainer.get_model_pred_proba_dict(
          X=X,
          models=all_trained_models_can_infer,
          record_pred_time=True,
      )
  
      if compute_oracle:
          pred_probas = list(model_pred_proba_dict.values())
          ensemble_selection = EnsembleSelection(
              ensemble_size=100,
              problem_type=trainer.problem_type,
              metric=self.eval_metric,
              quantile_levels=self.quantile_levels,
          )
          ensemble_selection.fit(
              predictions=pred_probas,
              labels=y_internal,
              identifiers=None,
              sample_weight=w,
          )  # TODO: Only fit non-nan
  
          oracle_weights = ensemble_selection.weights_
          oracle_pred_time_start = time.time()
          oracle_pred_proba_norm = [
              pred * weight
              for pred, weight in zip(pred_probas, oracle_weights)
          ]
          oracle_pred_proba_ensemble = np.sum(
              oracle_pred_proba_norm, axis=0
          )
          oracle_pred_time = time.time() - oracle_pred_time_start
          model_pred_proba_dict[
              "OracleEnsemble"
          ] = oracle_pred_proba_ensemble
          pred_time_test_marginal["OracleEnsemble"] = oracle_pred_time
          all_trained_models.append("OracleEnsemble")
  
      scoring_args = dict(y=y, y_internal=y_internal, sample_weight=w)
  
      extra_scores = {}
      for (
          model_name,
          y_pred_proba_internal,
      ) in model_pred_proba_dict.items():
          if skip_score:
              scores[model_name] = np.nan
          else:
              scores[model_name] = self._score_with_pred_proba(
                  y_pred_proba_internal=y_pred_proba_internal,
                  metric=self.eval_metric,
                  decision_threshold=decision_threshold,
                  **scoring_args,
              )
          for metric in extra_metrics:
              metric = get_metric(
                  metric, self.problem_type, "leaderboard_metric"
              )
              if metric.name not in extra_scores:
                  extra_scores[metric.name] = {}
              extra_scores[metric.name][
                  model_name
              ] = self._score_with_pred_proba(
                  y_pred_proba_internal=y_pred_proba_internal,
                  metric=metric,
                  decision_threshold=decision_threshold,
                  **scoring_args,
              )
  
      if extra_scores:
          series = []
          for metric in extra_scores:
              series.append(
                  pd.Series(extra_scores[metric], name=metric)
              )
          df_extra_scores = pd.concat(series, axis=1)
          extra_metrics_names = list(df_extra_scores.columns)
          df_extra_scores["model"] = df_extra_scores.index
          df_extra_scores = df_extra_scores.reset_index(drop=True)
      else:
          df_extra_scores = None
          extra_metrics_names = None
  
      pred_time_test = {}
      # TODO: Add support for calculating pred_time_test_full for oracle_ensemble, need to copy graph from trainer and add oracle_ensemble to it with proper edges.
      for model in model_pred_proba_dict.keys():
          if model in all_trained_models_original:
              base_model_set = trainer.get_minimum_model_set(model)
              if len(base_model_set) == 1:
                  pred_time_test[model] = pred_time_test_marginal[
                      base_model_set[0]
                  ]
              else:
                  pred_time_test_full_num = 0
                  for base_model in base_model_set:
                      pred_time_test_full_num += (
                          pred_time_test_marginal[base_model]
                      )
                  pred_time_test[model] = pred_time_test_full_num
          else:
              pred_time_test[model] = None
  
      scored_models = list(scores.keys())
      for model in all_trained_models:
          if model not in scored_models:
              scores[model] = None
              pred_time_test[model] = None
              pred_time_test_marginal[model] = None
  
      logger.debug("Model scores:")
      logger.debug(str(scores))
      model_names_final = list(scores.keys())
      df = pd.DataFrame(
          data={
              "model": model_names_final,
              "score_test": list(scores.values()),
              "pred_time_test": [
                  pred_time_test[model] for model in model_names_final
              ],
              "pred_time_test_marginal": [
                  pred_time_test_marginal[model]
                  for model in model_names_final
              ],
          }
      )
      if df_extra_scores is not None:
          df = pd.merge(df, df_extra_scores, on="model", how="left")
  
      df_merged = pd.merge(df, leaderboard_df, on="model", how="left")
      df_merged = df_merged.sort_values(
          by=[
              "score_test",
              "pred_time_test",
              "score_val",
              "pred_time_val",
              "model",
          ],
          ascending=[False, True, False, True, False],
      ).reset_index(drop=True)
      df_columns_lst = df_merged.columns.tolist()
      explicit_order = [
          "model",
          "score_test",
      ]
      if extra_metrics_names is not None:
          explicit_order += extra_metrics_names
      explicit_order += [
          "score_val",
          "eval_metric",
          "pred_time_test",
          "pred_time_val",
          "fit_time",
          "pred_time_test_marginal",
          "pred_time_val_marginal",
          "fit_time_marginal",
          "stack_level",
          "can_infer",
          "fit_order",
      ]
      df_columns_other = [
          column
          for column in df_columns_lst
          if column not in explicit_order
      ]
      df_columns_new = explicit_order + df_columns_other
      df_merged = df_merged[df_columns_new]
  
      return df_merged
  
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 26 for calling the AbstractTabularLearner obj's underlying member method code with example usage: obj.score_debug(X, y, extra_info, compute_oracle, extra_metrics, decision_threshold, skip_score, refit_full, set_refit_score_to_parent, display) and returns: df_merged