> ## Documentation Index
> Fetch the complete documentation index at: https://docs.priorlabs.ai/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> TabPFN-3 and later versions support up to 1,000,000 rows, subject to feature count and checkpoint/API limits.
> For large datasets, use per-estimator subsampling, e.g. inference_config={"SUBSAMPLE_SAMPLES": 100_000}, in TabPFNClassifier or TabPFNRegressor from tabpfn or tabpfn_client.
> Pass raw pandas DataFrames to fit and predict. Categorical strings/categories, raw text, and missing feature values are handled automatically; no manual integer/one-hot encoding, imputation, scaling, or outlier removal is needed.

# FAQ

Whether you're just getting started with TabPFN or pushing it into production, this FAQ highlights practical answers to common questions about model limits, performance, reproducibility, and API best practices.

<Accordion title="What GPUs does TabPFN require at minimum?">
  At minimum, TabPFN requires an NVIDIA T4 GPU to run efficiently. For best performance, we recommend A100 or H100 GPUs. Any dedicated GPU supported by PyTorch is compatible, but some models may not have enough memory for larger datasets or perform slowly. CPU, MPS (Apple Silicon), and integrated GPUs are also supported, but are only suitable for small datasets.

  For larger datasets, fit + predict time can be dramatically reduced by parallelizing inference over several GPUs. To enable this, set the `device` parameter of `TabPFNClassifier` and `TabPFNRegressor`.
</Accordion>

<Accordion title="What are TabPFN's practical limits for context size and features?">
  TabPFN is optimized for tabular datasets up to 1M rows, since it performs in-context learning using transformer attention. See our [Models](/models) for an overview of capabilities.
</Accordion>

<Accordion title="How are text features handled?">
  With TabPFN-3.5, the local `tabpfn` package supports text columns directly alongside numerical and categorical features. TabPFN-3.5-Plus and TabPFN-3.5-Thinking add enhanced text processing for stronger results on text-rich datasets. You can pass the text columns without manually vectorizing them. See [Text features](/capabilities/text-features) for examples.
</Accordion>

<Accordion title="How are date features handled?">
  With TabPFN-3.5, the local `tabpfn` package expands datetime columns into calendar features. Pass columns with a datetime dtype; convert date strings with `pd.to_datetime()` first. See [Datetime features](/improving-performance/preprocessing#datetime-features).
</Accordion>

<Accordion title="How reproducible are TabPFN results across runs and devices?">
  With a fixed seed and in the same environment TabPFN inference is deterministic. Across different hardware (CPU, GPU, MPS) configurations small differences are expected.
</Accordion>

<Accordion title="Does TabPFN handle missing values natively?">
  Yes. TabPFN's estimators can handle missing values internally, including `pd.NA`, without requiring manual imputation.
</Accordion>

<Accordion title="How should I handle imbalanced datasets?">
  TabPFN is inherently robust to imbalance. However, you can further optimize for specific objectives:

  * Use `balance_probabilities=True` to optimize for **balanced accuracy**, balanced loss or other evaluation metrics weighting each class equally regardless of its frequency.
  * Use `eval_metric="f1"` (or other supported metrics) for specific precision-recall tradeoffs.
</Accordion>

<Accordion title="My run is 'slow' on thousands of rows - what controls the fit/predict trade-off?">
  By default TabPFN performs most of its fitting inside the `predict()` step. That means latency scales roughly with the number of training rows. For fast inference we can use KV-caching (`TabPFNClassifier(fit_mode="fit_with_cache")`). We can also create a tree- or small MLP based model that yields almost the same accuracy as TabPFN. Contact [our sales team](http://priorlabs.ai/contact) to access this solution.
</Accordion>

<Accordion title="How can I speed up predictions on large test sets?">
  Unless the fitted-model cache is enabled, the model is retrained each time `.predict()` is called. It is much faster to make a prediction for all your test points in a single `.predict()` call rather than calling it repeatedly. If you run out of memory, split the test points into batches of 1,000 to 10,000 and call `.predict()` for each batch.

  You can also tune the `memory_saving_mode` and `n_preprocessing_jobs` parameters of `TabPFNClassifier` and `TabPFNRegressor` for additional speed improvements. See the code documentation for details.
</Accordion>

<Accordion title="What is the fitted-model cache and when should I use it?">
  The fitted-model cache stores the model during `.fit()`, making subsequent `.predict()` calls fast by using a KV-Cache. Enable it by setting the `fit_mode` parameter of `TabPFNClassifier` or `TabPFNRegressor` to `fit_with_cache`.

  For TabPFN-3.5, this setting consumes about 4GB of GPU memory per estimator (so 32GB for our default 8 estimators) for 1M rows (and roughly half for 500K rows). TabPFN-3.5-Fast needs about 2GB per estimator (8GB for its default 4 estimators). For previous model versions, this setting consumes a lot of memory and is not recommended
  except for very small datasets.
</Accordion>

<Accordion title="What PyTorch version should I use?">
  TabPFN-3 requires PyTorch 2.5 or above; we recommend 2.8 or above for best performance. Note that MPS (Apple Silicon) acceleration requires PyTorch 2.6 or above.
</Accordion>

<Accordion title="What are the API rate limits?">
  Predictions and Thinking fits consume tokens from the same usage budgets. Uploads and standard fits are not charged. Token charges depend on the selected model, operation, dataset size, and settings. You can check your current usage at [platform.priorlabs.ai/account/usage](https://platform.priorlabs.ai/account/usage), or from Python:

  ```python theme={null}
  from tabpfn_client.config import get_api_usage
  get_api_usage()
  ```

  See [API rate limits](/api/rate-limits) for request limits and token budgets, and [API metering](/api/metering) for how usage is charged.
</Accordion>

<Accordion title="How do I know which TabPFN model version am I using in the TabPFN API Client?">
  After making predictions with a TabPFN model using the client you can access model-level metadata, such as the exact model version used for inference. Each estimator exposes a .last\_meta attribute containing this information:

  ```python theme={null}
  # After model.predict():
  meta = model.last_meta
  print(meta)
  # Example output:
  # {'model_version': 'v2', 'info': 'Mi4yLjB8MjAyNS0xMC0zMVQxMjowMTo0My42Mzc3ODcrMDA6MDA='}
  ```
</Accordion>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.