TabFM: bazowy model zero-shot dla danych tabelarycznych

Otwórz wersję notebooka tej strony

TabFM to model bazowy Google Research dla danych tabelarowych. Wykorzystuje uczenie w kontekście, gdzie wiersze treningowe są przekazywane jako kontekst, a przewidywania dokonywane są w jednym przejściu do przodu, bez konieczności precyzyjnego dostrajania, wyszukiwania hiperparametrów ani treningu specyficznego dla zbioru danych. Obsługuje klasyfikację binarną i wieloklasową (do 10 klas) oraz regresję w tabelach z mieszanymi kolumnami liczbowymi i kategorycznymi.

Ten notatnik uruchamia klasyfikację zero-shot na zbiorze danych raka piersi oraz regresję zero-shot na zbiorze danych dotyczącym cukrzycy.

Note

Ten przykład wymaga środowiska AI Databricks w wersji 6 lub nowej.

Nawiązywanie połączenia z bezserwerowym przetwarzaniem GPU

Kliknij listę rozwijaną Połącz i wybierz pozycję Bezserwerowy procesor GPU. Otwórz panel boczny Środowisko, ustaw Akcelerator na 1xH100 i wybierz AI v6.

Requirements

  • Dostęp do Internetu w celu pobrania wag modeli z Hugging Face Hub przy pierwszym uruchomieniu.
  • Token Hugging Face odczytuje zapisany jako sekret Databricks. Ustaw widżety hf_secret_scope i hf_secret_key w kroku uwierzytelniania na zakres i klucz wpisu tajnego.
  • Wagi modeli są licencjonowane na podstawie licencji TabFM Non-Commercial License v1.0.
  • Ten notatnik zawiera kod źródłowy z tabfm-1.0.0-pytorch, © Google Research, objęty licencją Apache 2.0.

TabFM jest preinstalowany w środowisku AI Databricks w wersji 6, więc nie jest wymagana dodatkowa instalacja.

Importowanie bibliotek

Zaimportuj PyTorch, moduły do ładowania zbiorów danych i metryki z biblioteki scikit-learn oraz TabFMClassifier / TabFMRegressor z pakietu tabfm, a następnie sprawdź dostępność GPU.

import numpy as np
import pandas as pd
import torch

from sklearn.datasets import load_breast_cancer, load_diabetes
from sklearn.metrics import accuracy_score, roc_auc_score, mean_squared_error, r2_score
from sklearn.model_selection import train_test_split

from tabfm import TabFMClassifier, TabFMRegressor, tabfm_v1_0_0_pytorch as tabfm_v1_0_0

print(f"Torch version: {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")

Uwierzytelnij się za pomocą Hugging Face

Ustaw widgety hf_secret_scope i hf_secret_key na zakres wpisów tajnych Databricks i klucz, w których przechowywany jest token dostępu do odczytu Hugging Face, a następnie zaloguj się, aby klient Hub mógł uwierzytelniać pobieranie.

from huggingface_hub import login

# Set these widgets to the Databricks secret scope and key that hold your Hugging Face read token.
dbutils.widgets.text("hf_secret_scope", "", "Hugging Face secret scope")
dbutils.widgets.text("hf_secret_key", "hf_token", "Hugging Face secret key")

hf_token = dbutils.secrets.get(
    scope=dbutils.widgets.get("hf_secret_scope"),
    key=dbutils.widgets.get("hf_secret_key"),
)
login(token=hf_token)

Klasyfikacja bez przykładów

Przeprowadzić klasyfikację zerową na zbiorze danych dotyczących raka piersi (569 próbek, 30 cech numerycznych). Dodana jest kolumna kategoryczna radius_band wyprowadzona z , mean radius dzięki czemu tabela wejściowa miesza typy numeryczne i kategoryczne. TabFM przekazuje wiersze treningowe jako kontekst i przewiduje etykiety dla danych testowych w ramach jednego przebiegu modelu.

Załaduj i podziel zbiór danych klasyfikacji

Załaduj zbiór danych dotyczących raka piersi, dodaj pochodną cechę kategoryczną radius_band i podziel go na 80% zbiór treningowy i 20% zbiór testowy, ze stratyfikacją względem zmiennej docelowej.

breast = load_breast_cancer(as_frame=True)
clf_df = breast.frame.copy()
clf_df["radius_band"] = pd.qcut(
    clf_df["mean radius"],
    q=4,
    labels=["small", "medium", "large", "xlarge"],
).astype(str)

X_clf = clf_df.drop(columns=["target"])
y_clf = clf_df["target"]

