autogluon.tabular 1.3.2b20250711__py3-none-any.whl → 1.3.2b20250712__py3-none-any.whl

autogluon/tabular/models/tabpfnv2/rfpfn/utils.py

@@ -0,0 +1,106 @@
+"""Copyright 2023.
+
+Author: Lukas Schweizer <schweizer.lukas@web.de>
+"""
+
+#  Copyright (c) Prior Labs GmbH 2025.
+#  Licensed under the Apache License, Version 2.0
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+import torch
+# Type checking imports
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+
+def preprocess_data(
+    data,
+    nan_values=True,
+    one_hot_encoding=False,
+    normalization=True,
+    categorical_indices=None,
+):
+    """This method preprocesses data regarding missing values, categorical features
+    and data normalization (for the kNN Model)
+    :param data: Data to preprocess
+    :param nan_values: Preprocesses nan values if True
+    :param one_hot_encoding: Whether use OHE for categoricals
+    :param normalization: Normalizes data if True
+    :param categorical_indices: Categorical columns of data
+    :return: Preprocessed version of the data.
+    """
+    data = data.numpy() if torch.is_tensor(data) else data
+    data = data.astype(np.float32)
+    data = pd.DataFrame(data).reset_index().drop("index", axis=1)
+
+    if categorical_indices is None:
+        categorical_indices = []
+    preprocessed_data = data
+    # NaN values (replace NaN with zeros)
+    if nan_values:
+        preprocessed_data = preprocessed_data.fillna(0)
+    # Categorical Features (One Hot Encoding)
+    if one_hot_encoding:
+        # Setting dtypes of categorical data to 'category'
+        for idx in categorical_indices:
+            preprocessed_data[preprocessed_data.columns[idx]] = preprocessed_data[
+                preprocessed_data.columns[idx]
+            ].astype("category")
+        categorical_columns = list(
+            preprocessed_data.select_dtypes(include=["category"]).columns,
+        )
+        preprocessed_data = pd.get_dummies(
+            preprocessed_data,
+            columns=categorical_columns,
+        )
+    # Data normalization from R -> [0, 1]
+    if normalization:
+        if one_hot_encoding:
+            numerical_columns = list(
+                preprocessed_data.select_dtypes(exclude=["category"]).columns,
+            )
+            preprocessed_data[numerical_columns] = preprocessed_data[
+                numerical_columns
+            ].apply(
+                lambda x: (x - x.min()) / (x.max() - x.min())
+                if x.max() != x.min()
+                else x,
+            )
+        else:
+            preprocessed_data = preprocessed_data.apply(
+                lambda x: (x - x.min()) / (x.max() - x.min())
+                if x.max() != x.min()
+                else x,
+            )
+    return preprocessed_data
+
+def softmax(logits: NDArray) -> NDArray:
+    """Apply softmax function to convert logits to probabilities.
+
+    Args:
+        logits: Input logits array of shape (n_samples, n_classes) or (n_classes,)
+
+    Returns:
+        Probabilities where values sum to 1 across the last dimension
+    """
+    # Handle both 2D and 1D inputs
+    if logits.ndim == 1:
+        logits = logits.reshape(1, -1)
+
+    # Apply exponential to each logit with numerical stability
+    logits_max = np.max(logits, axis=1, keepdims=True)
+    exp_logits = np.exp(logits - logits_max)  # Subtract max for numerical stability
+
+    # Sum across classes and normalize
+    sum_exp_logits = np.sum(exp_logits, axis=1, keepdims=True)
+    probs = exp_logits / sum_exp_logits
+
+    # Return in the same shape as input
+    if logits.ndim == 1:
+        return probs.reshape(-1)
+    return probs

autogluon/tabular/models/tabpfnv2/tabpfnv2_model.py

