TabPFN's picture
Update app.py
292ba65
raw
history blame
6.4 kB
import sys
tabpfn_path = 'TabPFN'
sys.path.insert(0, tabpfn_path) # our submodule of the TabPFN repo (at 045c8400203ebd062346970b4f2c0ccda5a40618)
from TabPFN.scripts.transformer_prediction_interface import TabPFNClassifier
from decision_boundary import DecisionBoundaryDisplay
import numpy as np
from pathlib import Path
import pandas as pd
import torch
import gradio as gr
import openml
import os
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
default_device = "cuda:0" if torch.cuda.is_available() else "cpu:0"
classifier = TabPFNClassifier(base_path=tabpfn_path, device=default_device, N_ensemble_configurations=4)
def compute(df_table):
headers = df_table.columns
table = df_table.to_numpy()
vfunc = np.vectorize(lambda s: len(str(s)))
non_empty_row_mask = (vfunc(table).sum(1) != 0)
table = table[non_empty_row_mask]
empty_mask = table == ''
empty_inds = np.where(empty_mask)
if table.shape[0] > 1024:
return "⚠️ **ERROR: TabPFN is not made for datasets with a trainingsize > 1024.**", None, None
if table.shape[1] > 100:
return "⚠️ **ERROR: TabPFN is not made for datasets with a feature size > 100.**", None, None
if not len(empty_inds[0]):
return "⚠️ **ERROR: Please leave at least one field blank for prediction.**", None, None
if not np.all(empty_inds[1][0] == empty_inds[1]):
return "⚠️ **Please only leave fields of one column blank for prediction.**", None, None
y_column = empty_inds[1][0]
eval_lines = empty_inds[0]
train_table = np.delete(table, eval_lines, axis=0)
eval_table = table[eval_lines]
try:
x_train = torch.tensor(np.delete(train_table, y_column, axis=1).astype(np.float32))
x_eval = torch.tensor(np.delete(eval_table, y_column, axis=1).astype(np.float32))
#y_train = train_table[:, y_column]
y_train = np.array(train_table[:, y_column].tolist())
except ValueError:
return "⚠️ **Please only add numbers (to the inputs) or leave fields empty.**", None, None
print(y_train)
print(y_train[:10],y_train[-10:])
classifier.fit(x_train, y_train)
y_eval, p_eval = classifier.predict(x_eval, return_winning_probability=True)
# print(file, type(file))
out_table = pd.DataFrame(table.copy().astype(str))
out_table.iloc[eval_lines, y_column] = [f"{y_e} (p={p_e:.2f})" for y_e, p_e in zip(y_eval, p_eval)]
out_table = out_table.iloc[eval_lines, :]
out_table.columns = headers
# PLOTTING
fig = plt.figure(figsize=(10,10))
ax = fig.add_subplot(111)
cm = plt.cm.RdBu
cm_bright = ListedColormap(["#FF0000", "#0000FF"])
# Plot the training points
vfunc = np.vectorize(lambda x : np.where(classifier.classes_ == x)[0])
y_train_index = vfunc(y_train)
y_train_index = y_train_index == 0
y_train = y_train_index
#x_train = x_train[y_train_index <= 1]
#y_train = y_train[y_train_index <= 1]
#y_train_index = y_train_index[y_train_index <= 1]
ax.scatter(x_train[:, 0], x_train[:, 1], c=y_train_index, cmap=cm_bright)
classifier.fit(x_train[:, 0:2], y_train)
DecisionBoundaryDisplay.from_estimator(
classifier, x_train[:, 0:2], alpha=0.6, ax=ax, eps=2.0, grid_resolution=25, response_method="predict_proba"
)
plt.xlabel(headers[0])
plt.ylabel(headers[1])
return "The plot visualizes a predictor based on only two features and for two classes. The tabular results below are based on the full dataset.\nThis demo is running on a CPU only and with 4 ensemble members (32 in the paper).", out_table, fig
def upload_file(file, remove_entries=10):
if file.name.endswith('.arff'):
dataset = openml.datasets.OpenMLDataset('t', 'test', data_file=file.name)
X_, _, categorical_indicator_, attribute_names_ = dataset.get_data(
dataset_format="array"
)
df = pd.DataFrame(X_, columns=attribute_names_)
headers = np.arange(len(df.columns))
df.columns = headers
elif file.name.endswith('.csv') or file.name.endswith('.data'):
df = pd.read_csv(file.name, header='infer')
headers = np.arange(len(df.columns))
df.columns = headers
df.iloc[0:remove_entries, -1] = ''
return df
def update_table(table):
vfunc = np.vectorize(lambda s: len(str(s)))
non_empty_row_mask = (vfunc(table).sum(1) != 0)
table = table[non_empty_row_mask]
empty_mask = table == ''
empty_inds = np.where(empty_mask)
if not len(empty_inds[0]):
return table
y_column = empty_inds[1][0]
eval_lines = empty_inds[0]
table.iloc[eval_lines, y_column] = ''
return table
gr.Markdown("""This demo allows you to experiment with the **TabPFN** model for tabular data.
If you remove values in the target column, TabPFN will make predictions on them after clicking on the Button. The first 10 target values were already removed for this example dataset, so TabPFN will predict the first 10 classes.
Please, provide everything but the targets as numeric values and only remove values in one column (the target column).
""")
with gr.Blocks() as demo:
with gr.Row():
with gr.Column():
inp_table = gr.DataFrame(type='pandas', value=upload_file(Path('iris.csv'), remove_entries=10)
, headers=[''] * 5)
inp_file = gr.File(
label='Drop either a .csv (without header, only numeric values for all but the labels) or a .arff file.')
examples = gr.Examples(examples=['iris.csv', 'balance-scale.arff'],
inputs=[inp_file],
outputs=[inp_table],
fn=upload_file,
cache_examples=True)
#inp_table.change(fn=update_table, inputs=inp_table, outputs=inp_table)
with gr.Column():
btn = gr.Button("Calculate Predictions")
out_text = gr.Markdown()
out_plot = gr.Plot(type="Matplotlib")
out_table = gr.DataFrame()
btn.click(fn=compute, inputs=inp_table, outputs=[out_text, out_table, out_plot])
inp_file.change(fn=upload_file, inputs=inp_file, outputs=inp_table)
demo.launch()