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

autogluon/tabular/configs/hyperparameter_configs.py

@@ -2,6 +2,8 @@ import copy
 
 from .zeroshot.zeroshot_portfolio_2023 import hyperparameter_portfolio_zeroshot_2023
 from .zeroshot.zeroshot_portfolio_2025 import hyperparameter_portfolio_zeroshot_2025_small
+from .zeroshot.zeroshot_portfolio_cpu_2025_12_18 import hyperparameter_portfolio_zeroshot_cpu_2025_12_18
+from .zeroshot.zeroshot_portfolio_gpu_2025_12_18 import hyperparameter_portfolio_zeroshot_gpu_2025_12_18
 
 # Dictionary of preset hyperparameter configurations.
 hyperparameter_config_dict = dict(
@@ -117,6 +119,8 @@ hyperparameter_config_dict = dict(
     zeroshot=hyperparameter_portfolio_zeroshot_2023,
     zeroshot_2023=hyperparameter_portfolio_zeroshot_2023,
     zeroshot_2025_tabfm=hyperparameter_portfolio_zeroshot_2025_small,
+    zeroshot_2025_12_18_gpu=hyperparameter_portfolio_zeroshot_gpu_2025_12_18,
+    zeroshot_2025_12_18_cpu=hyperparameter_portfolio_zeroshot_cpu_2025_12_18,
 )
 
 tabpfnmix_default = {

autogluon/tabular/configs/presets_configs.py

@@ -9,6 +9,15 @@ tabular_presets_dict = dict(
         "hyperparameters": "zeroshot",
         "time_limit": 3600,
     },
+
+    best_quality_v150={
+        "auto_stack": True,
+        "dynamic_stacking": "auto",
+        "num_stack_levels": 0,
+        "hyperparameters": "zeroshot_2025_12_18_cpu",
+        "time_limit": 3600,
+        "callbacks": [["EarlyStoppingCountCallback", {"patience": [[100, 4], [500, 8], [2500, 15], [10000, 40], [100000, 100], None]}]],
+    },
     # High predictive accuracy with fast inference. ~8x faster inference and ~8x lower disk usage than `best_quality`.
     # Recommended for applications that require fast inference speed and/or small model size.
     # Aliases: high
@@ -21,6 +30,19 @@ tabular_presets_dict = dict(
         "set_best_to_refit_full": True,
         "save_bag_folds": False,
     },
+
+    high_quality_v150={
+        "auto_stack": True,
+        "dynamic_stacking": "auto",
+        "num_stack_levels": 0,
+        "hyperparameters": "zeroshot_2025_12_18_cpu",
+        "time_limit": 3600,
+        "callbacks": [["EarlyStoppingCountCallback", {"patience": [[100, 4], [500, 8], [2500, 15], [10000, 40], [100000, 100], None]}]],
+        "refit_full": True,
+        "set_best_to_refit_full": True,
+        "save_bag_folds": False,
+    },
+
     # Good predictive accuracy with very fast inference. ~4x faster training, ~8x faster inference and ~8x lower disk usage than `high_quality`.
     # Recommended for applications that require very fast inference speed.
     # Aliases: good
@@ -78,11 +100,20 @@ tabular_presets_dict = dict(
     # Absolute best predictive accuracy with **zero** consideration to inference time or disk usage.
     # Recommended for applications that benefit from the best possible model accuracy and **do not** care about inference speed.
     # Significantly stronger than `best_quality`, but can be over 10x slower in inference.
-    # Uses pre-trained tabular foundation models, which add a minimum of 1-2 GB to the predictor artifact's size.
+    # Uses pre-trained tabular foundation models, which add a minimum of 100 MB to the predictor artifact's size.
     # For best results, use as large of an instance as possible with a GPU and as many CPU cores as possible (ideally 64+ cores)
     # Aliases: extreme, experimental, experimental_quality
     # GPU STRONGLY RECOMMENDED
     extreme_quality={
+        "auto_stack": True,
+        "dynamic_stacking": "auto",
+        "num_stack_levels": 0,
+        "hyperparameters": "zeroshot_2025_12_18_gpu",
+        "time_limit": 3600,
+        "callbacks": [["EarlyStoppingCountCallback", {"patience": [[100, 4], [500, 8], [2500, 15], [10000, 40], [100000, 100], None]}]],
+    },
+
+    extreme_quality_v140={
         "auto_stack": True,
         "dynamic_stacking": "auto",
         "num_bag_sets": 1,
@@ -140,5 +171,11 @@ tabular_presets_alias = dict(
     mq="medium_quality",
     experimental="extreme_quality",
     experimental_quality="extreme_quality",
-    experimental_quality_v140="extreme_quality",
+    experimental_quality_v140="extreme_quality_v140",
+    best_v140="best_quality",
+    best_v150="best_quality_v150",
+    best_quality_v140="best_quality",
+    high_v150="high_quality_v150",
+    extreme_v140="extreme_quality_v140",
+    extreme_v150="extreme_quality",
 )

autogluon/tabular/configs/zeroshot/zeroshot_portfolio_2025.py

@@ -1,50 +1,8 @@
 # optimized for <=10000 samples and <=500 features, with a GPU present
 hyperparameter_portfolio_zeroshot_2025_small = {
-    "TABPFNV2": [
+    "REALTABPFN-V2": [
         {
-            "ag_args": {'name_suffix': '_r143', 'priority': -1},
-            "average_before_softmax": False,
-            "classification_model_path": 'tabpfn-v2-classifier-od3j1g5m.ckpt',
-            "inference_config/FINGERPRINT_FEATURE": False,
-            "inference_config/OUTLIER_REMOVAL_STD": None,
-            "inference_config/POLYNOMIAL_FEATURES": 'no',
-            "inference_config/PREPROCESS_TRANSFORMS": [{'append_original': True, 'categorical_name': 'ordinal_very_common_categories_shuffled', 'global_transformer_name': None, 'name': 'safepower', 'subsample_features': -1}, {'append_original': True, 'categorical_name': 'ordinal_very_common_categories_shuffled', 'global_transformer_name': None, 'name': 'quantile_uni', 'subsample_features': -1}],
-            "inference_config/REGRESSION_Y_PREPROCESS_TRANSFORMS": [None, 'power'],
-            "inference_config/SUBSAMPLE_SAMPLES": 0.99,
-            "model_type": 'single',
-            "n_ensemble_repeats": 4,
-            "regression_model_path": 'tabpfn-v2-regressor-wyl4o83o.ckpt',
-            "softmax_temperature": 0.75,
-        },
-        {
-            "ag_args": {'name_suffix': '_r94', 'priority': -3},
-            "average_before_softmax": True,
-            "classification_model_path": 'tabpfn-v2-classifier-vutqq28w.ckpt',
-            "inference_config/FINGERPRINT_FEATURE": True,
-            "inference_config/OUTLIER_REMOVAL_STD": None,
-            "inference_config/POLYNOMIAL_FEATURES": 'no',
-            "inference_config/PREPROCESS_TRANSFORMS": [{'append_original': True, 'categorical_name': 'ordinal_very_common_categories_shuffled', 'global_transformer_name': None, 'name': 'quantile_uni', 'subsample_features': 0.99}],
-            "inference_config/REGRESSION_Y_PREPROCESS_TRANSFORMS": [None],
-            "inference_config/SUBSAMPLE_SAMPLES": None,
-            "model_type": 'single',
-            "n_ensemble_repeats": 4,
-            "regression_model_path": 'tabpfn-v2-regressor-5wof9ojf.ckpt',
-            "softmax_temperature": 0.9,
-        },
-        {
-            "ag_args": {'name_suffix': '_r181', 'priority': -4},
-            "average_before_softmax": False,
-            "classification_model_path": 'tabpfn-v2-classifier-llderlii.ckpt',
-            "inference_config/FINGERPRINT_FEATURE": False,
-            "inference_config/OUTLIER_REMOVAL_STD": 9.0,
-            "inference_config/POLYNOMIAL_FEATURES": 50,
-            "inference_config/PREPROCESS_TRANSFORMS": [{'append_original': True, 'categorical_name': 'onehot', 'global_transformer_name': 'svd', 'name': 'quantile_uni_coarse', 'subsample_features': 0.99}],
-            "inference_config/REGRESSION_Y_PREPROCESS_TRANSFORMS": ['power'],
-            "inference_config/SUBSAMPLE_SAMPLES": None,
-            "model_type": 'single',
-            "n_ensemble_repeats": 4,
-            "regression_model_path": 'tabpfn-v2-regressor.ckpt',
-            "softmax_temperature": 0.95,
+            "ag_args": {'priority': -1},
         },
     ],
     "GBM": [

autogluon/tabular/configs/zeroshot/zeroshot_portfolio_cpu_2025_12_18.py

@@ -0,0 +1,2 @@
+# On par with `best_quality` while being much faster for smaller datasets. Runs on CPU.
+hyperparameter_portfolio_zeroshot_cpu_2025_12_18 = {'CAT': [{'ag_args': {'name_suffix': '_c1', 'priority': -1}}], 'GBM_PREP': [{'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r13', 'priority': -2}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.9923026236907, 'bagging_freq': 1, 'cat_l2': 0.014290368488, 'cat_smooth': 1.8662939903973, 'extra_trees': True, 'feature_fraction': 0.5533919718605, 'lambda_l1': 0.914411672958, 'lambda_l2': 1.90439560009, 'learning_rate': 0.0193225778401, 'max_cat_to_onehot': 18, 'min_data_in_leaf': 28, 'min_data_per_group': 54, 'num_leaves': 64}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r41', 'priority': -7}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.7215411996558, 'bagging_freq': 1, 'cat_l2': 1.887369154362, 'cat_smooth': 0.0278693980873, 'extra_trees': True, 'feature_fraction': 0.4247583287144, 'lambda_l1': 0.1129800247772, 'lambda_l2': 0.2623265718536, 'learning_rate': 0.0074201920651, 'max_cat_to_onehot': 9, 'min_data_in_leaf': 15, 'min_data_per_group': 10, 'num_leaves': 8}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r31', 'priority': -10}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.9591526242875, 'bagging_freq': 1, 'cat_l2': 1.8962346412823, 'cat_smooth': 0.0215219089995, 'extra_trees': False, 'feature_fraction': 0.5791844062459, 'lambda_l1': 0.938461750637, 'lambda_l2': 0.9899852075056, 'learning_rate': 0.0397613094741, 'max_cat_to_onehot': 27, 'min_data_in_leaf': 1, 'min_data_per_group': 39, 'num_leaves': 16}, {'ag.prep_params': [], 'ag_args': {'name_suffix': '_r21', 'priority': -12}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.7111549514262, 'bagging_freq': 1, 'cat_l2': 0.8679131150136, 'cat_smooth': 48.7244965504817, 'extra_trees': False, 'feature_fraction': 0.425140839263, 'lambda_l1': 0.5140528525242, 'lambda_l2': 0.5134051978198, 'learning_rate': 0.0134375321277, 'max_cat_to_onehot': 16, 'min_data_in_leaf': 2, 'min_data_per_group': 32, 'num_leaves': 20}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r17', 'priority': -17}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.9277474245702, 'bagging_freq': 1, 'cat_l2': 0.0731876168104, 'cat_smooth': 0.1369210915339, 'extra_trees': False, 'feature_fraction': 0.6680440910385, 'lambda_l1': 0.0125057410295, 'lambda_l2': 0.7157181359874, 'learning_rate': 0.0351342879995, 'max_cat_to_onehot': 20, 'min_data_in_leaf': 1, 'min_data_per_group': 2, 'num_leaves': 64}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]]]], 'ag_args': {'name_suffix': '_r47', 'priority': -18}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.9918048278435, 'bagging_freq': 1, 'cat_l2': 0.984162386723, 'cat_smooth': 0.0049687445294, 'extra_trees': True, 'feature_fraction': 0.4974006116018, 'lambda_l1': 0.7970644065518, 'lambda_l2': 1.2179933810825, 'learning_rate': 0.0537072755122, 'max_cat_to_onehot': 13, 'min_data_in_leaf': 1, 'min_data_per_group': 4, 'num_leaves': 32}, {'ag.prep_params': [[[['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r1', 'priority': -19}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.8836335684032, 'bagging_freq': 1, 'cat_l2': 0.6608043016307, 'cat_smooth': 0.0451936212097, 'extra_trees': True, 'feature_fraction': 0.6189315903408, 'lambda_l1': 0.6514130054123, 'lambda_l2': 1.7382678663835, 'learning_rate': 0.0412716109215, 'max_cat_to_onehot': 9, 'min_data_in_leaf': 9, 'min_data_per_group': 3, 'num_leaves': 128}, {'ag.prep_params': [[[['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r19', 'priority': -26}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.7106002663401, 'bagging_freq': 1, 'cat_l2': 0.1559746777257, 'cat_smooth': 0.0036366126697, 'extra_trees': False, 'feature_fraction': 0.688233104808, 'lambda_l1': 0.8732887427372, 'lambda_l2': 0.446716114323, 'learning_rate': 0.0815946452855, 'max_cat_to_onehot': 78, 'min_data_in_leaf': 12, 'min_data_per_group': 2, 'num_leaves': 16}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r34', 'priority': -32}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.8453534561545, 'bagging_freq': 1, 'cat_l2': 0.0321580936847, 'cat_smooth': 0.0011470238114, 'extra_trees': True, 'feature_fraction': 0.8611499511087, 'lambda_l1': 0.910743969343, 'lambda_l2': 1.2750027607225, 'learning_rate': 0.0151455176168, 'max_cat_to_onehot': 8, 'min_data_in_leaf': 60, 'min_data_per_group': 4, 'num_leaves': 32}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r32', 'priority': -37}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.927947070297, 'bagging_freq': 1, 'cat_l2': 0.0082294539727, 'cat_smooth': 0.0671878797989, 'extra_trees': True, 'feature_fraction': 0.9169657691675, 'lambda_l1': 0.9386485912678, 'lambda_l2': 1.619775689786, 'learning_rate': 0.0056864355547, 'max_cat_to_onehot': 11, 'min_data_in_leaf': 1, 'min_data_per_group': 10, 'num_leaves': 32}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r7', 'priority': -38}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.8984634022103, 'bagging_freq': 1, 'cat_l2': 0.0053608956358, 'cat_smooth': 89.7168790664636, 'extra_trees': False, 'feature_fraction': 0.847638045482, 'lambda_l1': 0.5684527742857, 'lambda_l2': 1.0738026980295, 'learning_rate': 0.0417108779005, 'max_cat_to_onehot': 8, 'min_data_in_leaf': 2, 'min_data_per_group': 7, 'num_leaves': 128}, {'ag.prep_params': [[[['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r14', 'priority': -40}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.9318953983366, 'bagging_freq': 1, 'cat_l2': 0.065532200068, 'cat_smooth': 0.0696287198368, 'extra_trees': True, 'feature_fraction': 0.4649868965096, 'lambda_l1': 0.6586569196642, 'lambda_l2': 1.7799375779553, 'learning_rate': 0.072046289471, 'max_cat_to_onehot': 72, 'min_data_in_leaf': 26, 'min_data_per_group': 32, 'num_leaves': 32}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]]]], 'ag_args': {'name_suffix': '_r27', 'priority': -42}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.811983527375, 'bagging_freq': 1, 'cat_l2': 0.0255048028385, 'cat_smooth': 1.5339379274002, 'extra_trees': True, 'feature_fraction': 0.5246746068724, 'lambda_l1': 0.9737915306165, 'lambda_l2': 1.929596568261, 'learning_rate': 0.0172284745143, 'max_cat_to_onehot': 9, 'min_data_in_leaf': 8, 'min_data_per_group': 51, 'num_leaves': 20}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]]]], 'ag_args': {'name_suffix': '_r37', 'priority': -46}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.7853761603489, 'bagging_freq': 1, 'cat_l2': 0.2934796127084, 'cat_smooth': 10.1721684646257, 'extra_trees': False, 'feature_fraction': 0.4813265290277, 'lambda_l1': 0.9744837697365, 'lambda_l2': 0.6058665958153, 'learning_rate': 0.0371000014124, 'max_cat_to_onehot': 85, 'min_data_in_leaf': 22, 'min_data_per_group': 3, 'num_leaves': 32}], 'GBM': [{'ag_args': {'name_suffix': '_r177', 'priority': -3}, 'bagging_fraction': 0.8769107816033, 'bagging_freq': 1, 'cat_l2': 0.3418014393813, 'cat_smooth': 15.4304556649114, 'extra_trees': True, 'feature_fraction': 0.4622189821941, 'lambda_l1': 0.2375070586896, 'lambda_l2': 0.3551561351804, 'learning_rate': 0.0178593900218, 'max_cat_to_onehot': 16, 'min_data_in_leaf': 3, 'min_data_per_group': 9, 'num_leaves': 39}, {'ag_args': {'name_suffix': '_r163', 'priority': -5}, 'bagging_fraction': 0.9783898288461, 'bagging_freq': 1, 'cat_l2': 0.1553395260142, 'cat_smooth': 0.0093122749318, 'extra_trees': False, 'feature_fraction': 0.5279825611461, 'lambda_l1': 0.0269274915833, 'lambda_l2': 0.8375250972309, 'learning_rate': 0.0113913650333, 'max_cat_to_onehot': 42, 'min_data_in_leaf': 3, 'min_data_per_group': 75, 'num_leaves': 84}, {'ag_args': {'name_suffix': '_r72', 'priority': -8}, 'bagging_fraction': 0.950146543918, 'bagging_freq': 1, 'cat_l2': 0.2159137242663, 'cat_smooth': 0.0638204395719, 'extra_trees': True, 'feature_fraction': 0.4044759649281, 'lambda_l1': 0.7661581500422, 'lambda_l2': 1.6041759693902, 'learning_rate': 0.0179845918984, 'max_cat_to_onehot': 11, 'min_data_in_leaf': 12, 'min_data_per_group': 3, 'num_leaves': 180}, {'ag_args': {'name_suffix': '_r120', 'priority': -13}, 'bagging_fraction': 0.8541333332514, 'bagging_freq': 1, 'cat_l2': 0.0110343197541, 'cat_smooth': 5.0905236124522, 'extra_trees': True, 'feature_fraction': 0.7334718346252, 'lambda_l1': 0.241338427726, 'lambda_l2': 0.298107723769, 'learning_rate': 0.0126654490778, 'max_cat_to_onehot': 67, 'min_data_in_leaf': 12, 'min_data_per_group': 93, 'num_leaves': 5}, {'ag_args': {'name_suffix': '_r6', 'priority': -16}, 'bagging_fraction': 0.8148132107231, 'bagging_freq': 1, 'cat_l2': 0.0058363329714, 'cat_smooth': 0.0289414318324, 'extra_trees': False, 'feature_fraction': 0.939979116902, 'lambda_l1': 0.4369494828584, 'lambda_l2': 0.2997524486083, 'learning_rate': 0.0078971749764, 'max_cat_to_onehot': 28, 'min_data_in_leaf': 24, 'min_data_per_group': 3, 'num_leaves': 8}, {'ag_args': {'name_suffix': '_r184', 'priority': -21}, 'bagging_fraction': 0.8406256713136, 'bagging_freq': 1, 'cat_l2': 0.9284921901786, 'cat_smooth': 0.0898191451684, 'extra_trees': False, 'feature_fraction': 0.5876132298377, 'lambda_l1': 0.078943697912, 'lambda_l2': 0.7713118402478, 'learning_rate': 0.0090676429159, 'max_cat_to_onehot': 16, 'min_data_in_leaf': 17, 'min_data_per_group': 11, 'num_leaves': 2}, {'ag_args': {'name_suffix': '_r46', 'priority': -23}, 'bagging_fraction': 0.999426150416, 'bagging_freq': 1, 'cat_l2': 0.0076879104679, 'cat_smooth': 89.4599055435924, 'extra_trees': False, 'feature_fraction': 0.8588138897928, 'lambda_l1': 0.0413597548025, 'lambda_l2': 0.2258713386858, 'learning_rate': 0.0074056102479, 'max_cat_to_onehot': 11, 'min_data_in_leaf': 1, 'min_data_per_group': 26, 'num_leaves': 14}, {'ag_args': {'name_suffix': '_r68', 'priority': -24}, 'bagging_fraction': 0.7199080522958, 'bagging_freq': 1, 'cat_l2': 0.9369509319667, 'cat_smooth': 11.0984745216942, 'extra_trees': False, 'feature_fraction': 0.9550596478029, 'lambda_l1': 0.1109843723892, 'lambda_l2': 0.5969094177111, 'learning_rate': 0.0079480499426, 'max_cat_to_onehot': 8, 'min_data_in_leaf': 3, 'min_data_per_group': 8, 'num_leaves': 111}, {'ag_args': {'name_suffix': '_r47', 'priority': -29}, 'bagging_fraction': 0.8831228358892, 'bagging_freq': 1, 'cat_l2': 0.1402622388062, 'cat_smooth': 3.3545774392409, 'extra_trees': True, 'feature_fraction': 0.6155890374887, 'lambda_l1': 0.1749502746898, 'lambda_l2': 0.8761391715812, 'learning_rate': 0.00891978331, 'max_cat_to_onehot': 84, 'min_data_in_leaf': 1, 'min_data_per_group': 21, 'num_leaves': 55}, {'ag_args': {'name_suffix': '_r63', 'priority': -31}, 'bagging_fraction': 0.7801003412553, 'bagging_freq': 1, 'cat_l2': 0.0071438335269, 'cat_smooth': 0.1338043459574, 'extra_trees': False, 'feature_fraction': 0.490455360592, 'lambda_l1': 0.6420805635778, 'lambda_l2': 0.5813319300456, 'learning_rate': 0.0308746408751, 'max_cat_to_onehot': 38, 'min_data_in_leaf': 1, 'min_data_per_group': 83, 'num_leaves': 24}, {'ag_args': {'name_suffix': '_r39', 'priority': -36}, 'bagging_fraction': 0.7035743460186, 'bagging_freq': 1, 'cat_l2': 0.0134845084619, 'cat_smooth': 56.4934757686511, 'extra_trees': True, 'feature_fraction': 0.7824899527144, 'lambda_l1': 0.3700115211248, 'lambda_l2': 0.0341499593689, 'learning_rate': 0.094652390088, 'max_cat_to_onehot': 13, 'min_data_in_leaf': 13, 'min_data_per_group': 4, 'num_leaves': 23}, {'ag_args': {'name_suffix': '_r18', 'priority': -43}, 'bagging_fraction': 0.7041134150362, 'bagging_freq': 1, 'cat_l2': 0.1139031650222, 'cat_smooth': 41.8937939300815, 'extra_trees': True, 'feature_fraction': 0.5028791565785, 'lambda_l1': 0.1031941284118, 'lambda_l2': 1.2554010747358, 'learning_rate': 0.0186530122901, 'max_cat_to_onehot': 29, 'min_data_in_leaf': 5, 'min_data_per_group': 74, 'num_leaves': 5}, {'ag_args': {'name_suffix': '_r50', 'priority': -45}, 'bagging_fraction': 0.9673434664048, 'bagging_freq': 1, 'cat_l2': 1.7662226703416, 'cat_smooth': 0.0097667848046, 'extra_trees': True, 'feature_fraction': 0.9286299570284, 'lambda_l1': 0.0448644389135, 'lambda_l2': 1.7322446850205, 'learning_rate': 0.0507909494543, 'max_cat_to_onehot': 11, 'min_data_in_leaf': 4, 'min_data_per_group': 2, 'num_leaves': 106}, {'ag_args': {'name_suffix': '_r104', 'priority': -48}, 'bagging_fraction': 0.9327643671568, 'bagging_freq': 1, 'cat_l2': 0.0067636494662, 'cat_smooth': 29.2351010915576, 'extra_trees': False, 'feature_fraction': 0.660864035482, 'lambda_l1': 0.556745328417, 'lambda_l2': 1.2717605868201, 'learning_rate': 0.0433336000175, 'max_cat_to_onehot': 42, 'min_data_in_leaf': 18, 'min_data_per_group': 6, 'num_leaves': 19}], 'NN_TORCH': [{'activation': 'elu', 'ag_args': {'name_suffix': '_r37', 'priority': -4}, 'dropout_prob': 0.0889772897547275, 'hidden_size': 109, 'learning_rate': 0.02184363543226557, 'num_layers': 3, 'use_batchnorm': True, 'weight_decay': 3.1736637236578543e-10}, {'activation': 'elu', 'ag_args': {'name_suffix': '_r31', 'priority': -9}, 'dropout_prob': 0.013288954106470907, 'hidden_size': 81, 'learning_rate': 0.005340914647396153, 'num_layers': 4, 'use_batchnorm': False, 'weight_decay': 8.76216837077536e-05}, {'activation': 'elu', 'ag_args': {'name_suffix': '_r193', 'priority': -14}, 'dropout_prob': 0.2976404923811552, 'hidden_size': 131, 'learning_rate': 0.0038408014156739775, 'num_layers': 3, 'use_batchnorm': False, 'weight_decay': 0.01745189206113213}, {'activation': 'elu', 'ag_args': {'name_suffix': '_r144', 'priority': -15}, 'dropout_prob': 0.2670859555485912, 'hidden_size': 52, 'learning_rate': 0.015189605588375421, 'num_layers': 4, 'use_batchnorm': True, 'weight_decay': 2.8013784883244263e-08}, {'activation': 'relu', 'ag_args': {'name_suffix': '_r82', 'priority': -22}, 'dropout_prob': 0.27342918414623907, 'hidden_size': 207, 'learning_rate': 0.0004069380929899853, 'num_layers': 4, 'use_batchnorm': False, 'weight_decay': 0.002473667327700422}, {'activation': 'elu', 'ag_args': {'name_suffix': '_r39', 'priority': -27}, 'dropout_prob': 0.21699951000415899, 'hidden_size': 182, 'learning_rate': 0.00014675249427915203, 'num_layers': 2, 'use_batchnorm': False, 'weight_decay': 9.787353852692089e-08}, {'activation': 'relu', 'ag_args': {'name_suffix': '_r1', 'priority': -30}, 'dropout_prob': 0.23713784729000734, 'hidden_size': 200, 'learning_rate': 0.0031125617090901805, 'num_layers': 4, 'use_batchnorm': True, 'weight_decay': 4.57301675647447e-08}, {'activation': 'relu', 'ag_args': {'name_suffix': '_r48', 'priority': -34}, 'dropout_prob': 0.14224509513998226, 'hidden_size': 26, 'learning_rate': 0.007085904739869829, 'num_layers': 2, 'use_batchnorm': False, 'weight_decay': 2.465786211798467e-10}, {'activation': 'elu', 'ag_args': {'name_suffix': '_r135', 'priority': -39}, 'dropout_prob': 0.06134755114373829, 'hidden_size': 144, 'learning_rate': 0.005834535148903802, 'num_layers': 5, 'use_batchnorm': True, 'weight_decay': 2.0826540090463376e-09}, {'activation': 'elu', 'ag_args': {'name_suffix': '_r24', 'priority': -49}, 'dropout_prob': 0.257596079691855, 'hidden_size': 168, 'learning_rate': 0.0034108596383714608, 'num_layers': 4, 'use_batchnorm': True, 'weight_decay': 1.4840689603685264e-07}, {'activation': 'relu', 'ag_args': {'name_suffix': '_r159', 'priority': -50}, 'dropout_prob': 0.16724368469920037, 'hidden_size': 44, 'learning_rate': 0.011043937174833164, 'num_layers': 4, 'use_batchnorm': False, 'weight_decay': 0.007265742373924609}], 'FASTAI': [{'ag_args': {'name_suffix': '_r25', 'priority': -6}, 'bs': 1024, 'emb_drop': 0.6167722379778131, 'epochs': 44, 'layers': [200, 100, 50], 'lr': 0.05344037785562929, 'ps': 0.48477211305443607}, {'ag_args': {'name_suffix': '_r162', 'priority': -11}, 'bs': 2048, 'emb_drop': 0.5474625640581479, 'epochs': 45, 'layers': [400, 200], 'lr': 0.0047438648957706655, 'ps': 0.07533239360470734}, {'ag_args': {'name_suffix': '_r147', 'priority': -20}, 'bs': 128, 'emb_drop': 0.6378380130337095, 'epochs': 48, 'layers': [200], 'lr': 0.058027179860229344, 'ps': 0.23253362133888375}, {'ag_args': {'name_suffix': '_r192', 'priority': -25}, 'bs': 1024, 'emb_drop': 0.0698130630643278, 'epochs': 37, 'layers': [400, 200], 'lr': 0.0018949411343821322, 'ps': 0.6526067160491229}, {'ag_args': {'name_suffix': '_r109', 'priority': -28}, 'bs': 128, 'emb_drop': 0.1978897556618756, 'epochs': 49, 'layers': [400, 200, 100], 'lr': 0.02155144303508465, 'ps': 0.005518872455908264}, {'ag_args': {'name_suffix': '_r78', 'priority': -33}, 'bs': 512, 'emb_drop': 0.4897354379753617, 'epochs': 26, 'layers': [400, 200, 100], 'lr': 0.027563880686468895, 'ps': 0.44524273881299886}, {'ag_args': {'name_suffix': '_r150', 'priority': -35}, 'bs': 2048, 'emb_drop': 0.6148607467659958, 'epochs': 27, 'layers': [400, 200], 'lr': 0.09351668652547614, 'ps': 0.5314977162016676}, {'ag_args': {'name_suffix': '_r133', 'priority': -41}, 'bs': 256, 'emb_drop': 0.6242606757570891, 'epochs': 43, 'layers': [200, 100, 50], 'lr': 0.001533613235987637, 'ps': 0.5354961132962562}, {'ag_args': {'name_suffix': '_r99', 'priority': -44}, 'bs': 512, 'emb_drop': 0.6071025838237253, 'epochs': 49, 'layers': [400, 200], 'lr': 0.02669945959641021, 'ps': 0.4897025421573259}, {'ag_args': {'name_suffix': '_r197', 'priority': -47}, 'bs': 256, 'emb_drop': 0.5277230463737563, 'epochs': 45, 'layers': [400, 200], 'lr': 0.006908743712130657, 'ps': 0.08262909528632323}]}

