Modele de fundație tabelară: o primă privire cu TabICL

Ce este un model de fundație tabelar?

Un model de fond de ten are trei ingrediente, iar versiunea tabelară le satisface în moduri specifice:

1. Preantrenat pe multe seturi de datenu unul. Nu te antrenezi pe masa ta specifică; te antrenezi pe o distributie de mese.
2. Transferuri într-un nou set de date în context — fără pași de gradient pe noul set de date. Modelul „citește” rândurile de antrenament și prezice pe rândurile de testare într-o singură trecere înainte.
3. Modelul este un transformator secvențial. Aceeași familie de arhitectură ca și LLM-urile, care operează doar pe rândurile unui tabel în loc de jetoane.

Ingredientul #1 este locul în care FM-urile tabelare diferă de FM-urile text/viziunii. Nu există un corp de tabele etichetate de răzuit. În schimb, TabICL folosește date sintetice: milioane de seturi de date tabulare extrase din antecedente structurate. Sarcina de preantrenament este „dată cu câteva rânduri dintr-un tabel sintetic, preziceți ținta pentru rândurile reținute”. După ce a văzut milioane de acestea, transformatorul învață un general procedură pentru predicție tabelară în context, nu un set de date specific.

Cum funcționează TabICL?

Două etape, în ordine:

1. Atenție coloană, apoi rând. Fiecare coloană este procesată independent pentru a produce o încorporare dimensională fixă ​​a valorilor acelei coloane; apoi rândurile merg pe coloane pentru a produce o dimensiune fixă încorporarea rândurilor. Aceasta decuplează modelul de schemă. Un tabel cu 10 coloane și un tabel cu 200 de coloane produc ambele înglobări de rânduri de aceeași dimensiune.
2. Transformator ICL peste rânduri. Înglobarile de rând (antrenament + test) sunt alimentate la un transformator care utilizează auto-atenția standard. Rândurile de antrenament cu etichete acționează ca „context”; rândurile de testare sunt prezise într-o singură trecere înainte. Nu există actualizări de gradient la inferență.

Asta e toată ideea. Obiectivul de preantrenament – ​​„prevăd ținte reținute date rânduri în context” – este exact ceea ce face modelul la inferență, astfel încât transferul zero-shot este încorporat structural. Designul în două etape este ceea ce permite TabICL să se extindă la seturi de antrenament mai mari decât TabPFNv2, care alternează atenția pe coloană și pe rând și devine costisitoare după rândurile 10K.

Configurare: Python env prin reticulate

TabICL este Python mai întâi. Din R, folosiți reticulate. Presupunând că aveți un env Python din postarea anterioară:

library(reticulate)
py_install(c("tabicl", "torch", "pandas", "scikit-learn"), pip = TRUE, pip_options = "--force-reinstall --no-cache-dir")

tabicl descarcă un punct de control preantrenat (câteva sute de MB) de la Hugging Face pe primul fit() apelați și îl memorează în cache local.

Un prim exemplu: estimarea ratei creditului cu TabICL

Vom folosi un set de date de credit în stilul LendingClub (10.000 de rânduri, ~150 de caracteristici) care este deja în repo. Ținta este bad_flag (1 = implicit / taxare, 0 = plătit). Mai întâi, puțină pregătire pentru partea R:

library(readr)
library(dplyr)
library(rsample)

# Load the credit sample (path is relative to the project root, not this post)
credit <- read.csv("https://bit.ly/42ypcnJ")

# Keep a focused subset — mostly numeric features plus a few categoricals
keep_cols <- c(
  "loan_amnt", "int_rate", "installment", "grade", "sub_grade",
  "annual_inc", "dti", "revol_util", "total_acc", "open_acc",
  "delinq_2yrs", "pub_rec", "fico_range_low", "inq_last_6mths",
  "home_ownership", "verification_status", "purpose", "term",
  "bad_flag"
)

df <- credit |>
  select(all_of(keep_cols)) |>
  mutate(across(where(is.character), as.factor)) |>
  mutate(bad_flag = factor(bad_flag))

# Train / test split (stratified on the target since it's imbalanced)
set.seed(42)
split <- initial_split(df, prop = 0.8, strata = "bad_flag")
train <- training(split)
test  <- testing(split)

# Quick class balance sanity check
prop.table(table(train$bad_flag))

Acum apelați TabICL prin reticulate. One gotcha: treceți caracteristicile ca un cadru de date, nu o matrice — TabICL detectează coloanele categoriale după dtype și le codifică intern. Constrângerea la o matrice face ca totul să fie caracter și pierde această manipulare.

library(reticulate)

# Import the Python classifier
tabicl <- import("tabicl")
clf <- tabicl$TabICLClassifier(random_state = 42L)

# Keep X as a data frame — reticulate auto-converts to a pandas DataFrame,
# preserving dtypes so TabICL can detect categoricals.
X_train <- train(, setdiff(names(train), "bad_flag"))
y_train <- as.character(train$bad_flag)
X_test  <- test(,  setdiff(names(test),  "bad_flag"))

# TabICL's "fit" is cheap — it just stashes the training data.
# The actual prediction happens in the forward pass at predict() time.
clf$fit(X_train, y_train)

# Predicted probabilities for the positive class
proba <- clf$predict_proba(X_test)
pred_prob <- as.numeric(proba(, 2))

Câteva lucruri care merită remarcate dacă ați folosit vreodată doar modele R-native:

• fit() revine aproape instantaneu. TabICL nu se antrenează cu privire la datele tale; doar o stochează. Lucrarea are loc la predict() timp — singura trecere înainte a transformatorului (tren + test) rânduri împreună. Rândurile tale de antrenament sunt contextul.
• Primul fit() descarcă punctul de control preantrenat. Utilizările ulterioare se încarcă din cache.

Evaluare: TabICL vs XGBoost pe aceeași împărțire

library(tidymodels)
library(tictoc)

# XGBoost with a modest tuning grid — a realistic "I spent 10 minutes" baseline
xgb_spec <- boost_tree(
  trees = 500,
  tree_depth = tune(),
  min_n = tune(),
  learn_rate = 0.01
) |>
  set_engine("xgboost") |>
  set_mode("classification")

xgb_grid <- grid_regular(
  tree_depth(range = c(4, 10)),
  min_n(range = c(2, 20)),
  levels = 3
)

xgb_wf <- workflow() |>
  add_model(xgb_spec) |>
  add_formula(bad_flag ~ .)

folds <- vfold_cv(train, v = 5, strata = "bad_flag")

tic("XGBoost tuning")
xgb_res <- tune_grid(
  xgb_wf,
  resamples = folds,
  grid = xgb_grid,
  metrics = metric_set(roc_auc)
)
toc(log = TRUE)

XGBoost tuning: 81.94 sec elapsed

best_xgb <- select_best(xgb_res, metric = "roc_auc")
xgb_final <- finalize_workflow(xgb_wf, best_xgb) |>
  fit(train)

xgb_prob <- predict(xgb_final, test, type = "prob")$.pred_1

Acum TabICL pe ceas:

tic("TabICL fit + predict")
clf$fit(X_train, y_train)

tabicl_prob <- as.numeric(clf$predict_proba(X_test)(, 2))
toc(log = TRUE)

TabICL fit + predict: 110.86 sec elapsed

Comparaţie:

library(pROC)

xgb_auc <- auc(test$bad_flag, xgb_prob)
tabicl_auc <- auc(test$bad_flag, tabicl_prob)

results <- tibble(
  model = c("XGBoost (tuned, 5-fold CV)", "TabICL (zero-shot)"),
  roc_auc = c(xgb_auc, tabicl_auc)
)
results

# A tibble: 2 × 2
  model                      roc_auc
                          
1 XGBoost (tuned, 5-fold CV)   0.648
2 TabICL (zero-shot)           0.701

Cateva observatii

De la rularea acestui eșantion de credit (set de antrenament de 8.000 rânduri, 18 funcții, rata pozitivă de ~12%):

• TabICL este un provocator serios Zero-shot ROC AUC a aterizat în jur 0,70 comparabil cu un XGBoost reglat modest pe aceeași împărțire
• Câștigul este „fără buclă de reglare”. XGBoost necesită o căutare în grilă cu un CV cu mai multe ori. TabICL nu necesită nimic din toate acestea, fit şi predict și ai terminat. Util pentru linii de referință rapide, porniri la rece sau benchmark înainte de a proiecta caracteristicile.
• TabICL nu este gratuit. Prima rulare descarcă un punct de control. Pe tabele foarte largi (500+ coloane), costul de inferență crește. Nu este instrumentul potrivit pentru fiecare lucrare tabelară.

Când TabICL este (și nu) o potrivire bună

Ajungeți la TabICL atunci când:

• Doriți o linie de bază puternică pe un nou set de date fără o buclă de reglare.
• Setul de date este mic spre mediu (de la sute la zeci de mii de rânduri), regimul în care învățarea în context strălucește
• Măturați rapid multe seturi de date și doriți o valoare implicită zero-shot
• Sarcina este clasificarea (v1 a fost doar clasificare; v2 adaugă regresie și prognoză pentru serii de timp prin TabICLForecaster).

Nu ajungeți la TabICL când:

• Monotonitatea sau interpretabilitatea reglementărilor nu este negociabilă. XGBoost/LightGBM au constrângeri monotone native și arbore SHAP; TabICL este un transformator fără constrângeri monotone native. Într-un canal de evaluare a creditului în cadrul revizuirii modelului de management al riscului, acesta este un adevărat blocant.
• Setul de date este foarte mare (500K+ rânduri). TabICL crește atât de mult cu descărcarea procesorului/discului, dar precizia se poate degrada. Tuned GBDT rămâne cel mai sigur pariu la scară.
• Aveți nevoie de imputarea personalizată a valorii lipsă. TabICL gestionează valorile lipsă în mod intern, dar dacă domeniul dvs. are o convenție specifică (valori sentinel, MICE), ar fi necesară preprocesarea.
• Regresie cu o distribuție țintă neobișnuită. Suportul de regresie al v2 este mai nou decât clasificarea; verifica documentele.

La pachet

Modelele de fundație tabulară nu înlocuiesc XGBoost, ci adaugă o linie de bază puternică, zero-shot, care nu necesită reglare și rulează într-o singură trecere înainte. Pentru clasificarea tabelară de la mic până la mediu, TabICL este un contestator credibil al standardului GBDT. Ar fi o idee bună să-l folosiți pentru a face benchmark înainte de a vă angaja într-o buclă de reglare. GBDT-urile sunt calea de urmat atunci când setul de date este mare, constrângerile sunt de reglementare sau este necesară interpretabilitatea nativă.