Add datasets and TabFM tuning

README.md

@@ -36,11 +36,11 @@ The app includes:
 The built-in catalog uses real open datasets where possible:
 
 - OpenML: Titanic, Ames Housing, Adult Income
-- KaggleHub: Credit Card Fraud, Epicurious Recipes
+- KaggleHub: Credit Card Fraud, Epicurious Recipes, CalCOFI, Szeged Weather, WWII Weather, Montreal Bike Lanes, NYC Bike Crossings, UK Road Safety, KCBS BBQ
 - FiveThirtyEight GitHub data: Halloween Candy
 - sklearn: California Housing, Iris, Wine, Breast Cancer, Digits, Diabetes
 
-TabFM is loaded through the public Google Research package when available. The app keeps graceful fallbacks so the Space still works on CPU-only or dependency-constrained runtimes.
+TabFM is loaded through the public Google Research package when available. The app keeps graceful fallbacks so the Space still works on CPU-only or dependency-constrained runtimes. Live TabFM runs are opt-in because the model weights are large and CPU-only inference can be slow.
 
 Note: TabFM's weights use their own non-commercial license. Review the upstream model license before using this Space commercially.
 

app.py

@@ -40,6 +40,12 @@ RANDOM_STATE = 42
 CANDY_DATA_URL = "https://raw.githubusercontent.com/fivethirtyeight/data/master/candy-power-ranking/candy-data.csv"
 GOOGLE_COLORS = ["#4285F4", "#DB4437", "#F4B400", "#0F9D58", "#A142F4", "#00ACC1"]
 METRIC_CHOICES = ["accuracy", "f1_weighted", "roc_auc", "rmse", "mae", "r2", "seconds"]
+TABFM_PRESETS = {
+    "Fast": {"n_estimators": 1, "max_num_rows": 256, "max_num_features": 64, "batch_size": 1, "enable_nnls": False, "n_feature_crosses": 0, "n_svd_features": 0, "max_eval_rows": 256},
+    "Balanced": {"n_estimators": 4, "max_num_rows": 512, "max_num_features": 128, "batch_size": 1, "enable_nnls": False, "n_feature_crosses": 0, "n_svd_features": 0, "max_eval_rows": 512},
+    "Default": {"n_estimators": 32, "max_num_rows": None, "max_num_features": 500, "batch_size": 1, "enable_nnls": False, "n_feature_crosses": 0, "n_svd_features": 0, "max_eval_rows": 1000},
+    "Ensemble": {"n_estimators": 32, "max_num_rows": None, "max_num_features": 500, "batch_size": 1, "enable_nnls": True, "n_feature_crosses": "sqrt", "n_svd_features": "sqrt", "max_eval_rows": 1000},
+}
 
 
 @dataclass(frozen=True)
@@ -73,6 +79,54 @@ def find_first_data_file(root: str | Path, suffixes: tuple[str, ...]) -> Path:
     raise FileNotFoundError(f"No data file with suffixes {suffixes} found in {root}")
 
 
+def normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+    df.columns = (
+        pd.Index(df.columns)
+        .astype(str)
+        .str.strip()
+        .str.lower()
+        .str.replace(r"[^0-9a-z]+", "_", regex=True)
+        .str.strip("_")
+    )
+    return df
+
+
+def choose_col(df: pd.DataFrame, candidates: list[str], contains: list[str] | None = None) -> str:
+    normalized = {c.lower(): c for c in df.columns}
+    for candidate in candidates:
+        key = candidate.lower()
+        if key in normalized:
+            return normalized[key]
+    if contains:
+        for col in df.columns:
+            lower = str(col).lower()
+            if all(part in lower for part in contains):
+                return col
+    raise KeyError(f"None of {candidates} found in columns.")
+
+
+def kaggle_csv(dataset_id: str, preferred_names: tuple[str, ...] = ()) -> pd.DataFrame:
+    import kagglehub
+
+    path = Path(kagglehub.dataset_download(dataset_id))
+    csvs = sorted(path.rglob("*.csv"))
+    if preferred_names:
+        for preferred in preferred_names:
+            for csv in csvs:
+                if preferred.lower() in csv.name.lower():
+                    return pd.read_csv(csv)
+    if not csvs:
+        raise FileNotFoundError(f"No CSV files found in Kaggle dataset {dataset_id}.")
+    return pd.read_csv(csvs[0])
+
+
+def select_numeric_features(df: pd.DataFrame, target: str, max_features: int = 12) -> pd.DataFrame:
+    numeric = df.select_dtypes(include=np.number).columns.tolist()
+    cols = [c for c in numeric if c != target][:max_features]
+    return df[[*cols, target]].dropna(subset=[target])
+
+
 @lru_cache(maxsize=1)
 def openml_titanic() -> pd.DataFrame:
     data = fetch_openml(data_id=40945, as_frame=True, parser="auto")
@@ -162,12 +216,95 @@ def kaggle_epirecipes() -> pd.DataFrame:
         "healthy",
         "vegetarian",
         "vegan",
+        "cakeweek",
         "rating",
     ]
     cols = [c for c in preferred if c in df.columns]
     return df[cols].dropna(subset=["rating"])
 
 