autogluon/tabular/configs/zeroshot/zeroshot_portfolio_gpu_2025_12_18.py

@@ -0,0 +1,2 @@
+# State-of-the-art for datasets < 100k samples. Requires a GPU with at least 20 GB VRAM.
+hyperparameter_portfolio_zeroshot_gpu_2025_12_18 = {'TABDPT': [{'ag_args': {'name_suffix': '_c1', 'priority': -3}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': False}}, {'ag_args': {'name_suffix': '_r20', 'priority': -5}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': False}, 'clip_sigma': 8, 'feature_reduction': 'subsample', 'missing_indicators': False, 'normalizer': 'quantile-uniform', 'permute_classes': False, 'temperature': 0.5}, {'ag_args': {'name_suffix': '_r1', 'priority': -7}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': False}, 'clip_sigma': 16, 'feature_reduction': 'subsample', 'missing_indicators': False, 'normalizer': 'log1p', 'permute_classes': False, 'temperature': 0.5}, {'ag_args': {'name_suffix': '_r15', 'priority': -9}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': False}, 'clip_sigma': 16, 'feature_reduction': 'subsample', 'missing_indicators': False, 'normalizer': 'standard', 'permute_classes': True, 'temperature': 0.7}, {'ag_args': {'name_suffix': '_r22', 'priority': -11}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': False}, 'clip_sigma': 8, 'feature_reduction': 'pca', 'missing_indicators': True, 'normalizer': 'robust', 'permute_classes': False, 'temperature': 0.5}], 'TABICL': [{'ag_args': {'name_suffix': '_c1', 'priority': -4}, 'ag_args_ensemble': {'refit_folds': True}}], 'MITRA': [{'ag_args': {'name_suffix': '_c1', 'priority': -12}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}}], 'TABM': [{'ag_args': {'name_suffix': '_r99', 'priority': -13}, 'amp': False, 'arch_type': 'tabm-mini', 'batch_size': 'auto', 'd_block': 880, 'd_embedding': 24, 'dropout': 0.10792355695428629, 'gradient_clipping_norm': 1.0, 'lr': 0.0013641856391615784, 'n_blocks': 5, 'num_emb_n_bins': 16, 'num_emb_type': 'pwl', 'patience': 16, 'share_training_batches': False, 'tabm_k': 32, 'weight_decay': 0.0}, {'ag_args': {'name_suffix': '_r124', 'priority': -17}, 'amp': False, 'arch_type': 'tabm-mini', 'batch_size': 'auto', 'd_block': 208, 'd_embedding': 16, 'dropout': 0.0, 'gradient_clipping_norm': 1.0, 'lr': 0.00042152744054701374, 'n_blocks': 2, 'num_emb_n_bins': 109, 'num_emb_type': 'pwl', 'patience': 16, 'share_training_batches': False, 'tabm_k': 32, 'weight_decay': 0.00014007839435474664}, {'ag_args': {'name_suffix': '_r69', 'priority': -21}, 'amp': False, 'arch_type': 'tabm-mini', 'batch_size': 'auto', 'd_block': 848, 'd_embedding': 28, 'dropout': 0.40215621636031007, 'gradient_clipping_norm': 1.0, 'lr': 0.0010413640454559532, 'n_blocks': 3, 'num_emb_n_bins': 18, 'num_emb_type': 'pwl', 'patience': 16, 'share_training_batches': False, 'tabm_k': 32, 'weight_decay': 0.0}, {'ag_args': {'name_suffix': '_r184', 'priority': -24}, 'amp': False, 'arch_type': 'tabm-mini', 'batch_size': 'auto', 'd_block': 864, 'd_embedding': 24, 'dropout': 0.0, 'gradient_clipping_norm': 1.0, 'lr': 0.0019256819924656217, 'n_blocks': 3, 'num_emb_n_bins': 3, 'num_emb_type': 'pwl', 'patience': 16, 'share_training_batches': False, 'tabm_k': 32, 'weight_decay': 0.0}, {'ag_args': {'name_suffix': '_r34', 'priority': -26}, 'amp': False, 'arch_type': 'tabm-mini', 'batch_size': 'auto', 'd_block': 896, 'd_embedding': 8, 'dropout': 0.0, 'gradient_clipping_norm': 1.0, 'lr': 0.002459175026451607, 'n_blocks': 4, 'num_emb_n_bins': 104, 'num_emb_type': 'pwl', 'patience': 16, 'share_training_batches': False, 'tabm_k': 32, 'weight_decay': 0.0006299584388562901}], 'GBM_PREP': [{'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r13', 'priority': -14}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.9923026236907, 'bagging_freq': 1, 'cat_l2': 0.014290368488, 'cat_smooth': 1.8662939903973, 'extra_trees': True, 'feature_fraction': 0.5533919718605, 'lambda_l1': 0.914411672958, 'lambda_l2': 1.90439560009, 'learning_rate': 0.0193225778401, 'max_cat_to_onehot': 18, 'min_data_in_leaf': 28, 'min_data_per_group': 54, 'num_leaves': 64}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r41', 'priority': -16}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.7215411996558, 'bagging_freq': 1, 'cat_l2': 1.887369154362, 'cat_smooth': 0.0278693980873, 'extra_trees': True, 'feature_fraction': 0.4247583287144, 'lambda_l1': 0.1129800247772, 'lambda_l2': 0.2623265718536, 'learning_rate': 0.0074201920651, 'max_cat_to_onehot': 9, 'min_data_in_leaf': 15, 'min_data_per_group': 10, 'num_leaves': 8}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r31', 'priority': -18}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.9591526242875, 'bagging_freq': 1, 'cat_l2': 1.8962346412823, 'cat_smooth': 0.0215219089995, 'extra_trees': False, 'feature_fraction': 0.5791844062459, 'lambda_l1': 0.938461750637, 'lambda_l2': 0.9899852075056, 'learning_rate': 0.0397613094741, 'max_cat_to_onehot': 27, 'min_data_in_leaf': 1, 'min_data_per_group': 39, 'num_leaves': 16}, {'ag.prep_params': [], 'ag_args': {'name_suffix': '_r21', 'priority': -20}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.7111549514262, 'bagging_freq': 1, 'cat_l2': 0.8679131150136, 'cat_smooth': 48.7244965504817, 'extra_trees': False, 'feature_fraction': 0.425140839263, 'lambda_l1': 0.5140528525242, 'lambda_l2': 0.5134051978198, 'learning_rate': 0.0134375321277, 'max_cat_to_onehot': 16, 'min_data_in_leaf': 2, 'min_data_per_group': 32, 'num_leaves': 20}, {'ag.prep_params': [[[['ArithmeticFeatureGenerator', {}]], [['CategoricalInteractionFeatureGenerator', {'passthrough': True}], ['OOFTargetEncodingFeatureGenerator', {}]]]], 'ag.prep_params.passthrough_types': {'invalid_raw_types': ['category', 'object']}, 'ag_args': {'name_suffix': '_r17', 'priority': -23}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'bagging_fraction': 0.9277474245702, 'bagging_freq': 1, 'cat_l2': 0.0731876168104, 'cat_smooth': 0.1369210915339, 'extra_trees': False, 'feature_fraction': 0.6680440910385, 'lambda_l1': 0.0125057410295, 'lambda_l2': 0.7157181359874, 'learning_rate': 0.0351342879995, 'max_cat_to_onehot': 20, 'min_data_in_leaf': 1, 'min_data_per_group': 2, 'num_leaves': 64}], 'CAT': [{'ag_args': {'name_suffix': '_c1', 'priority': -15}}], 'GBM': [{'ag_args': {'name_suffix': '_r73', 'priority': -19}, 'bagging_fraction': 0.7295548973583, 'bagging_freq': 1, 'cat_l2': 1.8025485263237, 'cat_smooth': 59.6178463268351, 'extra_trees': False, 'feature_fraction': 0.8242607305914, 'lambda_l1': 0.7265522905459, 'lambda_l2': 0.3492160682092, 'learning_rate': 0.0068803786367, 'max_cat_to_onehot': 16, 'min_data_in_leaf': 1, 'min_data_per_group': 10, 'num_leaves': 24}, {'ag_args': {'name_suffix': '_r37', 'priority': -22}, 'bagging_fraction': 0.8096374561947, 'bagging_freq': 1, 'cat_l2': 1.6385754694703, 'cat_smooth': 16.1922506671724, 'extra_trees': True, 'feature_fraction': 0.885927003286, 'lambda_l1': 0.0430386950502, 'lambda_l2': 0.2507506811761, 'learning_rate': 0.0079622660542, 'max_cat_to_onehot': 23, 'min_data_in_leaf': 7, 'min_data_per_group': 49, 'num_leaves': 6}, {'ag_args': {'name_suffix': '_r162', 'priority': -25}, 'bagging_fraction': 0.7552878818396, 'bagging_freq': 1, 'cat_l2': 0.0081083103544, 'cat_smooth': 75.7373446363438, 'extra_trees': False, 'feature_fraction': 0.6171258454584, 'lambda_l1': 0.1071522383181, 'lambda_l2': 1.7882554584069, 'learning_rate': 0.0229328987255, 'max_cat_to_onehot': 24, 'min_data_in_leaf': 23, 'min_data_per_group': 2, 'num_leaves': 125}, {'ag_args': {'name_suffix': '_r57', 'priority': -27}, 'bagging_fraction': 0.8515739264605, 'bagging_freq': 1, 'cat_l2': 0.2263901847144, 'cat_smooth': 1.7397457971767, 'extra_trees': True, 'feature_fraction': 0.6284015946887, 'lambda_l1': 0.6935431676756, 'lambda_l2': 1.7605230133162, 'learning_rate': 0.0294830579218, 'max_cat_to_onehot': 52, 'min_data_in_leaf': 8, 'min_data_per_group': 3, 'num_leaves': 43}, {'ag_args': {'name_suffix': '_r33', 'priority': -28}, 'bagging_fraction': 0.9625293420216, 'bagging_freq': 1, 'cat_l2': 0.1236875455555, 'cat_smooth': 68.8584757332856, 'extra_trees': False, 'feature_fraction': 0.6189215809382, 'lambda_l1': 0.1641757352921, 'lambda_l2': 0.6937755557881, 'learning_rate': 0.0154031028561, 'max_cat_to_onehot': 17, 'min_data_in_leaf': 1, 'min_data_per_group': 30, 'num_leaves': 68}], 'REALTABPFN-V2': [{'ag_args': {'name_suffix': '_r13', 'priority': -1}, 'ag_args_ensemble': {'model_random_seed': 104, 'vary_seed_across_folds': True}, 'balance_probabilities': False, 'inference_config/OUTLIER_REMOVAL_STD': 6, 'inference_config/POLYNOMIAL_FEATURES': 'no', 'inference_config/REGRESSION_Y_PREPROCESS_TRANSFORMS': [None, 'safepower'], 'preprocessing/append_original': False, 'preprocessing/categoricals': 'numeric', 'preprocessing/global': None, 'preprocessing/scaling': ['squashing_scaler_default', 'quantile_uni_coarse'], 'softmax_temperature': 1.0, 'zip_model_path': ['tabpfn-v2-classifier-finetuned-zk73skhh.ckpt', 'tabpfn-v2-regressor-v2_default.ckpt']}, {'ag_args': {'name_suffix': '_r106', 'priority': -2}, 'ag_args_ensemble': {'model_random_seed': 848, 'vary_seed_across_folds': True}, 'balance_probabilities': False, 'inference_config/OUTLIER_REMOVAL_STD': 6, 'inference_config/POLYNOMIAL_FEATURES': 'no', 'inference_config/REGRESSION_Y_PREPROCESS_TRANSFORMS': [None], 'preprocessing/append_original': True, 'preprocessing/categoricals': 'numeric', 'preprocessing/global': 'svd_quarter_components', 'preprocessing/scaling': ['quantile_uni_coarse'], 'softmax_temperature': 0.8, 'zip_model_path': ['tabpfn-v2-classifier-finetuned-zk73skhh.ckpt', 'tabpfn-v2-regressor-v2_default.ckpt']}, {'ag_args': {'name_suffix': '_r11', 'priority': -6}, 'ag_args_ensemble': {'model_random_seed': 88, 'vary_seed_across_folds': True}, 'balance_probabilities': True, 'inference_config/OUTLIER_REMOVAL_STD': 6, 'inference_config/POLYNOMIAL_FEATURES': 25, 'inference_config/REGRESSION_Y_PREPROCESS_TRANSFORMS': [None], 'preprocessing/append_original': True, 'preprocessing/categoricals': 'onehot', 'preprocessing/global': 'svd_quarter_components', 'preprocessing/scaling': ['safepower', 'quantile_uni'], 'softmax_temperature': 0.7, 'zip_model_path': ['tabpfn-v2-classifier-finetuned-zk73skhh.ckpt', 'tabpfn-v2-regressor-v2_default.ckpt']}, {'ag_args': {'name_suffix': '_c1', 'priority': -8}, 'ag_args_ensemble': {'model_random_seed': 0, 'vary_seed_across_folds': True}, 'zip_model_path': ['tabpfn-v2-classifier-finetuned-zk73skhh.ckpt', 'tabpfn-v2-regressor-v2_default.ckpt']}, {'ag_args': {'name_suffix': '_r196', 'priority': -10}, 'ag_args_ensemble': {'model_random_seed': 1568, 'vary_seed_across_folds': True}, 'balance_probabilities': False, 'inference_config/OUTLIER_REMOVAL_STD': 12, 'inference_config/POLYNOMIAL_FEATURES': 'no', 'inference_config/REGRESSION_Y_PREPROCESS_TRANSFORMS': ['kdi_alpha_1.0'], 'preprocessing/append_original': False, 'preprocessing/categoricals': 'numeric', 'preprocessing/global': None, 'preprocessing/scaling': ['squashing_scaler_default'], 'softmax_temperature': 1.25, 'zip_model_path': ['tabpfn-v2-classifier-finetuned-zk73skhh.ckpt', 'tabpfn-v2-regressor-v2_default.ckpt']}]}

autogluon/tabular/learner/default_learner.py

@@ -143,6 +143,7 @@ class DefaultLearner(AbstractTabularLearner):
             infer_limit=infer_limit,
             infer_limit_batch_size=infer_limit_batch_size,
             groups=groups,
+            label_cleaner=copy.deepcopy(self.label_cleaner),
             **trainer_fit_kwargs,
         )
         self.save_trainer(trainer=trainer)

autogluon/tabular/models/__init__.py

@@ -1,5 +1,6 @@
 from autogluon.core.models.abstract.abstract_model import AbstractModel
 
+from .tabprep.prep_lgb_model import PrepLGBModel
 from .automm.automm_model import MultiModalPredictorModel
 from .automm.ft_transformer import FTTransformerModel
 from .catboost.catboost_model import CatBoostModel
@@ -20,10 +21,11 @@ from .lgb.lgb_model import LGBModel
 from .lr.lr_model import LinearModel
 from .realmlp.realmlp_model import RealMLPModel
 from .rf.rf_model import RFModel
+from .tabdpt.tabdpt_model import TabDPTModel
 from .tabicl.tabicl_model import TabICLModel
 from .tabm.tabm_model import TabMModel
-from .tabpfnv2.tabpfnv2_model import TabPFNV2Model
 from .tabpfnmix.tabpfnmix_model import TabPFNMixModel
+from .tabpfnv2.tabpfnv2_5_model import RealTabPFNv2Model, RealTabPFNv25Model
 from .mitra.mitra_model import MitraModel
 from .tabular_nn.torch.tabular_nn_torch import TabularNeuralNetTorchModel
 from .text_prediction.text_prediction_v1_model import TextPredictorModel

autogluon/tabular/models/abstract/abstract_torch_model.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import logging
+
+from autogluon.core.models import AbstractModel
+
+logger = logging.getLogger(__name__)
+
+
+# TODO: Add type hints once torch is a required dependency
+class AbstractTorchModel(AbstractModel):
+    """
+    .. versionadded:: 1.5.0
+    """
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.device = None
+        self.device_train = None
+
+    def suggest_device_infer(self, verbose: bool = False) -> str:
+        import torch
+
+        # Put the model on the same device it was trained on (GPU/MPS) if it is available; otherwise use CPU
+        if self.device_train is None:
+            original_device_type = None  # skip update because no device is recorded
+        elif isinstance(self.device_train, str):
+            original_device_type = self.device_train
+        else:
+            original_device_type = self.device_train.type
+        if original_device_type is None:
+            # fallback to CPU
+            device = torch.device("cpu")
+        elif "cuda" in original_device_type:
+            # cuda: nvidia GPU
+            device = torch.device(original_device_type if torch.cuda.is_available() else "cpu")
+        elif "mps" in original_device_type:
+            # mps: Apple Silicon
+            device = torch.device(original_device_type if torch.backends.mps.is_available() else "cpu")
+        else:
+            device = torch.device(original_device_type)
+
+        if verbose and (original_device_type != device.type):
+            logger.log(
+                15,
+                f"Model is trained on {original_device_type}, but the device is not available - "
+                f"loading on {device.type}...",
+            )
+
+        return device.type
+
+    @classmethod
+    def to_torch_device(cls, device: str):
+        import torch
+        return torch.device(device)
+
+    def get_device(self) -> str:
+        """
+        Returns torch.device(...) of the fitted model
+
+        Requires implementation by the inheriting model class.
+        Refer to overriding methods in existing models for reference implementations.
+        """
+        raise NotImplementedError
+
+    def set_device(self, device: str):
+        if not isinstance(device, str):
+            device = device.type
+        self.device = device
+        self._set_device(device=device)
+
+    def _set_device(self, device: str):
+        """
+        Sets the device for the inner model object.
+
+        Requires implementation by the inheriting model class.
+        Refer to overriding methods in existing models for reference implementations.
+
+        If your model does not need to edit inner model object details, you can simply make the logic `pass`.
+        """
+        raise NotImplementedError
+
+    def _post_fit(self, **kwargs):
+        super()._post_fit(**kwargs)
+        if self._get_class_tags().get("can_set_device", False):
+            self.device_train = self.get_device()
+            self.device = self.device_train
+        return self
+
+    def save(self, path: str = None, verbose=True) -> str:
+        """
+        Need to set device to CPU to be able to load on a non-GPU environment
+        """
+        reset_device = False
+        og_device = self.device
+
+        # Save on CPU to ensure the model can be loaded without GPU
+        if self.is_fit():
+            device_save = self._get_class_tags().get("set_device_on_save_to", None)
+            if device_save is not None:
+                self.set_device(device=device_save)
+                reset_device = True
+        path = super().save(path=path, verbose=verbose)
+        # Put the model back to the device after the save
+        if reset_device:
+            self.set_device(device=og_device)
+        return path
+
+    @classmethod
+    def load(cls, path: str, reset_paths=True, verbose=True):
+        """
+        Loads the model from disk to memory.
+        The loaded model will be on the same device it was trained on (cuda/mps);
+        if the device is not available (trained on GPU, deployed on CPU), then `cpu` will be used.
+
+        Parameters
+        ----------
+        path : str
+            Path to the saved model, minus the file name.
+            This should generally be a directory path ending with a '/' character (or appropriate path separator value depending on OS).
+            The model file is typically located in os.path.join(path, cls.model_file_name).
+        reset_paths : bool, default True
+            Whether to reset the self.path value of the loaded model to be equal to path.
+            It is highly recommended to keep this value as True unless accessing the original self.path value is important.
+            If False, the actual valid path and self.path may differ, leading to strange behaviour and potential exceptions if the model needs to load any other files at a later time.
+        verbose : bool, default True
+            Whether to log the location of the loaded file.
+
+        Returns
+        -------
+        model : cls
+            Loaded model object.
+        """
+        model = super().load(path=path, reset_paths=reset_paths, verbose=verbose)
+
+        # Put the model on the same device it was trained on (GPU/MPS) if it is available; otherwise use CPU
+        if model.is_fit() and model._get_class_tags().get("set_device_on_load", False):
+            device = model.suggest_device_infer(verbose=verbose)
+            model.set_device(device=device)
+
+        return model
+
+    @classmethod
+    def _class_tags(cls):
+        return {
+            "can_set_device": True,
+            "set_device_on_save_to": "cpu",
+            "set_device_on_load": True,
+        }