@@ -0,0 +1,376 @@
+"""
+Code Adapted from TabArena: https://github.com/autogluon/tabrepo/blob/main/tabrepo/benchmark/models/ag/tabpfnv2/tabpfnv2_model.py
+
+Model: TabPFNv2
+Paper: Accurate predictions on small data with a tabular foundation model
+Authors: Noah Hollmann, Samuel Müller, Lennart Purucker, Arjun Krishnakumar, Max Körfer, Shi Bin Hoo, Robin Tibor Schirrmeister & Frank Hutter
+Codebase: https://github.com/PriorLabs/TabPFN
+License: https://github.com/PriorLabs/TabPFN/blob/main/LICENSE
+"""
+
+from __future__ import annotations
+
+import logging
+import warnings
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import scipy
+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
+
+logger = logging.getLogger(__name__)
+
+_HAS_LOGGED_TABPFN_LICENSE: bool = False
+
+
+# TODO: merge into TabPFnv2 codebase
+class FixedSafePowerTransformer(PowerTransformer):
+    """Fixed version of safe power."""
+
+    def __init__(
+        self,
+        variance_threshold: float = 1e-3,
+        large_value_threshold: float = 100,
+        method="yeo-johnson",
+        standardize=True,
+        copy=True,
+    ):
+        super().__init__(method=method, standardize=standardize, copy=copy)
+        self.variance_threshold = variance_threshold
+        self.large_value_threshold = large_value_threshold
+
+        self.revert_indices_ = None
+
+    def _find_features_to_revert_because_of_failure(
+        self,
+        transformed_X: np.ndarray,
+    ) -> None:
+        # Calculate the variance for each feature in the transformed data
+        variances = np.nanvar(transformed_X, axis=0)
+
+        # Identify features where the variance is not close to 1
+        mask = np.abs(variances - 1) > self.variance_threshold
+        non_unit_variance_indices = np.where(mask)[0]
+
+        # Identify features with values greater than the large_value_threshold
+        large_value_indices = np.any(transformed_X > self.large_value_threshold, axis=0)
+        large_value_indices = np.nonzero(large_value_indices)[0]
+
+        # Identify features to revert based on either condition
+        self.revert_indices_ = np.unique(
+            np.concatenate([non_unit_variance_indices, large_value_indices]),
+        )
+
+    def _yeo_johnson_optimize(self, x: np.ndarray) -> float:
+        try:
+            with warnings.catch_warnings():
+                warnings.filterwarnings(
+                    "ignore",
+                    message=r"overflow encountered",
+                    category=RuntimeWarning,
+                )
+                return super()._yeo_johnson_optimize(x)  # type: ignore
+        except scipy.optimize._optimize.BracketError:
+            return np.nan
+
+    def _yeo_johnson_transform(self, x: np.ndarray, lmbda: float) -> np.ndarray:
+        if np.isnan(lmbda):
+            return x
+
+        return super()._yeo_johnson_transform(x, lmbda)  # type: ignore
+
+    def _revert_failed_features(
+        self,
+        transformed_X: np.ndarray,
+        original_X: np.ndarray,
+    ) -> np.ndarray:
+        # Replace these features with the original features
+        if self.revert_indices_ and (self.revert_indices_) > 0:
+            transformed_X[:, self.revert_indices_] = original_X[:, self.revert_indices_]
+
+        return transformed_X
+
+    def fit(self, X: np.ndarray, y: Any | None = None) -> FixedSafePowerTransformer:
+        super().fit(X, y)
+
+        # Check and revert features as necessary
+        self._find_features_to_revert_because_of_failure(super().transform(X))  # type: ignore
+        return self
+
+    def transform(self, X: np.ndarray) -> np.ndarray:
+        transformed_X = super().transform(X)
+        return self._revert_failed_features(transformed_X, X)  # type: ignore
+
+
+class TabPFNV2Model(AbstractModel):
+    ag_key = "TABPFNV2"
+    ag_name = "TabPFNv2"
+    ag_priority = 105
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._feature_generator = None
+        self._cat_features = None
+
+    def _preprocess(self, X: pd.DataFrame, is_train=False, **kwargs) -> pd.DataFrame:
+        X = super()._preprocess(X, **kwargs)
+        self._cat_indices = []
+
+        if is_train:
+            # X will be the training data.
+            self._feature_generator = LabelEncoderFeatureGenerator(verbosity=0)
+            self._feature_generator.fit(X=X)
+
+        # This converts categorical features to numeric via stateful label encoding.
+        if self._feature_generator.features_in:
+            X = X.copy()
+            X[self._feature_generator.features_in] = self._feature_generator.transform(
+                X=X
+            )
+
+            # Detect/set cat features and indices
+            if self._cat_features is None:
+                self._cat_features = self._feature_generator.features_in[:]
+            self._cat_indices = [X.columns.get_loc(col) for col in self._cat_features]
+
+        return X
+
+    # FIXME: Crashes during model download if bagging with parallel fit.
+    #  Consider adopting same download logic as TabPFNMix which doesn't crash during model download.
+    # FIXME: Maybe support child_oof somehow with using only one model and being smart about inference time?
+    def _fit(
+        self,
+        X: pd.DataFrame,
+        y: pd.Series,
+        num_cpus: int = 1,
+        num_gpus: int = 0,
+        verbosity: int = 2,
+        **kwargs,
+    ):
+        try:
+            from tabpfn.model import preprocessing
+        except ImportError as err:
+            logger.log(
+                40,
+                f"\tFailed to import tabpfn! To use the TabPFNv2 model, "
+                f"do: `pip install autogluon.tabular[tabpfn]=={__version__}`.",
+            )
+            raise err
+
+        preprocessing.SafePowerTransformer = FixedSafePowerTransformer
+
+        from tabpfn import TabPFNClassifier, TabPFNRegressor
+        from tabpfn.model.loading import resolve_model_path
+        from torch.cuda import is_available
+
+        is_classification = self.problem_type in ["binary", "multiclass"]
+
+        model_base = TabPFNClassifier if is_classification else TabPFNRegressor
+
+        device = "cuda" if num_gpus != 0 else "cpu"
+        if (device == "cuda") and (not is_available()):
+            # FIXME: warn instead and switch to CPU.
+            raise AssertionError(
+                "Fit specified to use GPU, but CUDA is not available on this machine. "
+                "Please switch to CPU usage instead.",
+            )
+
+        if verbosity >= 2:
+            # logs "Built with PriorLabs-TabPFN"
+            self._log_license(device=device)
+
+        X = self.preprocess(X, is_train=True)
+
+        hps = self._get_model_params()
+        hps["device"] = device
+        hps["n_jobs"] = num_cpus
+        hps["categorical_features_indices"] = self._cat_indices
+
+        _, model_dir, _, _ = resolve_model_path(
+            model_path=None,
+            which="classifier" if is_classification else "regressor",
+        )
+        if is_classification:
+            if "classification_model_path" in hps:
+                hps["model_path"] = model_dir / hps.pop("classification_model_path")
+            if "regression_model_path" in hps:
+                del hps["regression_model_path"]
+        else:
+            if "regression_model_path" in hps:
+                hps["model_path"] = model_dir / hps.pop("regression_model_path")
+            if "classification_model_path" in hps:
+                del hps["classification_model_path"]
+
+        # Resolve inference_config
+        inference_config = {
+            _k: v
+            for k, v in hps.items()
+            if k.startswith("inference_config/") and (_k := k.split("/")[-1])
+        }
+        if inference_config:
+            hps["inference_config"] = inference_config
+        for k in list(hps.keys()):
+            if k.startswith("inference_config/"):
+                del hps[k]
+
+        # TODO: remove power from search space and TabPFNv2 codebase
+        # Power transform can fail. To avoid this, make all power be safepower instead.
+        if "PREPROCESS_TRANSFORMS" in inference_config:
+            safe_config = []
+            for preprocessing_dict in inference_config["PREPROCESS_TRANSFORMS"]:
+                if preprocessing_dict["name"] == "power":
+                    preprocessing_dict["name"] = "safepower"
+                safe_config.append(preprocessing_dict)
+            inference_config["PREPROCESS_TRANSFORMS"] = safe_config
+        if "REGRESSION_Y_PREPROCESS_TRANSFORMS" in inference_config:
+            safe_config = []
+            for preprocessing_name in inference_config[
+                "REGRESSION_Y_PREPROCESS_TRANSFORMS"
+            ]:
+                if preprocessing_name == "power":
+                    preprocessing_name = "safepower"
+                safe_config.append(preprocessing_name)
+            inference_config["REGRESSION_Y_PREPROCESS_TRANSFORMS"] = safe_config
+
+        # Resolve model_type
+        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,
+            )
+
+            hps["n_estimators"] = 1
+            rf_model_base = (
+                RandomForestTabPFNClassifier
+                if is_classification
+                else RandomForestTabPFNRegressor
+            )
+            self.model = rf_model_base(
+                tabpfn=model_base(**hps),
+                categorical_features=self._cat_indices,
+                n_estimators=n_ensemble_repeats,
+            )
+        else:
+            if n_ensemble_repeats is not None:
+                hps["n_estimators"] = n_ensemble_repeats
+            self.model = model_base(**hps)
+
+        self.model = self.model.fit(
+            X=X,
+            y=y,
+        )
+
+    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
+            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."
+                )
+            _HAS_LOGGED_TABPFN_LICENSE = True  # Avoid repeated logging
+
+    def _get_default_resources(self) -> tuple[int, int]:
+        num_cpus = ResourceManager.get_cpu_count(only_physical_cores=True)
+        num_gpus = min(ResourceManager.get_gpu_count_torch(), 1)
+        return num_cpus, num_gpus
+
+    def _set_default_params(self):
+        default_params = {
+            "random_state": 42,
+            "ignore_pretraining_limits": True,  # to ignore warnings and size limits
+        }
+        for param, val in default_params.items():
+            self._set_default_param_value(param, val)
+
+    @classmethod
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass", "regression"]
+
+    def _get_default_auxiliary_params(self) -> dict:
+        default_auxiliary_params = super()._get_default_auxiliary_params()
+        default_auxiliary_params.update(
+            {
+                "max_rows": 10000,
+                "max_features": 500,
+                "max_classes": 10,
+            }
+        )
+        return default_auxiliary_params
+
+    @classmethod
+    def _get_default_ag_args_ensemble(cls, **kwargs) -> dict:
+        """Set fold_fitting_strategy to sequential_local,
+        as parallel folding crashes if model weights aren't pre-downloaded.
+        """
+        default_ag_args_ensemble = super()._get_default_ag_args_ensemble(**kwargs)
+        extra_ag_args_ensemble = {
+            # FIXME: Find a work-around to avoid crash if parallel and weights are not downloaded
+            "fold_fitting_strategy": "sequential_local",
+            "refit_folds": True,  # Better to refit the model for faster inference and similar quality as the bag.
+        }
+        default_ag_args_ensemble.update(extra_ag_args_ensemble)
+        return default_ag_args_ensemble
+
+    def _estimate_memory_usage(self, X: pd.DataFrame, **kwargs) -> int:
+        hyperparameters = self._get_model_params()
+        return self.estimate_memory_usage_static(
+            X=X,
+            problem_type=self.problem_type,
+            num_classes=self.num_classes,
+            hyperparameters=hyperparameters,
+            **kwargs,
+        )
+
+    @classmethod
+    def _estimate_memory_usage_static(
+        cls,
+        *,
+        X: pd.DataFrame,
+        hyperparameters: dict | None = None,
+        **kwargs,
+    ) -> int:
+        """Heuristic memory estimate based on TabPFN's memory estimate logic in:
+        https://github.com/PriorLabs/TabPFN/blob/57a2efd3ebdb3886245e4d097cefa73a5261a969/src/tabpfn/model/memory.py#L147.
+
+        This is based on GPU memory usage, but hopefully with overheads it also approximates CPU memory usage.
+        """
+        # features_per_group = 2  # Based on TabPFNv2 default (unused)
+        n_layers = 12  # Based on TabPFNv2 default
+        embedding_size = 192  # Based on TabPFNv2 default
+        dtype_byte_size = 2  # Based on TabPFNv2 default
+
+        model_mem = 14489108  # Based on TabPFNv2 default
+
+        n_samples, n_features = X.shape[0], X.shape[1]
+        n_feature_groups = n_features + 1  # TODO: Unsure how to calculate this
+
+        X_mem = n_samples * n_feature_groups * dtype_byte_size
+        activation_mem = (
+            n_samples * n_feature_groups * embedding_size * n_layers * dtype_byte_size
+        )
+
+        baseline_overhead_mem_est = 1e9  # 1 GB generic overhead
+
+        # Add some buffer to each term + 1 GB overhead to be safe
+        return int(
+            model_mem + 4 * X_mem + 1.5 * activation_mem + baseline_overhead_mem_est
+        )
+
+    @classmethod
+    def _class_tags(cls):
+        return {"can_estimate_memory_usage_static": True}
+
+    def _more_tags(self) -> dict:
+        return {"can_refit_full": True}

