> ## 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. # Amazon SageMaker > Deploy TabPFN-3.5-Plus on Amazon SageMaker. Data stays inside your AWS account; the tabpfn-client Python SDK wraps the endpoint with a familiar scikit-learn surface. TabPFN is available on the AWS SageMaker Marketplace. By subscribing to a listing, you provision and run TabPFN inside your own AWS account — data never leaves your private AWS network. Three listings are available: * **[TabPFN-3.5-Plus](https://aws.amazon.com/marketplace/pp/prodview-sor7k6q2iz42q)** - Public, free for non-commercial use, recommended version. * **[TabPFN-3-Plus](https://aws.amazon.com/marketplace/pp/prodview-b6rjndzxhbqww)** - Public, free for non-commercial use. * **[TabPFN-2.5](https://aws.amazon.com/marketplace/pp/prodview-chfhncrdzlb3s)** - Public, free for non-commercial use. ## TabPFN-3.5-Plus Using TabPFN-3.5-Plus on the AWS SageMaker Marketplace is free of charge; you only pay for the underlying AWS compute. Model weights are released under the [TABPFN-3.5 License v1.0](https://huggingface.co/Prior-Labs/tabpfn_3_5/blob/main/LICENSE), which is permissive for research and internal evaluation. For production / commercial use, we offer a *Commercial Enterprise License* that includes dedicated support, integration tooling, and other internal models. Contact [our sales team](http://priorlabs.ai/contact) for commercial licensing. ### What's bundled in the listing TabPFN-3.5-Plus on SageMaker bundles every base TabPFN-3.5 capability: * State-of-the-art classification and regression in a single forward pass — tops the public TabArena benchmark for classification and regression. * Supports up to 1M training rows or 20,000 columns, with up to 6,000 columns recommended. Row and column limits trade off; see [model and text preprocessing limits](/models#tabpfn-3-5-family). * Native handling of mixed feature types — numerical, categorical, **and free-text (string-valued) columns** — plus missing values, outliers, and uninformative columns. No bespoke preprocessing required. * Native many-class classification (up to 160 classes). * **[Thinking mode](#thinking-mode)** — additional inference-time compute for higher prediction quality — is also available via a separate enterprise listing (see below). ### Subscribe and deploy Deploying on Sagemaker consists of subscribing to the listing, creating a deployable model, and creating an inference endpoint: 1. Open the [TabPFN-3.5-Plus Marketplace listing](https://aws.amazon.com/marketplace/pp/prodview-sor7k6q2iz42q) and click **View Purchase Options** → **Subscribe**. 2. Open the Amazon SageMaker AI console, switch to the AWS region where you want to deploy, and open **Deployments & inference** → **Deployable models** → **Create model**. Under **Container definition**, choose *Use a model package subscription*, and select **TabPFN-3.5-Plus**. Create the model. 3. Select the model just created, and choose **Create endpoint**. Pick an endpoint name, and create or pick an existing endpoint configuration. Optionally, when creating the endpoint configuration, we recommend configuring **Async invocation config** in the same step — this enables use of `use_async=True` in the Python SDK for larger payloads or longer-running requests (see below). 4. Under **Variants**, you can set the instance type (**Actions** → **Edit**). You must use a GPU instance such as `ml.g5.xlarge`, running NVIDIA driver 535 or later (see the note below). 5. After clicking **Submit**, SageMaker provisions the endpoint. The endpoint is ready when its status transitions to **InService** (typically 6–10 minutes). **TabPFN-3.5-Plus requires NVIDIA driver 535 or later.** On instances with an older driver (for example 470), the model container fails to start and endpoint creation ends in a container startup failure. Pin the inference AMI on the endpoint configuration by setting `InferenceAmiVersion` on the production variant; `al2-ami-sagemaker-inference-gpu-3-1` is the lowest version we recommend. If the console endpoint configuration form does not offer that field, create the endpoint configuration with the AWS CLI instead: ```bash theme={null} # Create the SageMaker model aws sagemaker create-model --model-name tabpfn --execution-role-arn \ --primary-container ModelPackageName= --enable-network-isolation # Set up the endpoint configuration including inference AMI aws sagemaker create-endpoint-config --endpoint-config-name tabpfn \ --production-variants VariantName=primary,ModelName=tabpfn,InstanceType=ml.g5.xlarge,InitialInstanceCount=1,InferenceAmiVersion=al2-ami-sagemaker-inference-gpu-3-1 # Create the endpoint aws sagemaker create-endpoint --endpoint-name tabpfn --endpoint-config-name tabpfn ``` See the AWS [`ProductionVariant` reference](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html) for the available inference AMI versions. ### Using your endpoint You can use [tabpfn-client](https://github.com/PriorLabs/tabpfn-client) (recommended), or invoke the endpoint directly, for example using `boto3`: Install the SageMaker extra of `tabpfn-client`: ```bash theme={null} pip install --upgrade 'tabpfn-client[sagemaker]' ``` The SDK mirrors the scikit-learn surface. AWS credentials are resolved through the standard `boto3` credential chain (env vars, `~/.aws/credentials`, instance profile, SSO). ```python theme={null} from tabpfn_client.sagemaker import TabPFNClassifier # For regression, use: # from tabpfn_client.sagemaker import TabPFNRegressor from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score, log_loss X, y = load_breast_cancer(return_X_y=True) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) clf = TabPFNClassifier( endpoint_name="your-tabpfn-3.5-plus-endpoint", region_name="us-east-1", ) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) proba = clf.predict_proba(X_test) ``` If you'd rather call the endpoint without the SDK, the request body is JSON. Required top-level fields: `task_config` (with `task`, `tabpfn_config`, `predict_params`), `X_train`, `y_train`, `X_test`. The [Marketplace listing](https://aws.amazon.com/marketplace/pp/prodview-sor7k6q2iz42q)'s *Usage information* section is the authoritative reference for the full request parameter list and response schema. ```python theme={null} import boto3, json rt = boto3.client("sagemaker-runtime", region_name="us-east-1") resp = rt.invoke_endpoint( EndpointName="your-tabpfn-3.5-plus-endpoint", ContentType="application/json", Accept="application/json", Body=json.dumps({ "task_config": { "task": "classification", "tabpfn_config": {"n_estimators": 4}, "predict_params": {"output_type": "probas"}, }, "X_train": X_train.tolist(), "y_train": y_train.tolist(), "X_test": X_test.tolist(), }), ) out = json.loads(resp["Body"].read()) proba = out["prediction"] # 2D list, shape (n_test, n_classes) metadata = out["metadata"] # echoed task / package_version / dataset shape ``` ### Async inference for larger datasets SageMaker real-time invocations cap a single request at **6 MB payload** and **60 s processing time**. For larger payloads or longer-running requests, deploy the endpoint with `AsyncInferenceConfig` and use the SDK's `use_async=True` switch. Async invocations support up to 1 GB payload and 60 min processing. [Model and text preprocessing limits](/models#tabpfn-3-5-family) still apply. ```python theme={null} from tabpfn_client.sagemaker import TabPFNClassifier clf = TabPFNClassifier( endpoint_name="your-tabpfn-3.5-plus-async-endpoint", region_name="us-east-1", use_async=True, s3_bucket="your-async-io-bucket", # bucket the endpoint role can read+write ) clf.fit(X_train, y_train) proba = clf.predict_proba(X_test) ``` The SDK handles the S3-staging-input / poll-output round-trip transparently; the call shape stays the same. See the [sample notebook](https://github.com/PriorLabs/tabpfn-client/blob/main/examples/sagemaker/tabpfn-3-sample.ipynb) in the `tabpfn-client` repo for the end-to-end deploy → invoke → teardown walkthrough. ### Thinking mode **Thinking mode on SageMaker is available through a separate enterprise listing.** [TabPFN-3.5-Thinking](/capabilities/thinking-mode) spends more compute during fitting to improve prediction quality, especially on grouped and temporal data. To get access for your AWS account, contact [our sales team](http://priorlabs.ai/contact). Once you've been granted access, the Thinking listing surfaces the same `tabpfn-client` SDK; the only change is an optional `thinking_effort` constructor kwarg on `TabPFNClassifier` / `TabPFNRegressor` that engages Thinking mode per request. Omitting it falls back to the standard TabPFN-3.5-Plus single-forward-pass behavior, so a single endpoint serves both modes. See the Thinking mode page for effort settings and the [technical report](https://priorlabs.ai/technical-reports/tabpfn-3-5) for benchmark results. ### Limitations * **Payload caps.** Real-time invocations are capped by AWS at 6 MB payload / 60 s processing. Use async inference (see above) for anything bigger or slower. * **GPU-only.** The model package only declares GPU instance types as supported. The SageMaker console default (`ml.m4.xlarge`, CPU) is rejected with a `ValidationException`; see the [Marketplace listing](https://aws.amazon.com/marketplace/pp/prodview-sor7k6q2iz42q)'s *Recommended instance types* section for the GPU-only allowlist. End-to-end deploy → invoke → teardown walkthrough using `tabpfn-client.sagemaker`. Source for the Python SDK that wraps SageMaker endpoints with the scikit-learn surface. ## TabPFN-2.5 The earlier **TabPFN-2.5** SageMaker listing is still available. New deployments are recommended on TabPFN-3.5-Plus above.