autogluon.tabular 1.4.1b20251214__py3-none-any.whl → 1.5.0b20251222__py3-none-any.whl

autogluon/tabular/models/tabprep/prep_mixin.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import logging
+from typing import Type
+
+import numpy as np
+import pandas as pd
+
+from autogluon.features import ArithmeticFeatureGenerator
+from autogluon.features import CategoricalInteractionFeatureGenerator
+from autogluon.features import OOFTargetEncodingFeatureGenerator
+from autogluon.features import BulkFeatureGenerator
+from autogluon.features.generators.abstract import AbstractFeatureGenerator
+
+logger = logging.getLogger(__name__)
+
+# TODO: In future we can have a feature generator registry like what is done for models
+_feature_generator_class_lst = [
+    ArithmeticFeatureGenerator,
+    CategoricalInteractionFeatureGenerator,
+    OOFTargetEncodingFeatureGenerator,
+]
+
+_feature_generator_class_map = {
+    feature_generator_cls.__name__: feature_generator_cls for feature_generator_cls in _feature_generator_class_lst
+}
+
+
+def _recursive_expand_prep_param(prep_param: tuple | list[list | tuple]) -> list[tuple]:
+    if isinstance(prep_param, list):
+        if len(prep_param) == 0:
+            param_type = "list"
+        elif len(prep_param) == 2:
+            if isinstance(prep_param[0], (str, AbstractFeatureGenerator)):
+                param_type = "generator"
+            else:
+                param_type = "list"
+        else:
+            param_type = "list"
+    elif isinstance(prep_param, tuple):
+        param_type = "generator"
+    else:
+        raise ValueError(f"Invalid value for prep_param: {prep_param}")
+    if param_type == "list":
+        out = []
+        for p in prep_param:
+            out += _recursive_expand_prep_param(p)
+        return out
+    elif param_type == "generator":
+        return [prep_param]
+    else:
+        raise ValueError(f"Invalid value for prep_param: {prep_param}")
+
+
+# FIXME: Why is preprocessing twice as slow per fold when bagging LightGBM??? Need to investigate. Try sequential fold fit
+# TODO: Why is `prep_params` a dict instead of a list?
+class ModelAgnosticPrepMixin:
+    def _estimate_dtypes_after_preprocessing(self, X: pd.DataFrame, **kwargs) -> int:
+        prep_params = self._get_ag_params().get("prep_params", None)
+        if prep_params is None:
+            prep_params = []
+
+        # FIXME: Temporarily simplify for memory calculation
+        prep_params = _recursive_expand_prep_param(prep_params)
+
+        X_nunique = X.nunique().values
+        n_categorical = X.select_dtypes(exclude=[np.number]).shape[1]
+        n_numeric = X.loc[:, X_nunique > 2].select_dtypes(include=[np.number]).shape[1]
+        n_binary = X.loc[:, X_nunique <= 2].select_dtypes(include=[np.number]).shape[
+            1]  # NOTE: It can happen that features have less than two unique values if cleaning is applied before the bagging, i.e. Bioresponse
+
+        assert n_numeric + n_categorical + n_binary == X.shape[1]  # NOTE: FOr debugging, to be removed later
+        for preprocessor_cls_name, init_params in prep_params:
+            if preprocessor_cls_name == 'ArithmeticFeatureGenerator':
+                prep_cls = ArithmeticFeatureGenerator(target_type=self.problem_type, **init_params)
+            elif preprocessor_cls_name == 'CategoricalInteractionFeatureGenerator':
+                prep_cls = CategoricalInteractionFeatureGenerator(target_type=self.problem_type, **init_params)
+            elif preprocessor_cls_name == 'OOFTargetEncodingFeatureGenerator':
+                prep_cls = OOFTargetEncodingFeatureGenerator(target_type=self.problem_type, **init_params)
+            else:
+                raise ValueError(f"Unknown preprocessor class name: {preprocessor_cls_name}")
+            n_numeric, n_categorical, n_binary = prep_cls.estimate_new_dtypes(n_numeric, n_categorical, n_binary,
+                                                                              num_classes=self.num_classes)
+
+        return n_numeric, n_categorical, n_binary
+
+    def _estimate_memory_usage(self, X: pd.DataFrame, **kwargs) -> int:
+        hyperparameters = self._get_model_params()
+        n_numeric, n_categorical, n_binary = self._estimate_dtypes_after_preprocessing(X=X, **kwargs)
+
+        if hasattr(self, "_estimate_memory_usage_static_lite"):
+            return self._estimate_memory_usage_static_lite(
+                num_samples=X.shape[0],
+                num_features=n_numeric + n_categorical + n_binary,
+                num_bytes_per_cell=4,
+                hyperparameters=hyperparameters,
+                problem_type=self.problem_type,
+                num_classes=self.num_classes,
+                **kwargs,
+            )
+
+        # TODO: Replace with memory estimation logic based on no. of features instead of dataframe generation
+        shape = X.shape[0]
+        df_lst = []
+        if n_numeric > 0:
+            X_estimate = np.random.random(size=[shape, n_numeric]).astype(np.float32)
+            X_estimate_numeric = pd.DataFrame(X_estimate)
+            df_lst.append(X_estimate_numeric)
+        if n_categorical > 0:
+            cardinality = int(X.select_dtypes(exclude=[np.number]).nunique().mean())
+            X_estimate = np.random.randint(0, cardinality, [shape, n_categorical]).astype('str')
+            X_estimate_cat = pd.DataFrame(X_estimate)
+            df_lst.append(X_estimate_cat)
+        if n_binary > 0:
+            X_estimate = np.random.randint(0, 2, [shape, n_binary]).astype(np.int8)
+            X_estimate_binary = pd.DataFrame(X_estimate)
+            df_lst.append(X_estimate_binary)
+        X = pd.concat(df_lst, ignore_index=True, axis=1)
+
+        return self.estimate_memory_usage_static(
+            X=X,
+            problem_type=self.problem_type,
+            num_classes=self.num_classes,
+            hyperparameters=hyperparameters,
+            **kwargs,
+        )
+
+    def _init_preprocessor(
+            self,
+            preprocessor_cls: Type[AbstractFeatureGenerator] | str,
+            init_params: dict | None,
+    ) -> AbstractFeatureGenerator:
+        if isinstance(preprocessor_cls, str):
+            preprocessor_cls = _feature_generator_class_map[preprocessor_cls]
+        if init_params is None:
+            init_params = {}
+        _init_params = dict(
+            verbosity=0,
+            random_state=self.random_seed,  # FIXME: Not a generic param
+            target_type=self.problem_type,  # FIXME: Not a generic param
+        )
+        _init_params.update(**init_params)
+        return preprocessor_cls(
+            **_init_params,
+        )
+
+    def _recursive_init_preprocessors(self, prep_param: tuple | list[list | tuple]):
+        if isinstance(prep_param, list):
+            if len(prep_param) == 0:
+                param_type = "list"
+            elif len(prep_param) == 2:
+                if isinstance(prep_param[0], (str, AbstractFeatureGenerator)):
+                    param_type = "generator"
+                else:
+                    param_type = "list"
+            else:
+                param_type = "list"
+        elif isinstance(prep_param, tuple):
+            param_type = "generator"
+        else:
+            raise ValueError(f"Invalid value for prep_param: {prep_param}")
+
+        if param_type == "list":
+            out = []
+            for i, p in enumerate(prep_param):
+                out.append(self._recursive_init_preprocessors(p))
+            return out
+        elif param_type == "generator":
+            assert len(prep_param) == 2
+            preprocessor_cls = prep_param[0]
+            init_params = prep_param[1]
+            return self._init_preprocessor(preprocessor_cls=preprocessor_cls, init_params=init_params)
+        else:
+            raise ValueError(f"Invalid value for prep_param: {prep_param}")
+
+    def get_preprocessors(self) -> list[AbstractFeatureGenerator]:
+        ag_params = self._get_ag_params()
+        prep_params = ag_params.get("prep_params", None)
+        passthrough_types = ag_params.get("prep_params.passthrough_types", None)
+        if prep_params is None:
+            return []
+        if not prep_params:
+            return []
+
+        preprocessors = self._recursive_init_preprocessors(prep_param=prep_params)
+        if len(preprocessors) == 0:
+            return []
+        if len(preprocessors) == 1 and isinstance(preprocessors[0], AbstractFeatureGenerator):
+            return preprocessors
+        else:
+            preprocessors = [BulkFeatureGenerator(
+                generators=preprocessors,
+                # TODO: "false_recursive" technically can slow down inference, but need to optimize `True` first
+                #  Refer to `Bioresponse` dataset where setting to `True` -> 200s fit time vs `false_recursive` -> 1s fit time
+                remove_unused_features="false_recursive",
+                post_drop_duplicates=True,
+                passthrough=True,
+                passthrough_types=passthrough_types,
+                verbosity=0,
+            )]
+            return preprocessors
+
+    def _preprocess(self, X: pd.DataFrame, y=None, is_train: bool = False, **kwargs):
+        if is_train:
+            self.preprocessors = self.get_preprocessors()
+            if self.preprocessors:
+                assert y is not None, f"y must be specified to fit preprocessors... Likely the inheriting class isn't passing `y` in its `preprocess` call."
+                # FIXME: add `post_drop_useless`, example: anneal has many useless features
+                feature_metadata_in = self._feature_metadata
+                for prep in self.preprocessors:
+                    X = prep.fit_transform(X, y, feature_metadata_in=feature_metadata_in)
+                    # FIXME: Nick: This is incorrect because it strips away special dtypes. Need to do this properly by fixing in the preprocessors
+                    feature_metadata_in = prep.feature_metadata
+                self._feature_metadata = feature_metadata_in
+                self._features_internal = self._feature_metadata.get_features()
+        else:
+            for prep in self.preprocessors:
+                X = prep.transform(X)
+
+        return super()._preprocess(X, y=y, is_train=is_train, **kwargs)

