TabPFN

https://docs.priorlabs.ai/
Admin
TabPFN is a pre-trained tabular foundation model that makes instant, accurate predictions on...
Tokens:374,699
Snippets:2,790
Trust Score:8.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### Setup, data loading, and example demand plots

Source: https://docs.priorlabs.ai/cookbook/forecast_spare_parts_demand

The setup installs required packages if missinglint and imports libraries.,fetches the synthetic panel if not local, and prints the dataset summary. The final block plots four example series with a 28-day rolling mean.

```text
import importlib.util

required = ("tabpfn", "pandas", "sklearn", "matplotlib")
if not all(importlib.util.find_spec(package) for package in required):
    %pip install -q tabpfn pandas scikit-learn matplotlib

```

```text
import warnings

warnings.filterwarnings("ignore", message="IProgress not found.*")
warnings.filterwarnings("ignore", category=FutureWarning)

import urllib.request
from pathlib import Path

import matplotlib.dates as mdates
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.metrics import mean_absolute_error, root_mean_squared_error
from tabpfn import TabPFNRegressor

plt.style.use("seaborn-v0_8-whitegrid")
# Synthetic demand panel shipped with the cookbook (scripts/generate_spare_parts_data.py).
DATA_PATH = Path("../datasets/forecast_spare_parts_demand/spare_parts_daily.csv")
if not DATA_PATH.exists():  # not running from a repo checkout, e.g. on Colab
    DATA_PATH = Path("spare_parts_daily.csv")
    urllib.request.urlretrieve(
        "https://raw.githubusercontent.com/PriorLabs/tabpfn-cookbook/main/datasets/forecast_spare_parts_demand/spare_parts_daily.csv",
        DATA_PATH,
    )
panel = pd.read_csv(DATA_PATH, parse_dates=["date"])
print(f"{len(panel):,} rows | {panel['series_id'].nunique()} daily series | "
      f"{panel['date'].min().date()} to {panel['date'].max().date()}")

```

```text
8,772 rows | 12 daily series | 2023-01-01 to 2024-12-31

```

```text
EXAMPLES = [
    "BRG-6204 · Augsburg", "FLT-HYD-010 · Augsburg",
    "FLT-AIR-220 · Bremen", "DRV-BELT-A45 · Bremen",
]
fig, axes = plt.subplots(2, 2, figsize=(14, 7), sharex=True)
for ax, series_id in zip(axes.flat, EXAMPLES):
    series = panel.loc[panel["series_id"].eq(series_id)].set_index("date")["demand"]
    ax.plot(series, color="#B7B7B7", alpha=0.55, linewidth=0.7)
    ax.plot(series.rolling(28).mean(), color="#F28E2B", linewidth=2)
    ax.set(title=series_id, ylabel="units/day")
fig.suptitle("Daily demand across parts and plants", fontsize=14)
fig.tight_layout()
plt.show()

```

--------------------------------

### Install required packages

Source: https://docs.priorlabs.ai/cookbook/insurance_claim_modeling

Installs the TabPFN client, matplotlib, and scikit-learn. This is the setup step for running the notebook, which uses the hosted TabPFN client and requires a free API token.

```bash
!pip install tabpfn_client matplotlib scikit-learn

```

--------------------------------

### Install tabpfn-client and set API key

Source: https://docs.priorlabs.ai/quickstart

Install the tabpfn-client package and set the TABPFN_TOKEN environment variable to your API key. Get the key from platform.priorlabs.ai.

```bash
pip install --upgrade tabpfn-client
export TABPFN_TOKEN="<your-api-key>"

```

--------------------------------

### Output of Rosenbrock setup

Source: https://docs.priorlabs.ai/cookbook/bayesian_optimization

Example output from the setup code. Shows the device (CPU in this case) and the negated Rosenbrock optimum as 0.0000 with bounds from -5.0 to 10.0 in all four dimensions.

```text
Device: cpu
Objective optimum: 0.0000 on [-5.0, -5.0, -5.0, -5.0]..[10.0, 10.0, 10.0, 10.0]

```

--------------------------------

### Install required Python packages

Source: https://docs.priorlabs.ai/agentic/tutorials/databricks

Install the required Python packages for the tutorial.

```bash
pip install openai-agents databricks-sdk databricks-sql-connector httpx pandas scikit-learn
```

--------------------------------

### Install pinned dependencies for TabPFN and XGBoost comparison

Source: https://docs.priorlabs.ai/cookbook/grouped_data_model_comparison

