updated tabbench space with up-to-date data

app.py

@@ -5,6 +5,11 @@ import pandas as pd
 import json
 import random
 
+import plotly.express as px
+import seaborn as sns
+from io import BytesIO
+import base64
+
 # TabBench currently supports the following models, with new additions that keep coming:
 # - **NICL (Neuralk In-Context-Learning)**: Our in-house tabular foundation model based on an in-context learning architecture (proprietary).
 # - **TabICL**: A transformer-based model that performs feature compression before doing in-context learning on tabular data by conditioning on labeled support examples to predict unseen queries without task-specific training.
@@ -12,15 +17,13 @@ import random
 # - **XGBoost**: An optimized distributed gradient boosting library designed to be highly efficient, flexible, and portable.
 # - **CatBoost**: A gradient boosting on decision trees library, particularly strong with categorical features.
 # - **LightGBM**: A fast gradient boosting framework that builds decision trees using histogram-based learning for scalable, high-performance tabular modeling.
-# - **MLP**: A feedforward neural network that models tabular data by learning non-linear interactions between numerical and embedded categorical features.
-# - **Random Forest**: A robust ensemble method that builds multiple decision trees and averages their predictions to reduce overfitting and improve accuracy.
 # - **ModernNCA**: An advanced extension of Neighborhood Component Analysis (NCA) that employs deep neural networks with stochastic neighborhood sampling to learn complex feature interactions for tabular data.
 # - **RealMLP**: An enhanced MLP optimized with strong default parameters, achieving competitive performance on tabular data.
 # - **TabM**: A deep learning model that efficiently imitates an ensemble of MLPs, enhancing performance on tabular data tasks without the overhead of training multiple models.
 # It is capable of processing datasets up to 100× larger and running up to 10× faster than TabPFNv2.
 
 PUBLIC_DATASETS_TEXT = """
-We curate a list of **214 datasets** from OpenML that span various industries such as **retail, healthcare, finance, and more**. 
+We curate a list of **195 datasets** from OpenML that span various industries such as **retail, healthcare, finance, and more**. 
 
 🔎 You can easily filter datasets by industry below or explore the industry specific leaderboards via the sidebar.
 """
@@ -28,8 +31,10 @@ We curate a list of **214 datasets** from OpenML that span various industries su
 MODELS_TEXT = """
 TabBench currently supports the following models, with more additions planned:
 - **Tabular foundation models**: NICL, TabICL, TabPFNv2
-- **Tree-based**: XGBoost, CatBoost, LightGBM, Random Forest
-- **Neural networks**: MLP, RealMLP, TabM, ModernNCA
+- **Tree-based**: XGBoost, CatBoost, LightGBM
+- **Neural networks**: RealMLP, TabM, ModernNCA
+
+__Note__ : Tree-based models are also ensembled according to best practices.
 """
 
 BENCHMARKING_TEXT = """
@@ -47,32 +52,34 @@ Evaluation is optimized for ROC-AUC and preprocessing steps vary following each
 METRICS_TEXT = """
 TabBench uses different types of metrics to evaluate model performance:
 - **Classic metrics**: Accuracy, Precision, Recall, F1 score, AUC
-- **Ranking metrics**: Precision@k, Rank, Harmonic Rank, [Elo score?]
-- **Industry-relevant metrics**: [ADD WHICH]
+- **Ranking metrics**: Rank, Elo score
 """
 
 TITLE = """
-<h1 style="text-align:center; color:#25ccb9;">
-TabBench
-</h1>
-<h2 style="text-align:center">
-An industry-first benchmark suite for machine learning on tabular data
-</h2>
+<div style="display:flex; text-align:center">
+    <h1 style="margin:0; font-size:34px; font-weight:600;">
+        <span style="color:#25ccb9; font-style: bold;">TabBench</span>
+        <span> 
+            : An Industry Benchmark for Tabular Machine Learning
+        </span>
+    </h1>
+</div>
+
 """
 
 INTRODUCTION_TEXT = """
-<p style="font-size: 16px; text-align:center">
+<p style="font-size: 16px; text-align:center; font-style: italic;">
 Bridging the gap between academic benchmarks and industry needs
 </p>
 """
 
 DATA_MAP_TEXT = """
-- 🔎 **Explore dataset statistics & distributions** by industry and data type (public vs proprietary)
-- 📈 **Compare public and proprietary datasets** to reveal how academic benchmarks might misrepresent model performance
+- 🔎 **Explore different settings of dataset generation**
+- 📈 **Compare Tabular Foundation Models on specific situations and identify strengths & weaknesses**
 """
 
 PUBLIC_BENCHMARK_TEXT = """
-- 📊 **A curation of 200+ public datasets** across industries such as retail, healthcare, finance, energy, etc 
+- 📊 **A curation of 195 public datasets** across industries such as retail, healthcare, finance, energy, etc 
 - 🤖 **Evaluations on 10+ powerful models** from gradient boosting and decision trees to tabular foundation models
 - 💥 **Integration of NICL**, the Neuralk AI tabular foundation model designed for industry-grade use cases 
 - 🏅 **Leaderboards by sector** to discover which models perform best for each industry
@@ -87,7 +94,7 @@ PRIVATE_BENCHMARK_TEXT = """
 # rewrite new uses continuously being added
 
 PRIVATE_DATA_TEXT = """
-We curate a list of **60 proprietary datasets** from different retailers focused on the **use case of product categorization**.
+We curate a list of **63 proprietary datasets** from different retailers focused on the **use case of product categorization**.
 
 👚 Each dataset contains product titles, descriptions, and hierarchical product categories with four levels. 
 
