TabPFN

@misc{grinsztajn2025tabpfn,
  title={TabPFN-2.5: Advancing the State of the Art in Tabular Foundation Models},
  author={Léo Grinsztajn and Klemens Flöge and Oscar Key and Felix Birkel and Philipp Jund and Brendan Roof and
          Benjamin Jäger and Dominik Safaric and Simone Alessi and Adrian Hayler and Mihir Manium and Rosen Yu and
          Felix Jablonski and Shi Bin Hoo and Anurag Garg and Jake Robertson and Magnus Bühler and Vladyslav Moroshan and
          Lennart Purucker and Clara Cornu and Lilly Charlotte Wehrhahn and Alessandro Bonetto and
          Bernhard Schölkopf and Sauraj Gambhir and Noah Hollmann and Frank Hutter},
  year={2025},
  eprint={2511.08667},
  archivePrefix={arXiv},
  url={https://arxiv.org/abs/2511.08667},
}

@article{hollmann2025tabpfn,
 title={Accurate predictions on small data with a tabular foundation model},
 author={Hollmann, Noah and M{\"u}ller, Samuel and Purucker, Lennart and
         Krishnakumar, Arjun and K{\"o}rfer, Max and Hoo, Shi Bin and
         Schirrmeister, Robin Tibor and Hutter, Frank},
 journal={Nature},
 year={2025},
 month={01},
 day={09},
 doi={10.1038/s41586-024-08328-6},
 publisher={Springer Nature},
 url={https://www.nature.com/articles/s41586-024-08328-6},
}

@inproceedings{hollmann2023tabpfn,
  title={TabPFN: A transformer that solves small tabular classification problems in a second},
  author={Hollmann, Noah and M{\"u}ller, Samuel and Eggensperger, Katharina and Hutter, Frank},
  booktitle={International Conference on Learning Representations 2023},
  year={2023}
}

Recommended row and feature limits vary by checkpoint — see the Models page for the per-release limits. As a quick reference, the current default (TabPFN-3) supports up to 1,000,000 × 200, 100,000 × 2,000, or 1,000 × 20,000 (rows × features); larger feature counts trade off against row capacity. The previous default (TabPFN-2.6) is recommended for up to 100,000 rows and 2,000 features. If your dataset exceeds the recommended limits for your checkpoint, you can subsample, set ignore_pretraining_limits=True to push past the size guardrail, or upgrade to a release with a higher limit.

TabPFN requires Python 3.9+ due to newer language features. Compatible versions: 3.9, 3.10, 3.11, 3.12, 3.13.

On first use, TabPFN will automatically open a browser window where you can log in via PriorLabs and accept the license terms. Your authentication token is cached locally so you only need to do this once.

For headless / CI environments where a browser is not available, visit https://ux.priorlabs.ai, go to the License tab to accept the license, and then set the TABPFN_TOKEN environment variable with a token obtained from your account.

If access via the browser-based flow is not an option for you, please contact us at sales@priorlabs.ai.

TabPFN automatically downloads model weights when first used. For offline usage:

Using the Provided Download Script

If you have the TabPFN repository, you can use the included script to download all models (including ensemble variants):

# After installing TabPFN
python scripts/download_all_models.py

This script will download the main classifier and regressor models, as well as all ensemble variant models to your system's default cache directory.

Manual Download

1. Download the model files manually from HuggingFace:

   • Classifier: tabpfn-v3-classifier-20260506.ckpt
   • Regressor: tabpfn-v3-regressor-20260506.ckpt

2. Place the file in one of these locations:

   • Specify directly: TabPFNClassifier(model_path="/path/to/model.ckpt")
   • Set environment variable: export TABPFN_MODEL_CACHE_DIR="/path/to/dir" (see environment variables FAQ below)
   • Default OS cache directory:
     • Windows: %APPDATA%\tabpfn\
     • macOS: ~/Library/Caches/tabpfn/
     • Linux: ~/.cache/tabpfn/

Try the following:

• Download the newest version of tabpfn pip install tabpfn --upgrade
• Ensure model files downloaded correctly (re-download if needed)

TabPFN uses Pydantic settings for configuration, supporting environment variables and .env files:

Authentication:

• TABPFN_TOKEN: Provide a PriorLabs authentication token directly (useful for headless/CI environments). Obtain one from https://ux.priorlabs.ai.
• TABPFN_NO_BROWSER: Set to disable automatic browser-based login (e.g. in environments where opening a browser is undesirable).

Model Configuration:

• TABPFN_MODEL_CACHE_DIR: Custom directory for caching downloaded TabPFN models (default: platform-specific user cache directory)
• TABPFN_ALLOW_CPU_LARGE_DATASET: Allow running TabPFN on CPU with large datasets (>1000 samples). Set to true to override the CPU limitation. Note: This will be very slow!

PyTorch Settings:

• PYTORCH_CUDA_ALLOC_CONF: PyTorch CUDA memory allocation configuration to optimize GPU memory usage (default: max_split_size_mb:512). See PyTorch CUDA documentation for more information.

Example:

export TABPFN_MODEL_CACHE_DIR="/path/to/models"
export TABPFN_ALLOW_CPU_LARGE_DATASET=true
export PYTORCH_CUDA_ALLOC_CONF="max_split_size_mb:512"

Or simply set them in your .env

Use :func:save_fitted_tabpfn_model to persist a fitted estimator and reload it later with :func:load_fitted_tabpfn_model (or the corresponding load_from_fit_state class methods).

from tabpfn import TabPFNRegressor
from tabpfn.model_loading import (
    load_fitted_tabpfn_model,
    save_fitted_tabpfn_model,
)

# Train the regressor on GPU
reg = TabPFNRegressor(device="cuda")
reg.fit(X_train, y_train)
save_fitted_tabpfn_model(reg, "my_reg.tabpfn_fit")

# Later or on a CPU-only machine
reg_cpu = load_fitted_tabpfn_model("my_reg.tabpfn_fit", device="cpu")

To store just the foundation model weights (without a fitted estimator) use save_tabpfn_model(reg.model_, "my_tabpfn.ckpt"). This merely saves a checkpoint of the pre-trained weights so you can later create and fit a fresh estimator. Reload the checkpoint with load_model_criterion_config.

Yes!

Best practices:

• Feature engineering: Add domain-specific features to improve model performance
• See the Improving Performance guide for the full escalation path

Not effective:

• Adapt feature scaling
• Convert categorical features to numerical values (e.g., one-hot encoding)

Each TabPFN release publishes a default classification and regression checkpoint. Some releases also publish a handful of experimental variants — these aren't guaranteed to exist for every release. We recommend starting with the defaults; the variants are experimental and worse on average. When present, they can be used as part of an ensembling or hyperparameter optimization system, or tried out manually. Their name suffixes refer to what we expect them to be good at.