check

app.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from gradio_leaderboard import Leaderboard, ColumnFilter, SelectColumns
+from gradio_leaderboard import Leaderboard, SelectColumns
 import pandas as pd
 from apscheduler.schedulers.background import BackgroundScheduler
 from huggingface_hub import snapshot_download
@@ -73,33 +73,44 @@ LEADERBOARD_DF_CDM_FI = get_leaderboard_df(EVAL_RESULTS_PATH_CDM_FI, COLS, BENCH
 
 def init_leaderboard(dataframe):
     if dataframe is None or dataframe.empty:
-        raise ValueError("Leaderboard DataFrame is empty or None.")
-    return Leaderboard(
-        value=dataframe,
-        datatype=[c.type for c in fields(AutoEvalColumn)],
-        select_columns=SelectColumns(
-            default_selection=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default],
-            cant_deselect=[c.name for c in fields(AutoEvalColumn) if c.never_hidden],
-            label="Select Columns to Display:",
-        ),
-        search_columns=[AutoEvalColumn.model.name],
-        interactive=False,
-    )
-
-
+        print("Warning: Empty dataframe provided to leaderboard")
+        # Return a simple empty dataframe instead of trying to create a custom one
+        return gr.Dataframe(value=pd.DataFrame())
+
+    print(f"Initializing leaderboard with {len(dataframe)} rows")
+    print(f"Columns: {dataframe.columns.tolist()}")
+
+    # Convert dataframe to ensure proper types
+    for col in dataframe.columns:
+        if col in ["average", "params"] + [t.value.col_name for t in Tasks]:
+            dataframe[col] = pd.to_numeric(dataframe[col], errors="coerce")
+        elif col == "still_on_hub":
+            dataframe[col] = dataframe[col].astype(bool)
+        else:
+            dataframe[col] = dataframe[col].astype(str)
+
+    try:
+        return gr.Dataframe(value=dataframe, interactive=False, wrap=True)
+    except Exception as e:
+        print(f"Error initializing leaderboard: {e}")
+        return gr.Dataframe(value=pd.DataFrame())
+
+
+# Initialize the app
 demo = gr.Blocks(css=custom_css)
+
 with demo:
     gr.HTML(TITLE)
     gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
 
-    with gr.Tabs(elem_classes="tab-buttons") as tabs:
-        with gr.TabItem("MIMIC CDM", elem_id="llm-benchmark-tab-table", id=0):
+    with gr.Tabs() as tabs:
+        with gr.Tab("MIMIC CDM"):
             leaderboard_cdm = init_leaderboard(LEADERBOARD_DF_CDM)
 
-        with gr.TabItem("MIMIC CDM FI", elem_id="llm-benchmark-tab-table", id=1):
+        with gr.Tab("MIMIC CDM FI"):
             leaderboard_cdm_fi = init_leaderboard(LEADERBOARD_DF_CDM_FI)
 
-        with gr.TabItem("📝 About", elem_id="llm-benchmark-tab-table", id=2):
+        with gr.Tab("📝 About"):
             gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
 
     with gr.Row():
@@ -112,7 +123,10 @@ with demo:
                 show_copy_button=True,
             )
 
+# Start the scheduler
 scheduler = BackgroundScheduler()
 scheduler.add_job(restart_space, "interval", seconds=1800)
 scheduler.start()
-demo.queue(default_concurrency_limit=40).launch(share=True)
+
+# Launch the app
+demo.queue(default_concurrency_limit=40).launch()

src/display/utils.py

@@ -26,18 +26,18 @@ class ColumnContent:
 auto_eval_column_dict = []
 # Init
 # auto_eval_column_dict.append(["model_type_symbol", ColumnContent, ColumnContent("T", "str", True, never_hidden=True)])
-auto_eval_column_dict.append(["model", ColumnContent, ColumnContent("Model", "markdown", True, never_hidden=True)])
+auto_eval_column_dict.append(["model", ColumnContent, ColumnContent("Model", "str", True, never_hidden=True)])
 # Scores
-auto_eval_column_dict.append(["average", ColumnContent, ColumnContent("Average ⬆️", "number", True)])
+auto_eval_column_dict.append(["average", ColumnContent, ColumnContent("Average ⬆️", "float", True)])
 for task in Tasks:
-    auto_eval_column_dict.append([task.name, ColumnContent, ColumnContent(task.value.col_name, "number", True)])
+    auto_eval_column_dict.append([task.name, ColumnContent, ColumnContent(task.value.col_name, "float", True)])
 # Model information
 # auto_eval_column_dict.append(["model_type", ColumnContent, ColumnContent("Type", "str", False)])
 auto_eval_column_dict.append(["architecture", ColumnContent, ColumnContent("Architecture", "str", False)])
 # auto_eval_column_dict.append(["weight_type", ColumnContent, ColumnContent("Weight type", "str", False, True)])
 # auto_eval_column_dict.append(["precision", ColumnContent, ColumnContent("Precision", "str", False)])
 # auto_eval_column_dict.append(["license", ColumnContent, ColumnContent("Hub License", "str", False)])
-auto_eval_column_dict.append(["params", ColumnContent, ColumnContent("#Params (B)", "number", False)])
+auto_eval_column_dict.append(["params", ColumnContent, ColumnContent("#Params (B)", "float", False)])
 auto_eval_column_dict.append(["seq_length", ColumnContent, ColumnContent("Max Sequence Length", "number", False)])
 auto_eval_column_dict.append(
     ["model_quantization_bits", ColumnContent, ColumnContent("Quantization Bits", "number", False)]

src/populate.py

@@ -11,15 +11,48 @@ from src.leaderboard.read_evals import get_raw_eval_results
 def get_leaderboard_df(results_path: str, cols: list, benchmark_cols: list) -> pd.DataFrame:
     """Creates a dataframe from all the individual experiment results"""
     raw_data = get_raw_eval_results(results_path)
+    if not raw_data:
+        print(f"Warning: No results found in {results_path}")
+        return pd.DataFrame(columns=cols)
+
     all_data_json = [v.to_dict() for v in raw_data]
 
-    df = pd.DataFrame.from_records(all_data_json)
-    df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
-    df = df[cols].round(decimals=2)
+    try:
+        df = pd.DataFrame.from_records(all_data_json)
+
+        # Ensure all required columns exist with proper types
+        for col in cols:
+            if col not in df.columns:
+                df[col] = None
+
+        # Convert numeric columns
+        numeric_cols = ["average", "params"] + [t.value.col_name for t in Tasks]
+        for col in numeric_cols:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors="coerce")
+
+        # Convert boolean columns
+        if "still_on_hub" in df.columns:
+            df["still_on_hub"] = df["still_on_hub"].astype(bool)
+
+        # Convert string columns
+        string_cols = ["model", "architecture"]
+        for col in string_cols:
+            if col in df.columns:
+                df[col] = df[col].astype(str)
+
+        df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
+        df = df[cols].round(decimals=2)
+
+        # filter out if any of the benchmarks have not been produced
+        df = df[has_no_nan_values(df, benchmark_cols)]
 
-    # filter out if any of the benchmarks have not been produced
-    df = df[has_no_nan_values(df, benchmark_cols)]
-    return df
+        print(f"Loaded {len(df)} results from {results_path}")
+        print(f"Columns: {df.columns.tolist()}")
+        return df
+    except Exception as e:
+        print(f"Error creating dataframe: {e}")
+        return pd.DataFrame(columns=cols)
 
 
 def get_evaluation_queue_df(save_path: str, cols: list) -> list[pd.DataFrame]: