Upload 3 files

README.md

@@ -1,15 +1,35 @@
 ---
 title: BSTabDiff Studio
-emoji: 🐨
-colorFrom: yellow
-colorTo: blue
+emoji: 🧬
+colorFrom: purple
+colorTo: pink
 sdk: gradio
-sdk_version: 6.31.0
-python_version: '3.12'
+sdk_version: 6.5.1
+python_version: "3.10.13"
 app_file: app.py
-pinned: false
 license: mit
-short_description: Generate and explore high-dimensional synthetic tabular data
+short_description: Generate high-dimensional synthetic tabular data from CSV.
+pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# BSTabDiff Studio · NeurIPS 2026
+
+An interactive demo for generating synthetic tabular datasets from user-uploaded CSV files using the [BSTabDiff package](https://pypi.org/project/bstabdiff/).
+
+1. Upload a CSV with numeric feature columns (optional discrete class target).
+2. Choose a synthetic sample count and random seed.
+3. Generate a synthetic dataset using BSTabDiff diffusion with no hyperparameter tuning or GO-BS.
+4. Compare feature distributions, PCA projections, and feature correlations.
+5. Download the generated CSV.
+
+**Demo configuration:** The initial Space uses a fixed **200-epoch** training budget to limit resource usage. This is intentionally shorter than the estimator's standard 1,500-epoch default and is **not a replication of the NeurIPS paper evaluation protocol**.
+
+**Privacy:** Uploaded datasets are processed on shared hosting infrastructure. Do not upload private, confidential, medical, identifying, or restricted datasets. Synthetic data does not guarantee privacy or non-memorization.
+
+**Limits:** At least 20 rows; up to 1,200 rows, 4,096 features, and 220,000 numeric input cells; max 8 MB CSV; up to 500 synthetic rows. Missing values are supported; nonnumeric features other than the optional class target are not supported by this first version.
+
+- [Project page](https://www.zadidhabib.com/bstabdiff.html)
+- [Source code](https://github.com/zadid6pretam/BSTabDiff)
+- [NeurIPS 2026 paper](https://openreview.net/forum?id=ciPCMXX1aj)
+
+MIT license.

app.py

@@ -0,0 +1,366 @@
+"""BSTabDiff Studio: user-uploaded CSV synthetic-data explorer.
+
+Public demo constraints: numeric feature columns, optional categorical target,
+fast fixed-budget default/no-tuning BSTabDiff with diffusion and no GO-BS.
+"""
+from __future__ import annotations
+
+import html
+import os
+import tempfile
+import time
+from pathlib import Path
+
+# ZeroGPU requires this import before any library that might touch CUDA.
+import spaces
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import gradio as gr
+import torch
+from bstabdiff import BSTabDiff
+from sklearn.decomposition import PCA
+from sklearn.impute import SimpleImputer
+from sklearn.preprocessing import StandardScaler
+
+MAX_FILE_MB = 8
+MAX_ROWS = 1200
+MAX_FEATURES = 4096
+MAX_CELLS = 220_000
+MAX_SYNTHETIC = 500
+DEMO_EPOCHS = 200  # An explicit fast-demo override; estimator default is 1500.
+NO_TARGET = "None (unconditional)"
+
+CSS = """
+.gradio-container {max-width: 1380px !important;}
+#studio-hero {padding: 28px 30px; margin: 3px 0 18px; border-radius: 24px;
+ background: linear-gradient(116deg,#182b6e 0%,#6037aa 55%,#c2488d 100%);
+ color:white; box-shadow: 0 12px 28px rgba(57,40,131,.17);}
+#studio-hero h1 {font-size: clamp(2rem,4vw,3.4rem); margin:0 0 6px; color:white !important; font-weight:800;}
+#studio-hero p {font-size: 1rem; margin: 0; opacity:.95; color:white !important;}
+#studio-hero .sub {margin-top:12px;font-size:.85rem;opacity:.87;}
+.studio-section {border-radius:18px !important;}
+#generate-btn {background: linear-gradient(90deg,#5236be,#cf4f96) !important;
+ color:#fff !important; border:0 !important; font-weight:800 !important;}
+#generate-btn:hover {filter:brightness(1.08);}
+#studio-metrics {line-height:1.8;}
+#studio-metrics .metric-row {display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;margin-top:10px;}
+#studio-metrics .metric {background:var(--block-background-fill);border:1px solid var(--block-border-color);
+ padding:12px;border-radius:12px;text-align:center;}
+#studio-metrics .metric b{display:block;font-size:1.4rem;color:#6653c8;}
+#studio-metrics .metric span{font-size:.77rem;opacity:.8;}
+@media(max-width:700px){#studio-hero{padding:21px 17px;}#studio-metrics .metric-row{grid-template-columns:1fr 1fr;}}
+"""
+
+
+def read_csv(path: str) -> pd.DataFrame:
+    if not path:
+        raise gr.Error("Upload a CSV file first.")
+    file = Path(path)
+    if file.suffix.lower() != ".csv":
+        raise gr.Error("Only .csv files are accepted.")
+    if file.stat().st_size > MAX_FILE_MB * 1024**2:
+        raise gr.Error(f"Please upload a CSV smaller than {MAX_FILE_MB} MB.")
+    try:
+        df = pd.read_csv(path, low_memory=False)
+    except Exception as exc:
+        raise gr.Error(f"Could not read CSV: {exc}") from exc
+    if df.empty or len(df.columns) < 2:
+        raise gr.Error("The CSV must contain rows and at least two columns.")
+    if len(df) < 20:
+        raise gr.Error("Use at least 20 rows. A single or tiny sample is not suitable for fitting a generator.")
+    if len(df) > MAX_ROWS:
+        raise gr.Error(f"For this public demo, upload at most {MAX_ROWS:,} rows.")
+    if len(df.columns) - 1 > MAX_FEATURES:
+        raise gr.Error(f"For this public demo, upload at most {MAX_FEATURES:,} feature columns.")
+    if df.columns.duplicated().any():
+        raise gr.Error("Column names must be unique.")
+    return df
+
+
+def numeric_columns(df):
+    return [c for c in df.columns if pd.api.types.is_numeric_dtype(df[c])]
+
+
+def shape_card(df, target=NO_TARGET):
+    m = len(df.columns) - (target != NO_TARGET and target in df.columns)
+    n = len(df)
+    ratio = m / max(n, 1)
+    miss = df.isna().sum().sum() / max(df.size, 1)
+    regime = "HDLSS (m > n)" if m > n else "n ≥ m"
+    return f"""<div id='studio-metrics'><div class='metric-row'>
+      <div class='metric'><b>{n:,}</b><span>Rows (n)</span></div>
+      <div class='metric'><b>{m:,}</b><span>Features (m)</span></div>
+      <div class='metric'><b>{ratio:.2f}</b><span>m / n</span></div>
+      <div class='metric'><b>{miss:.1%}</b><span>Missing cells</span></div>
+      </div><p>Regime: <b>{regime}</b> · CSV remains user supplied.</p></div>"""
+
+
+def inspect_csv(path):
+    if not path:
+        return (gr.update(choices=[NO_TARGET], value=NO_TARGET),
+                gr.update(choices=[], value=None), "Upload a dataset to get started.", pd.DataFrame())
+    df = read_csv(path)
+    numeric = numeric_columns(df)
+    target_candidates = [NO_TARGET] + [str(c) for c in df.columns]
+    summary = shape_card(df)
+    extra = f"<p><b>Detected:</b> {len(numeric)} numeric columns and {len(df.columns)-len(numeric)} nonnumeric columns. "
+    if len(numeric) < 2:
+        extra += "Choose a target or upload at least two numeric features."
+    else:
+        extra += "Choose an optional class target; nonnumeric features must be removed or encoded."
+    extra += "</p>"
+    return (gr.update(choices=target_candidates, value=NO_TARGET),
+            gr.update(choices=numeric, value=numeric[0] if numeric else None),
+            summary + extra, df.head(8))
+
+
+def select_default_m(n, m):
+    # Dataset-aware no-Optuna initialization from the BSTabDiff project README.
+    if m <= 64:
+        return m
+    rho, kappa = m/n, n*m
+    if rho < 10:
+        return min(64, m)
+    return min(32 if kappa < 250_000 else
+               64 if kappa < 1_000_000 else
+               128 if kappa < 3_000_000 else 192, m)
+
+
+def validate_features(df, target):
+    if target != NO_TARGET and target not in df.columns:
+        raise gr.Error("Select an existing target column or None.")
+    feature_df = df.drop(columns=[target]) if target != NO_TARGET else df.copy()
+    if feature_df.shape[1] < 2:
+        raise gr.Error("At least two numerical feature columns are required.")
+    invalid = [str(c) for c in feature_df.columns if not pd.api.types.is_numeric_dtype(feature_df[c])]
+    if invalid:
+        names = ", ".join(invalid[:4])
+        raise gr.Error(f"Feature columns must be numerical for this first demo. Encode or remove: {names}.")
+    if feature_df.shape[1] > MAX_FEATURES:
+        raise gr.Error(f"Please use at most {MAX_FEATURES:,} feature columns.")
+    if len(df) * feature_df.shape[1] > MAX_CELLS:
+        raise gr.Error(f"Shared-hardware limit: n × m must be at most {MAX_CELLS:,}. Try a smaller CSV.")
+    X = feature_df.to_numpy(dtype=np.float32)
+    if np.isinf(X).any():
+        raise gr.Error("Infinite values are not supported; replace ±inf with missing values first.")
+    if not np.isfinite(X).any():
+        raise gr.Error("The CSV contains no finite numerical feature values.")
+    all_missing = np.all(np.isnan(X), axis=0)
+    if all_missing.any():
+        raise gr.Error(f"Remove entirely missing feature column: {feature_df.columns[np.flatnonzero(all_missing)[0]]}")
+    y = None
+    if target != NO_TARGET:
+        y = df[target]
+        if y.isna().any():
+            raise gr.Error("The target column must not contain missing class labels.")
+        if y.nunique() < 2 or y.nunique() > 15:
+            raise gr.Error("Select a classification target with 2–15 classes, or choose None.")
+        if y.value_counts().min() < 2:
+            raise gr.Error("Every class must have at least two rows for this demo.")
+    return feature_df, X, y
+
+
+def chart_layout(fig, title):
+    fig.update_layout(template="plotly_white", title=dict(text=title, x=.02),
+                      paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor="rgba(0,0,0,0)",
+                      margin=dict(l=28,r=18,t=55,b=35), font=dict(size=12),
+                      legend=dict(orientation="h", y=-.2), height=390)
+    return fig
+
+
+def distribution_plot(real, synth, column):
+    if not column or column not in real.columns:
+        return go.Figure()
+    fig = go.Figure()
+    for name, frame, color in [("Real", real, "#536ed7"), ("Synthetic", synth, "#f06f9c")]:
+        values = pd.to_numeric(frame[column], errors="coerce").replace([np.inf,-np.inf],np.nan).dropna()
+        fig.add_trace(go.Histogram(x=values, name=name, marker_color=color,
+                                   opacity=.58, nbinsx=30, histnorm="probability density"))
+    fig.update_layout(barmode="overlay", xaxis_title=str(column), yaxis_title="Density")
+    return chart_layout(fig, f"Feature distribution · {column}")
+
+
+def pca_plot(real, synth):
+    cols = real.columns
+    nr, ns = min(500,len(real)), min(500,len(synth))
+    R = real[cols].head(nr).to_numpy(dtype=float)
+    S = synth[cols].head(ns).to_numpy(dtype=float)
+    imp = SimpleImputer(strategy="median", keep_empty_features=True)
+    R1 = imp.fit_transform(R)
+    S1 = imp.transform(S)
+    scale = StandardScaler()
+    R2 = scale.fit_transform(R1)
+    S2 = scale.transform(S1)
+    pca = PCA(n_components=2, random_state=42)
+    rp = pca.fit_transform(R2)
+    sp = pca.transform(S2)
+    fig = go.Figure()
+    for name, pts, color in [("Real",rp,"#536ed7"),("Synthetic",sp,"#f06f9c")]:
+        fig.add_trace(go.Scatter(x=pts[:,0],y=pts[:,1],mode="markers",name=name,
+                                 marker=dict(size=7,color=color,opacity=.63)))
+    fig.update_layout(xaxis_title="PC 1",yaxis_title="PC 2")
+    return chart_layout(fig,"Shared PCA projection · training-data diagnostic")
+
+
+def correlation_plot(real, synth):
+    variance = real.var(skipna=True).fillna(0).sort_values(ascending=False)
+    cols = list(variance.head(min(18,len(variance))).index)
+    if len(cols) < 2:
+        return go.Figure()
+    rc = real[cols].corr().fillna(0)
+    sc = synth[cols].corr().fillna(0)
+    fig = make_subplots(rows=1,cols=2, subplot_titles=("Real", "Synthetic"),horizontal_spacing=.12)
+    for idx, mat in enumerate((rc,sc),start=1):
+        fig.add_trace(go.Heatmap(z=mat.values,x=cols,y=cols,zmin=-1,zmax=1,
+                                 colorscale="RdBu", reversescale=True,
+                                 showscale=idx==2,colorbar=dict(title="r") if idx==2 else None),
+                      row=1,col=idx)
+    fig.update_layout(height=490)
+    fig.update_xaxes(tickangle=-45, tickfont=dict(size=9))
+    fig.update_yaxes(tickfont=dict(size=9))
+    chart_layout(fig,"Feature correlations · highest-variance columns")
+    fig.update_layout(height=490,margin=dict(l=28,r=25,t=65,b=65))
+    return fig
+
+
+@spaces.GPU(duration=180)
+def generate(path, target, n_synth, seed, feature):
+    df = read_csv(path)
+    features, X, y = validate_features(df,target)
+    n_synth = int(n_synth)
+    seed = int(seed)
+    if n_synth < 10 or n_synth > MAX_SYNTHETIC:
+        raise gr.Error(f"Choose between 10 and {MAX_SYNTHETIC} synthetic rows.")
+    if not 0 <= seed <= 2**31-1:
+        raise gr.Error("Use a nonnegative random seed smaller than 2,147,483,648.")
+    n, m = X.shape
+    M = select_default_m(n,m)
+    started = time.perf_counter()
+    torch.set_num_threads(min(2,os.cpu_count() or 2))
+    try:
+        # Default/no-tuning diffusion method, with fixed reduced epochs for demo speed.
+        model = BSTabDiff(
+            M=M,
+            prior_type="diffusion",
+            device="cuda" if torch.cuda.is_available() else "cpu",
+            random_state=seed,
+            prior_epochs=DEMO_EPOCHS,
+            verbose_every=0,
+            use_gobs=False,
+            use_gobs_fc=False,
+        )
+        model.fit(features, None if y is None else y.to_numpy())
+        X_syn,R_syn,y_syn = model.sample(n_samples=n_synth,return_mask=True)
+    except Exception as exc:
+        raise gr.Error(f"BSTabDiff training or sampling failed: {type(exc).__name__}: {exc}") from exc
+    X_syn = np.asarray(X_syn,dtype=np.float32)
+    if X_syn.shape != (n_synth,m):
+        raise gr.Error(f"Unexpected generated shape {X_syn.shape}; expected {(n_synth,m)}.")
+    if R_syn is not None:
+        mask = np.asarray(R_syn)
+        if mask.shape == X_syn.shape:
+            X_syn = X_syn.copy()
+            X_syn[mask == 0] = np.nan
+    syn = pd.DataFrame(X_syn,columns=features.columns)
+    if y is not None and y_syn is not None:
+        syn[target] = np.asarray(y_syn).reshape(-1)
+    real = features.reset_index(drop=True)
+    syn_features = syn[features.columns]
+    column = feature if feature in features.columns else features.columns[0]
+    path_csv = os.path.join(tempfile.mkdtemp(prefix="bstabdiff_studio_"),"bstabdiff_synthetic.csv")
+    syn.to_csv(path_csv,index=False)
+    seconds = time.perf_counter()-started
+    summary = (f"### ✅ Generated **{n_synth:,}** synthetic samples\n"
+               f"**Input:** {n:,} rows × {m:,} features · **Latent blocks:** {M} · "
+               f"**Diffusion epochs:** {DEMO_EPOCHS} · **Seed:** {seed} · "
+               f"**Device:** {model.device_} · **Elapsed:** {seconds:.1f}s\n\n"
+               "*Fast demo settings: fixed 200-epoch training budget, no tuning or GO-BS. "
+               "Plots compare against the uploaded training data, **not** a held-out test set.*")
+    # The input frame may contain a class target; output a privacy-minded 10-row preview only.
+    state=(real,syn_features)
+    return (summary,syn.head(10),distribution_plot(*state,column),
+            pca_plot(*state),correlation_plot(*state),path_csv,state,
+            gr.update(choices=list(features.columns),value=column))
+
+
+def update_plot(feature, state):
+    if not state or not feature:
+        return go.Figure()
+    real, synthetic = state
+    return distribution_plot(real,synthetic,feature)
+
+
+with gr.Blocks(title="BSTabDiff Studio — NeurIPS 2026",
+               delete_cache=(3600,3600)) as demo:
+    gr.HTML("""
+      <div id="studio-hero">
+        <div style="font-weight:700;letter-spacing:.13em;font-size:.74rem;opacity:.88">NEURIPS 2026 · RESEARCH DEMO</div>
+        <h1>✦ BSTabDiff Studio</h1>
+        <p>From your CSV to high-dimensional synthetic data.</p>
+        <div class="sub">Upload → Generate → Visualize → Download · Default diffusion, no hyperparameter tuning.</div>
+      </div>
+    """)
+    gr.Markdown("**How it works:** Supply a CSV containing numeric features and optionally a discrete class label. "
+                "This Space trains BSTabDiff on your uploaded table and generates new synthetic rows. "
+                "**Please do not upload confidential, patient-level, or personally identifying data.**")
+
+    with gr.Row(equal_height=False):
+        with gr.Column(scale=5,elem_classes=["studio-section"]):
+            gr.Markdown("### ① Upload & configure")
+            file_input=gr.File(label="Upload CSV",file_types=[".csv"],type="filepath")
+            target=gr.Dropdown(label="Optional class target",choices=[NO_TARGET],value=NO_TARGET,
+                               info="Use None for unconditional generation. Other nonnumeric columns are unsupported.")
+            with gr.Row():
+                samples=gr.Slider(label="Synthetic rows",minimum=10,maximum=MAX_SYNTHETIC,
+                                  step=10,value=100)
+                seed_input=gr.Number(label="Random seed",value=42,precision=0,minimum=0,maximum=9999)
+            gr.Markdown(f"**Fast public demo:** {DEMO_EPOCHS} diffusion epochs, no GO-BS, no Optuna. "
+                        "Larger uploaded datasets may exceed free hardware limits.")
+            run_btn=gr.Button("✦ Generate synthetic dataset",variant="primary",elem_id="generate-btn",size="lg")
+        with gr.Column(scale=6,elem_classes=["studio-section"]):
+            gr.Markdown("### ② Dataset snapshot")
+            file_info=gr.HTML("<p>Upload a CSV to inspect its structure.</p>")
+            preview=gr.Dataframe(label="Original data · first 8 rows",interactive=False,
+                                 max_height=310)
+
+    gr.Markdown("## ③ Explore your generated data")
+    result=gr.Markdown("The synthetic-data dashboard will appear here after generation.")
+    state=gr.State(value=None)
+    with gr.Row():
+        real_plot_feature=gr.Dropdown(label="Feature to inspect",choices=[],interactive=True)
+        download=gr.File(label="Download synthetic CSV",interactive=False)
+    with gr.Row():
+        with gr.Column():
+            with gr.Tab("📊 Feature distribution"):
+                hist=gr.Plot(label="Real vs synthetic feature distribution")
+            with gr.Tab("🧭 PCA projection"):
+                pca=gr.Plot(label="Shared PCA projection")
+        with gr.Column():
+            with gr.Tab("🧩 Correlations"):
+                corr=gr.Plot(label="Real and synthetic correlation matrices")
+            with gr.Tab("🧬 Synthetic preview"):
+                generated_table=gr.Dataframe(label="Synthetic data · first 10 rows",interactive=False)
+
+    gr.HTML("""<div style="text-align:center;padding:16px;font-size:12px;opacity:.75">
+      <a href="https://www.zadidhabib.com/bstabdiff.html" target="_blank">Project webpage</a> ·
+      <a href="https://github.com/zadid6pretam/BSTabDiff" target="_blank">GitHub</a> ·
+      <a href="https://pypi.org/project/bstabdiff/" target="_blank">PyPI</a> ·
+      <a href="https://openreview.net/forum?id=ciPCMXX1aj" target="_blank">NeurIPS 2026 paper</a>
+      <p>Research demonstration only. Synthetic data are not necessarily private or faithful to the source distribution.</p>
+      </div>""")
+
+    file_input.change(inspect_csv,inputs=file_input,
+                      outputs=[target,real_plot_feature,file_info,preview],show_progress="minimal")
+    run_btn.click(generate,inputs=[file_input,target,samples,seed_input,real_plot_feature],
+                  outputs=[result,generated_table,hist,pca,corr,download,state,real_plot_feature],
+                  concurrency_limit=1,show_progress="full")
+    real_plot_feature.change(update_plot,inputs=[real_plot_feature,state],outputs=hist,
+                             show_progress="minimal")
+
+demo.queue(max_size=6)
+
+if __name__ == "__main__":
+    demo.launch(theme=gr.themes.Soft(primary_hue="indigo",secondary_hue="pink"), css=CSS)

requirements.txt

@@ -0,0 +1,2 @@
+bstabdiff==0.2.1
+plotly>=6.0,<7.0