autogluon/tabular/models/tabular_nn/torch/tabular_nn_torch.py

@@ -495,7 +495,7 @@ class TabularNeuralNetTorchModel(AbstractNeuralNetworkModel):
 
             if time_limit is not None:
                 time_elapsed = time.time() - start_fit_time
-                time_epoch_average = time_elapsed / (epoch + 1)
+                time_epoch_average = time_elapsed / max(epoch, 1)  # avoid divide by 0
                 time_left = time_limit - time_elapsed
                 if time_left < time_epoch_average:
                     logger.log(20, f"\tRan out of time, stopping training early. (Stopping on epoch {epoch})")

autogluon/tabular/models/tabular_nn/utils/data_preprocessor.py

@@ -37,10 +37,18 @@ def create_preprocessor(
             steps=[("ordinal", OrdinalMergeRaresHandleUnknownEncoder(max_levels=max_category_levels))]
         )  # returns 0-n when max_category_levels = n-1. category n is reserved for unknown test-time categories.
         transformers.append(("ordinal", ordinal_transformer, embed_features))
-    return ColumnTransformer(
-        transformers=transformers, remainder="passthrough", force_int_remainder_cols=False,
-    )  # numeric features are processed in the same order as in numeric_features vector, so feature-names remain the same.
-
+    try:
+        out = ColumnTransformer(
+            transformers=transformers, remainder="passthrough", force_int_remainder_cols=False,
+        )  # numeric features are processed in the same order as in numeric_features vector, so feature-names remain the same.
+    except:
+        # TODO: Avoid try/except once scikit-learn 1.5 is minimum
+        # Needed for scikit-learn 1.4 and 1.9+, force_int_remainder_cols is deprecated in 1.7 and introduced in 1.5
+        # ref: https://github.com/autogluon/autogluon/issues/5289
+        out = ColumnTransformer(
+            transformers=transformers, remainder="passthrough",
+        )  # numeric features are processed in the same order as in numeric_features vector, so feature-names remain the same.
+    return out
 
 def convert_df_dtype_to_str(df):
     return df.astype(str)

autogluon/tabular/models/xgboost/xgboost_model.py

@@ -122,6 +122,8 @@ class XGBoostModel(AbstractModel):
             if eval_metric is not None:
                 params["eval_metric"] = eval_metric
                 eval_metric_name = eval_metric.__name__ if not isinstance(eval_metric, str) else eval_metric
+        else:
+            eval_metric_name = params["eval_metric"].__name__ if not isinstance(params["eval_metric"], str) else params["eval_metric"]
 
         if X_val is None:
             early_stopping_rounds = None

autogluon/tabular/predictor/predictor.py

@@ -19,6 +19,8 @@ from packaging import version
 from autogluon.common import FeatureMetadata, TabularDataset
 from autogluon.common.loaders import load_json
 from autogluon.common.savers import save_json
+from autogluon.common.utils.cv_splitter import CVSplitter
+from autogluon.common.utils.decorators import apply_presets
 from autogluon.common.utils.file_utils import get_directory_size, get_directory_size_per_file
 from autogluon.common.utils.resource_utils import ResourceManager, get_resource_manager
 from autogluon.common.utils.hyperparameter_utils import get_hyperparameter_str_deprecation_msg, is_advanced_hyperparameter_format
@@ -46,10 +48,9 @@ from autogluon.core.pseudolabeling.pseudolabeling import filter_ensemble_pseudo,
 from autogluon.core.scheduler.scheduler_factory import scheduler_factory
 from autogluon.core.stacked_overfitting.utils import check_stacked_overfitting_from_leaderboard
 from autogluon.core.utils import get_pred_from_proba_df, plot_performance_vs_trials, plot_summary_of_models, plot_tabular_models
-from autogluon.core.utils.decorators import apply_presets
 from autogluon.core.utils.loaders import load_pkl, load_str
 from autogluon.core.utils.savers import save_pkl, save_str
-from autogluon.core.utils.utils import CVSplitter, generate_train_test_split_combined
+from autogluon.core.utils.utils import generate_train_test_split_combined
 
 from ..configs.feature_generator_presets import get_default_feature_generator
 from ..configs.hyperparameter_configs import get_hyperparameter_config
@@ -422,7 +423,7 @@ class TabularPredictor:
         num_gpus: int | str = "auto",
         fit_strategy: Literal["sequential", "parallel"] = "sequential",
         memory_limit: float | str = "auto",
-        callbacks: list[AbstractCallback] = None,
+        callbacks: list[AbstractCallback | list | tuple] = None,
         **kwargs,
     ) -> "TabularPredictor":
         """
@@ -463,16 +464,23 @@ class TabularPredictor:
             It is recommended to only use one `quality` based preset in a given call to `fit()` as they alter many of the same arguments and are not compatible with each-other.
 
             In-depth Preset Info:
-                extreme_quality={"auto_stack": True, "dynamic_stacking": "auto", "_experimental_dynamic_hyperparameters": True, "hyperparameters": None}
-                    Significantly more accurate than `best_quality` on datasets <= 30000 samples. Requires a GPU for best results.
-                    For datasets <= 30000 samples, will use recent tabular foundation models TabPFNv2, TabICL, and Mitra to maximize performance.
-                    For datasets > 30000 samples, will behave identically to `best_quality`.
+                extreme_quality={...}
+                    New in v1.5: The state-of-the-art for tabular machine learning.
+                    Requires `pip install autogluon.tabular[tabarena]` to install TabPFN, TabICL, and TabDPT.
+                    Significantly more accurate than `best_quality` on datasets <= 100000 samples. Requires a GPU.
+                    Will use recent tabular foundation models TabPFNv2, TabICL, TabDPT, and Mitra to maximize performance.
                     Recommended for applications that benefit from the best possible model accuracy.
 
+                best_quality_v150={...}
+                    New in v1.5: Better quality than 'best_quality' and 5x+ faster to train. Give it a try!
+
                 best_quality={'auto_stack': True, 'dynamic_stacking': 'auto', 'hyperparameters': 'zeroshot'}
                     Best predictive accuracy with little consideration to inference time or disk usage. Achieve even better results by specifying a large time_limit value.
                     Recommended for applications that benefit from the best possible model accuracy.
 
+                high_quality_v150={...}
+                    New in v1.5: Better quality than 'high_quality' and 5x+ faster to train. Give it a try!
+
                 high_quality={'auto_stack': True, 'dynamic_stacking': 'auto', 'hyperparameters': 'zeroshot', 'refit_full': True, 'set_best_to_refit_full': True, 'save_bag_folds': False}
                     High predictive accuracy with fast inference. ~8x faster inference and ~8x lower disk usage than `best_quality`.
                     Recommended for applications that require reasonable inference speed and/or model size.
@@ -1106,11 +1114,13 @@ class TabularPredictor:
                 20,
                 "No presets specified! To achieve strong results with AutoGluon, it is recommended to use the available presets. Defaulting to `'medium'`...\n"
                 "\tRecommended Presets (For more details refer to https://auto.gluon.ai/stable/tutorials/tabular/tabular-essentials.html#presets):\n"
-                "\tpresets='extreme' : New in v1.4: Massively better than 'best' on datasets <30000 samples by using new models meta-learned on https://tabarena.ai: TabPFNv2, TabICL, Mitra, and TabM. Absolute best accuracy. Requires a GPU. Recommended 64 GB CPU memory and 32+ GB GPU memory.\n"
-                "\tpresets='best'    : Maximize accuracy. Recommended for most users. Use in competitions and benchmarks.\n"
-                "\tpresets='high'    : Strong accuracy with fast inference speed.\n"
-                "\tpresets='good'    : Good accuracy with very fast inference speed.\n"
-                "\tpresets='medium'  : Fast training time, ideal for initial prototyping.",
+                "\tpresets='extreme'  : New in v1.5: The state-of-the-art for tabular data. Massively better than 'best' on datasets <100000 samples by using new Tabular Foundation Models (TFMs) meta-learned on https://tabarena.ai: TabPFNv2, TabICL, Mitra, TabDPT, and TabM. Requires a GPU and `pip install autogluon.tabular[tabarena]` to install TabPFN, TabICL, and TabDPT.\n"
+                "\tpresets='best'     : Maximize accuracy. Recommended for most users. Use in competitions and benchmarks.\n"
+                "\tpresets='best_v150': New in v1.5: Better quality than 'best' and 5x+ faster to train. Give it a try!\n"
+                "\tpresets='high'     : Strong accuracy with fast inference speed.\n"
+                "\tpresets='high_v150': New in v1.5: Better quality than 'high' and 5x+ faster to train. Give it a try!\n"
+                "\tpresets='good'     : Good accuracy with very fast inference speed.\n"
+                "\tpresets='medium'   : Fast training time, ideal for initial prototyping.",
             )
 
         kwargs_orig = kwargs.copy()
@@ -1164,7 +1174,7 @@ class TabularPredictor:
         # TODO: Temporary for v1.4. Make this more extensible for v1.5 by letting users make their own dynamic hyperparameters.
         dynamic_hyperparameters = kwargs["_experimental_dynamic_hyperparameters"]
         if dynamic_hyperparameters:
-            logger.log(20, f"`extreme` preset uses a dynamic portfolio based on dataset size...")
+            logger.log(20, f"`extreme_v140` preset uses a dynamic portfolio based on dataset size...")
             assert hyperparameters is None, f"hyperparameters must be unspecified when `_experimental_dynamic_hyperparameters=True`."
             n_samples = len(train_data)
             if n_samples > 30000:
@@ -1593,6 +1603,25 @@ class TabularPredictor:
         memory_safe_fits = ds_fit_kwargs.get("memory_safe_fits", True)
         enable_ray_logging = ds_fit_kwargs.get("enable_ray_logging", True)
         normal_fit = False
+        total_resources = ag_fit_kwargs["core_kwargs"]["total_resources"]
+
+        if memory_safe_fits == "auto":
+            num_gpus = total_resources.get("num_gpus", "auto")
+            if num_gpus == "auto":
+                num_gpus = ResourceManager.get_gpu_count_torch()
+                if num_gpus > 0:
+                    logger.log(
+                        30,
+                        f"DyStack: Disabling memory safe fit mode in DyStack "
+                        f"because GPUs were detected and num_gpus='auto' (GPUs cannot be used in memory safe fit mode). "
+                        f"If you want to use memory safe fit mode, manually set `num_gpus=0`."
+                    )
+            if num_gpus > 0:
+                memory_safe_fits = False
+            else:
+                memory_safe_fits = True
+
+
         if memory_safe_fits:
             try:
                 _ds_ray = try_import_ray()
@@ -1633,8 +1662,6 @@ class TabularPredictor:
                 # Handle resources
                 # FIXME: what about distributed?
 
-                total_resources = ag_fit_kwargs["core_kwargs"]["total_resources"]
-
                 num_cpus = total_resources.get("num_cpus", "auto")
 
                 if num_cpus == "auto":
@@ -5244,11 +5271,11 @@ class TabularPredictor:
             holdout_frac=1 / 9,
             n_folds=2,
             n_repeats=1,
-            memory_safe_fits=True,
+            memory_safe_fits="auto",
             clean_up_fits=True,
             holdout_data=None,
             enable_ray_logging=True,
-            enable_callbacks=False,
+            enable_callbacks=True,
         )
         allowed_kes = set(ds_args.keys())
 
@@ -5263,9 +5290,11 @@ class TabularPredictor:
             (not isinstance(ds_args["validation_procedure"], str)) or (ds_args["validation_procedure"] not in ["holdout", "cv"])
         ):
             raise ValueError("`validation_procedure` in `ds_args` must be str in {'holdout','cv'}. " + f"Got: {ds_args['validation_procedure']}")
-        for arg_name in ["memory_safe_fits", "clean_up_fits", "enable_ray_logging"]:
+        for arg_name in ["clean_up_fits", "enable_ray_logging"]:
             if (arg_name in ds_args) and (not isinstance(ds_args[arg_name], bool)):
                 raise ValueError(f"`{arg_name}` in `ds_args` must be bool.  Got: {type(ds_args[arg_name])}")
+        if "memory_safe_fits" in ds_args and not isinstance(ds_args["memory_safe_fits"], (bool, str)):
+            raise ValueError(f"`memory_safe_fits` in `ds_args` must be bool or 'auto'.  Got: {type(ds_args['memory_safe_fits'])}")
         for arg_name in ["detection_time_frac", "holdout_frac"]:
             if (arg_name in ds_args) and ((not isinstance(ds_args[arg_name], float)) or (ds_args[arg_name] >= 1) or (ds_args[arg_name] <= 0)):
                 raise ValueError(f"`{arg_name}` in `ds_args` must be float in (0,1).  Got: {type(ds_args[arg_name])}, {ds_args[arg_name]}")

autogluon/tabular/registry/_ag_model_registry.py

@@ -20,14 +20,17 @@ from ..models import (
     LinearModel,
     MultiModalPredictorModel,
     NNFastAiTabularModel,
+    PrepLGBModel,
     RealMLPModel,
     RFModel,
     RuleFitModel,
+    TabDPTModel,
     TabICLModel,
     TabMModel,
     TabPFNMixModel,
     MitraModel,
-    TabPFNV2Model,
+    RealTabPFNv2Model,
+    RealTabPFNv25Model,
     TabularNeuralNetTorchModel,
     TextPredictorModel,
     XGBoostModel,
@@ -47,14 +50,17 @@ REGISTERED_MODEL_CLS_LST = [
     TabularNeuralNetTorchModel,
     LinearModel,
     NNFastAiTabularModel,
+    PrepLGBModel,
     TextPredictorModel,
     ImagePredictorModel,
     MultiModalPredictorModel,
     FTTransformerModel,
+    TabDPTModel,
     TabICLModel,
     TabMModel,
     TabPFNMixModel,
-    TabPFNV2Model,
+    RealTabPFNv2Model,
+    RealTabPFNv25Model,
     MitraModel,
     FastTextModel,
     GreedyWeightedEnsembleModel,

autogluon/tabular/testing/fit_helper.py

@@ -4,6 +4,9 @@ import copy
 import os
 import pandas as pd
 import shutil
+import sys
+import subprocess
+import textwrap
 import uuid
 from typing import Any, Type
 
@@ -12,6 +15,7 @@ from autogluon.core.constants import BINARY, MULTICLASS, REGRESSION
 from autogluon.core.metrics import METRICS
 from autogluon.core.models import AbstractModel, BaggedEnsembleModel
 from autogluon.core.stacked_overfitting.utils import check_stacked_overfitting_from_leaderboard
+from autogluon.core.testing.global_context_snapshot import GlobalContextSnapshot
 from autogluon.core.utils import download, generate_train_test_split_combined, infer_problem_type, unzip
 
 from autogluon.tabular import TabularDataset, TabularPredictor
@@ -176,6 +180,7 @@ class FitHelper:
         raise_on_model_failure: bool | None = None,
         deepcopy_fit_args: bool = True,
         verify_model_seed: bool = False,
+        verify_load_wo_cuda: bool = False,
     ) -> TabularPredictor:
         if compiler_configs is None:
             compiler_configs = {}
@@ -219,6 +224,8 @@ class FitHelper:
                 expected_model_count -= 1
             fit_args["fit_weighted_ensemble"] = fit_weighted_ensemble
 
+        ctx_before = GlobalContextSnapshot.capture()
+
         predictor: TabularPredictor = FitHelper.fit_dataset(
             train_data=train_data,
             init_args=init_args,
@@ -227,6 +234,10 @@ class FitHelper:
             scikit_api=scikit_api,
             min_cls_count_train=min_cls_count_train,
         )
+        
+        ctx_after = GlobalContextSnapshot.capture()
+        ctx_before.assert_unchanged(ctx_after)
+
         if compile:
             predictor.compile(models="all", compiler_configs=compiler_configs)
             predictor.persist(models="all")
@@ -287,6 +298,28 @@ class FitHelper:
         predictor_load = predictor.load(path=predictor.path)
         predictor_load.predict(test_data)
 
+        # TODO: This is expensive, only do this sparingly.
+        if verify_load_wo_cuda:
+            import torch
+            if torch.cuda.is_available():
+                # Checks if the model is able to predict w/o CUDA.
+                # This verifies that a model artifact works on a CPU machine.
+                predictor_path = predictor.path
+
+                code = textwrap.dedent(f"""
+                        import os
+                        os.environ["CUDA_VISIBLE_DEVICES"] = ""
+                        from autogluon.tabular import TabularPredictor
+    
+                        import torch
+                        assert torch.cuda.is_available() is False
+                        predictor = TabularPredictor.load(r"{predictor_path}")
+                        X, y = predictor.load_data_internal()
+                        predictor.persist("all")
+                        predictor.predict_multi(X, transform_features=False)
+                    """)
+                subprocess.run([sys.executable, "-c", code], check=True)
+
         assert os.path.realpath(save_path) == os.path.realpath(predictor.path)
         if delete_directory:
             shutil.rmtree(save_path, ignore_errors=True)  # Delete AutoGluon output directory to ensure runs' information has been removed.

autogluon/tabular/trainer/abstract_trainer.py

@@ -27,7 +27,7 @@ from autogluon.core.calibrate.conformity_score import compute_conformity_score
 from autogluon.core.calibrate.temperature_scaling import apply_temperature_scaling, tune_temperature_scaling
 from autogluon.core.callbacks import AbstractCallback
 from autogluon.core.constants import BINARY, MULTICLASS, QUANTILE, REFIT_FULL_NAME, REGRESSION, SOFTCLASS
-from autogluon.core.data.label_cleaner import LabelCleanerMulticlassToBinary
+from autogluon.core.data.label_cleaner import LabelCleanerMulticlassToBinary, LabelCleaner
 from autogluon.core.metrics import Scorer, compute_metric, get_metric
 from autogluon.core.models import (
     AbstractModel,
@@ -530,7 +530,7 @@ class AbstractTabularTrainer(AbstractTrainer[AbstractModel]):
         self.save()
         return model_names_fit
 
-    def _fit_setup(self, time_limit: float | None = None, callbacks: list[AbstractCallback] | None = None):
+    def _fit_setup(self, time_limit: float | None = None, callbacks: list[AbstractCallback | list | tuple] | None = None):
         """
         Prepare the trainer state at the start of / prior to a fit call.
         Should be paired with a `self._fit_cleanup()` at the conclusion of the fit call.
@@ -539,15 +539,45 @@ class AbstractTabularTrainer(AbstractTrainer[AbstractModel]):
         self._time_train_start_last = self._time_train_start
         self._time_limit = time_limit
         self.reset_callbacks()
+        callbacks_new = []
         if callbacks is not None:
             assert isinstance(callbacks, list), f"`callbacks` must be a list. Found invalid type: `{type(callbacks)}`."
             for callback in callbacks:
-                assert isinstance(
-                    callback, AbstractCallback
-                ), f"Elements in `callbacks` must be of type AbstractCallback. Found invalid type: `{type(callback)}`."
+                if isinstance(callback, (list, tuple)):
+                    assert len(callback) == 2, f"Callback must either be an initialized object or a tuple/list of length 2, found: {callback}"
+                    callback_cls = callback[0]
+                    if isinstance(callback_cls, str):
+                        from autogluon.core.callbacks._early_stopping_count_callback import EarlyStoppingCountCallback
+                        from autogluon.core.callbacks._early_stopping_callback import EarlyStoppingCallback
+                        from autogluon.core.callbacks._early_stopping_ensemble_callback import EarlyStoppingEnsembleCallback
+
+                        _callback_cls_lst = [
+                            EarlyStoppingCallback,
+                            EarlyStoppingCountCallback,
+                            EarlyStoppingEnsembleCallback,
+                        ]
+
+                        _callback_cls_name_map = {
+                            c.__name__: c for c in _callback_cls_lst
+                        }
+
+                        assert callback_cls in _callback_cls_name_map.keys(), (
+                            f"Unknown callback class: {callback_cls}. "
+                            f"Valid classes: {list(_callback_cls_name_map.keys())}"
+                        )
+                        callback_cls = _callback_cls_name_map[callback_cls]
+
+                    callback_kwargs = callback[1]
+                    assert isinstance(callback_kwargs, dict), f"Callback kwargs must be a dictionary, found: {callback_kwargs}"
+                    callback = callback_cls(**callback_kwargs)
+                else:
+                    assert isinstance(
+                        callback, AbstractCallback
+                    ), f"Elements in `callbacks` must be of type AbstractCallback. Found invalid type: `{type(callback)}`."
+                callbacks_new.append(callback)
         else:
-            callbacks = []
-        self.callbacks = callbacks
+            callbacks_new = []
+        self.callbacks = callbacks_new
 
     def _fit_cleanup(self):
         """
@@ -2493,6 +2523,7 @@ class AbstractTabularTrainer(AbstractTrainer[AbstractModel]):
         errors_ignore: list | None = None,
         errors_raise: list | None = None,
         is_ray_worker: bool = False,
+        label_cleaner: None | LabelCleaner = None,
         **kwargs,
     ) -> list[str]:
         """
@@ -2527,7 +2558,8 @@ class AbstractTabularTrainer(AbstractTrainer[AbstractModel]):
             return []
 
         model_fit_kwargs = self._get_model_fit_kwargs(
-            X=X, X_val=X_val, time_limit=time_limit, k_fold=k_fold, fit_kwargs=fit_kwargs, ens_sample_weight=kwargs.get("ens_sample_weight", None)
+            X=X, X_val=X_val, time_limit=time_limit, k_fold=k_fold, fit_kwargs=fit_kwargs,
+            ens_sample_weight=kwargs.get("ens_sample_weight", None), label_cleaner=label_cleaner,
         )
         exception = None
         if hyperparameter_tune_kwargs:
@@ -4294,7 +4326,8 @@ class AbstractTabularTrainer(AbstractTrainer[AbstractModel]):
         return distilled_model_names
 
     def _get_model_fit_kwargs(
-        self, X: pd.DataFrame, X_val: pd.DataFrame, time_limit: float, k_fold: int, fit_kwargs: dict, ens_sample_weight: list | None = None
+        self, X: pd.DataFrame, X_val: pd.DataFrame, time_limit: float, k_fold: int,
+        fit_kwargs: dict, ens_sample_weight: list | None = None, label_cleaner: None | LabelCleaner = None
     ) -> dict:
         # Returns kwargs to be passed to AbstractModel's fit function
         if fit_kwargs is None:
@@ -4316,6 +4349,9 @@ class AbstractTabularTrainer(AbstractTrainer[AbstractModel]):
             if k_fold == self.k_fold:  # don't do this on refit full
                 model_fit_kwargs["groups"] = self._groups
 
+        if label_cleaner is not None:
+            model_fit_kwargs["label_cleaner"] = label_cleaner
+
         # FIXME: Sample weight `extract_column` is a hack, have to compute feature_metadata here because sample weight column could be in X upstream, extract sample weight column upstream instead.
         if "feature_metadata" not in model_fit_kwargs:
             raise AssertionError(f"Missing expected parameter 'feature_metadata'.")

autogluon/tabular/trainer/auto_trainer.py

@@ -59,6 +59,7 @@ class AutoTrainer(AbstractTabularTrainer):
         use_bag_holdout=False,
         groups=None,
         callbacks: list[callable] = None,
+        label_cleaner=None,
         **kwargs,
     ):
         for key in kwargs:
@@ -112,6 +113,7 @@ class AutoTrainer(AbstractTabularTrainer):
         extra_log_str = ""
         display_all = (n_configs < 20) or (self.verbosity >= 3)
         if not display_all:
+            # FIXME: This isn't correct
             extra_log_str = (
                 f"Large model count detected ({n_configs} configs) ... " f"Only displaying the first 3 models of each family. To see all, set `verbosity=3`.\n"
             )
@@ -132,6 +134,9 @@ class AutoTrainer(AbstractTabularTrainer):
         log_str += "}"
         logger.log(20, log_str)
 
+        if label_cleaner is not None:
+            core_kwargs["label_cleaner"] = label_cleaner
+
         self._train_multi_and_ensemble(
             X=X,
             y=y,