@@ -99,10 +106,10 @@ You can read more about product categorization and its challenges [here](https:/
 """
 
 PRIVATE_MODEL_TEXT = """
-[WIP] TabBench Pro currently supports the following models, with more additions planned:
+TabBench Enterprise currently supports the following models, with more additions planned:
 - **Tabular foundation models**: NICL, TabICL, TabPFNv2
-- **Tree-based**: XGBoost, CatBoost, LightGBM, Random Forest
-- **Neural networks**: MLP, RealMLP, TabM, ModernNCA
+- **Tree-based**: XGBoost
+- **Neural networks**: RealMLP, TabM, ModernNCA
 """
 
 PRIVATE_BENCHMARKING_TEXT = """
@@ -116,11 +123,9 @@ For a deeper understanding, you can explore our [Notebooks](https://github.com/N
 """
 
 PRIVATE_METRICS_TEXT = """
-[WIP]
-TabBench Pro uses different types of metrics to evaluate model performance:
+TabBench Enterprise uses different types of metrics to evaluate model performance:
 - **Classic metrics**: Accuracy, Precision, Recall, F1 score, AUC
-- **Ranking metrics**: Precision@k, Rank, Harmonic Rank, [Elo score?]
-- **Industry-relevant metrics**: [ADD WHICH]
+- **Ranking metrics**: Rank, Elo score
 """
 
 
@@ -132,7 +137,8 @@ CITATION_BUTTON_TEXT = """
     year={2025},
     publisher={GitHub},
     url={https://github.com/Neuralk-AI/TabBench}
-}"""
+}
+"""
 
 
 data = {
@@ -184,12 +190,47 @@ def highlight_max(df: pd.DataFrame):
     return df.style.apply(style_column, axis=0)
 
 
-with open("public_dummy.json", "r") as f:
+with open("complete_results_acad.json", "r") as f:
     public_per_dataset = pd.json_normalize(json.load(f))
 
-with open("private_dummy.json", "r") as f:
+with open("complete_results_indus.json", "r") as f:
     private_per_dataset = pd.json_normalize(json.load(f))
 
+with open("qrt.json", "r") as f:
+    qrt_scores = json.load(f)
+
+# Suppose qrt_scores is a dict like {"NICL": 0.8, "TabPFNv2": 0.6, "XGBoost": 0.5}
+models = ["Models"]+ list(qrt_scores.keys()) 
+accuracies = ["Test Accuracy"] + list(qrt_scores.values())
+
+# Create a DataFrame with two rows: "Model" and "Test Accuracy"
+df_qrt = pd.DataFrame([accuracies], index=["Test Accuracy"], columns=models)
+
+# Optional: highlight best accuracy
+def highlight_best_qrt(df):
+    styles = pd.DataFrame("", index=df.index, columns=df.columns)
+    styles.loc["Test Accuracy", df.loc["Test Accuracy"] == 51.7] = "background-color: gold; color: black;"
+    styles.loc["Test Accuracy", df.loc["Test Accuracy"] == 51.58] = "background-color: #a6a6a6; color: black;"
+    styles.loc["Test Accuracy", df.loc["Test Accuracy"] == 51.18] = "background-color: #ad5803; color: black;"
+    return styles
+
+styled_df_qrt = df_qrt.style.apply(highlight_best_qrt, axis=None)
+
+def add_top3_ranks(df, metric_cols):
+    df = df.copy()
+
+    for col in metric_cols:
+        if col not in df.columns:
+            continue
+
+        ranks = df[col].rank(ascending=False, method="min")
+
+        df[f"{col}_rank"] = ranks.map(
+            lambda r: "🥇" if r == 1 else "🥈" if r == 2 else "🥉" if r == 3 else ""
+        )
+
+    return df
+
 # -------------------------
 # Leaderboard builder
 # -------------------------
@@ -226,6 +267,10 @@ df_comparison = pd.DataFrame(data)
 # Gradio UI
 # -------------------------
 css = """
+:root {
+    color-scheme: light;
+}
+
 .lg {
     font-size: 14px;
 }
@@ -308,25 +353,63 @@ def df_to_wrapped_html(df: pd.DataFrame):
     html += '</table>'
     return html
 
+def plot_global_model_ranking_plotly(df, metric="Accuracy"):
+    import plotly.graph_objects as go
+
+    df_sorted = df.sort_values(metric, ascending=True).reset_index(drop=True)
+    x_max = df_sorted[metric].max() * 1.1  # 10% buffer
+
+    fig = go.Figure(go.Bar(
+        x=df_sorted[metric],
+        y=df_sorted['model'],
+        orientation='h',
+        text=df_sorted[metric],
+        textposition='inside',
+        marker=dict(
+            color=df_sorted[metric],
+            colorscale='Viridis',
+            showscale=False
+        )
+    ))
+
+    fig.update_layout(
+        template="plotly_white",
+        plot_bgcolor="white",
+        paper_bgcolor="white",
+        xaxis=dict(title=metric, automargin=True, range=[0, x_max]),
+        yaxis=dict(title="Model", automargin=True),
+        height=100 + 40 * len(df_sorted),
+        margin=dict(l=180, r=40, t=60, b=40),
+    )
 
-with gr.Blocks(css=css) as demo:
-    # Sidemenu for benchmark selection
-    with gr.Sidebar():
-        gr.Markdown("### Select benchmark")
-        home_btn = gr.Button("🏡 Home", elem_classes=["white-btn", "selected-btn"])
-        # gr.Markdown("---")
+    return fig
 
-        public_btn = gr.Button("🌐 TabBench public", elem_classes=["white-btn"])
-        with gr.Column():
-            with gr.Accordion("Industry specific ", open=False):
-                domain_retail_btn = gr.Button("🛍️ Retail", elem_classes=["white-btn"])
-                domain_finance_btn = gr.Button("💰 Finance", elem_classes=["white-btn"])
-                domain_healthcare_btn = gr.Button("🏥 Healthcare", elem_classes=["white-btn"])
-        # gr.Markdown("---")
+def update_ranking_plot(metric):
+    return plot_global_model_ranking_plotly(
+        public_model_agg,
+        metric=metric
+    )
 
-        private_btn = gr.Button("💼 TabBench Pro ", elem_classes=["white-btn"])
+with gr.Blocks(css=css, theme=gr.themes.Default()) as demo:
+    # # Sidemenu for benchmark selection
+    # with gr.Sidebar(visible=True) as sidebar:
+    #     gr.Markdown("### Select benchmark")
+    #     home_btn = gr.Button("🏡 Home", elem_classes=["white-btn", "selected-btn"])
+    #     # gr.Markdown("---")
 
-        datamap_btn = gr.Button("🗺️ Data mapping", elem_classes=["white-btn"])
+    #     public_btn = gr.Button("🌐 TabBench public", elem_classes=["white-btn"])
+    #     private_btn = gr.Button("💼 TabBench Enterprise ", elem_classes=["white-btn"])
+
+    #     with gr.Column():
+    #         with gr.Accordion("🔍 Search by Industry", open=False):
+    #             domain_retail_btn = gr.Button("🛍️ Retail", elem_classes=["white-btn"])
+    #             domain_finance_btn = gr.Button("💰 Finance", elem_classes=["white-btn"])
+    #             domain_healthcare_btn = gr.Button("🏥 Healthcare", elem_classes=["white-btn"])
+    #     # gr.Markdown("---")
+
+        
+
+    #     datamap_btn = gr.Button("🗺️ Data mapping", elem_classes=["white-btn"])
 
 
 
@@ -337,42 +420,80 @@ with gr.Blocks(css=css) as demo:
             # gr.Markdown("---")
             gr.Markdown(INTRODUCTION_TEXT)
             gr.Markdown(" ")
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("## ⚡ The TabBench Evaluation Suite")
-                    gr.Markdown(
-                    """
-                    While useful for research, academic benchmarks rarely capture the challenges faced in industry, offering teams little guidance on which models to trust in production (see comparison table 👉).
-                    
-                    TabBench bridges this gap with an evaluation suite designed with industry challenges in mind, making it easier for teams across different sectors to identify the best models for their real-world needs.
-                    """
-                    )
-                    #                     """
-                    # While academic benchmarks for ML on tabular data offer useful insights for researchers, they rarely capture the challenges industry teams face, like messy data, complex pipelines and the need for deployment readiness.
-
-                    # This makes it hard to translate benchmark results into real-world impact and gives industry practitioners little clarity on which models to trust.
-
-                    # TabBench bridges this gap with an evaluation suite designed with industry challenges in mind, making it easier for teams across sectors to evaluate which models perform best in practice.
-                    # """
+            with gr.Column():
+                gr.Markdown("## ⚡ Why TabBench ?")
+                gr.Markdown(
+                """
+                While useful for research, academic benchmarks rarely capture the challenges faced in industry, offering teams little guidance on which models to trust in production.
+                
+                TabBench is the first Open Source benchmark designed to test both Predictive Foundation Models and Traditional ML Models on real Enterprise data and use cases, Unlike most benchmarks, TabBench evaluates models on real-world scenarios across industries, helping Data scientists confidently choose the models that work best in production, not just in theory.
+                Real-workd data is complex, messy and high-dimensional; TabBench is particularly useful in showcasing the performance of SOTA Predictive Foundation models as well as traditional ML tools in this context.
+                """
+                )
 
-                    gr.Markdown("### Features")
-                    with gr.Accordion("🌐 TabBench Public", open=False):
-                        gr.Markdown(PUBLIC_BENCHMARK_TEXT)
-                    with gr.Accordion("💼 TabBench Pro", open=False):
-                        gr.Markdown(PRIVATE_BENCHMARK_TEXT)
-                    with gr.Accordion("🗺️ Data landscape mapping", open=False):
-                        gr.Markdown(DATA_MAP_TEXT)
+                gr.Markdown('  ')
+                gr.Markdown("## 🚀 Search by Benchmark Type")
+                with gr.Row():
+                    with gr.Column():
+                        with gr.Accordion("🌐 TabBench Public", open=False):
+                            gr.Markdown(PUBLIC_BENCHMARK_TEXT)
+                            public_btn_home = gr.Button("Go to TabBench Public", elem_classes=["white-btn"])
+                    with gr.Column():
+                        with gr.Accordion("💼 TabBench Enterprise", open=False):
+                            gr.Markdown(PRIVATE_BENCHMARK_TEXT)
+                            private_btn_home = gr.Button("Go to TabBench Enterprise", elem_classes=["white-btn"])
+                    with gr.Column():
+                        with gr.Accordion("🤖 Understanding Tabular Foundation Models", open=False):
+                            gr.Markdown(DATA_MAP_TEXT)
+                            datamap_btn_home = gr.Button("Go to TabFMs space", elem_classes=["white-btn"])
+                # ,gr.DataFrame(df_comparison, interactive=False, wrap=True, type="pandas")
+                
+                public_model_agg = public_per_dataset.groupby('model')[['Accuracy', 'Precision', 'Recall', 'F1_score', 'AUC', 'Elo_score']].mean().reset_index()
+                public_model_agg = public_model_agg.round(3)
+                # ranking_fig = plot_global_model_ranking_plotly(public_model_agg, metric="Accuracy")
+                # Search by industry section
+                gr.Markdown('  ')
+                gr.Markdown("## 🔍 Search by Industry")
+                with gr.Row():
+                    finance_btn_home = gr.Button("💰 Finance", elem_classes=["white-btn"])
+                    healthcare_btn_home = gr.Button("🏥 Healthcare", elem_classes=["white-btn"])
+                    retail_btn_home = gr.Button("🛍️ Retail", elem_classes=["white-btn"])
+
+                gr.Markdown('  ')
+                gr.Markdown("## 🏆 Overview of the Leaderboard *(Evaluation on Public Datasets)*")
+                gr.Markdown('  ')
+                # ranking_fig = plot_global_model_ranking_plotly(
+                #     public_model_agg,
+                #     metric="Accuracy",
+                # )
+
+                # gr.Plot(ranking_fig)
+
+                with gr.Row():
+                    metric_selector = gr.Dropdown(
+                        choices=["Accuracy", "Precision", "Recall", "F1_score", "AUC", "Elo_score"],
+                        value="Accuracy",
+                        label="📊 Metric to display"
+                    )
 
-                with gr.Column():
-                    wrapped_table_html = df_to_wrapped_html(df_comparison)
-                    gr.Markdown(wrapped_table_html)
-                    # ,gr.DataFrame(df_comparison, interactive=False, wrap=True, type="pandas")
+                ranking_plot = gr.Plot(
+                    value=plot_global_model_ranking_plotly(
+                        public_model_agg,
+                        metric="Accuracy"
+                    )
+                )
 
+                metric_selector.change(
+                    fn=update_ranking_plot,
+                    inputs=metric_selector,
+                    outputs=ranking_plot
+                )
+                
 
         public_content = gr.Column(visible=False)
         with public_content:
-            label_md = gr.Markdown("## 🥇 TabBench Public Leaderboard - All Industries")
-
+            home_btn_public = gr.Button("🏡 Home", elem_classes=["white-btn", "selected-btn"])
+            label_md = gr.Markdown("# 🥇 TabBench Public Leaderboard - All Industries")
             gr.Markdown('### Features')
             # -------------------------
             # Top row: Models & Datasets
@@ -436,96 +557,123 @@ with gr.Blocks(css=css) as demo:
                     gr.Markdown(f"Estimated average model performance over {num_unique_datasets} datasets.")
                     # Use per-model averages for leaderboard, allow filtering by model_type
                     per_model_leaderboard = init_leaderboard(public_model_agg, include_model_type_filter=True, industry_filter=False)
-                
+
+
                 with gr.Tab("📊 Performance by dataset"):
-                    gr.Markdown("[WIP - Update with correct dataset industries and targets]")
-                    # Merge public_per_dataset with datasets_info for rich dataset metadata
+                    # Load dataset metadata
                     with open("public_datasets_info.json", "r") as f:
                         public_datasets_info = pd.DataFrame(json.load(f))
+
                     public_per_dataset_merged = public_per_dataset.merge(
                         public_datasets_info,
                         left_on=["dataset_name", "dataset_id"],
                         right_on=["dataset_name", "dataset_id"],
                         how="left"
                     )
-                    # Set industry directly from public_datasets_info.json
-                    public_per_dataset_merged['industry'] = public_per_dataset_merged['dataset_industry']
 
-                    public_per_dataset_merged = public_per_dataset_merged.dropna(subset=['industry'])
+                    public_per_dataset_merged["industry"] = public_per_dataset_merged["dataset_industry"]
+                    public_per_dataset_merged = public_per_dataset_merged.dropna(subset=["industry"])
+
+                    # --- Sliders and controls ---
+                    min_features, max_features = int(public_per_dataset_merged["features"].min()), int(public_per_dataset_merged["features"].max())
+                    min_rows, max_rows = int(public_per_dataset_merged["rows"].min()), int(public_per_dataset_merged["rows"].max())
+                    min_pct_cat, max_pct_cat = float(public_per_dataset_merged["pct_cat"].min()), float(public_per_dataset_merged["pct_cat"].max())
 
-                    dataset_perf_cols = [
-                        "dataset_name", "dataset_id", "industry", "dataset_target", "model", "Accuracy", "Precision", "Recall", "F1_score", "AUC", "Elo_score",
-                         "num_rows", "num_features", "num_classes", "imbalance_ratio", "missing_values", "categorical_features_ratio"
-                    ]
-                    show_cols = [col for col in dataset_perf_cols] #if col in public_per_dataset_merged.columns]
-                    # Slider for filtering by number of features
-                    min_num_features = int(public_per_dataset_merged['num_features'].min())
-                    max_num_features = int(public_per_dataset_merged['num_features'].max())
                     with gr.Row():
                         with gr.Column():
                             features_slider = gr.Slider(
-                                minimum=min_num_features,
-                                maximum=max_num_features,
-                                value=min_num_features,
+                                minimum=min_features,
+                                maximum=max_features,
+                                value=min_features,
                                 step=1,
                                 label="Min Number of Features",
                             )
+                            rows_slider = gr.Slider(
+                                minimum=min_rows,
+                                maximum=max_rows,
+                                value=min_rows,
+                                step=100,
+                                label="Min Number of Rows",
+                            )
+                            pct_cat_slider = gr.Slider(
+                                minimum=min_pct_cat,
+                                maximum=max_pct_cat,
+                                value=min_pct_cat,
+                                step=0.01,
+                                label="Min % Categorical Features",
+                            )
+
                         with gr.Column():
-                            min_num_classes = int(public_per_dataset_merged['num_classes'].min())
-                            max_num_classes = int(public_per_dataset_merged['num_classes'].max())
-                            with gr.Row():
-                                classes_slider = gr.Slider(
-                                    minimum=min_num_classes,
-                                    maximum=max_num_classes,
-                                    value=min_num_classes,
-                                    step=1,
-                                    label="Min Number of Classes",
-                                )
-
-                    # Add model filter to leaderboard
-                    public_per_dataset_leaderboard = Leaderboard(
-                        value=public_per_dataset_merged[show_cols],
-                        datatype=["str"] + ["number"] * (len(show_cols) - 1),
-                        select_columns=SelectColumns(
-                            default_selection=show_cols,
-                            cant_deselect=["model"] if "model" in show_cols else [],
-                            label="Select Columns to Display:",
-                        ),
-                        search_columns=["dataset_name"] if "dataset_name" in show_cols else [],
-                        hide_columns=[],
-                        filter_columns=[
-                            ColumnFilter("model", type="checkboxgroup", label="🤖 Model"),
-                            ColumnFilter("industry", type="checkboxgroup", label="🏭 Industry"),
-                        ],
-                        interactive=False,
-                    )
+                            task_button = gr.Radio(
+                                choices=["Binary", "Multi-class"],
+                                value="Binary",
+                                label="Task Type",
+                            )
+
+                    # --- Columns ---
+                    dataset_perf_cols = [
+                        "model",
+                        "Accuracy",
+                        "Precision",
+                        "Recall",
+                        "F1_score",
+                        "AUC",
+                        "Elo_score",
+                    ]
+
+                    # --- Filtering & aggregation ---
+                    def filter_and_aggregate_models(min_features, min_rows, min_pct_cat, task_type):
+                        task_val = 0 if task_type == "Binary" else 1
 
-                    def public_filter_per_dataset_leaderboard(min_features, min_classes):
                         filtered = public_per_dataset_merged[
-                            (public_per_dataset_merged['num_features'] >= min_features) &
-                            (public_per_dataset_merged['num_classes'] >= min_classes)
+                            (public_per_dataset_merged["features"] >= min_features)
+                            & (public_per_dataset_merged["rows"] >= min_rows)
+                            & (public_per_dataset_merged["pct_cat"] >= min_pct_cat)
+                            & (public_per_dataset_merged["task"] == task_val)
                         ]
-                        return filtered[show_cols]
 
-                    features_slider.change(
-                        fn=lambda min_f, min_c: public_filter_per_dataset_leaderboard(min_f, min_c),
-                        inputs=[features_slider, classes_slider],
-                        outputs=public_per_dataset_leaderboard
-                    )
-                    classes_slider.change(
-                        fn=lambda min_f, min_c: public_filter_per_dataset_leaderboard(min_f, min_c),
-                        inputs=[features_slider, classes_slider],
-                        outputs=public_per_dataset_leaderboard
+                        if filtered.empty:
+                            return pd.DataFrame(columns=dataset_perf_cols)
+
+                        per_model_avg = (
+                            filtered
+                            .groupby("model")[dataset_perf_cols[1:]]
+                            .mean()
+                            .reset_index()
+                        )
+
+                        return highlight_max(per_model_avg)
+
+                    # --- Styled table ---
+                    performance_table = gr.DataFrame(
+                        value=filter_and_aggregate_models(
+                            min_features,
+                            min_rows,
+                            min_pct_cat,
+                            "Binary",
+                        ),
+                        interactive=False,
+                        wrap=True,
+                        type="pandas",
                     )
 
+                    # --- Bind controls ---
+                    inputs = [features_slider, rows_slider, pct_cat_slider, task_button]
+                    for control in inputs:
+                        control.change(
+                            fn=filter_and_aggregate_models,
+                            inputs=inputs,
+                            outputs=performance_table,
+                        )
+
 
         def make_domain_content(industry, label, public_per_dataset, public_datasets_info, model_info):
             domain_content = gr.Column(visible=False)
             with domain_content:
+                home_btn_domain = gr.Button("🏡 Home", elem_classes=["white-btn", "selected-btn"])
                 gr.Markdown(f"## 🥇 {label} Benchmark Leaderboard")
-                # Do not filter by industry here; industry is only available after merging with public_datasets_info.json
-                # domain_per_dataset = public_per_dataset.copy()
-                # Filter datasets for this industry first
+
+                # Filter datasets for this industry
                 domain_per_dataset = public_per_dataset.merge(
                     public_datasets_info[['dataset_name', 'dataset_id', 'dataset_industry']],
                     on=['dataset_name', 'dataset_id'],
@@ -533,15 +681,12 @@ with gr.Blocks(css=css) as demo:
                 )
                 domain_per_dataset = domain_per_dataset[domain_per_dataset['dataset_industry'] == industry]
 
-                with open("model_info.json", "r") as f:
-                    model_info = pd.DataFrame(json.load(f))
-                # Compute model overview for the industry
+                # Compute model overview
                 model_agg = domain_per_dataset.groupby('model')[['Accuracy', 'Precision', 'Recall', 'F1_score', 'AUC', 'Elo_score']].mean().reset_index()
                 model_agg = model_agg.round(3)
                 model_agg = model_agg.merge(model_info[["model_name", "model_type"]], left_on="model", right_on="model_name", how="left").drop(columns=["model_name"])
                 cols = ["model", "model_type"] + [c for c in model_agg.columns if c not in ["model", "model_type"]]
                 model_agg = model_agg[cols]
-                # Sort so NICL is always first
                 model_agg = model_agg.sort_values(by=["model"], key=lambda x: x != "NICL").reset_index(drop=True)
                 gr.DataFrame(
                     value=highlight_max(model_agg),
@@ -550,53 +695,62 @@ with gr.Blocks(css=css) as demo:
                     type="pandas",
                 )
 
-                gr.Markdown("## 🔍 Explore more and filter")
-                # Merge per_dataset with datasets_info for rich dataset metadata
-                with open("public_datasets_info.json", "r") as f:
-                    public_datasets_info = pd.DataFrame(json.load(f))
+                gr.Markdown("## 🔍 Explore performance by dataset")
 
+                # Merge for full dataset info
                 domain_per_dataset_merged = domain_per_dataset.merge(
                     public_datasets_info,
                     left_on=["dataset_name", "dataset_id"],
                     right_on=["dataset_name", "dataset_id"],
                     how="left"
                 )
-                print(domain_per_dataset_merged.columns)
-                # Set industry directly from public_datasets_info.json
                 domain_per_dataset_merged['industry'] = domain_per_dataset_merged['dataset_industry_y']
-                # Filter for the correct industry only
                 domain_per_dataset_merged = domain_per_dataset_merged[domain_per_dataset_merged['industry'] == industry]
-                num_unique_datasets = domain_per_dataset_merged['dataset_name'].nunique() if 'dataset_name' in domain_per_dataset_merged.columns else 0
-
-                with gr.Tabs() as tabs:
-                    with gr.Tab("🤖 Average model performance"):
-                        gr.Markdown(f"Estimated average model performance over {num_unique_datasets} datasets.")
-                        model_leaderboard = init_leaderboard(model_agg, include_model_type_filter=True, industry_filter=False)
-                    
-                    with gr.Tab("📊 Performance by dataset"):
-                        dataset_perf_cols = [
-                        "dataset_name", "dataset_id", "industry", "dataset_target", "model", "Accuracy", "Precision", "Recall", "F1_score", "AUC", "Elo_score",
-                         "num_rows", "num_features", "num_classes", "imbalance_ratio", "missing_values", "categorical_features_ratio"
-                        ]
-                        show_cols = [col for col in dataset_perf_cols if col in domain_per_dataset_merged.columns]
-                        # Add model filter just like in TabBench Public
-                        per_dataset_leaderboard = Leaderboard(
-                            value=domain_per_dataset_merged[show_cols],
-                            datatype=["str"] + ["number"] * (len(show_cols) - 1),
-                            select_columns=SelectColumns(
-                                default_selection=show_cols,
-                                cant_deselect=["model"] if "model" in show_cols else [],
-                                label="Select Columns to Display:",
-                            ),
-                            search_columns=["dataset_name"] if "dataset_name" in show_cols else [],
-                            hide_columns=[],
-                            filter_columns=[
-                                ColumnFilter("model", type="checkboxgroup", label="🤖 Model"),
-                            ],
-                            interactive=False,
-                        )
 
-            return domain_content
+                # Columns for dataset-wise leaderboard
+                dataset_perf_cols = [
+                    "model",
+                    "Accuracy",
+                    "Precision",
+                    "Recall",
+                    "F1_score",
+                    "AUC",
+                    "Elo_score",
+                ]   
+                num_unique_datasets = domain_per_dataset_merged['dataset_id'].nunique() if 'dataset_id' in domain_per_dataset_merged.columns else 0
+                gr.Markdown(f"Estimated average model performance over {num_unique_datasets} datasets.")
+                # Available datasets
+                dataset_ids = sorted(domain_per_dataset_merged["dataset_name"].dropna().unique().tolist())
+
+                dataset_dropdown = gr.Dropdown(
+                    choices=dataset_ids,
+                    label="📂 Select a dataset",
+                    value=dataset_ids[0] if dataset_ids else None,
+                )
+
+                dataset_leaderboard = gr.DataFrame(
+                    value=highlight_max(domain_per_dataset_merged[
+                        domain_per_dataset_merged["dataset_name"] == dataset_ids[0]
+                    ][dataset_perf_cols]) if dataset_ids else pd.DataFrame(),
+                    interactive=False,
+                    wrap=True,
+                    type="pandas",
+                )
+
+                # Callback to update leaderboard
+                def update_dataset_leaderboard(selected_dataset_id):
+                    return highlight_max(domain_per_dataset_merged[
+                        domain_per_dataset_merged["dataset_name"] == selected_dataset_id
+                    ][dataset_perf_cols])
+
+                dataset_dropdown.change(
+                    fn=update_dataset_leaderboard,
+                    inputs=dataset_dropdown,
+                    outputs=dataset_leaderboard,
+                )
+
+            return domain_content, home_btn_domain
+
 
         with open("public_datasets_info.json", "r") as f:
             public_datasets_info = pd.DataFrame(json.load(f))
@@ -604,14 +758,25 @@ with gr.Blocks(css=css) as demo:
         with open("model_info.json", "r") as f:
             model_info = pd.DataFrame(json.load(f))
 
-        retail_domain_content = make_domain_content('Retail', 'Retail', public_per_dataset, public_datasets_info, model_info)
-        finance_domain_content = make_domain_content('Finance/insurance', 'Finance/insurance', public_per_dataset, public_datasets_info, model_info)
-        healthcare_domain_content = make_domain_content('Healthcare', 'Healthcare', public_per_dataset, public_datasets_info, model_info)
+        retail_domain_content, home_btn_retail = make_domain_content('Retail', 'Retail', public_per_dataset, public_datasets_info, model_info)
+        finance_domain_content, home_btn_finance = make_domain_content('Finance/insurance', 'Finance/insurance', public_per_dataset, public_datasets_info, model_info)
+        healthcare_domain_content, home_btn_health = make_domain_content('Healthcare', 'Healthcare', public_per_dataset, public_datasets_info, model_info)
 
         private_content = gr.Column(visible=False)
         with private_content:
-            label_md2 = gr.Markdown("## 🥇 TabBench Pro Leaderboard")
-
+            home_btn_private = gr.Button("🏡 Home", elem_classes=["white-btn", "selected-btn"])
+            label_md2 = gr.Markdown("# 🥇 TabBench Enterprise Leaderboard")
+            gr.Markdown("## Example: comparative results on QRT Data Challenge")
+            gr.Markdown("" \
+            "Qube Research & Technologies (QRT) is a leading global quantitative and systematic investment manager. Their use of real-world business data to sponsor a data challenge with ENS Paris provided a real-world opportunity to highlight the value of Neuralk's Predictive Foundation Models on Enterprise financial data. " \
+            "The proposed challenge aimed predicting the return of a stock in the US market using historical data over a recent period of 20 days. More info on the challenge [here](https://challengedata.ens.fr/challenges/23)."
+            )
+            gr.DataFrame(
+                value=styled_df_qrt,
+                interactive=False,
+                wrap=True,
+                type="pandas",
+            )
             gr.Markdown('### Features')
             # -------------------------
             # Top row: Models & Datasets
@@ -666,134 +831,216 @@ with gr.Blocks(css=css) as demo:
                 wrap=True,
                 type="pandas",
             )
-            gr.Markdown("## 🔍 Explore more and filter")
-            with gr.Tabs() as tabs:
-                with gr.Tab("🤖 Average model performance"):
-                    # Count unique datasets by id used for model performance
-                    num_unique_datasets = private_per_dataset['dataset_id'].nunique() if 'dataset_id' in private_per_dataset.columns else 0
-                    gr.Markdown(f"Estimated average model performance over {num_unique_datasets} datasets.")
-                    # Use per-model averages for leaderboard, allow filtering by model_type
-                    per_model_leaderboard = init_leaderboard(private_model_agg, include_model_type_filter=True, industry_filter=False)
-                with gr.Tab("📊 Performance by dataset"):
-                    # Merge private_per_dataset with datasets_info for rich dataset metadata
-                    with open("private_datasets_info.json", "r") as f:
-                        private_datasets_info = pd.DataFrame(json.load(f))
-                    private_per_dataset_merged = private_per_dataset.merge(
-                        private_datasets_info,
-                        left_on=["dataset_name", "dataset_id"],
-                        right_on=["dataset_name", "dataset_id"],
-                        how="left"
+            gr.Markdown("## 🔍 Explore performance by dataset")
+
+            # Columns to display
+            dataset_perf_cols = [
+                "model",
+                "Accuracy",
+                "Precision",
+                "Recall",
+                "F1_score",
+                "AUC",
+                "Elo_score",
+            ]
+
+            # Available datasets
+            dataset_ids = (
+                private_per_dataset["dataset_id"]
+                .dropna()
+                .unique()
+                .tolist()
+            )
+
+            dataset_ids = sorted(dataset_ids)
+
+            dataset_dropdown = gr.Dropdown(
+                choices=dataset_ids,
+                label="📂 Select a dataset",
+                value=dataset_ids[0],
+            )
+
+            dataset_leaderboard = gr.DataFrame(
+                value=highlight_max(private_per_dataset[
+                    private_per_dataset["dataset_id"] == dataset_ids[0]
+                ][dataset_perf_cols]),
+                interactive=False,
+                wrap=True,
+                type="pandas",
+            )
+
+            def update_dataset_leaderboard(selected_dataset_id):
+                return highlight_max(private_per_dataset[
+                    private_per_dataset["dataset_id"] == selected_dataset_id
+                ][dataset_perf_cols])
+
+            dataset_dropdown.change(
+                fn=update_dataset_leaderboard,
+                inputs=dataset_dropdown,
+                outputs=dataset_leaderboard,
+            )
+
+
+        datamap_content = gr.Column(visible=False)
+        with datamap_content:
+            home_btn_datamap = gr.Button("🏡 Home", elem_classes=["white-btn", "selected-btn"])
+            gr.Markdown("# 🤖 Understanding tabular Foundation Models")
+            gr.Markdown("  ")
+            gr.Markdown(
+                "Side study using scikit-learn's make_classification data generation function to have an in-depth understanding of Tabular Foundation Models strengths and weaknesses under specific data characteristics.")
+            
+            gr.Markdown('')
+            PARQUET_PATH = "make_classif-parameter_space.parquet"  
+            df_sklearn = pd.read_parquet(PARQUET_PATH)
+
+            # =====================
+            # Basic preprocessing
+            # =====================
+
+            MODEL_COLS = {
+                "NICL": "acc_NICL",
+                "TABPFN": "acc_TABPFN",
+                "TABICL": "acc_TABICL",
+                "RF": "acc_RF",
+            }
+
+            # =====================
+            # Slider ranges
+            # =====================
+            min_features, max_features = int(df_sklearn["n_features"].min()), int(df_sklearn["n_features"].max())
+            min_samples, max_samples = int(df_sklearn["n_samples"].min()), int(df_sklearn["n_samples"].max())
+            min_classes, max_classes = int(df_sklearn["n_classes"].min()), int(df_sklearn["n_classes"].max())
+            min_sep, max_sep = float(df_sklearn["class_sep"].min()), float(df_sklearn["class_sep"].max())
+
+            # =====================
+            # Filtering + aggregation
+            # =====================
+            def filter_and_aggregate(
+                f_min, f_max,
+                s_min, s_max,
+                c_min, c_max,
+                sep_min, sep_max,
+            ):
+                # sécurité si sliders se croisent
+                if f_min > f_max or s_min > s_max or c_min > c_max or sep_min > sep_max:
+                    return (
+                        pd.DataFrame(columns=["Model", "Accuracy"]),
+                        "⚠️ Invalid interval selection",
                     )
-                    # Set industry directly from private_datasets_info.json
-                    private_per_dataset_merged['industry'] = private_per_dataset_merged['dataset_industry']
-                    dataset_perf_cols = [
-                        "dataset_name", "dataset_id", "industry", "dataset_target", "model", "Accuracy", "Precision", "Recall", "F1_score", "AUC", "Elo_score",
-                         "num_rows", "num_features", "num_classes", "imbalance_ratio", "missing_values", "categorical_features_ratio"
-                    ]
-                    show_cols = [col for col in dataset_perf_cols] #if col in private_per_dataset_merged.columns]
 
-                    # Slider for filtering by number of features
-                    min_num_features = int(private_per_dataset_merged['num_features'].min())
-                    max_num_features = int(private_per_dataset_merged['num_features'].max())
-                    with gr.Row():
-                        with gr.Column():
-                            features_slider = gr.Slider(
-                                minimum=min_num_features,
-                                maximum=max_num_features,
-                                value=min_num_features,
-                                step=1,
-                                label="Min Number of Features",
-                            )
-                        with gr.Column():
-                            min_num_classes = int(private_per_dataset_merged['num_classes'].min())
-                            max_num_classes = int(private_per_dataset_merged['num_classes'].max())
-                            with gr.Row():
-                                classes_slider = gr.Slider(
-                                    minimum=min_num_classes,
-                                    maximum=max_num_classes,
-                                    value=min_num_classes,
-                                    step=1,
-                                    label="Min Number of Classes",
-                                )
-
-                    # Add model filter to leaderboard
-                    private_per_dataset_leaderboard = Leaderboard(
-                        value=private_per_dataset_merged[show_cols],
-                        datatype=["str"] + ["number"] * (len(show_cols) - 1),
-                        select_columns=SelectColumns(
-                            default_selection=show_cols,
-                            cant_deselect=["model"] if "model" in show_cols else [],
-                            label="Select Columns to Display:",
-                        ),
-                        search_columns=["dataset_name"] if "dataset_name" in show_cols else [],
-                        hide_columns=[],
-                        filter_columns=[
-                            ColumnFilter("model", type="checkboxgroup", label="🤖 Model"),
-                            ColumnFilter("industry", type="checkboxgroup", label="🏭 Industry"),
-                        ],
-                        interactive=False,
+                filtered = df_sklearn[
+                    df_sklearn["n_features"].between(f_min, f_max)
+                    & df_sklearn["n_samples"].between(s_min, s_max)
+                    & df_sklearn["n_classes"].between(c_min, c_max)
+                    & df_sklearn["class_sep"].between(sep_min, sep_max)
+                ]
+
+                n_datasets = len(filtered)
+
+                if filtered.empty:
+                    return (
+                        pd.DataFrame(columns=["Model", "Accuracy"]),
+                        "⚠️ No datasets match the current filters.",
                     )
 
-                    def filter_per_dataset_leaderboard(min_features, min_classes):
-                        filtered = private_per_dataset_merged[
-                            (private_per_dataset_merged['num_features'] >= min_features) &
-                            (private_per_dataset_merged['num_classes'] >= min_classes)
-                        ]
-                        return filtered[show_cols]
+                rows = []
+                for model, col in MODEL_COLS.items():
+                    rows.append({
+                        "Model": model,
+                        "Accuracy": filtered[col].mean(),
+                    })
+
+                out = highlight_max(pd.DataFrame(rows))
+                return out, f"📦 **{n_datasets} datasets** considered"
 
-                    features_slider.change(
-                        fn=lambda min_f, min_c: filter_per_dataset_leaderboard(min_f, min_c),
-                        inputs=[features_slider, classes_slider],
-                        outputs=private_per_dataset_leaderboard
+            
+            gr.Markdown("## 📊 Average Model Accuracy by Dataset Properties")
+
+            with gr.Row():
+                with gr.Column():
+                    features_min = gr.Slider(
+                        min_features, max_features,
+                        value=min_features,
+                        step=1,
+                        label="Min number of features"
                     )
-                    classes_slider.change(
-                        fn=lambda min_f, min_c: filter_per_dataset_leaderboard(min_f, min_c),
-                        inputs=[features_slider, classes_slider],
-                        outputs=private_per_dataset_leaderboard
+
+                    features_max = gr.Slider(
+                        min_features, max_features,
+                        value=max_features,
+                        step=1,
+                        label="Max number of features"
                     )
 
-        datamap_content = gr.Column(visible=False)
-        with datamap_content:
-            gr.Markdown("# 🗺️ Data mapping")
-            
-            # gr.Markdown("## 📊 Public vs Private Dataset Statistics Comparison")
-
-            # Select numeric columns to compare
-            compare_columns = [
-                # "num_rows",
-                # "num_features",
-                "num_classes",
-                "imbalance_ratio",
-                "skewness",
-                "frobenius_norm",
-                "min_eigenvalue"
-            ]
+                with gr.Column():
+                    samples_min = gr.Slider(
+                        min_samples, max_samples,
+                        value=min_samples,
+                        step=10,
+                        label="Min number of samples"
+                    )
 
-            # Compute summary stats for both dataset groups
-            public_summary = public_datasets_info[compare_columns].describe().loc[["mean", "std"]]
-            private_summary = private_datasets_info[compare_columns].describe().loc[["mean", "std"]]
+                    samples_max = gr.Slider(
+                        min_samples, max_samples,
+                        value=max_samples,
+                        step=10,
+                        label="Max number of samples"
+                    )
 
-            # Combine into a single comparison DataFrame
-            comparison_df = pd.DataFrame({
-                "Statistic": compare_columns,
-                "🌐 Public Mean": [public_summary.loc["mean", c] for c in compare_columns],
-                "🌐 Public Std": [public_summary.loc["std", c] for c in compare_columns],
-                "💼 Industry Mean": [private_summary.loc["mean", c] for c in compare_columns],
-                "💼 Industry Std": [private_summary.loc["std", c] for c in compare_columns],
-            })
+                with gr.Column():
+                    classes_min = gr.Slider(
+                        min_classes, max_classes,
+                        value=min_classes,
+                        step=1,
+                        label="Min number of classes"
+                    )
 
-            # Round numbers and clean up formatting
-            comparison_df = comparison_df.round(3)
+                    classes_max = gr.Slider(
+                        min_classes, max_classes,
+                        value=max_classes,
+                        step=1,
+                        label="Max number of classes"
+                    )
 
-            gr.Markdown("Below is a comparison of average dataset characteristics between **public** and **private (industry)** datasets. These stats help visualize how academic benchmarks differ from real-world data distributions.")
+                with gr.Column():
+                    sep_min = gr.Slider(
+                        min_sep, max_sep,
+                        value=min_sep,
+                        step=0.01,
+                        label="Min class separation"
+                    )
 
-            gr.DataFrame(
-                value=comparison_df,
+                    sep_max = gr.Slider(
+                        min_sep, max_sep,
+                        value=max_sep,
+                        step=0.01,
+                        label="Max class separation"
+                    )
+
+            perf_table = gr.DataFrame(
                 interactive=False,
-                wrap=True,
                 type="pandas",
+                wrap=True,
             )
 
+            count_md = gr.Markdown("")
+
+
+            controls = [
+                features_min, features_max,
+                samples_min, samples_max,
+                classes_min, classes_max,
+                sep_min, sep_max,
+            ]
+
+            for c in controls:
+                c.change(
+                    fn=filter_and_aggregate,
+                    inputs=controls,
+                    outputs=[perf_table, count_md],
+                )
+
+
             # # Optional: visual comparison chart
             # with gr.Accordion("📈 Visualize Differences", open=False):
 
@@ -829,7 +1076,8 @@ with gr.Blocks(css=css) as demo:
         def show_content(visible_content, selected_btn):
             # All content blocks and buttons
             content_blocks = [home_intro, public_content, retail_domain_content, finance_domain_content, healthcare_domain_content, private_content, datamap_content]
-            btns = [home_btn, public_btn, domain_retail_btn, domain_finance_btn, domain_healthcare_btn, private_btn, datamap_btn]
+            ## btns = [home_btn, public_btn, domain_retail_btn, domain_finance_btn, domain_healthcare_btn, private_btn, datamap_btn]
+            btns = [public_btn_home, home_btn_public, home_btn_retail, home_btn_finance, home_btn_health, home_btn_private, home_btn_datamap]
             # Set visibility
             updates = {block: gr.update(visible=(block == visible_content)) for block in content_blocks}
             # Set button classes
@@ -841,35 +1089,50 @@ with gr.Blocks(css=css) as demo:
             return updates
 
         def show_home():
-            return show_content(home_intro, home_btn)
+            return show_content(home_intro, public_btn_home)
         
         def show_public():
-            return show_content(public_content, public_btn)
+            return show_content(public_content, home_btn_public)
         def show_demain_retail():
-            return show_content(retail_domain_content, domain_retail_btn)
+            return show_content(retail_domain_content, home_btn_retail)
         def show_domain_finance():
-            return show_content(finance_domain_content, domain_finance_btn)
+            return show_content(finance_domain_content, home_btn_finance)
         def show_domain_healthcare():
-            return show_content(healthcare_domain_content, domain_healthcare_btn)
+            return show_content(healthcare_domain_content, home_btn_health)
         
         def show_private():
-            return show_content(private_content, private_btn)
+            return show_content(private_content, home_btn_private)
         
         def show_datamap():
-            return show_content(datamap_content, datamap_btn)
+            return show_content(datamap_content, home_btn_datamap)
         
 
-    outputs = [home_intro, public_content, retail_domain_content, finance_domain_content, healthcare_domain_content, private_content, datamap_content, home_btn, public_btn, domain_retail_btn, domain_finance_btn, domain_healthcare_btn, private_btn, datamap_btn]
-    home_btn.click(fn=show_home, inputs=None, outputs=outputs)
-    
-    public_btn.click(fn=show_public, inputs=None, outputs=outputs)
-    domain_retail_btn.click(fn=show_demain_retail, inputs=None, outputs=outputs)
-    domain_finance_btn.click(fn=show_domain_finance, inputs=None, outputs=outputs)
-    domain_healthcare_btn.click(fn=show_domain_healthcare, inputs=None, outputs=outputs)
+    # outputs = [home_intro, public_content, retail_domain_content, finance_domain_content, healthcare_domain_content, private_content, datamap_content, home_btn, public_btn, domain_retail_btn, domain_finance_btn, domain_healthcare_btn, private_btn, datamap_btn]
+    outputs = [home_intro, public_content, retail_domain_content, finance_domain_content, healthcare_domain_content, private_content, datamap_content, public_btn_home, home_btn_public, home_btn_retail, home_btn_finance, home_btn_health, home_btn_private, home_btn_datamap]
+    # home_btn.click(fn=show_home, inputs=None, outputs=outputs)
+    home_btn_retail.click(fn=show_home, inputs=None, outputs=outputs)
+    home_btn_finance.click(fn=show_home, inputs=None, outputs=outputs)
+    home_btn_health.click(fn=show_home, inputs=None, outputs=outputs)
+    home_btn_public.click(fn=show_home, inputs=None, outputs=outputs)
+    home_btn_private.click(fn=show_home, inputs=None, outputs=outputs)
+    home_btn_datamap.click(fn=show_home, inputs=None, outputs=outputs)
+
 
-    private_btn.click(fn=show_private, inputs=None, outputs=outputs)
+    # public_btn.click(fn=show_public, inputs=None, outputs=outputs)
+    # domain_retail_btn.click(fn=show_demain_retail, inputs=None, outputs=outputs)
+    # domain_finance_btn.click(fn=show_domain_finance, inputs=None, outputs=outputs)
+    # domain_healthcare_btn.click(fn=show_domain_healthcare, inputs=None, outputs=outputs)
 
-    datamap_btn.click(fn=show_datamap, inputs=None, outputs=outputs)
+    # private_btn.click(fn=show_private, inputs=None, outputs=outputs)
+
+    # datamap_btn.click(fn=show_datamap, inputs=None, outputs=outputs)
+    
+    public_btn_home.click(fn=show_public, inputs=None, outputs=outputs)
+    private_btn_home.click(fn=show_private, inputs=None, outputs=outputs)
+    datamap_btn_home.click(fn=show_datamap, inputs=None, outputs=outputs)
 
+    finance_btn_home.click(fn=show_domain_finance, inputs=None, outputs=outputs)
+    healthcare_btn_home.click(fn=show_domain_healthcare, inputs=None, outputs=outputs)
+    retail_btn_home.click(fn=show_demain_retail, inputs=None, outputs=outputs)
 
-demo.launch(ssr_mode=False)
+demo.launch(ssr_mode=False, share=False)

workflow.png → make_classif-parameter_space.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:10b4e35313af20b830b513ff4e79dbabe781d2a73452b5f6962604a1082b1b6d
-size 429650
+oid sha256:0959a1f1204634a61bbc732fdeac0f1397755f1daadcd9e72b869f3c58cf4d99
+size 5623086

model_info.json

@@ -1,56 +1,61 @@
 [
     {
-        "model_name": "NICL",
+        "model_name": "nicl",
         "model_type": "Tabular Foundation Model",
         "model_description": "Our in-house tabular foundation model based on an in-context learning architecture."
     },
   {
-    "model_name": "Random Forest",
+    "model_name": "xgboost",
     "model_type": "Decision Trees",
-    "model_description": "A robust ensemble method that builds multiple decision trees and averages their predictions to reduce overfitting and improve accuracy."
+    "model_description": "A highly efficient and scalable gradient boosting framework that improves performance with regularization and handles large tabular datasets effectively."
   },
   {
-    "model_name": "MLP",
-    "model_type": "Neural Networks",
-    "model_description": "A Neural Networks that models tabular data by learning non-linear interactions between numerical and embedded categorical features."
+    "model_name": "xgboost_ensemble",
+    "model_type": "Decision Trees",
+    "model_description": "(Ensembled Version) A highly efficient and scalable gradient boosting framework that improves performance with regularization and handles large tabular datasets effectively."
   },
   {
-    "model_name": "XGBoost",
+    "model_name": "catboost",
     "model_type": "Decision Trees",
-    "model_description": "A highly efficient and scalable gradient boosting framework that improves performance with regularization and handles large tabular datasets effectively."
+    "model_description": "A high-performance gradient boosting algorithm that handles categorical features natively and requires minimal preprocessing."
   },
   {
-    "model_name": "CatBoost",
+    "model_name": "catboost_ensemble",
     "model_type": "Decision Trees",
-    "model_description": "A high-performance gradient boosting algorithm that handles categorical features natively and requires minimal preprocessing."
+    "model_description": "(Ensembled Version) A high-performance gradient boosting algorithm that handles categorical features natively and requires minimal preprocessing."
   },
   {
-    "model_name": "ModernNCA",
+    "model_name": "modern-nca",
     "model_type": "Neural Networks",
     "model_description": "An advanced extension of Neighborhood Component Analysis (NCA) that employs deep neural networks with stochastic neighborhood sampling to learn complex feature interactions for tabular data."
   },
   {
-    "model_name": "TabPFNv2",
+    "model_name": "tabpfn2.5",
     "model_type": "Tabular Foundation Model",
     "model_description": "A transformer-based model that performs in-context learning by approximating Bayesian inference for tabular classification on small datasets."
   },
   {
-    "model_name": "RealMLP",
-    "model_type": "Multilayer Perceptron",
-    "model_description": "An enhanced MLP optimized with strong default parameters, achieving competitive performance on tabular data."
+    "model_name": "realmlp",
+    "model_type": "Neural Networks",
+    "model_description": "An enhanced MLP optimized with strong default parameters, achieving competitive performance on tabular data. Note that due to computate limitation, we used the simple version of realmlp."
   },
   {
-    "model_name": "TabICL",
+    "model_name": "tabicl",
     "model_type": "Tabular Foundation Model",
     "model_description": "A transformer-based model that performs feature compression before doing in-context learning on tabular data by conditioning on labeled support examples to predict unseen queries without task-specific training."
   },
   {
-    "model_name": "LightGBM",
+    "model_name": "lightgbm",
     "model_type": "Decision Trees",
     "model_description": "A fast gradient boosting framework that builds decision trees using histogram-based learning for scalable, high-performance tabular modeling."
   },
   {
-    "model_name": "TabM",
+    "model_name": "lightgbm_ensemble",
+    "model_type": "Decision Trees",
+    "model_description": "(Ensembled Version) A fast gradient boosting framework that builds decision trees using histogram-based learning for scalable, high-performance tabular modeling."
+  },
+  {
+    "model_name": "tabm",
     "model_type": "Neural Networks",
     "model_description": "A deep learning model that efficiently imitates an Neural Networks, enhancing performance on tabular data tasks without the overhead of training multiple models."
   }

qrt.json

@@ -0,0 +1,7 @@
+{
+    "tabpfn2.5" : 50.72,
+    "lightgbm" : 50.98,
+    "xgboost" : 51.18,
+    "tabicl" : 51.58,
+    "nicl" : 51.70 
+}

requirements.txt

@@ -12,3 +12,5 @@ seaborn
 scikit-learn
 
 requests
+
+pyarrow

run.py

@@ -2,7 +2,7 @@ import pandas as pd
 import json
 
 # Load model performance per dataset
-with open("public_dummy.json", "r") as f:
+with open("complete_results_acad.json", "r") as f:
     public_per_dataset = pd.json_normalize(json.load(f))
 
 # Load dataset metadata (including industries)