autogluon/tabular/models/catboost/catboost_model.py

@@ -146,7 +146,7 @@ class CatBoostModel(AbstractModel):
         num_cols_train = len(X.columns)
         num_classes = self.num_classes if self.num_classes else 1  # self.num_classes could be None after initialization if it's a regression problem
 
-        X = self.preprocess(X)
+        X = self.preprocess(X, y=y, is_train=True)
         cat_features = list(X.select_dtypes(include="category").columns)
         X = Pool(data=X, label=y, cat_features=cat_features, weight=sample_weight)
 

autogluon/tabular/models/fastainn/tabular_nn_fastai.py

@@ -660,7 +660,11 @@ class NNFastAiTabularModel(AbstractModel):
 
     @classmethod
     def _class_tags(cls):
-        return {"can_estimate_memory_usage_static": True}
+        return {
+            "can_estimate_memory_usage_static": True,
+            "reset_torch_threads": True,
+            "reset_torch_cudnn_deterministic": True,
+        }
 
     def _more_tags(self):
         return {"can_refit_full": True}

autogluon/tabular/models/lgb/lgb_model.py

@@ -103,10 +103,46 @@ class LGBModel(AbstractModel):
             Scales linearly with the number of estimators, number of classes, and number of leaves.
             Memory usage peaks during model saving, with the peak consuming approximately 2-4x the size of the model in memory.
         """
+        data_mem_usage = get_approximate_df_mem_usage(X).sum()
+        return cls._estimate_memory_usage_common(
+            num_features=X.shape[1],
+            data_mem_usage=data_mem_usage,
+            hyperparameters=hyperparameters,
+            num_classes=num_classes,
+        )
+
+    @classmethod
+    def _estimate_memory_usage_static_lite(
+        cls,
+        num_samples: int,
+        num_features: int,
+        num_bytes_per_cell: float = 4,
+        hyperparameters: dict = None,
+        num_classes: int = 1,
+        **kwargs,
+    ) -> int:
+        data_mem_usage = num_samples * num_features * num_bytes_per_cell
+        return cls._estimate_memory_usage_common(
+            num_features=num_features,
+            data_mem_usage=data_mem_usage,
+            hyperparameters=hyperparameters,
+            num_classes=num_classes,
+        )
+
+    @classmethod
+    def _estimate_memory_usage_common(
+        cls,
+        num_features: int,
+        data_mem_usage: int | float,
+        hyperparameters: dict | None = None,
+        num_classes: int = 1,
+    ) -> int:
+        """
+        Utility method to avoid code duplication
+        """
         if hyperparameters is None:
             hyperparameters = {}
         num_classes = num_classes if num_classes else 1  # num_classes could be None after initialization if it's a regression problem
-        data_mem_usage = get_approximate_df_mem_usage(X).sum()
         data_mem_usage_bytes = data_mem_usage * 5 + data_mem_usage / 4 * num_classes  # TODO: Extremely crude approximation, can be vastly improved
 
         n_trees_per_estimator = num_classes if num_classes > 2 else 1
@@ -114,7 +150,7 @@ class LGBModel(AbstractModel):
         max_bins = hyperparameters.get("max_bins", 255)
         num_leaves = hyperparameters.get("num_leaves", 31)
         # Memory usage of histogram based on https://github.com/microsoft/LightGBM/issues/562#issuecomment-304524592
-        histogram_mem_usage_bytes = 20 * max_bins * len(X.columns) * num_leaves
+        histogram_mem_usage_bytes = 20 * max_bins * num_features * num_leaves
         histogram_mem_usage_bytes_max = hyperparameters.get("histogram_pool_size", None)
         if histogram_mem_usage_bytes_max is not None:
             histogram_mem_usage_bytes_max *= 1e6  # Convert megabytes to bytes, `histogram_pool_size` is in MB.
@@ -124,11 +160,11 @@ class LGBModel(AbstractModel):
 
         mem_size_per_estimator = n_trees_per_estimator * num_leaves * 100  # very rough estimate
         n_estimators = hyperparameters.get("num_boost_round", DEFAULT_NUM_BOOST_ROUND)
-        n_estimators_min = min(n_estimators, 1000)
-        mem_size_estimators = n_estimators_min * mem_size_per_estimator  # memory estimate after fitting up to 1000 estimators
+        n_estimators_min = min(n_estimators, 5000)
+        mem_size_estimators = n_estimators_min * mem_size_per_estimator  # memory estimate after fitting up to 5000 estimators
 
         approx_mem_size_req = data_mem_usage_bytes + histogram_mem_usage_bytes + mem_size_estimators
-        return approx_mem_size_req
+        return int(approx_mem_size_req)
 
     def _fit(self, X, y, X_val=None, y_val=None, time_limit=None, num_gpus=0, num_cpus=0, sample_weight=None, sample_weight_val=None, verbosity=2, **kwargs):
         try_import_lightgbm()  # raise helpful error message if LightGBM isn't installed
@@ -371,6 +407,9 @@ class LGBModel(AbstractModel):
         X = self.preprocess(X, **kwargs)
 
         y_pred_proba = self.model.predict(X, num_threads=num_cpus)
+        return self._post_process_predictions(y_pred_proba=y_pred_proba)
+
+    def _post_process_predictions(self, y_pred_proba) -> np.ndarray:
         if self.problem_type == QUANTILE:
             # y_pred_proba is a pd.DataFrame, need to convert
             y_pred_proba = y_pred_proba.to_numpy()
@@ -423,7 +462,7 @@ class LGBModel(AbstractModel):
         self,
         X: DataFrame,
         y: Series,
-        params,
+        params: dict,
         X_val=None,
         y_val=None,
         X_test=None,
@@ -432,11 +471,14 @@ class LGBModel(AbstractModel):
         sample_weight_val=None,
         sample_weight_test=None,
         save=False,
+        init_train=None,
+        init_val=None,
+        init_test=None,
     ):
         lgb_dataset_params_keys = ["two_round"]  # Keys that are specific to lightGBM Dataset object construction.
         data_params = {key: params[key] for key in lgb_dataset_params_keys if key in params}.copy()
 
-        X = self.preprocess(X, is_train=True)
+        X = self.preprocess(X, y=y, is_train=True)
         if X_val is not None:
             X_val = self.preprocess(X_val)
         if X_test is not None:
@@ -458,7 +500,13 @@ class LGBModel(AbstractModel):
 
         # X, W_train = self.convert_to_weight(X=X)
         dataset_train = construct_dataset(
-            x=X, y=y, location=os.path.join("self.path", "datasets", "train"), params=data_params, save=save, weight=sample_weight
+            x=X,
+            y=y,
+            location=os.path.join("self.path", "datasets", "train"),
+            params=data_params,
+            save=save,
+            weight=sample_weight,
+            init_score=init_train,
         )
         # dataset_train = construct_dataset_lowest_memory(X=X, y=y, location=self.path + 'datasets/train', params=data_params)
         if X_val is not None:
@@ -471,6 +519,7 @@ class LGBModel(AbstractModel):
                 params=data_params,
                 save=save,
                 weight=sample_weight_val,
+                init_score=init_val,
             )
             # dataset_val = construct_dataset_lowest_memory(X=X_val, y=y_val, location=self.path + 'datasets/val', reference=dataset_train, params=data_params)
         else:
@@ -485,6 +534,7 @@ class LGBModel(AbstractModel):
                 params=data_params,
                 save=save,
                 weight=sample_weight_test,
+                init_score=init_test,
             )
         else:
             dataset_test = None

autogluon/tabular/models/lgb/lgb_utils.py

@@ -104,11 +104,11 @@ def softclass_lgbobj(preds, train_data):
     return grad.flatten("F"), hess.flatten("F")
 
 
-def construct_dataset(x: DataFrame, y: Series, location=None, reference=None, params=None, save=False, weight=None):
+def construct_dataset(x: DataFrame, y: Series, location=None, reference=None, params=None, save=False, weight=None, init_score=None):
     try_import_lightgbm()
     import lightgbm as lgb
 
-    dataset = lgb.Dataset(data=x, label=y, reference=reference, free_raw_data=True, params=params, weight=weight)
+    dataset = lgb.Dataset(data=x, label=y, reference=reference, free_raw_data=True, params=params, weight=weight, init_score=init_score)
 
     if save:
         assert location is not None

autogluon/tabular/models/mitra/_internal/core/trainer_finetune.py

@@ -73,6 +73,20 @@ class TrainerFinetune(BaseEstimator):
 
         self.metric = self.cfg.hyperparams['metric']
 
+    def set_device(self, device: str):
+        self.device = device
+        self.model = self.model.to(device=device, non_blocking=True)
+
+    def post_fit_optimize(self):
+        # Minimize memory usage post-fit
+        self.checkpoint = None
+        self.optimizer = None
+        self.scaler = None
+        self.scheduler_warmup = None
+        self.scheduler_reduce_on_plateau = None
+        self.loss = None
+        self.early_stopping = None
+        self.metric = None
 
     def train(self, x_train: np.ndarray, y_train: np.ndarray, x_val: np.ndarray, y_val: np.ndarray):
 
@@ -184,7 +198,6 @@ class TrainerFinetune(BaseEstimator):
 
         self.checkpoint.set_to_best(self.model)
 
-
     def evaluate(self, x_support: np.ndarray, y_support: np.ndarray, x_query: np.ndarray, y_query: np.ndarray) -> PredictionMetrics:
 
         self.model.eval()