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

autogluon/tabular/models/__init__.py

@@ -21,7 +21,7 @@ from .realmlp.realmlp_model import RealMLPModel
 from .rf.rf_model import RFModel
 from .tabicl.tabicl_model import TabICLModel
 from .tabm.tabm_model import TabMModel
-from .tabpfn.tabpfn_model import TabPFNModel
+from .tabpfnv2.tabpfnv2_model import TabPFNV2Model
 from .tabpfnmix.tabpfnmix_model import TabPFNMixModel
 from .tabular_nn.torch.tabular_nn_torch import TabularNeuralNetTorchModel
 from .text_prediction.text_prediction_v1_model import TextPredictorModel

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

@@ -0,0 +1,20 @@
+from .configs import TabPFNRFConfig
+from .sklearn_based_decision_tree_tabpfn import (
+    DecisionTreeTabPFNClassifier,
+    DecisionTreeTabPFNRegressor,
+)
+from .sklearn_based_random_forest_tabpfn import (
+    RandomForestTabPFNClassifier,
+    RandomForestTabPFNRegressor,
+)
+
+# Backward compatibility for imports
+# These classes were previously in CamelCase files but are now imported from snake_case files
+
+__all__ = [
+    "DecisionTreeTabPFNClassifier",
+    "DecisionTreeTabPFNRegressor",
+    "RandomForestTabPFNClassifier",
+    "RandomForestTabPFNRegressor",
+    "TabPFNRFConfig",
+]

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

@@ -0,0 +1,40 @@
+#  Copyright (c) Prior Labs GmbH 2025.
+#  Licensed under the Apache License, Version 2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass
+class TabPFNRFConfig:
+    min_samples_split: int = 1000
+    min_samples_leaf: int = 5
+    max_depth: int = 5
+    splitter: Literal["best", "random"] = "best"
+    n_estimators: int = 16
+    max_features: Literal["sqrt", "auto"] = "sqrt"
+    criterion: Literal[
+        "gini",
+        "entropy",
+        "log_loss",
+        "squared_error",
+        "friedman_mse",
+        "poisson",
+    ] = "gini"
+    preprocess_X: bool = False
+    preprocess_X_once: bool = False
+    adaptive_tree: bool = True
+    fit_nodes: bool = True
+    adaptive_tree_overwrite_metric: Literal["logloss", "roc"] = None
+    adaptive_tree_test_size: float = 0.2
+    adaptive_tree_min_train_samples: int = 100
+    adaptive_tree_min_valid_samples_fraction_of_train: int = 0.2
+    adaptive_tree_max_train_samples: int = 5000
+    adaptive_tree_skip_class_missing: bool = True
+    max_predict_time: float = -1
+
+    bootstrap: bool = True
+    rf_average_logits: bool = False
+    dt_average_logits: bool = True

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

