Quick question: In the breast cancer example from the README, simple support vector machines from sklearn (the first thing i tried to compare baseline performance, incidentally) seem to outperform TabPFN. Is this expected? I know it's a baseline to demonstrate ease of use rather than SOTA performance, but I am curious.
# (TabPFN)
In [13]: print("ROC AUC:", roc_auc_score(y_test, prediction_probabilities[:, 1]))
ROC AUC: 0.996299494264216
# (LinearSVC)
In [27]: from sklearn.svm import LinearSVC
In [28]: clf=LinearSVC(C=0.01).fit(X_train, y_train)
In [29]: roc_auc_score(y_test, clf.decision_function(X_test))
Out[29]: 0.997532996176144 TabPFN mean ROC AUC: 0.9973
SVM mean ROC AUC: 0.9903
TabPFN per split: [0.99737963 0.99639699 0.99966931 0.99338624 0.99966465]
SVM per split: [0.99312152 0.98788077 0.99603175 0.98313492 0.99128102]
from sklearn.model_selection import cross_val_score
from tabpfn import TabPFNClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.svm import LinearSVC
import numpy as np
data = load_breast_cancer()
X, y = data.data, data.target
# TabPFN
tabpfn_clf = TabPFNClassifier()
tabpfn_scores = cross_val_score(tabpfn_clf, X, y, cv=5,
scoring='roc_auc')
print("TabPFN per split:", tabpfn_scores)
print("TabPFN mean ROC AUC:", np.mean(tabpfn_scores))
# SVM
svm_clf = LinearSVC(C=0.01)
svm_scores = cross_val_score(svm_clf, X, y, cv=5,
scoring='roc_auc')
print("SVM per split:", svm_scores)
print("SVM mean ROC AUC:", np.mean(svm_scores))
I certainly appreciate how the example in the README makes it instantly apparent how to use the code.
https://soda-inria.github.io/carte/ https://arxiv.org/pdf/2402.16785
The paper includes a comparison to TabPFN v1 (among others), noting the lack of categorical & missing values handling which v2 now seems to have. Would be curious to see an updated comparison.
What I read in this paper blew that idea out the water! I mean, it’s still doable but you’ve far exceeded it.
I love that you covered many types of structures, used 8x consumer GPU’s more like OSS folks do (widely-accessible pretraining), claim no copyright infringement for pretraining, and use enough techniques in ML that people can enjoy Googling stuff for days.
I do have some questions about what I might have overlooked in the paper.
1. Is the training data and code available to reproduce the model? And iteratively improve its architectural decisions?
2. Most authors claiming their data was legal or open were actually committing copyright infringement. Your method might dodge that if users generate their own synthetic data using methods they can verify aren’t themselves encumbered. Is that code available under open licensing? If not, would you offer it for a fee for companies or free for researchers?
3. What specific, common uses could amateurs try that would display the model’s ability in a business setting? (Both to drive more research or build products on the model.)
I thank you for your time.
Thanks :)
1. Only for the first version, not for this version. I am sorry! 2. Yeah ours is guaranteed ok, as we wrote code to generate it basically just from plain torch ops. The code to run inference is available, just not the training code and data generation. 3. We have put it to work on time series data, which is very business relevant for example https://github.com/liam-sbhoo/tabpfn-time-series, and we have a table in the Appendix with all datasets we evaluate on in our main analysis to give you some ideas for possible datasets.
This is where there might be claims. It already sounds safer than training on copyrighted works. The only thing that could remain is if it was a derivative work by reusing parts of copyrighted works in your process.
So, I’m curious about how you produced the specifications that the data was generated from. In my case, I was going to just use open versions of all kinds of equations that I’d hand-convert to internal representations. Others might be fair use if my description were high level enough that it wasn’t close to theirs. Some I couldn’t use at all because they were patented and independent versions are prohibited by law.
Did you all also derive your causal models from real-world formulas and data sets? If so, did you have a rule about putting distance between your representation and theirs? Or was it an entirely-random, search process across endless configurations? (I have a hard time imagining the latter would work.)
200 voters on 50 statements would fall within the 10,000 sample threshold. This is well within the bounds of some existing conversations with open data, so it could be tested... Potential values on each statement are agree/disagree/pass (+1/-1/0)
https://github.com/compdemocracy/openData/blob/master/brexit...
https://github.com/compdemocracy/openData/blob/master/brexit...
I think you misinterpreted. 1 voter on 50 statements with (+1/-1/0) would be 1 datapoint with 50 features. 200 voters would be 200 rows with 50 features so you would not need to be concerned about the 10,000 sample threshold. Hope that helps your study.
Do you see any artifacts from having trained on synthetic data? Is there a natural benchmark dataset (real tables in the wild)?
In my experience synthetic data can only take you so far, it has all the quirk the dataset creator can think of but the real value is usually in patterns they cannot. Vision took a huge leap forward with ImageNet dataset release
- It is not entirely clear how the datasets split is done. Do you make sure that the model is evaluated on unseen data ? More generally how does one knows whether a dataset was part of the training or not ?
- You mention some serious limitations (10k rows, 500 cols.). It seems a bit weird to have fixed numbers. Can these numbers be roughly balanced ? (eg. 1M rows, 5 columns ... ). Does these numbers scale with memory ? (what memory was used for the 10k rows / 500 cols figure ?)
Just looking through the code a bit, it seems that the model both supports a (custom) attention mechanism between features and between rows (code uses the term items)? If so, does the attention between rows help improve accuracy significantly?
Generally, for standard regression and classification use cases, rows (observations) are seen to be independent, but I'm guessing cross-row attention might help the model see the gestalt of the data in some way that improves accuracy even when the independence assumption holds?
Could you please explain like I'm five what is doing a trick? You have model pre-trained on large set of small datasets and you leverage it to boost performance?
Training is fast, few seconds, but what is time needed to compute predictions?
How large is the model?
To draw a parallel to NLP: previously people trained a neural network for each kind of text classification they wanted to do, but then LLMs came around that pre-trained to learn to perform new tasks on the fly. Similarly, TabPFN learns to do new tasks on the fly just from the context (dataset) given.
Training and prediction in these models is by default one and the same, similar to how the prediction of the next token in an LLM is not split into learning from context and then doing the actual prediction. There is a way to split this even up, though, then the predictions, I believe, take something like 1/10s for medium-sized datasets.
Just playing around with regression mode...
A very simple dataset, powers of two:
1:2, 2:4, 3:8, 5:32, 6:64, 7:128 (missing the #4 value)
Predictions (1-10):
1.582 5.236 13.150 22.943 37.584 67.475 109.945 155.322 218.001 10,300.425
Error (1-10):
-26.4% 23.6% 39.2% 30.3% 14.9% 5.2% -16.4% -64.8% -134.9% -240.9% Let's see what happens if we copy the exact same values in the dataset 10 times first.
Predictions (1-10):
1.993 3.967 7.986 18.138 31.965 64.140 128.125 126.607 130.667 161.756
Error (1-10):
-0.3% -0.8% -0.2% 11.8% -0.1% 0.2% 0.1% -102.2% -291.8% -533.1%
Looking forward to trying it on real world data with more features.
There's some interesting work on using LLMs for tabular data (TabLLM: https://proceedings.mlr.press/v206/hegselmann23a.html), but this only works for datasets with tens of samples rather than the thousands of rows needed in real-world applications.
What o1 and other LLMs typically do is wrap around existing tabular tools like XGBoost or scikit-learn. While this works, they're ultimately constrained by these tools' limitations. We're taking a fundamentally different approach - building foundation models that natively understand tabular relationships and patterns. Our approach combines the benefits of foundation models with architectures specifically designed for tabular data structures.