+@lru_cache(maxsize=1)
+def kaggle_calcofi() -> pd.DataFrame:
+    df = normalize_columns(kaggle_csv("sohier/calcofi", ("bottle",)))
+    target = choose_col(df, ["t_deg_c", "temperature"], ["t", "deg"])
+    salinity = choose_col(df, ["salnty", "salinity"], ["sal"])
+    cols = [c for c in [salinity, "depthm", "o2ml_l", "sio3um", "no3um", "po4um", target] if c in df.columns]
+    return df[cols].rename(columns={target: "water_temperature", salinity: "salinity"}).dropna(subset=["water_temperature"])
+
+
+@lru_cache(maxsize=1)
+def kaggle_szeged_weather() -> pd.DataFrame:
+    df = normalize_columns(kaggle_csv("budincsevity/szeged-weather"))
+    target = choose_col(df, ["apparent_temperature_c", "apparent_temperature"], ["apparent", "temperature"])
+    cols = [c for c in ["temperature_c", "humidity", "wind_speed_km_h", "wind_bearing_degrees", "visibility_km", "pressure_millibars", "summary", "precip_type", target] if c in df.columns]
+    return df[cols].rename(columns={target: "apparent_temperature"}).dropna(subset=["apparent_temperature"])
+
+
+@lru_cache(maxsize=1)
+def kaggle_weather_ww2() -> pd.DataFrame:
+    df = normalize_columns(kaggle_csv("smid80/weatherww2", ("summary",)))
+    target = choose_col(df, ["maxtemp", "max_temp", "max"], ["max"])
+    cols = [c for c in ["mintemp", "meantemp", "precip", "snowfall", "yr", "mo", "da", target] if c in df.columns]
+    return df[cols].rename(columns={target: "max_temperature"}).dropna(subset=["max_temperature"])
+
+
+@lru_cache(maxsize=1)
+def kaggle_montreal_bike_lanes() -> pd.DataFrame:
+    df = normalize_columns(kaggle_csv("pablomonleon/montreal-bike-lanes"))
+    numeric = df.select_dtypes(include=np.number)
+    if numeric.shape[1] < 2:
+        raise ValueError("Montreal bike lanes dataset needs at least two numeric count columns.")
+    target = numeric.columns[-1]
+    cols = numeric.columns[: min(8, len(numeric.columns))].tolist()
+    if target not in cols:
+        cols.append(target)
+    return df[cols].rename(columns={target: "rider_count"}).dropna(subset=["rider_count"])
+
+
+@lru_cache(maxsize=1)
+def kaggle_nyc_bike_crossings() -> pd.DataFrame:
+    df = normalize_columns(kaggle_csv("new-york-city/nyc-east-river-bicycle-crossings"))
+    numeric = df.select_dtypes(include=np.number)
+    target = choose_col(numeric, ["total", "total_bicycle_count"], ["total"])
+    cols = [c for c in numeric.columns[:8] if c != target]
+    return df[[*cols, target]].rename(columns={target: "total_bike_crossings"}).dropna(subset=["total_bike_crossings"])
+
+
+@lru_cache(maxsize=1)
+def kaggle_uk_road_safety() -> pd.DataFrame:
+    df = normalize_columns(kaggle_csv("bluehorseshoe/uk-2016-road-safety-data", ("accident",)))
+    target = choose_col(df, ["number_of_casualties", "casualties"], ["casual"])
+    preferred = [
+        "number_of_vehicles",
+        "day_of_week",
+        "speed_limit",
+        "light_conditions",
+        "weather_conditions",
+        "road_surface_conditions",
+        "urban_or_rural_area",
+        target,
+    ]
+    cols = [c for c in preferred if c in df.columns]
+    return df[cols].rename(columns={target: "casualty_count"}).dropna(subset=["casualty_count"])
+
+
+@lru_cache(maxsize=1)
+def kaggle_kcbs_bbq() -> pd.DataFrame:
+    df = normalize_columns(kaggle_csv("jaysobel/kcbs-bbq"))
+    numeric = df.select_dtypes(include=np.number)
+    if "place" in df.columns:
+        target = "place"
+    elif "rank" in df.columns:
+        target = "rank"
+    else:
+        target = numeric.columns[0]
+    out = df.copy()
+    out["first_place"] = pd.to_numeric(out[target], errors="coerce").eq(1).astype(int)
+    feature_cols = [c for c in numeric.columns if c != target][:10]
+    categorical_cols = [c for c in out.columns if c not in numeric.columns and c != target][:4]
+    return out[[*feature_cols, *categorical_cols, "first_place"]].dropna(subset=["first_place"])
+
+
 def load_iris_df(limit: int, seed: int) -> pd.DataFrame:
     data = load_iris(as_frame=True)
     df = data.frame.rename(columns={"target": "species"})
@@ -324,6 +461,19 @@ def load_epirecipes_df(limit: int, seed: int) -> pd.DataFrame:
         return load_epirecipes_proxy_df(limit, seed)
 
 