Installs the pinned client and dependencies. TabPFN runs through the API; XGBoost runs on CPU. Authenticate with your usual TabPFN client setup before running the comparison.

```bash
%pip install -q --upgrade tabpfn-client==0.6.0 pandas==2.3.3 numpy==2.5.3 scikit-learn==1.9.0 xgboost==3.4.1 matplotlib==3.11.2 pyarrow==25.0.1 huggingface-hub==1.31.0

```

--------------------------------

### Install and environment setup for TabPFN-Rel

Source: https://docs.priorlabs.ai/cookbook/relational_predictions_tabpfn_rel

Installs tabpfn-rel with the api extra and kagglehub, then sets up the environment for Colab. It checks for a pandas version mismatch and prints a restart instruction if needed. Requires Python 3.11 or 3.12.

```python
!pip install -q "tabpfn-rel[api]==0.0.1"
!pip install -q kagglehub

import importlib.metadata
import importlib.util
import os
import sys

IN_COLAB = (
    importlib.util.find_spec("google") is not None
    and importlib.util.find_spec("google.colab") is not None
)
os.environ.setdefault("OMP_NUM_THREADS", "1")

print(
    f"Python {sys.version.split()[0]}, "
    f"tabpfn-rel {importlib.metadata.version('tabpfn-rel')}"
)

if IN_COLAB and "pandas" in sys.modules:
    if sys.modules["pandas"].__version__ != importlib.metadata.version("pandas"):
        print(
            "\n>>> Restart the session (Runtime > Restart session), then continue "
            "from the next cell—do not re-run this one."
        )

```

--------------------------------

### Install TabPFN and scikit-learn

Source: https://docs.priorlabs.ai/cookbook/faster_performance_with_cache

Installs the required packages using pip.

```bash
!pip install tabpfn scikit-learn

```

--------------------------------

### Install tabpfn-extensions with Bayesian optimization extras

Source: https://docs.priorlabs.ai/cookbook/bayesian_optimization

Install the TabPFN package with Bayesian optimization extras and required dependencies. Use this before running the example. The local PyTorch-backed TabPFN implementation is used because the optimizer refines candidates with gradients (`differentiable_input=True`).

```bash
%pip install -q -U "tabpfn-extensions[bayesian-optimization]" "tabpfn>=8.1.0" "tqdm>=4.63.0,<=4.67.3" matplotlib

```

--------------------------------

### Installation

Source: https://docs.priorlabs.ai/api-reference/python/tabpfn/overview

Install the TabPFN Python package using pip.

```APIDOC
## Installation

### Description
Install the TabPFN Python package.

### Method
pip install

### Command
pip install tabpfn

### Example
```bash
pip install tabpfn
```
```

--------------------------------

### Install required packages with pip

Source: https://docs.priorlabs.ai/benchmarking

Install the required packages before running any code in this guide. Python 3.10 or later is required; all examples were tested with Python 3.11.

```bash
pip install tabpfn xgboost scikit-learn

```

--------------------------------

### FinetuningLogger.setup

Source: https://docs.priorlabs.ai/api-reference/python/tabpfn/finetuning/logging

Initialize the logger with run configuration.

```APIDOC
## FinetuningLogger.setup

### Description
Initialize the logger with run configuration.

### Method
setup

### Signature
```
FinetuningLogger.setup(
    config: dict[str, Any],
) -> None
```

### Parameters
- **config** (dict[str, Any]) - Required - Run configuration.

### Returns
- **None** - No return value.
```

--------------------------------

### API Regression with tabpfn-client

Source: https://docs.priorlabs.ai/capabilities/fast-checkpoint

Use the hosted API (tabpfn-client) to run TabPFN-3.5-Fast for regression. Requires installation and API key setup from the quickstart. Select model_path="v3.5-fast_default" when creating the estimator.

```python
from tabpfn_client import TabPFNRegressor

model = TabPFNRegressor(model_path="v3.5-fast_default")
model.fit(X_train, y_train)
predictions = model.predict(X_test)

```

--------------------------------

### Go example for prepare train set upload

Source: https://docs.priorlabs.ai/api-reference/training/prepare-train-set-upload