autogluon/tabular/registry/_ag_model_registry.py

@@ -25,7 +25,7 @@ from ..models import (
     TabICLModel,
     TabMModel,
     TabPFNMixModel,
-    TabPFNModel,
+    TabPFNV2Model,
     TabularNeuralNetTorchModel,
     TextPredictorModel,
     XGBoostModel,
@@ -51,8 +51,8 @@ REGISTERED_MODEL_CLS_LST = [
     FTTransformerModel,
     TabICLModel,
     TabMModel,
-    TabPFNModel,
     TabPFNMixModel,
+    TabPFNV2Model,
     FastTextModel,
     GreedyWeightedEnsembleModel,
     SimpleWeightedEnsembleModel,

autogluon/tabular/version.py

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

{autogluon.tabular-1.3.2b20250711.dist-info → autogluon.tabular-1.3.2b20250712.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.tabular
-Version: 1.3.2b20250711
+Version: 1.3.2b20250712
 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.2b20250711
-Requires-Dist: autogluon.features==1.3.2b20250711
+Requires-Dist: autogluon.core==1.3.2b20250712
+Requires-Dist: autogluon.features==1.3.2b20250712
 Provides-Extra: all
-Requires-Dist: lightgbm<4.7,>=4.0; extra == "all"
-Requires-Dist: autogluon.core[all]==1.3.2b20250711; extra == "all"
 Requires-Dist: spacy<3.9; extra == "all"
-Requires-Dist: xgboost<3.1,>=2.0; extra == "all"
-Requires-Dist: fastai<2.9,>=2.3.1; extra == "all"
 Requires-Dist: catboost<1.3,>=1.2; extra == "all"
-Requires-Dist: huggingface-hub[torch]; extra == "all"
-Requires-Dist: numpy<2.3.0,>=1.25; extra == "all"
 Requires-Dist: einops<0.9,>=0.7; extra == "all"
-Requires-Dist: torch<2.8,>=2.2; extra == "all"
+Requires-Dist: lightgbm<4.7,>=4.0; extra == "all"
+Requires-Dist: numpy<2.3.0,>=1.25; extra == "all"
+Requires-Dist: autogluon.core[all]==1.3.2b20250712; extra == "all"
+Requires-Dist: fastai<2.9,>=2.3.1; extra == "all"
 Requires-Dist: pytabkit<1.6,>=1.5; extra == "all"
+Requires-Dist: xgboost<3.1,>=2.0; extra == "all"
+Requires-Dist: torch<2.8,>=2.2; extra == "all"
+Requires-Dist: huggingface-hub[torch]; extra == "all"
 Provides-Extra: catboost
 Requires-Dist: numpy<2.3.0,>=1.25; extra == "catboost"
 Requires-Dist: catboost<1.3,>=1.2; extra == "catboost"
@@ -67,7 +67,7 @@ Requires-Dist: imodels<2.1.0,>=1.3.10; extra == "imodels"
 Provides-Extra: lightgbm
 Requires-Dist: lightgbm<4.7,>=4.0; extra == "lightgbm"
 Provides-Extra: ray
-Requires-Dist: autogluon.core[all]==1.3.2b20250711; extra == "ray"
+Requires-Dist: autogluon.core[all]==1.3.2b20250712; extra == "ray"
 Provides-Extra: realmlp
 Requires-Dist: pytabkit<1.6,>=1.5; extra == "realmlp"
 Provides-Extra: skex
@@ -83,15 +83,13 @@ Requires-Dist: tabicl<0.2,>=0.1.3; extra == "tabicl"
 Provides-Extra: tabm
 Requires-Dist: torch<2.8,>=2.2; extra == "tabm"
 Provides-Extra: tabpfn
-Requires-Dist: tabpfn<2.0,>=0.1.11; extra == "tabpfn"
+Requires-Dist: tabpfn<2.2,>=2.0.9; extra == "tabpfn"
 Provides-Extra: tabpfnmix
 Requires-Dist: torch<2.8,>=2.2; extra == "tabpfnmix"
 Requires-Dist: huggingface-hub[torch]; extra == "tabpfnmix"
 Requires-Dist: einops<0.9,>=0.7; extra == "tabpfnmix"
 Provides-Extra: tests
-Requires-Dist: torch<2.8,>=2.2; extra == "tests"
-Requires-Dist: huggingface-hub[torch]; extra == "tests"
-Requires-Dist: einops<0.9,>=0.7; extra == "tests"
+Requires-Dist: tabpfn<2.2,>=2.0.9; extra == "tests"
 Requires-Dist: imodels<2.1.0,>=1.3.10; extra == "tests"
 Requires-Dist: skl2onnx<1.18.0,>=1.15.0; extra == "tests"
 Requires-Dist: onnxruntime<1.20.0,>=1.17.0; extra == "tests"

{autogluon.tabular-1.3.2b20250711.dist-info → autogluon.tabular-1.3.2b20250712.dist-info}/RECORD

@@ -1,6 +1,6 @@
-autogluon.tabular-1.3.2b20250711-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.tabular-1.3.2b20250712-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/tabular/__init__.py,sha256=2OXpJCvENRHubBTYNIPpHX93WWuFZzsJBtTZbNVHVas,400
-autogluon/tabular/version.py,sha256=v0iakvttW3DdrV3QLVZS9POR34hhZdNc3hc0eVzEc6k,91
+autogluon/tabular/version.py,sha256=C6OW_vajErF7r9El7B0X_XkhCzzEn70hhuGbhroLKSU,91
 autogluon/tabular/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/configs/config_helper.py,sha256=JsdVGmpcYL88GPKBznPtqJ1sGaByOSvLn7KWU-HyVoQ,21085
 autogluon/tabular/configs/feature_generator_presets.py,sha256=EV5Ym8VW15q92MwOUpTi7wZFS2QooM51fLg3RdUsn-M,1223
@@ -16,7 +16,7 @@ autogluon/tabular/experimental/plot_leaderboard.py,sha256=BN_kB-zmOZNUYWyI7z9pF6
 autogluon/tabular/learner/__init__.py,sha256=Hhmk5WpKQHohVmI-veOaKMelKJpIdzeXrmw_DPn3DTU,63
 autogluon/tabular/learner/abstract_learner.py,sha256=0kf0huvg0nphe-lrdKtNTzdIFr14jzJPsfZDRBkKo3g,55253
 autogluon/tabular/learner/default_learner.py,sha256=hjdKbcFtIQxQ3-k1LiGOo-w5sLxIIQAyFLs3-R35aw0,24781
-autogluon/tabular/models/__init__.py,sha256=yxyjo4hzfpSR42swWVcT-4iDh24H-5lctafb2_P1zuY,1168
+autogluon/tabular/models/__init__.py,sha256=x6hmZ0RhFIznnO1UFrHrcu0wRFTV8sGZN_SwoXdW1u8,1174
 autogluon/tabular/models/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/_utils/rapids_utils.py,sha256=9A2Y10Owva6zhcLkBVQ_T4tOAMDp1idSMzDWhl_QyBI,1083
 autogluon/tabular/models/_utils/torch_utils.py,sha256=dxs_KMMAOmNkRNjYf_hrzqaHIfkqn1xoKRKqCFbQ1Rk,537
@@ -83,8 +83,6 @@ autogluon/tabular/models/tabm/_tabm_internal.py,sha256=LbIohrZYnXiKbD1ZnXWDJQMBL
 autogluon/tabular/models/tabm/rtdl_num_embeddings.py,sha256=omDKJT0MjniUPUnk8tSU-brE8dXIjw27BHFbYc2bswQ,30119
 autogluon/tabular/models/tabm/tabm_model.py,sha256=43I8429yTq5U2IDp6ATZB27lyewAW20VzdbPxS-01sA,10115
 autogluon/tabular/models/tabm/tabm_reference.py,sha256=h9FXzyeu6b4vXg9nnM3L2I8dYbcE39USr9C4uMnt4Ek,21788
-autogluon/tabular/models/tabpfn/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon/tabular/models/tabpfn/tabpfn_model.py,sha256=PEYMuIh5TFLIDy3hcjfz1DcvDu77rbwRq0pKWyuUR04,6787
 autogluon/tabular/models/tabpfnmix/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/tabpfnmix/tabpfnmix_model.py,sha256=7cLjAfstq6Xb-l2DxBdwtSAIanSJN2sMfKPtijDQwXo,16193
 autogluon/tabular/models/tabpfnmix/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -111,6 +109,15 @@ autogluon/tabular/models/tabpfnmix/_internal/models/foundation/embedding.py,sha2
 autogluon/tabular/models/tabpfnmix/_internal/models/foundation/foundation_transformer.py,sha256=bhNpGIA5BKqIVX-kDW4bZLgsOB_A8iNsnpgoyyBLR98,5383
 autogluon/tabular/models/tabpfnmix/_internal/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/tabpfnmix/_internal/results/prediction_metrics.py,sha256=1tRPHyViSSLJ7BkQJi6wai-PwXJ56od86Dy1WWKWZq4,1743
+autogluon/tabular/models/tabpfnv2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autogluon/tabular/models/tabpfnv2/tabpfnv2_model.py,sha256=DC4t-woswX3mWYRWF6zMfpjEtPZXJ9qgr-mKxWVFs3w,14254
+autogluon/tabular/models/tabpfnv2/rfpfn/__init__.py,sha256=yE5XAhGxKEFV0JcelZ_JTQZIWGlVEVUQ9a-lxcH_Esc,585
+autogluon/tabular/models/tabpfnv2/rfpfn/configs.py,sha256=lzBY9kKOeBZACVrtRDPHF4ATs9g1rxyNnIs2CMjE20c,1175
+autogluon/tabular/models/tabpfnv2/rfpfn/scoring_utils.py,sha256=uvHsfvnnMdg4tP3_7zAilktkw7nr65LaqfVKXabXAow,6785
+autogluon/tabular/models/tabpfnv2/rfpfn/sklearn_based_decision_tree_tabpfn.py,sha256=-KQNm_HYWem6HWUsdbnIX4lKe-eW0PQAXZUny2kqego,55582
+autogluon/tabular/models/tabpfnv2/rfpfn/sklearn_based_random_forest_tabpfn.py,sha256=FRJSelTtDaKnpsKKHphjy2rJrFX302miSdHZ0YqHxCQ,28045
+autogluon/tabular/models/tabpfnv2/rfpfn/sklearn_compat.py,sha256=jv2ZHsGwcO4Inhxtol_tig3NoXZQR649dhmW_Kv69QY,29607
+autogluon/tabular/models/tabpfnv2/rfpfn/utils.py,sha256=vjMQsNaZZcW1BBf0hduSCtrNCtSd467xfkhsbHspUog,3489
 autogluon/tabular/models/tabular_nn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/tabular_nn/compilers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/tabular_nn/compilers/native.py,sha256=W8d8cqBj7U-KVhfGK3hdtGj8JJm3lXr_SecU0615Gbs,1330
@@ -141,7 +148,7 @@ autogluon/tabular/predictor/__init__.py,sha256=zCMgjxQlWpDWnr1l1xjBCiK3rWC3N3RoD
 autogluon/tabular/predictor/interpretable_predictor.py,sha256=5UeKgnMFsfY65tiO3kxfHBPr03lyswLrgdtjPhI0Y7Q,6934
 autogluon/tabular/predictor/predictor.py,sha256=cjszntXs6k5BZMOaLGaMiC1e2sGkCsnXrH9rVI972-0,356548
 autogluon/tabular/registry/__init__.py,sha256=vZpzX4Xve7bfA9crt5LxjgQv9PPfxbi1E1U6Im0Y_xU,93
-autogluon/tabular/registry/_ag_model_registry.py,sha256=Jz9V7IGBosbYCjDmkgUhGvAVXQ6fVwSuB23OB4txSMo,1514
+autogluon/tabular/registry/_ag_model_registry.py,sha256=6Rro0BBN3yb34Ysi2hffuJDdP9eV6el2HjQ-a48N2-E,1518
 autogluon/tabular/registry/_model_registry.py,sha256=Rl8Q7BLzaif4hxNxJF20xGE02vrWwh2ZuUaTmA-UJnE,6824
 autogluon/tabular/testing/__init__.py,sha256=XrEGLmMdmRT6QHNR13M9wna57LO4O3Q4tt27Ca8omAc,79
 autogluon/tabular/testing/fit_helper.py,sha256=dzyzIBD9s7Ekb_inoAE6sep3bW9QKeYqO4WcDzAhAwg,19818
@@ -155,11 +162,11 @@ autogluon/tabular/trainer/model_presets/presets.py,sha256=hoWADaOG576Q_XLV1nY_ju
 autogluon/tabular/trainer/model_presets/presets_distill.py,sha256=MnFC2GJc6RmDBNAGbsO2XMfo3PjR8cUrZoilWW8gTYQ,3295
 autogluon/tabular/tuning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/tuning/feature_pruner.py,sha256=9iNku8gVbYEkjuKlyITPJDicsNkoraaQOlINQq9iZlQ,6877
-autogluon.tabular-1.3.2b20250711.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.tabular-1.3.2b20250711.dist-info/METADATA,sha256=H3u2cwrwzE0Z2RjaOZsjmL-8e5O2veEKF_u88DCaB0A,14394
-autogluon.tabular-1.3.2b20250711.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.tabular-1.3.2b20250711.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.tabular-1.3.2b20250711.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.tabular-1.3.2b20250711.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.tabular-1.3.2b20250711.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.tabular-1.3.2b20250711.dist-info/RECORD,,
+autogluon.tabular-1.3.2b20250712.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.tabular-1.3.2b20250712.dist-info/METADATA,sha256=6abZh-VsVqsBp5JZrRellfiGEvoKRi5z2c3LGRUfJDI,14290
+autogluon.tabular-1.3.2b20250712.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.tabular-1.3.2b20250712.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.tabular-1.3.2b20250712.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.tabular-1.3.2b20250712.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.tabular-1.3.2b20250712.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.tabular-1.3.2b20250712.dist-info/RECORD,,

autogluon/tabular/models/tabpfn/__init__.py

@@ -1 +0,0 @@
-