+def load_epirecipes_cakeweek_df(limit: int, seed: int) -> pd.DataFrame:
+    try:
+        df = kaggle_epirecipes().copy()
+        if "cakeweek" not in df.columns:
+            raise KeyError("cakeweek")
+        df["cakeweek"] = pd.to_numeric(df["cakeweek"], errors="coerce").fillna(0).astype(int)
+        return sample_df(df, limit, seed)
+    except Exception:
+        df = load_epirecipes_proxy_df(limit, seed).copy()
+        df["cakeweek"] = ((df["course"] == "dessert") & (df["rating"] >= df["rating"].median())).astype(int)
+        return df
+
+
 def load_candy_proxy_df(limit: int, seed: int) -> pd.DataFrame:
     rng = np.random.default_rng(seed)
     n = min(limit, 1200)
@@ -357,6 +507,13 @@ def load_candy_df(limit: int, seed: int) -> pd.DataFrame:
         return load_candy_proxy_df(limit, seed)
 
 
+def load_candy_chocolate_df(limit: int, seed: int) -> pd.DataFrame:
+    df = load_candy_df(limit, seed).copy()
+    if "chocolate" not in df.columns:
+        raise gr.Error("Candy dataset does not include the chocolate target.")
+    return df
+
+
 def load_adult_income_proxy_df(limit: int, seed: int) -> pd.DataFrame:
     rng = np.random.default_rng(seed)
     n = min(limit, 30000)
@@ -398,6 +555,81 @@ def load_bike_demand_proxy_df(limit: int, seed: int) -> pd.DataFrame:
     return pd.DataFrame({"hour": hour, "temp": temp.round(1), "workingday": workingday, "weather": weather, "rental_count": count.clip(0).round(0)})
 
 
