# 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.

<div data-sim="tfm" data-v="col"><p>Interactive simulation. It needs JavaScript; the text below explains what it shows.</p></div>

## 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.

<div class="cl-start"></div>

### Step 1 · Three unrelated tables, one model

```python
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

```python
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.

<div class="cl-end"></div>

## More simulations

[← Large tables](/ai-simulations/tfm-large-tables) · [All AI Simulations](/ai-simulations) · [Calibration →](/ai-simulations/tfm-calibration)
