autogluon.tabular 1.3.2b20250715__py3-none-any.whl → 1.3.2b20250717__py3-none-any.whl

autogluon/tabular/models/mitra/sklearn_interface.py

@@ -1,20 +1,21 @@
-import numpy as np
 import time
-import torch
-import pandas as pd
-
 from pathlib import Path
+import contextlib
+
+import numpy as np
+import pandas as pd
+import torch
 from sklearn.base import BaseEstimator, ClassifierMixin, RegressorMixin
 
-from ._internal.data.dataset_split import make_stratified_dataset_split
 from ._internal.config.config_run import ConfigRun
+from ._internal.config.enums import ModelName
 from ._internal.core.trainer_finetune import TrainerFinetune
+from ._internal.data.dataset_split import make_stratified_dataset_split
 from ._internal.models.tab2d import Tab2D
-from ._internal.config.enums import ModelName
 
 # Hyperparameter search space
 DEFAULT_FINE_TUNE = True # [True, False]
-DEFAULT_FINE_TUNE_STEPS = 50 # [50, 60, 70, 80, 90, 100] 
+DEFAULT_FINE_TUNE_STEPS = 50 # [50, 60, 70, 80, 90, 100]
 DEFAULT_CLS_METRIC = 'log_loss' # ['log_loss', 'accuracy', 'auc']
 DEFAULT_REG_METRIC = 'mse' # ['mse', 'mae', 'rmse', 'r2']
 SHUFFLE_CLASSES = False # [True, False]
@@ -32,7 +33,17 @@ DEFAULT_REG_MODEL = 'autogluon/mitra-regressor'
 # Constants
 SEED = 0
 DEFAULT_MODEL_TYPE = "Tab2D"
-DEFAULT_DEVICE = "cuda"
+
+def _get_default_device():
+    """Get the best available device for the current system."""
+    if torch.cuda.is_available():
+        return "cuda"
+    elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
+        return "mps"  # Apple silicon
+    else:
+        return "cpu"
+
+DEFAULT_DEVICE = _get_default_device()
 DEFAULT_ENSEMBLE = 1
 DEFAULT_DIM = 512
 DEFAULT_LAYERS = 12
@@ -43,13 +54,13 @@ USE_HF = True  # Use Hugging Face pretrained models if available
 
 class MitraBase(BaseEstimator):
     """Base class for Mitra models with common functionality."""