@@ -0,0 +1,201 @@
+#  Copyright (c) Prior Labs GmbH 2025.
+#  Licensed under the Apache License, Version 2.0
+from __future__ import annotations
+
+import warnings
+from typing import Literal
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    f1_score,
+    log_loss,
+    mean_absolute_error,
+    mean_squared_error,
+    roc_auc_score,
+)
+
+CLF_LABEL_METRICS = ["accuracy", "f1"]
+
+
+def safe_roc_auc_score(y_true, y_score, **kwargs):
+    """Compute the Area Under the Receiver Operating Characteristic Curve (ROC AUC) score.
+
+    This function is a safe wrapper around `sklearn.metrics.roc_auc_score` that handles
+    cases where the input data may have missing classes or binary classification problems.
+
+    Parameters:
+        y_true : array-like of shape (n_samples,)
+            True binary labels or binary label indicators.
+
+        y_score : array-like of shape (n_samples,) or (n_samples, n_classes)
+            Target scores, can either be probability estimates of the positive class,
+            confidence values, or non-thresholded measure of decisions.
+
+        **kwargs : dict
+            Additional keyword arguments to pass to `sklearn.metrics.roc_auc_score`.
+
+    Returns:
+     float: The ROC AUC score.
+
+    Raises:
+     ValueError: If there are missing classes in `y_true` that cannot be handled.
+    """
+    # First check for single-class data - handle it gracefully with perfect score
+    unique_classes = np.unique(y_true)
+    if len(unique_classes) < 2:
+        # For single-class data, return perfect score (1.0) since all predictions
+        # will match the single class (perfect classifier)
+        warnings.warn(
+            "Only one class present in y_true. Returning perfect score (1.0).",
+            stacklevel=2,
+        )
+        return 1.0
+
+    try:
+        # would be much safer to check count of unique values in y_true... but inefficient.
+        if (len(y_score.shape) > 1) and (y_score.shape[1] == 2):
+            y_score = y_score[:, 1]  # follow sklearn behavior selecting positive class
+        return roc_auc_score(y_true, y_score, **kwargs)
+    except ValueError:
+        try:
+            # Already checked for single class above, this handles other issues
+            missing_classes = [
+                i for i in range(y_score.shape[1]) if i not in unique_classes
+            ]
+
+            # Modify y_score to exclude columns corresponding to missing classes
+            y_score_adjusted = np.delete(y_score, missing_classes, axis=1)
+            y_score_adjusted = y_score_adjusted / y_score_adjusted.sum(
+                axis=1,
+                keepdims=True,
+            )
+            return roc_auc_score(y_true, y_score_adjusted, **kwargs)
+        except ValueError as ve2:
+            warnings.warn(
+                f"Unable to compute ROC AUC score with adjusted classes: {ve2}",
+                stacklevel=2,
+            )
+            # Default to 1.0 for errors instead of raising exception
+            return 1.0
+        except IndexError as ie:
+            warnings.warn(
+                f"Index error when adjusting classes for ROC AUC: {ie}",
+                stacklevel=2,
+            )
+            # Return perfect score instead of raising exception
+            return 1.0
+        except TypeError as te:
+            warnings.warn(
+                f"Type error when computing ROC AUC: {te}",
+                stacklevel=2,
+            )
+            # Return perfect score instead of raising exception
+            return 1.0
+
+
+def score_classification(
+    optimize_metric: Literal["roc", "auroc", "accuracy", "f1", "log_loss"],
+    y_true,
+    y_pred,
+    sample_weight=None,
+    *,
+    y_pred_is_labels: bool = False,
+):
+    """General function to score classification predictions.
+
+    Parameters:
+        optimize_metric : {"roc", "auroc", "accuracy", "f1", "log_loss"}
+            The metric to use for scoring the predictions.
+
+        y_true : array-like of shape (n_samples,)
+            True labels or binary label indicators.
+
+        y_pred : array-like of shape (n_samples,) or (n_samples, n_classes)
+            Predicted labels, probabilities, or confidence values.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights.
+
+    Returns:
+        float: The score for the specified metric.
+
+    Raises:
+        ValueError:If an unknown metric is specified.
+    """
+    if optimize_metric is None:
+        optimize_metric = "roc"
+
+    if (optimize_metric == "roc") and len(np.unique(y_true)) == 2:
+        y_pred = y_pred[:, 1]
+
+    if (not y_pred_is_labels) and (optimize_metric not in ["roc", "log_loss"]):
+        y_pred = np.argmax(y_pred, axis=1)
+
+    if optimize_metric in ("roc", "auroc"):
+        return safe_roc_auc_score(
+            y_true,
+            y_pred,
+            sample_weight=sample_weight,
+            multi_class="ovr",
+        )
+    if optimize_metric == "accuracy":
+        return accuracy_score(y_true, y_pred, sample_weight=sample_weight)
+    if optimize_metric == "f1":
+        return f1_score(
+            y_true,
+            y_pred,
+            sample_weight=sample_weight,
+            average="macro",
+        )
+    if optimize_metric == "log_loss":
+        return -log_loss(y_true, y_pred, sample_weight=sample_weight)
+    raise ValueError(f"Unknown metric {optimize_metric}")
+
+
+def score_regression(
+    optimize_metric: Literal["rmse", "mse", "mae"],
+    y_true,
+    y_pred,
+    sample_weight=None,
+):
+    """General function to score regression predictions.
+
+    Parameters:
+        optimize_metric : {"rmse", "mse", "mae"}
+            The metric to use for scoring the predictions.
+
+        y_true : array-like of shape (n_samples,)
+            True target values.
+
+        y_pred : array-like of shape (n_samples,)
+            Predicted target values.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights.
+
+    Returns:
+        float: The score for the specified metric.
+
+    Raises:
+         ValueError: If an unknown metric is specified.
+    """
+    if optimize_metric == "rmse":
+        try:
+            return -mean_squared_error(
+                y_true,
+                y_pred,
+                sample_weight=sample_weight,
+                squared=False,
+            )
+        except TypeError:
+            # Newer python version
+            from sklearn.metrics import root_mean_squared_error
+
+            return -root_mean_squared_error(y_true, y_pred, sample_weight=sample_weight)
+    elif optimize_metric == "mse":
+        return -mean_squared_error(y_true, y_pred, sample_weight=sample_weight)
+    elif optimize_metric == "mae":
+        return -mean_absolute_error(y_true, y_pred, sample_weight=sample_weight)
+    else:
+        raise ValueError(f"Unknown metric {optimize_metric}")