Uses net/http to send a POST request with a JSON string body. Prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.priorlabs.ai/tabpfn/prepare_train_set_upload"

	payload := strings.NewReader("{\n  \"x_train_info\": {\n    \"format\": \"csv\"\n  },\n  \"y_train_info\": {\n    \"format\": \"csv\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### API Classification with tabpfn-client

Source: https://docs.priorlabs.ai/capabilities/fast-checkpoint

Use the hosted API (tabpfn-client) to run TabPFN-3.5-Fast for classification. Requires installation and API key setup from the quickstart. Select model_path="v3.5-fast_default" when creating the estimator.

```python
from tabpfn_client import TabPFNClassifier

model = TabPFNClassifier(model_path="v3.5-fast_default")
model.fit(X_train, y_train)
predictions = model.predict(X_test)

```

--------------------------------

### Usage example for TabPFNEmbedding

Source: https://docs.priorlabs.ai/api-reference/python/tabpfn-extensions/embedding

Shows how to create a TabPFNEmbedding instance, fit_transform to get out-of-fold embeddings, and transform to get embeddings from the final model.

```python
>>> from tabpfn_extensions.embedding import TabPFNEmbedding
>>> embedding = TabPFNEmbedding(n_fold=5)
>>> train_embeds = embedding.fit_transform(X_train, y_train)  # OOF
>>> test_embeds = embedding.transform(X_test)                 # final model

```

--------------------------------

### WandbLogger.setup

Source: https://docs.priorlabs.ai/api-reference/python/tabpfn/finetuning/logging

Initializes a new WandB run with the given configuration.

```APIDOC
## WandbLogger.setup

### Description
Initializes a new WandB run with the given config.

### Method
`WandbLogger.setup(config: dict[str, Any]) -> None`

### Parameters
- `config` (dict[str, Any]) - Required - Configuration dictionary for the WandB run.

### Returns
- `None`

```

--------------------------------

### Install tabpfn-extensions with all optional extras

Source: https://docs.priorlabs.ai/api-reference/python/tabpfn-extensions/overview

Installs the package along with all optional dependencies using the 'all' extra.

```bash
pip install "tabpfn-extensions[all]"

```

--------------------------------

### Install tabpfn package

Source: https://docs.priorlabs.ai/quickstart

Install the tabpfn package for running TabPFN-3.5 on your own hardware. Before first run, follow the model access setup to accept the license and download the weights.

```bash
pip install --upgrade tabpfn

```

--------------------------------

### Configure and initialize pretraining

Source: https://docs.priorlabs.ai/cookbook/pretrain_nanotabpfn

Sets hyperparameters, seeds, and device for pretraining. Prints the selected device.

```python
import math
import time

import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.nn.functional as F
from torch import nn

# ---------------------------------------------------------------- configuration
EPOCHS = 80
STEPS_PER_EPOCH = 25
BATCH_SIZE = 50
LR = 1e-4
NUM_ROWS = 50  # datapoints per synthetic table
NUM_FEATURES = 3  # columns per synthetic table
MAX_CLASSES = 3

SEED = 2402
torch.manual_seed(SEED)
np.random.seed(SEED)

device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print("device:", device)

```

--------------------------------

### Prepare test set upload - Python

Source: https://docs.priorlabs.ai/api-reference/prediction/prepare-test-set-upload

Python example for preparing a test set upload using the requests library.

```APIDOC
## [POST] /tabpfn/prepare_test_set_upload

### Description
Prepares a test set for upload by providing the fitted train set ID and test data format.

### Method
POST

### Endpoint
https://api.priorlabs.ai/tabpfn/prepare_test_set_upload

### Request Example
{
  "fitted_train_set_id": "22222222-2222-4222-8222-222222222222",
  "x_test_info": {
    "format": "csv"
  }
}
```

--------------------------------

### Example: Using get_tabpfn_inf_explainer with TabPFNClassifier

Source: https://docs.priorlabs.ai/api-reference/python/tabpfn-extensions/interpretability/shapley-explainers

Demonstrates constructing a TabPFNClassifier with PASSTHROUGH_INF and fit_with_cache, fitting, enabling on-device cache, creating the explainer, and explaining a test instance.

```python
>>> from tabpfn import TabPFNClassifier
>>> from tabpfn_extensions.interpretability import shapiq as tpe_shapiq
>>> clf = TabPFNClassifier(
...     inference_config={"PASSTHROUGH_INF": True},
...     fit_mode="fit_with_cache",
... )
>>> clf.fit(X_train, y_train)
>>> clf.executor_.keep_cache_on_device = True  # optional but faster
>>> explainer = tpe_shapiq.get_tabpfn_inf_explainer(
...     model=clf, data=X_train, class_index=1
... )
>>> iv = explainer.explain(x=X_test[0], budget=2 ** X_train.shape[1])

```

--------------------------------

### Install and configure TabPFN MCP for Codex CLI

Source: https://docs.priorlabs.ai/agentic/setup-guide

Install Codex CLI, add the TabPFN MCP server, and start Codex. Codex will detect OAuth support and open your browser for authorization.

```bash
# Install Codex
npm i -g @openai/codex
 
# Add TabPFN MCP
codex mcp add tabpfn --url https://api.priorlabs.ai/mcp/server
 
# Start Codex
codex
```

--------------------------------

### Java Unirest GET request to get_model_limits

Source: https://docs.priorlabs.ai/api-reference/training/get-model-limits

Java example using Unirest to send a GET request to the get_model_limits endpoint. Requires a valid Bearer token in the Authorization header. The response is returned as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.priorlabs.ai/tabpfn/get_model_limits")
  .header("Authorization", "Bearer <token>")
  .asString();

```

--------------------------------

### Go net/http GET request to get_model_limits

Source: https://docs.priorlabs.ai/api-reference/training/get-model-limits

Go example using net/http to send a GET request to the get_model_limits endpoint. Requires a valid Bearer token in the Authorization header. Prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.priorlabs.ai/tabpfn/get_model_limits"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

```

--------------------------------

### Install TabPFN client and dependencies

Source: https://docs.priorlabs.ai/cookbook/quickstart

Installs the TabPFN client, local package, and scikit-learn using pip. Run this in a notebook or environment where pip is available.

```bash
%pip install -q tabpfn tabpfn-client scikit-learn

```

--------------------------------

### Install tabpfn-client with SageMaker extra

Source: https://docs.priorlabs.ai/integrations/sagemaker

Install the SageMaker extra of tabpfn-client using pip. This is required to use the SDK with SageMaker.

```bash
pip install --upgrade 'tabpfn-client[sagemaker]'

```

--------------------------------

### Go request to prepare test set upload

Source: https://docs.priorlabs.ai/api-reference/prediction/prepare-test-set-upload

Uses net/http to POST the payload. Prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.priorlabs.ai/tabpfn/prepare_test_set_upload"

	payload := strings.NewReader("{\n  \"fitted_train_set_id\": \"22222222-2222-4222-8222-222222222222\",\n  \"x_test_info\": {\n    \"format\": \"csv\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

```

--------------------------------

### Ruby Net::HTTP GET request to get_model_limits

Source: https://docs.priorlabs.ai/api-reference/training/get-model-limits

Ruby example using Net::HTTP to send a GET request to the get_model_limits endpoint. Requires a valid Bearer token in the Authorization header. Prints the response body.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.priorlabs.ai/tabpfn/get_model_limits")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

```

--------------------------------

### Install dependencies with pip

Source: https://docs.priorlabs.ai/cookbook/memory_optimisation

Installs the required packages for the tutorial: tabpfn, scikit-learn, tabpfn-client, matplotlib, numpy, and torch.

```bash
!pip install -q tabpfn scikit-learn tabpfn-client matplotlib numpy torch

```

--------------------------------

### PHP cURL GET request to get_model_limits

Source: https://docs.priorlabs.ai/api-reference/training/get-model-limits

PHP example using cURL to send a GET request to the get_model_limits endpoint. Requires a valid Bearer token in the Authorization header. Prints the response body or a cURL error.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.priorlabs.ai/tabpfn/get_model_limits",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

```

--------------------------------

### Install and configure TabPFN MCP for Claude Code

Source: https://docs.priorlabs.ai/agentic/setup-guide

Install Claude Code globally, navigate to your project, add the TabPFN MCP server over HTTP, start Claude, and authenticate via /mcp to trigger the OAuth flow.

```bash
# If you haven't, install Claude Code
npm install -g @anthropic-ai/claude-code
 
# Navigate to your project
cd your-tabpfn-project
 
# Add TabPFN MCP (general access)
claude mcp add --transport http tabpfn https://api.priorlabs.ai/mcp/server

# Start coding with Claude
claude
 
# Authenticate the MCP tools by typing /mcp
# This will trigger the OAuth flow
/mcp
```

--------------------------------

### NullLogger.setup

Source: https://docs.priorlabs.ai/api-reference/python/tabpfn/finetuning/logging

No-op method to initialize the logger. It accepts a configuration dictionary but does nothing.

```APIDOC
## NullLogger.setup

### Description
No-op method to initialize the logger. It accepts a configuration dictionary but does nothing.

### Method
`NullLogger.setup(config: dict[str, Any]) -> None`

### Parameters
- `config` (dict[str, Any]) - Required - Configuration dictionary.

### Returns
- `None`

```
Tokens:
Raw