-    
-    def __init__(self, 
-            model_type=DEFAULT_MODEL_TYPE, 
-            n_estimators=DEFAULT_ENSEMBLE, 
-            device=DEFAULT_DEVICE, 
+
+    def __init__(self,
+            model_type=DEFAULT_MODEL_TYPE,
+            n_estimators=DEFAULT_ENSEMBLE,
+            device=DEFAULT_DEVICE,
             fine_tune=DEFAULT_FINE_TUNE,
-            fine_tune_steps=DEFAULT_FINE_TUNE_STEPS, 
+            fine_tune_steps=DEFAULT_FINE_TUNE_STEPS,
             metric=DEFAULT_CLS_METRIC,
             state_dict=None,
             hf_general_model=DEFAULT_GENERAL_MODEL,
@@ -155,7 +166,7 @@ class MitraBase(BaseEstimator):
 
         return cfg, Tab2D
 
-    
+
     def _split_data(self, X, y):
         """Split data into training and validation sets."""
         if hasattr(self, 'task') and self.task == 'classification':
@@ -165,7 +176,7 @@ class MitraBase(BaseEstimator):
             val_indices = np.random.choice(range(len(X)), int(DEFAULT_VALIDATION_SPLIT * len(X)), replace=False).tolist()
             train_indices = [i for i in range(len(X)) if i not in val_indices]
             return X[train_indices], X[val_indices], y[train_indices], y[val_indices]
-    
+
     def _train_ensemble(self, X_train, y_train, X_valid, y_valid, task, dim_output, n_classes=0, time_limit=None):
         """Train the ensemble of models."""
 
@@ -175,7 +186,7 @@ class MitraBase(BaseEstimator):
         while not (success and cfg.hyperparams["max_samples_support"] > 0 and cfg.hyperparams["max_samples_query"] > 0):
             try:
                 self.trainers.clear()
-                
+
                 self.train_time = 0
                 for _ in range(self.n_estimators):
                     if USE_HF:
@@ -212,7 +223,7 @@ class MitraBase(BaseEstimator):
 
                     self.trainers.append(trainer)
                     self.train_time += end_time - start_time
-                    
+
                     success = True
 
             except torch.cuda.OutOfMemoryError:
@@ -233,24 +244,24 @@ class MitraBase(BaseEstimator):
                     )
                     print(f"Reducing max_samples_query from {cfg.hyperparams['max_samples_query'] * 2}"
                           f"to {cfg.hyperparams['max_samples_query']} due to OOM error.")
-                    
+
         if not success:
             raise RuntimeError(
-                f"Failed to train Mitra model after multiple attempts due to out of memory error."
+                "Failed to train Mitra model after multiple attempts due to out of memory error."
             )
-        
+
         return self
 
 
 class MitraClassifier(MitraBase, ClassifierMixin):
     """Classifier implementation of Mitra model."""
 
-    def __init__(self, 
-            model_type=DEFAULT_MODEL_TYPE, 
-            n_estimators=DEFAULT_ENSEMBLE, 
-            device=DEFAULT_DEVICE, 
+    def __init__(self,
+            model_type=DEFAULT_MODEL_TYPE,
+            n_estimators=DEFAULT_ENSEMBLE,
+            device=DEFAULT_DEVICE,
             fine_tune=DEFAULT_FINE_TUNE,
-            fine_tune_steps=DEFAULT_FINE_TUNE_STEPS, 
+            fine_tune_steps=DEFAULT_FINE_TUNE_STEPS,
             metric=DEFAULT_CLS_METRIC,
             state_dict=None,
             patience=PATIENCE,
@@ -265,12 +276,12 @@ class MitraClassifier(MitraBase, ClassifierMixin):
         ):
         """Initialize the classifier."""
         super().__init__(
-            model_type, 
-            n_estimators, 
-            device, 
+            model_type,
+            n_estimators,
+            device,
             fine_tune,
             fine_tune_steps,
-            metric, 
+            metric,
             state_dict,
             patience=patience,
             lr=lr,
@@ -283,7 +294,7 @@ class MitraClassifier(MitraBase, ClassifierMixin):
             seed=seed,
         )
         self.task = 'classification'
-    
+
     def fit(self, X, y, X_val = None, y_val = None, time_limit = None):
         """
         Fit the ensemble of models.
@@ -301,23 +312,25 @@ class MitraClassifier(MitraBase, ClassifierMixin):
             Returns self
         """
 
-        if isinstance(X, pd.DataFrame):
-            X = X.values
-        if isinstance(y, pd.Series):
-            y = y.values
+        with mitra_deterministic_context():
 
-        self.X, self.y = X, y
+            if isinstance(X, pd.DataFrame):
+                X = X.values
+            if isinstance(y, pd.Series):
+                y = y.values
 
-        if X_val is not None and y_val is not None:
-            if isinstance(X_val, pd.DataFrame):
-                X_val = X_val.values
-            if isinstance(y_val, pd.Series):
-                y_val = y_val.values
-            X_train, X_valid, y_train, y_valid = X, X_val, y, y_val
-        else:
-            X_train, X_valid, y_train, y_valid = self._split_data(X, y)
+            self.X, self.y = X, y
+
+            if X_val is not None and y_val is not None:
+                if isinstance(X_val, pd.DataFrame):
+                    X_val = X_val.values
+                if isinstance(y_val, pd.Series):
+                    y_val = y_val.values
+                X_train, X_valid, y_train, y_valid = X, X_val, y, y_val
+            else:
+                X_train, X_valid, y_train, y_valid = self._split_data(X, y)
 
-        return self._train_ensemble(X_train, y_train, X_valid, y_valid, self.task, DEFAULT_CLASSES, n_classes=DEFAULT_CLASSES, time_limit=time_limit)
+            return self._train_ensemble(X_train, y_train, X_valid, y_valid, self.task, DEFAULT_CLASSES, n_classes=DEFAULT_CLASSES, time_limit=time_limit)
 
     def predict(self, X):
         """
@@ -353,26 +366,30 @@ class MitraClassifier(MitraBase, ClassifierMixin):
         p : ndarray of shape (n_samples, n_classes)
             The class probabilities of the input samples
         """
-        if isinstance(X, pd.DataFrame):
-            X = X.values
 
-        preds = []
-        for trainer in self.trainers:
-            logits = trainer.predict(self.X, self.y, X)[...,:len(np.unique(self.y))] # Remove extra classes
-            preds.append(np.exp(logits) / np.exp(logits).sum(axis=1, keepdims=True)) # Softmax
-        preds = sum(preds) / len(preds)  # Averaging ensemble predictions
-        return preds
+        with mitra_deterministic_context():
+
+            if isinstance(X, pd.DataFrame):
+                X = X.values
+
+            preds = []
+            for trainer in self.trainers:
+                logits = trainer.predict(self.X, self.y, X)[...,:len(np.unique(self.y))] # Remove extra classes
+                preds.append(np.exp(logits) / np.exp(logits).sum(axis=1, keepdims=True)) # Softmax
+            preds = sum(preds) / len(preds)  # Averaging ensemble predictions
+
+            return preds
 
 
 class MitraRegressor(MitraBase, RegressorMixin):
     """Regressor implementation of Mitra model."""
 
-    def __init__(self, 
-            model_type=DEFAULT_MODEL_TYPE, 
-            n_estimators=DEFAULT_ENSEMBLE, 
-            device=DEFAULT_DEVICE, 
+    def __init__(self,
+            model_type=DEFAULT_MODEL_TYPE,
+            n_estimators=DEFAULT_ENSEMBLE,
+            device=DEFAULT_DEVICE,
             fine_tune=DEFAULT_FINE_TUNE,
-            fine_tune_steps=DEFAULT_FINE_TUNE_STEPS, 
+            fine_tune_steps=DEFAULT_FINE_TUNE_STEPS,
             metric=DEFAULT_REG_METRIC,
             state_dict=None,
             patience=PATIENCE,
@@ -387,12 +404,12 @@ class MitraRegressor(MitraBase, RegressorMixin):
         ):
         """Initialize the regressor."""
         super().__init__(
-            model_type, 
-            n_estimators, 
-            device, 
+            model_type,
+            n_estimators,
+            device,
             fine_tune,
             fine_tune_steps,
-            metric, 
+            metric,
             state_dict,
             patience=patience,
             lr=lr,
@@ -423,23 +440,25 @@ class MitraRegressor(MitraBase, RegressorMixin):
             Returns self
         """
 
-        if isinstance(X, pd.DataFrame):
-            X = X.values
-        if isinstance(y, pd.Series):
-            y = y.values
+        with mitra_deterministic_context():
 
-        self.X, self.y = X, y
+            if isinstance(X, pd.DataFrame):
+                X = X.values
+            if isinstance(y, pd.Series):
+                y = y.values
 
-        if X_val is not None and y_val is not None:
-            if isinstance(X_val, pd.DataFrame):
-                X_val = X_val.values
-            if isinstance(y_val, pd.Series):
-                y_val = y_val.values
-            X_train, X_valid, y_train, y_valid = X, X_val, y, y_val
-        else:
-            X_train, X_valid, y_train, y_valid = self._split_data(X, y)
+            self.X, self.y = X, y
+
+            if X_val is not None and y_val is not None:
+                if isinstance(X_val, pd.DataFrame):
+                    X_val = X_val.values
+                if isinstance(y_val, pd.Series):
+                    y_val = y_val.values
+                X_train, X_valid, y_train, y_valid = X, X_val, y, y_val
+            else:
+                X_train, X_valid, y_train, y_valid = self._split_data(X, y)
 
-        return self._train_ensemble(X_train, y_train, X_valid, y_valid, self.task, 1, time_limit=time_limit)
+            return self._train_ensemble(X_train, y_train, X_valid, y_valid, self.task, 1, time_limit=time_limit)
 
     def predict(self, X):
         """
@@ -455,8 +474,30 @@ class MitraRegressor(MitraBase, RegressorMixin):
         y : ndarray of shape (n_samples,)
             The predicted values
         """
-        if isinstance(X, pd.DataFrame):
-            X = X.values
+
+        with mitra_deterministic_context():
+
+            if isinstance(X, pd.DataFrame):
+                X = X.values
+            
+            preds = []
+            for trainer in self.trainers:
+                preds.append(trainer.predict(self.X, self.y, X))
+        
+            return sum(preds) / len(preds)  # Averaging ensemble predictions
+    
+
+@contextlib.contextmanager
+def mitra_deterministic_context():
+    """Context manager to set deterministic settings only for Mitra operations."""
+    
+    original_deterministic_algorithms_set = False
+
+    try:
+        torch.use_deterministic_algorithms(True)
+        original_deterministic_algorithms_set = True
+        yield
         
-        preds = [trainer.predict(self.X, self.y, X) for trainer in self.trainers]
-        return sum(preds) / len(preds)  # Averaging ensemble predictions
+    finally:
+        if original_deterministic_algorithms_set:
+            torch.use_deterministic_algorithms(False)

autogluon/tabular/models/realmlp/realmlp_model.py

@@ -55,7 +55,12 @@ class RealMLPModel(AbstractModel):
         self._bool_to_cat = None
 
     def get_model_cls(self, default_hyperparameters: Literal["td", "td_s"] = "td"):
-        from pytabkit import RealMLP_TD_Classifier, RealMLP_TD_Regressor, RealMLP_TD_S_Classifier, RealMLP_TD_S_Regressor
+        from pytabkit import (
+            RealMLP_TD_Classifier,
+            RealMLP_TD_Regressor,
+            RealMLP_TD_S_Classifier,
+            RealMLP_TD_S_Regressor,
+        )
 
         assert default_hyperparameters in ["td", "td_s"]
         if self.problem_type in ['binary', 'multiclass']:
@@ -267,9 +272,11 @@ class RealMLPModel(AbstractModel):
         return self.eval_metric
 
     def _get_default_resources(self) -> tuple[int, int]:
-        # only_physical_cores=True is faster in training
+        # Use only physical cores for better performance based on benchmarks
         num_cpus = ResourceManager.get_cpu_count(only_physical_cores=True)
-        num_gpus = min(ResourceManager.get_gpu_count_torch(), 1)
+
+        num_gpus = min(1, ResourceManager.get_gpu_count_torch(cuda_only=True))
+
         return num_cpus, num_gpus
 
     def _estimate_memory_usage(self, X: pd.DataFrame, **kwargs) -> int:
@@ -345,3 +352,4 @@ class RealMLPModel(AbstractModel):
         #  How to mirror RealMLP learning rate scheduler while forcing stopping at a specific epoch?
         tags = {"can_refit_full": False}
         return tags
+        return tags

autogluon/tabular/models/tabicl/tabicl_model.py

@@ -109,8 +109,10 @@ class TabICLModel(AbstractModel):
         return ["binary", "multiclass"]
 
     def _get_default_resources(self) -> tuple[int, int]:
+        # Use only physical cores for better performance based on benchmarks
         num_cpus = ResourceManager.get_cpu_count(only_physical_cores=True)
-        num_gpus = min(ResourceManager.get_gpu_count_torch(), 1)
+
+        num_gpus = min(1, ResourceManager.get_gpu_count_torch(cuda_only=True))
         return num_cpus, num_gpus
 
     def _estimate_memory_usage(self, X: pd.DataFrame, **kwargs) -> int:

autogluon/tabular/models/tabm/_tabm_internal.py

@@ -12,13 +12,14 @@ import numpy as np
 import pandas as pd
 import scipy
 import torch
-from autogluon.core.metrics import compute_metric
 from sklearn.base import BaseEstimator, TransformerMixin
 from sklearn.impute import SimpleImputer
 from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import OrdinalEncoder, QuantileTransformer
 from sklearn.utils.validation import check_is_fitted
 
+from autogluon.core.metrics import compute_metric
+
 from . import rtdl_num_embeddings, tabm_reference
 from .tabm_reference import make_parameter_groups
 
@@ -468,7 +469,7 @@ class TabMImplementation:
                 best = {"val": val_score, "epoch": epoch}
                 remaining_patience = patience
                 with torch.no_grad():
-                    for bp, p in zip(best_params, model.parameters(), strict=False):
+                    for bp, p in zip(best_params, model.parameters()):
                         bp.copy_(p)
             else:
                 remaining_patience -= 1
@@ -481,7 +482,7 @@ class TabMImplementation:
 
         logger.log(15, "Restoring best model")
         with torch.no_grad():
-            for bp, p in zip(best_params, model.parameters(), strict=False):
+            for bp, p in zip(best_params, model.parameters()):
                 p.copy_(bp)
 
         self.model_ = model

autogluon/tabular/models/tabm/tabm_model.py

@@ -19,6 +19,7 @@ import logging
 import time
 
 import pandas as pd
+
 from autogluon.common.utils.resource_utils import ResourceManager
 from autogluon.core.models import AbstractModel
 from autogluon.tabular import __version__
@@ -55,8 +56,9 @@ class TabMModel(AbstractModel):
 
         try:
             # imports various dependencies such as torch
-            from ._tabm_internal import TabMImplementation
             from torch.cuda import is_available
+
+            from ._tabm_internal import TabMImplementation
         except ImportError as err:
             logger.log(
                 40,
@@ -146,9 +148,10 @@ class TabMModel(AbstractModel):
         return self.eval_metric
 
     def _get_default_resources(self) -> tuple[int, int]:
-        # only_physical_cores=True is faster in training
+        # Use only physical cores for better performance based on benchmarks
         num_cpus = ResourceManager.get_cpu_count(only_physical_cores=True)
-        num_gpus = min(ResourceManager.get_gpu_count_torch(), 1)
+
+        num_gpus = min(1, ResourceManager.get_gpu_count_torch(cuda_only=True))
         return num_cpus, num_gpus
 
     def _estimate_memory_usage(self, X: pd.DataFrame, **kwargs) -> int:

autogluon/tabular/models/tabm/tabm_reference.py

@@ -4,7 +4,7 @@
 # The minimum required versions of the dependencies are specified in README.md.
 
 import itertools
-from typing import Any, Literal
+from typing import Any, Literal, Union
 
 import torch
 import torch.nn as nn
@@ -159,9 +159,9 @@ class LinearEfficientEnsemble(nn.Module):
     avoids the term "adapter".
     """
 
-    r: None | Tensor
-    s: None | Tensor
-    bias: None | Tensor
+    r: Union[None, Tensor]
+    s: Union[None, Tensor]
+    bias: Union[None, Tensor]
 
     def __init__(
         self,
@@ -259,8 +259,8 @@ class MLP(nn.Module):
     def __init__(
         self,
         *,
-        d_in: None | int = None,
-        d_out: None | int = None,
+        d_in: Union[None, int] = None,
+        d_out: Union[None, int] = None,
         n_blocks: int,
         d_block: int,
         dropout: float,
@@ -386,19 +386,21 @@ def default_zero_weight_decay_condition(
     del module_name, parameter
     return parameter_name.endswith('bias') or isinstance(
         module,
-        nn.BatchNorm1d
-        | nn.LayerNorm
-        | nn.InstanceNorm1d
-        | rtdl_num_embeddings.LinearEmbeddings
-        | rtdl_num_embeddings.LinearReLUEmbeddings
-        | _Periodic,
+        (
+            nn.BatchNorm1d,
+            nn.LayerNorm,
+            nn.InstanceNorm1d,
+            rtdl_num_embeddings.LinearEmbeddings,
+            rtdl_num_embeddings.LinearReLUEmbeddings,
+            _Periodic,
+        ),
     )
 
 
 def make_parameter_groups(
     module: nn.Module,
     zero_weight_decay_condition=default_zero_weight_decay_condition,
-    custom_groups: None | list[dict[str, Any]] = None,
+    custom_groups: Union[None, list[dict[str, Any]]] = None,
 ) -> list[dict[str, Any]]:
     if custom_groups is None:
         custom_groups = []
@@ -439,10 +441,10 @@ class Model(nn.Module):
         *,
         n_num_features: int,
         cat_cardinalities: list[int],
-        n_classes: None | int,
+        n_classes: Union[None, int],
         backbone: dict,
-        bins: None | list[Tensor],  # For piecewise-linear encoding/embeddings.
-        num_embeddings: None | dict = None,
+        bins: Union[None, list[Tensor]],  # For piecewise-linear encoding/embeddings.
+        num_embeddings: Union[None, dict] = None,
         arch_type: Literal[
             # Plain feed-forward network without any kind of ensembling.
             'plain',
@@ -464,7 +466,7 @@ class Model(nn.Module):
             # This variant was not used in the paper.
             'tabm-mini-normal',
         ],
-        k: None | int = None,
+        k: Union[None, int] = None,
         share_training_batches: bool = True,
     ) -> None:
         # >>> Validate arguments.
@@ -593,7 +595,7 @@ class Model(nn.Module):
         self.share_training_batches = share_training_batches
 
     def forward(
-        self, x_num: None | Tensor = None, x_cat: None | Tensor = None
+        self, x_num: Union[None, Tensor] = None, x_cat: Union[None, Tensor] = None
     ) -> Tensor:
         x = []
         if x_num is not None:
@@ -624,4 +626,4 @@ class Model(nn.Module):
             # with the rest of the script (loss, metrics, predictions, ...).
             # (B, D_OUT) -> (B, 1, D_OUT)
             x = x[:, None]
-        return x
+        return x

autogluon/tabular/models/tabpfnv2/tabpfnv2_model.py

@@ -16,11 +16,12 @@ from typing import TYPE_CHECKING, Any
 
 import numpy as np
 import scipy
+from sklearn.preprocessing import PowerTransformer
+
 from autogluon.common.utils.resource_utils import ResourceManager
 from autogluon.core.models import AbstractModel
 from autogluon.features.generators import LabelEncoderFeatureGenerator
 from autogluon.tabular import __version__
-from sklearn.preprocessing import PowerTransformer
 
 if TYPE_CHECKING:
     import pandas as pd
@@ -243,10 +244,7 @@ class TabPFNV2Model(AbstractModel):
         n_ensemble_repeats = hps.pop("n_ensemble_repeats", None)
         model_is_rf_pfn = hps.pop("model_type", "no") == "dt_pfn"
         if model_is_rf_pfn:
-            from .rfpfn import (
-                RandomForestTabPFNClassifier,
-                RandomForestTabPFNRegressor,
-            )
+            from .rfpfn import RandomForestTabPFNClassifier, RandomForestTabPFNRegressor
 
             hps["n_estimators"] = 1
             rf_model_base = (
@@ -272,18 +270,21 @@ class TabPFNV2Model(AbstractModel):
     def _log_license(self, device: str):
         global _HAS_LOGGED_TABPFN_LICENSE
         if not _HAS_LOGGED_TABPFN_LICENSE:
-            logger.log(20, f"\tBuilt with PriorLabs-TabPFN")  # Aligning with TabPFNv2 license requirements
+            logger.log(20, "\tBuilt with PriorLabs-TabPFN")  # Aligning with TabPFNv2 license requirements
             if device == "cpu":
                 logger.log(
                     20,
-                    f"\tRunning TabPFNv2 on CPU. This can be very slow. "
-                    f"It is recommended to run TabPFNv2 on a GPU."
+                    "\tRunning TabPFNv2 on CPU. This can be very slow. "
+                    "It is recommended to run TabPFNv2 on a GPU."
                 )
             _HAS_LOGGED_TABPFN_LICENSE = True  # Avoid repeated logging
 
     def _get_default_resources(self) -> tuple[int, int]:
+        # Use only physical cores for better performance based on benchmarks
         num_cpus = ResourceManager.get_cpu_count(only_physical_cores=True)
-        num_gpus = min(ResourceManager.get_gpu_count_torch(), 1)
+
+        num_gpus = min(1, ResourceManager.get_gpu_count_torch(cuda_only=True))
+
         return num_cpus, num_gpus
 
     def _set_default_params(self):

autogluon/tabular/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.3.2b20250715"
+__version__ = "1.3.2b20250717"
 __lite__ = False

{autogluon.tabular-1.3.2b20250715.dist-info → autogluon.tabular-1.3.2b20250717.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.tabular
-Version: 1.3.2b20250715
+Version: 1.3.2b20250717
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -41,20 +41,20 @@ Requires-Dist: scipy<1.17,>=1.5.4
 Requires-Dist: pandas<2.4.0,>=2.0.0
 Requires-Dist: scikit-learn<1.8.0,>=1.4.0
 Requires-Dist: networkx<4,>=3.0
-Requires-Dist: autogluon.core==1.3.2b20250715
-Requires-Dist: autogluon.features==1.3.2b20250715
+Requires-Dist: autogluon.core==1.3.2b20250717
+Requires-Dist: autogluon.features==1.3.2b20250717
 Provides-Extra: all
+Requires-Dist: einops<0.9,>=0.7; extra == "all"
 Requires-Dist: spacy<3.9; extra == "all"
+Requires-Dist: huggingface-hub[torch]; extra == "all"
+Requires-Dist: autogluon.core[all]==1.3.2b20250717; extra == "all"
+Requires-Dist: lightgbm<4.7,>=4.0; extra == "all"
 Requires-Dist: torch<2.8,>=2.2; extra == "all"
+Requires-Dist: pytabkit<1.6,>=1.5; extra == "all"
+Requires-Dist: fastai<2.9,>=2.3.1; extra == "all"
 Requires-Dist: xgboost<3.1,>=2.0; extra == "all"
 Requires-Dist: numpy<2.3.0,>=1.25; extra == "all"
-Requires-Dist: lightgbm<4.7,>=4.0; extra == "all"
-Requires-Dist: huggingface-hub[torch]; extra == "all"
-Requires-Dist: autogluon.core[all]==1.3.2b20250715; extra == "all"
 Requires-Dist: catboost<1.3,>=1.2; extra == "all"
-Requires-Dist: fastai<2.9,>=2.3.1; extra == "all"
-Requires-Dist: einops<0.9,>=0.7; extra == "all"
-Requires-Dist: pytabkit<1.6,>=1.5; extra == "all"
 Provides-Extra: catboost
 Requires-Dist: numpy<2.3.0,>=1.25; extra == "catboost"
 Requires-Dist: catboost<1.3,>=1.2; extra == "catboost"
@@ -72,7 +72,7 @@ Requires-Dist: einx; extra == "mitra"
 Requires-Dist: omegaconf; extra == "mitra"
 Requires-Dist: transformers; extra == "mitra"
 Provides-Extra: ray
-Requires-Dist: autogluon.core[all]==1.3.2b20250715; extra == "ray"
+Requires-Dist: autogluon.core[all]==1.3.2b20250717; extra == "ray"
 Provides-Extra: realmlp
 Requires-Dist: pytabkit<1.6,>=1.5; extra == "realmlp"
 Provides-Extra: skex