+def load_calcofi_df(limit: int, seed: int) -> pd.DataFrame:
+    try:
+        return sample_df(kaggle_calcofi(), limit, seed)
+    except Exception:
+        rng = np.random.default_rng(seed)
+        n = min(limit, 12000)
+        salinity = rng.normal(33.5, 0.7, n)
+        depth = rng.gamma(2.0, 40.0, n)
+        temp = 23 - 0.38 * depth / 10 - 1.7 * (salinity - 33.5) + rng.normal(0, 1.8, n)
+        return pd.DataFrame({"salinity": salinity, "depthm": depth, "water_temperature": temp})
+
+
+def load_szeged_weather_df(limit: int, seed: int) -> pd.DataFrame:
+    try:
+        return sample_df(kaggle_szeged_weather(), limit, seed)
+    except Exception:
+        rng = np.random.default_rng(seed)
+        n = min(limit, 20000)
+        humidity = rng.beta(4, 2, n)
+        temp = rng.normal(12, 10, n)
+        apparent = temp - 5 * humidity + rng.normal(0, 2.5, n)
+        return pd.DataFrame({"temperature_c": temp, "humidity": humidity, "wind_speed_km_h": rng.gamma(2, 4, n), "apparent_temperature": apparent})
+
+
+def load_weather_ww2_df(limit: int, seed: int) -> pd.DataFrame:
+    try:
+        return sample_df(kaggle_weather_ww2(), limit, seed)
+    except Exception:
+        rng = np.random.default_rng(seed)
+        n = min(limit, 15000)
+        mintemp = rng.normal(15, 9, n)
+        return pd.DataFrame({"mintemp": mintemp, "precip": rng.gamma(1.5, 2, n), "max_temperature": mintemp + rng.normal(8, 3, n)})
+
+
+def load_montreal_bike_lanes_df(limit: int, seed: int) -> pd.DataFrame:
+    try:
+        return sample_df(kaggle_montreal_bike_lanes(), limit, seed)
+    except Exception:
+        return load_bike_demand_proxy_df(limit, seed).rename(columns={"rental_count": "rider_count"})
+
+
+def load_nyc_bike_crossings_df(limit: int, seed: int) -> pd.DataFrame:
+    try:
+        return sample_df(kaggle_nyc_bike_crossings(), limit, seed)
+    except Exception:
+        df = load_bike_demand_proxy_df(limit, seed)
+        df["brooklyn_bridge"] = (df["rental_count"] * 0.32).round()
+        df["manhattan_bridge"] = (df["rental_count"] * 0.27).round()
+        df["total_bike_crossings"] = df["rental_count"]
+        return df.drop(columns=["rental_count"])
+
+
+def load_uk_road_safety_df(limit: int, seed: int) -> pd.DataFrame:
+    try:
+        return sample_df(kaggle_uk_road_safety(), limit, seed)
+    except Exception:
+        rng = np.random.default_rng(seed)
+        n = min(limit, 30000)
+        vehicles = rng.integers(1, 5, n)
+        speed = rng.choice([20, 30, 40, 50, 60, 70], n)
+        casualties = rng.poisson(0.4 + vehicles * 0.28 + (speed > 50) * 0.25, n)
+        return pd.DataFrame({"number_of_vehicles": vehicles, "speed_limit": speed, "light_conditions": rng.choice(["daylight", "dark"], n), "casualty_count": casualties})
+
+
+def load_kcbs_bbq_df(limit: int, seed: int) -> pd.DataFrame:
+    try:
+        return sample_df(kaggle_kcbs_bbq(), limit, seed)
+    except Exception:
+        rng = np.random.default_rng(seed)
+        n = min(limit, 8000)
+        score = rng.normal(165, 12, n)
+        first = rng.binomial(1, 1 / (1 + np.exp(-(score - 184) / 5)))
+        return pd.DataFrame({"score": score, "contest_size": rng.integers(10, 80, n), "category": rng.choice(["chicken", "ribs", "pork", "brisket"], n), "first_place": first})
+
+
 DATASETS: list[DatasetSpec] = [
     DatasetSpec("Titanic Survival", "classification", "survived", "OpenML data_id=40945", 1309, "Mixed categorical/numeric binary classification.", load_titanic_df),
     DatasetSpec("Ames Housing Prices", "regression", "sale_price", "OpenML data_id=42165", 1460, "Ames real-estate regression with neighborhood and quality features.", load_ames_housing_df),
@@ -405,6 +637,15 @@ DATASETS: list[DatasetSpec] = [
     DatasetSpec("Credit Card Fraud", "classification", "fraud", "KaggleHub mlg-ulb/creditcardfraud", 284807, "Large imbalanced binary fraud task.", load_credit_fraud_df),
     DatasetSpec("Epicurious Recipes", "regression", "rating", "KaggleHub hugodarwood/epirecipes", 20000, "Recipe nutrition and tags to rating.", load_epirecipes_df),
     DatasetSpec("Halloween Candy", "regression", "winpercent", "FiveThirtyEight GitHub CSV", 85, "Candy attributes to popularity score.", load_candy_df),
+    DatasetSpec("Candy Chocolate", "classification", "chocolate", "FiveThirtyEight GitHub CSV", 85, "Predict whether a candy is chocolate from other candy attributes.", load_candy_chocolate_df),
+    DatasetSpec("Epicurious Cakeweek", "classification", "cakeweek", "KaggleHub hugodarwood/epirecipes", 20000, "Predict cakeweek recipes from nutrition and recipe tags.", load_epirecipes_cakeweek_df),
+    DatasetSpec("CalCOFI Ocean Temperature", "regression", "water_temperature", "KaggleHub sohier/calcofi", 864863, "Predict ocean water temperature from salinity and chemistry readings.", load_calcofi_df),
+    DatasetSpec("Szeged Apparent Temperature", "regression", "apparent_temperature", "KaggleHub budincsevity/szeged-weather", 96453, "Predict apparent temperature from humidity, wind, pressure, and weather.", load_szeged_weather_df),
+    DatasetSpec("WW2 Max Temperature", "regression", "max_temperature", "KaggleHub smid80/weatherww2", 119040, "Predict daily maximum temperature from minimum temperature and weather fields.", load_weather_ww2_df),
+    DatasetSpec("Montreal Bike Lane Counts", "regression", "rider_count", "KaggleHub pablomonleon/montreal-bike-lanes", 319, "Predict rider counts on one Montreal bike path from other paths.", load_montreal_bike_lanes_df),
+    DatasetSpec("NYC Bike Crossings", "regression", "total_bike_crossings", "KaggleHub new-york-city/nyc-east-river-bicycle-crossings", 210, "Predict total East River bicycle crossings from bridge counts.", load_nyc_bike_crossings_df),
+    DatasetSpec("UK Road Casualties", "regression", "casualty_count", "KaggleHub bluehorseshoe/uk-2016-road-safety-data", 136621, "Predict accident casualty count from road safety fields.", load_uk_road_safety_df),
+    DatasetSpec("KCBS BBQ First Place", "classification", "first_place", "KaggleHub jaysobel/kcbs-bbq", 1559, "Predict whether a BBQ competition team wins first place.", load_kcbs_bbq_df),
     DatasetSpec("Adult Income", "classification", "income_gt_50k", "OpenML data_id=1590", 48842, "Demographic and work attributes to income bucket.", load_adult_income_df),
     DatasetSpec("Bike Demand", "regression", "rental_count", "Kaggle-style proxy", 15000, "Weather and time features to rental demand.", load_bike_demand_proxy_df),
     DatasetSpec("Iris", "classification", "species", "sklearn", 150, "Classic multi-class flower classification.", load_iris_df),
@@ -473,16 +714,16 @@ def make_preprocessor(x: pd.DataFrame, scale_numeric: bool = False) -> ColumnTra
 def available_baselines(task: str) -> dict[str, object]:
     if task == "classification":
         models: dict[str, object] = {
-            "Logistic": Pipeline([("prep", make_preprocessor(pd.DataFrame(), True)), ("model", LogisticRegression(max_iter=1200, n_jobs=-1))]),
-            "RandomForest": Pipeline([("prep", make_preprocessor(pd.DataFrame())), ("model", RandomForestClassifier(n_estimators=180, min_samples_leaf=2, n_jobs=-1, random_state=RANDOM_STATE))]),
-            "HistGradientBoosting": Pipeline([("prep", make_preprocessor(pd.DataFrame())), ("model", HistGradientBoostingClassifier(random_state=RANDOM_STATE))]),
+            "Logistic": Pipeline([("prep", make_preprocessor(pd.DataFrame(), True)), ("model", LogisticRegression(max_iter=800))]),
+            "RandomForest": Pipeline([("prep", make_preprocessor(pd.DataFrame())), ("model", RandomForestClassifier(n_estimators=80, min_samples_leaf=2, n_jobs=-1, random_state=RANDOM_STATE))]),
+            "HistGradientBoosting": Pipeline([("prep", make_preprocessor(pd.DataFrame())), ("model", HistGradientBoostingClassifier(max_iter=120, random_state=RANDOM_STATE))]),
             "Dummy": Pipeline([("prep", make_preprocessor(pd.DataFrame())), ("model", DummyClassifier(strategy="most_frequent"))]),
         }
     else:
         models = {
             "Ridge": Pipeline([("prep", make_preprocessor(pd.DataFrame(), True)), ("model", Ridge(alpha=1.0))]),
-            "RandomForest": Pipeline([("prep", make_preprocessor(pd.DataFrame())), ("model", RandomForestRegressor(n_estimators=180, min_samples_leaf=2, n_jobs=-1, random_state=RANDOM_STATE))]),
-            "HistGradientBoosting": Pipeline([("prep", make_preprocessor(pd.DataFrame())), ("model", HistGradientBoostingRegressor(random_state=RANDOM_STATE))]),
+            "RandomForest": Pipeline([("prep", make_preprocessor(pd.DataFrame())), ("model", RandomForestRegressor(n_estimators=80, min_samples_leaf=2, n_jobs=-1, random_state=RANDOM_STATE))]),
+            "HistGradientBoosting": Pipeline([("prep", make_preprocessor(pd.DataFrame())), ("model", HistGradientBoostingRegressor(max_iter=120, random_state=RANDOM_STATE))]),
             "Dummy": Pipeline([("prep", make_preprocessor(pd.DataFrame())), ("model", DummyRegressor(strategy="median"))]),
         }
     if importlib.util.find_spec("xgboost"):
@@ -492,14 +733,14 @@ def available_baselines(task: str) -> dict[str, object]:
             models["XGBoost"] = Pipeline(
                 [
                     ("prep", make_preprocessor(pd.DataFrame())),
-                    ("model", XGBClassifier(n_estimators=160, max_depth=4, learning_rate=0.08, eval_metric="logloss", random_state=RANDOM_STATE)),
+                    ("model", XGBClassifier(n_estimators=80, max_depth=4, learning_rate=0.08, eval_metric="logloss", random_state=RANDOM_STATE)),
                 ]
             )
         else:
             models["XGBoost"] = Pipeline(
                 [
                     ("prep", make_preprocessor(pd.DataFrame())),
-                    ("model", XGBRegressor(n_estimators=160, max_depth=4, learning_rate=0.08, random_state=RANDOM_STATE)),
+                    ("model", XGBRegressor(n_estimators=80, max_depth=4, learning_rate=0.08, random_state=RANDOM_STATE)),
                 ]
             )
     return models
@@ -519,11 +760,44 @@ def load_tabfm_model():
     return tabfm_v1_0_0_pytorch.load()
 
 
-def run_tabfm(task: str, x_train: pd.DataFrame, x_test: pd.DataFrame, y_train: pd.Series):
+def resolve_tabfm_params(
+    preset: str,
+    n_estimators: int,
+    max_num_rows: int,
+    max_num_features: int,
+    batch_size: int,
+    enable_nnls: bool,
+    n_feature_crosses: str,
+    n_svd_features: str,
+    max_eval_rows: int,
+) -> dict[str, object]:
+    if preset in TABFM_PRESETS:
+        return dict(TABFM_PRESETS[preset])
+    resolved_rows = None if max_num_rows <= 0 else int(max_num_rows)
+    resolved = {
+        "n_estimators": int(n_estimators),
+        "max_num_rows": resolved_rows,
+        "max_num_features": int(max_num_features),
+        "batch_size": int(batch_size),
+        "enable_nnls": bool(enable_nnls),
+        "n_feature_crosses": 0 if n_feature_crosses == "0" else n_feature_crosses,
+        "n_svd_features": 0 if n_svd_features == "0" else n_svd_features,
+        "max_eval_rows": None if max_eval_rows <= 0 else int(max_eval_rows),
+    }
+    if resolved["enable_nnls"] and resolved["max_num_rows"] is not None:
+        resolved["max_num_rows"] = None
+    return resolved
+
+
+def run_tabfm(task: str, x_train: pd.DataFrame, x_test: pd.DataFrame, y_train: pd.Series, tabfm_params: dict[str, object]):
     from tabfm import TabFMClassifier, TabFMRegressor
 
     foundation_model = load_tabfm_model()
-    estimator = TabFMClassifier(model=foundation_model) if task == "classification" else TabFMRegressor(model=foundation_model)
+    estimator = (
+        TabFMClassifier(model=foundation_model, **tabfm_params)
+        if task == "classification"
+        else TabFMRegressor(model=foundation_model, **tabfm_params)
+    )
     estimator.fit(x_train, y_train.to_numpy())
     pred = estimator.predict(x_test)
     proba = estimator.predict_proba(x_test) if task == "classification" and hasattr(estimator, "predict_proba") else None
@@ -560,6 +834,7 @@ def benchmark_frame(
     seed: int,
     selected_models: list[str],
     include_tabfm: bool,
+    tabfm_params: dict[str, object] | None = None,
 ) -> tuple[pd.DataFrame, pd.DataFrame, str]:
     df = df.sample(min(sample_size, len(df)), random_state=seed).reset_index(drop=True)
     x, y = split_xy(df, target)
@@ -589,9 +864,22 @@ def benchmark_frame(
     if include_tabfm:
         start = time.perf_counter()
         try:
-            pred, proba = run_tabfm(task, x_train, x_test, y_train)
-            metrics = score_predictions(task, y_test, pred, proba)
-            rows.append({"model": "TabFM", "status": "ok", "seconds": time.perf_counter() - start, **metrics})
+            tabfm_params = tabfm_params or TABFM_PRESETS["Fast"]
+            tabfm_display_params = dict(tabfm_params)
+            tabfm_model_params = dict(tabfm_params)
+            tabfm_eval_rows = tabfm_model_params.pop("max_eval_rows", None)
+            if tabfm_eval_rows is not None and len(x_test) > int(tabfm_eval_rows):
+                eval_idx = x_test.sample(int(tabfm_eval_rows), random_state=seed).index
+                x_eval = x_test.loc[eval_idx]
+                y_eval = y_test.loc[eval_idx]
+                status = f"ok ({len(x_eval):,}/{len(x_test):,} test rows)"
+            else:
+                x_eval = x_test
+                y_eval = y_test
+                status = "ok"
+            pred, proba = run_tabfm(task, x_train, x_eval, y_train, tabfm_model_params)
+            metrics = score_predictions(task, y_eval, pred, proba)
+            rows.append({"model": "TabFM", "status": status, "seconds": time.perf_counter() - start, **metrics})
         except Exception as exc:
             rows.append({"model": "TabFM", "status": f"unavailable: {exc}", "seconds": time.perf_counter() - start})
             notes.append(f"TabFM did not run in this environment. On Spaces, keep Python 3.11 and allow the GitHub dependency plus model download for `{TABFM_MODEL_ID}`.")
@@ -609,6 +897,8 @@ def benchmark_frame(
     )
     if notes:
         summary += "\n\n" + "\n".join(f"- {note}" for note in notes)
+    if include_tabfm:
+        summary += f"\n\n**TabFM params:** `{tabfm_display_params}`"
     return results[["rank", "model", "status", *metric_cols]], preview, summary
 
 
@@ -716,10 +1006,20 @@ def run_catalog(
     include_tabfm: bool,
     selected_metrics: list[str],
     chart_style: str,
+    tabfm_preset: str,
+    tabfm_n_estimators: int,
+    tabfm_max_rows: int,
+    tabfm_max_features: int,
+    tabfm_batch_size: int,
+    tabfm_enable_nnls: bool,
+    tabfm_crosses: str,
+    tabfm_svd: str,
+    tabfm_max_eval_rows: int,
 ):
     spec = get_spec(dataset_name)
     df = get_dataset(dataset_name, sample_size, seed)
-    results, preview, summary = benchmark_frame(df, spec.target, spec.task, sample_size, test_percent / 100, seed, selected_models, include_tabfm)
+    tabfm_params = resolve_tabfm_params(tabfm_preset, tabfm_n_estimators, tabfm_max_rows, tabfm_max_features, tabfm_batch_size, tabfm_enable_nnls, tabfm_crosses, tabfm_svd, tabfm_max_eval_rows)
+    results, preview, summary = benchmark_frame(df, spec.target, spec.task, sample_size, test_percent / 100, seed, selected_models, include_tabfm, tabfm_params)
     return summary, results.round(4), metric_chart(results, selected_metrics, chart_style), time_chart(results), preview
 
 
@@ -734,12 +1034,22 @@ def run_upload(
     include_tabfm: bool,
     selected_metrics: list[str],
     chart_style: str,
+    tabfm_preset: str,
+    tabfm_n_estimators: int,
+    tabfm_max_rows: int,
+    tabfm_max_features: int,
+    tabfm_batch_size: int,
+    tabfm_enable_nnls: bool,
+    tabfm_crosses: str,
+    tabfm_svd: str,
+    tabfm_max_eval_rows: int,
 ):
     if file is None:
         raise gr.Error("Upload a CSV file first.")
     df = pd.read_csv(file.name)
     selected_task = None if task == "Auto" else task.lower()
-    results, preview, summary = benchmark_frame(df, target, selected_task, sample_size, test_percent / 100, seed, selected_models, include_tabfm)
+    tabfm_params = resolve_tabfm_params(tabfm_preset, tabfm_n_estimators, tabfm_max_rows, tabfm_max_features, tabfm_batch_size, tabfm_enable_nnls, tabfm_crosses, tabfm_svd, tabfm_max_eval_rows)
+    results, preview, summary = benchmark_frame(df, target, selected_task, sample_size, test_percent / 100, seed, selected_models, include_tabfm, tabfm_params)
     return summary, results.round(4), metric_chart(results, selected_metrics, chart_style), time_chart(results), preview
 
 
@@ -794,7 +1104,7 @@ def build_app() -> gr.Blocks:
                 """
             )
             with gr.Row():
-                gr.HTML('<div class="stat-card"><div class="label">Benchmark catalog</div><div class="value">12 <span class="trend">mixed tasks</span></div><div class="label">Classification + regression</div></div>')
+                gr.HTML(f'<div class="stat-card"><div class="label">Benchmark catalog</div><div class="value">{len(DATASETS)} <span class="trend">mixed tasks</span></div><div class="label">Classification + regression</div></div>')
                 gr.HTML('<div class="stat-card"><div class="label">Linked HF model</div><div class="value">TabFM <span class="trend">1.0</span></div><div class="label">google/tabfm-1.0.0-pytorch</div></div>')
                 gr.HTML('<div class="stat-card"><div class="label">User datasets</div><div class="value">CSV <span class="trend">upload</span></div><div class="label">Pick target, task, sample size</div></div>')
             with gr.Tabs():
@@ -802,13 +1112,23 @@ def build_app() -> gr.Blocks:
                     with gr.Row():
                         with gr.Column(scale=1, elem_classes=["panel"]):
                             dataset = gr.Dropdown(dataset_names(), value="Titanic Survival", label="Dataset")
-                            sample = gr.Slider(100, 50000, value=1200, step=100, label="Sample size")
+                            sample = gr.Slider(100, 50000, value=1000, step=100, label="Sample size")
                             test_pct = gr.Slider(10, 40, value=25, step=5, label="Test split (%)")
                             seed = gr.Number(value=42, precision=0, label="Random seed")
-                            models = gr.CheckboxGroup(DEFAULT_MODELS, value=["RandomForest", "HistGradientBoosting", "XGBoost", "Dummy"], label="Baselines")
+                            models = gr.CheckboxGroup(DEFAULT_MODELS, value=["HistGradientBoosting", "Dummy"], label="Baselines")
                             include_tabfm = gr.Checkbox(value=False, label="Run TabFM live")
                             metric_toggles = gr.CheckboxGroup(METRIC_CHOICES, value=["rmse", "mae", "r2", "accuracy", "f1_weighted", "roc_auc"], label="Chart metrics")
                             chart_style = gr.Radio(["Line", "Radar"], value="Line", label="Chart style")
+                            with gr.Accordion("TabFM tuning", open=False):
+                                tabfm_preset = gr.Dropdown(list(TABFM_PRESETS.keys()) + ["Custom"], value="Fast", label="Preset")
+                                tabfm_n_estimators = gr.Slider(1, 32, value=1, step=1, label="Estimators")
+                                tabfm_max_rows = gr.Slider(0, 5000, value=256, step=64, label="Max context rows (0 = no cap)")
+                                tabfm_max_features = gr.Slider(8, 500, value=64, step=8, label="Max features")
+                                tabfm_batch_size = gr.Slider(1, 8, value=1, step=1, label="Batch size")
+                                tabfm_enable_nnls = gr.Checkbox(value=False, label="NNLS ensemble weights")
+                                tabfm_crosses = gr.Radio(["0", "sqrt"], value="0", label="Feature crosses")
+                                tabfm_svd = gr.Radio(["0", "sqrt"], value="0", label="SVD features")
+                                tabfm_max_eval_rows = gr.Slider(0, 5000, value=256, step=64, label="Max TabFM test rows (0 = no cap)")
                             run_btn = gr.Button("Run benchmark", variant="primary")
                         with gr.Column(scale=3):
                             summary = gr.Markdown()
@@ -817,7 +1137,25 @@ def build_app() -> gr.Blocks:
                                 chart = gr.Plot(label="Metric comparison")
                                 speed = gr.Plot(label="Speed")
                             preview = gr.Dataframe(label="Held-out preview", interactive=False)
-                    run_inputs = [dataset, sample, test_pct, seed, models, include_tabfm, metric_toggles, chart_style]
+                    run_inputs = [
+                        dataset,
+                        sample,
+                        test_pct,
+                        seed,
+                        models,
+                        include_tabfm,
+                        metric_toggles,
+                        chart_style,
+                        tabfm_preset,
+                        tabfm_n_estimators,
+                        tabfm_max_rows,
+                        tabfm_max_features,
+                        tabfm_batch_size,
+                        tabfm_enable_nnls,
+                        tabfm_crosses,
+                        tabfm_svd,
+                        tabfm_max_eval_rows,
+                    ]
                     run_btn.click(run_catalog, run_inputs, [summary, leaderboard, chart, speed, preview])
                     metric_toggles.change(redraw_metric_chart, [leaderboard, metric_toggles, chart_style], chart)
                     chart_style.change(redraw_metric_chart, [leaderboard, metric_toggles, chart_style], chart)
@@ -828,13 +1166,23 @@ def build_app() -> gr.Blocks:
                             file = gr.File(label="CSV file", file_types=[".csv"])
                             target = gr.Textbox(label="Target column")
                             task = gr.Radio(["Auto", "Classification", "Regression"], value="Auto", label="Task")
-                            upload_sample = gr.Slider(100, 50000, value=2000, step=100, label="Sample size")
+                            upload_sample = gr.Slider(100, 50000, value=1000, step=100, label="Sample size")
                             upload_test_pct = gr.Slider(10, 40, value=25, step=5, label="Test split (%)")
                             upload_seed = gr.Number(value=42, precision=0, label="Random seed")
-                            upload_models = gr.CheckboxGroup(DEFAULT_MODELS, value=["RandomForest", "HistGradientBoosting", "XGBoost", "Dummy"], label="Baselines")
+                            upload_models = gr.CheckboxGroup(DEFAULT_MODELS, value=["HistGradientBoosting", "Dummy"], label="Baselines")
                             upload_tabfm = gr.Checkbox(value=False, label="Run TabFM live")
                             upload_metric_toggles = gr.CheckboxGroup(METRIC_CHOICES, value=["rmse", "mae", "r2", "accuracy", "f1_weighted", "roc_auc"], label="Chart metrics")
                             upload_chart_style = gr.Radio(["Line", "Radar"], value="Line", label="Chart style")
+                            with gr.Accordion("TabFM tuning", open=False):
+                                upload_tabfm_preset = gr.Dropdown(list(TABFM_PRESETS.keys()) + ["Custom"], value="Fast", label="Preset")
+                                upload_tabfm_n_estimators = gr.Slider(1, 32, value=1, step=1, label="Estimators")
+                                upload_tabfm_max_rows = gr.Slider(0, 5000, value=256, step=64, label="Max context rows (0 = no cap)")
+                                upload_tabfm_max_features = gr.Slider(8, 500, value=64, step=8, label="Max features")
+                                upload_tabfm_batch_size = gr.Slider(1, 8, value=1, step=1, label="Batch size")
+                                upload_tabfm_enable_nnls = gr.Checkbox(value=False, label="NNLS ensemble weights")
+                                upload_tabfm_crosses = gr.Radio(["0", "sqrt"], value="0", label="Feature crosses")
+                                upload_tabfm_svd = gr.Radio(["0", "sqrt"], value="0", label="SVD features")
+                                upload_tabfm_max_eval_rows = gr.Slider(0, 5000, value=256, step=64, label="Max TabFM test rows (0 = no cap)")
                             upload_btn = gr.Button("Run uploaded dataset", variant="primary")
                         with gr.Column(scale=3):
                             upload_summary = gr.Markdown()
@@ -845,7 +1193,27 @@ def build_app() -> gr.Blocks:
                             upload_preview = gr.Dataframe(label="Held-out preview", interactive=False)
                     upload_btn.click(
                         run_upload,
-                        [file, target, task, upload_sample, upload_test_pct, upload_seed, upload_models, upload_tabfm, upload_metric_toggles, upload_chart_style],
+                        [
+                            file,
+                            target,
+                            task,
+                            upload_sample,
+                            upload_test_pct,
+                            upload_seed,
+                            upload_models,
+                            upload_tabfm,
+                            upload_metric_toggles,
+                            upload_chart_style,
+                            upload_tabfm_preset,
+                            upload_tabfm_n_estimators,
+                            upload_tabfm_max_rows,
+                            upload_tabfm_max_features,
+                            upload_tabfm_batch_size,
+                            upload_tabfm_enable_nnls,
+                            upload_tabfm_crosses,
+                            upload_tabfm_svd,
+                            upload_tabfm_max_eval_rows,
+                        ],
                         [upload_summary, upload_leaderboard, upload_chart, upload_speed, upload_preview],
                     )
                     upload_metric_toggles.change(redraw_metric_chart, [upload_leaderboard, upload_metric_toggles, upload_chart_style], upload_chart)
@@ -854,7 +1222,7 @@ def build_app() -> gr.Blocks:
                     gr.Dataframe(catalog_table(), interactive=False, label="Included benchmark catalog")
                     gr.Markdown(
                         """
-                        Kaggle datasets such as the credit-card fraud and Epicurious recipe datasets are license/account gated, so this Space ships proxy tasks and accepts the real CSV through the upload tab. For a private Space, place the real CSVs in `data/` and swap the catalog loaders to `pd.read_csv`.
+                        Most catalog datasets are loaded from OpenML, KaggleHub, FiveThirtyEight GitHub data, or sklearn. Each remote loader has a fallback so the Space remains usable if an upstream dataset is temporarily unavailable.
                         """
                     )
                 with gr.Tab("Implementation Notes"):
@@ -862,7 +1230,7 @@ def build_app() -> gr.Blocks:
                         """
                         This Space declares `models: google/tabfm-1.0.0-pytorch` in its README metadata, which is what Hugging Face uses to associate Spaces with model pages.
 
-                        TabFM is attempted only when **Run TabFM live** is enabled because loading foundation model weights can be slow on free CPU Spaces. The leaderboard remains useful without it by comparing deterministic tabular baselines.
+                        TabFM is attempted only when **Run TabFM live** is enabled because the first run downloads large model weights and CPU Basic inference can be slow. Use the **Fast** preset for a quick smoke test, then increase estimators/context rows for stronger but slower runs.
 
                         The TabFM integration follows the Google Research README pattern: load `tabfm_v1_0_0_pytorch`, wrap it with `TabFMClassifier` or `TabFMRegressor`, call `fit` for context preparation, then `predict`.
                         """