Özer Cem KELAHMETKELAHMET
AI Simulations · Large tabular foundation model

Any table, any schema: column order, names and units do not matter

A classic model is tied to one schema. A tabular foundation model reads whatever table it is given. Switch tables, shuffle, rename and rescale the columns, and check whether any prediction moves.

Interactive simulation. It needs JavaScript; the text below explains what it shows.

What you are looking at

The table shows what the model sees; the panel shows test accuracy (or error) and the largest change in any prediction since the last reset, which stays at zero under every transformation.

Things to try

  • Shuffle the columns several times.
  • Rename them to nonsense.
  • Multiply every column by 1000.
  • Switch to the machine-failure and house-price tables.

How it works in real systems

Tabular foundation models are pre-trained on many unrelated tables and treat columns as a set, so a new schema needs no retraining; meaningful column names can still add information when a model is built to read them.

Code lab

The same idea in real code, step by step. Copy each block into a notebook or a file and run it in order.

Step 1 · Three unrelated tables, one model

from sklearn.datasets import load_breast_cancer, load_wine, load_digits
from sklearn.model_selection import train_test_split
from tabpfn import TabPFNClassifier
for loader in (load_breast_cancer, load_wine, load_digits):
    X, y = loader(return_X_y=True)
    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=.3, random_state=0, stratify=y)
    acc = TabPFNClassifier().fit(Xtr, ytr).score(Xte, yte)
    print(f"{loader.__name__[5:]:14s} {X.shape[1]:3d} columns  accuracy {acc:.3f}")

No model was trained for any of these tables; the same pre-trained weights read each one.

Step 2 · Column order, names and units

import pandas as pd
X, y = load_wine(return_X_y=True, as_frame=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=.3, random_state=0, stratify=y)
base = TabPFNClassifier(random_state=0).fit(Xtr, ytr).predict_proba(Xte)
import numpy as np
perm = np.random.default_rng(1).permutation(X.shape[1])
renamed = {c: f"col_{i}" for i, c in enumerate(X.columns)}
X2tr, X2te = Xtr.iloc[:, perm].rename(columns=renamed) * 1000, Xte.iloc[:, perm].rename(columns=renamed) * 1000
alt = TabPFNClassifier(random_state=0).fit(X2tr, ytr).predict_proba(X2te)
print("largest change in a probability:", abs(base - alt).max())

TabPFN pre-processes features and ensembles over feature orderings, so the change is small but not always exactly zero; the in-browser stand-in, which has no such randomness, is exactly invariant.

More simulations

← Large tables · All AI Simulations · Calibration →

Last updated Nov 17, 2026
Type to search.
    ↑↓ navigate↵ open