X_train_clf, X_test_clf, y_train_clf, y_test_clf = train_test_split(
    X_clf,
    y_clf,
    test_size=0.2,
    random_state=42,
    stratify=y_clf,
)

display(X_train_clf.head(5))
print({
    "train_rows": len(X_train_clf),
    "test_rows": len(X_test_clf),
    "feature_count": X_train_clf.shape[1],
})

Dopasuj i przewiduj

Załaduj wagi modelu klasyfikacyjnego, przekaż wszystkie wiersze treningowe jako przykłady w kontekście wejściowym i przewidź etykiety klas oraz prawdopodobieństwa dla zbioru testowego. Podaj dokładność i ROC-AUC.

tabfm_clf_model = tabfm_v1_0_0.load(model_type="classification")
tabfm_clf = TabFMClassifier(model=tabfm_clf_model)

tabfm_clf.fit(X_train_clf, y_train_clf)
clf_pred_proba = np.asarray(tabfm_clf.predict_proba(X_test_clf))
clf_pred = (clf_pred_proba[:, 1] >= 0.5).astype(int)

clf_results = pd.DataFrame({
    "actual": y_test_clf.reset_index(drop=True),
    "predicted": clf_pred.astype(int),
    "positive_class_probability": clf_pred_proba[:, 1],
})

accuracy = accuracy_score(y_test_clf, clf_pred)
roc_auc = roc_auc_score(y_test_clf, clf_pred_proba[:, 1])

print({
    "accuracy": round(float(accuracy), 4),
    "roc_auc": round(float(roc_auc), 4),
})
display(clf_results.head(10))

Regresja bez przykładów

Uruchom regresję typu zero-shot na zbiorze danych dotyczącym cukrzycy (442 próbki, 10 cech numerycznych). Dodana jest kolumna kategoryczna bmi_band . TabFM przewiduje ciągły wynik progresji choroby dla każdej próbki testowej.

Załaduj i rozdziel zbiór danych regresji

Załaduj zbiór danych dotyczący cukrzycy, dodaj pochodną cechę kategorialną bmi_band i podziel go na 80% zbiór treningowy / 20% zbiór testowy.

diabetes = load_diabetes(as_frame=True)
reg_df = diabetes.frame.copy()
reg_df["bmi_band"] = pd.qcut(
    reg_df["bmi"],
    q=4,
    labels=["low", "mid_low", "mid_high", "high"],
).astype(str)

X_reg = reg_df.drop(columns=["target"])
y_reg = reg_df["target"]

X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(
    X_reg,
    y_reg,
    test_size=0.2,
    random_state=42,
)

display(X_train_reg.head(5))
print({
    "train_rows": len(X_train_reg),
    "test_rows": len(X_test_reg),
    "feature_count": X_train_reg.shape[1],
})

Dopasuj i przewiduj

Załaduj wagi modelu regresyjnego, przekaż wszystkie wiersze treningowe jako przykłady kontekstowe i przewidź ciągłe wartości dla zbioru testowego. Zgłoś RMSE i R².

tabfm_reg_model = tabfm_v1_0_0.load(model_type="regression")
tabfm_reg = TabFMRegressor(model=tabfm_reg_model)

tabfm_reg.fit(X_train_reg, y_train_reg)
reg_pred = np.asarray(tabfm_reg.predict(X_test_reg)).reshape(-1)

rmse = np.sqrt(mean_squared_error(y_test_reg, reg_pred))
r2 = r2_score(y_test_reg, reg_pred)

reg_results = pd.DataFrame({
    "actual": y_test_reg.reset_index(drop=True),
    "predicted": reg_pred,
})
reg_results["absolute_error"] = (reg_results["actual"] - reg_results["predicted"]).abs()

print({
    "rmse": round(float(rmse), 4),
    "r2": round(float(r2), 4),
})
display(reg_results.head(10))

Następne kroki

Aby dostosować ten notatnik do innego zbioru danych, wczytaj ramkę danych pandas, oddziel kolumnę docelową, pozostaw kolumny kategoryczne jako ciągi znaków, podziel dane na zbiory treningowy i testowy oraz zamień na TabFMClassifier lub TabFMRegressor. Ponieważ TabFM wykorzystuje wiersze treningowe jako przykłady podawane w kontekście, zużycie pamięci rośnie wraz z rozmiarem zbioru treningowego, więc w przypadku dużych tabel zacznij od reprezentatywnej próbki, a liczba klas docelowych w klasyfikacji nie powinna przekraczać 10.

Przykładowy notatnik

TabFM: bazowy model zero-shot dla danych tabelarycznych

Pobierz laptopa

  • Ostatnia aktualizacja o