Update UI with centered layout and move assets to LFS

.gitattributes

@@ -37,3 +37,4 @@ scale-hf-logo.png filter=lfs diff=lfs merge=lfs -text
 *.avif filter=lfs diff=lfs merge=lfs -text
 background.png filter=lfs diff=lfs merge=lfs -text
 logo.avif filter=lfs diff=lfs merge=lfs -text
+assets/*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -12,3 +12,9 @@ eval-results/
 eval-queue-bk/
 eval-results-bk/
 logs/
+
+submissions/
+teams/
+true-labels/
+
+.DS_Store

app.py

@@ -1,3 +1,5 @@
+import os
+
 import gradio as gr
 import pandas as pd
 from apscheduler.schedulers.background import BackgroundScheduler
@@ -5,8 +7,6 @@ from gradio_leaderboard import Leaderboard, SelectColumns
 from huggingface_hub import snapshot_download
 
 from src.about import (
-    CITATION_BUTTON_LABEL,
-    CITATION_BUTTON_TEXT,
     INTRODUCTION_TEXT,
     LLM_BENCHMARKS_TEXT,
     TITLE,
@@ -78,54 +78,75 @@ LEADERBOARD_DF = get_leaderboard_df(SUBMISSIONS_PATH, COLS)
 
 
 def init_leaderboard(dataframe):
-    team_columns = [c for c in fields(TeamColumn) if c is not None and hasattr(c, "name") and c.name is not None]
+    team_columns = [c for c in fields(TeamColumn) if isinstance(c, type(TeamColumn.team_name))]
+
+    valid_cols = [col for col in COLS if col is not None and isinstance(col, str) and col.strip() != ""]
+    if not valid_cols:
+        valid_cols = ["Team Name", "Best Accuracy ⬆️", "Best F1 Score", "Best Error Rate", "Last Submission"]
 
     if dataframe is None or dataframe.empty:
-        empty_df = pd.DataFrame(columns=COLS)
+        empty_df = pd.DataFrame(columns=valid_cols)
         column_to_type = {c.name: c.type for c in team_columns}
-        datatypes = [column_to_type.get(col, "str") for col in COLS]
+        datatypes = []
+        for col in valid_cols:
+            dtype = column_to_type.get(col, "str")
+            if not dtype or dtype == "":
+                dtype = "str"
+            datatypes.append(dtype)
+
+        print(empty_df)
+        print(datatypes)
+
+        search_col = TeamColumn.team_name.name if TeamColumn.team_name.name in valid_cols else valid_cols[0]
+
         return Leaderboard(
             value=empty_df,
             datatype=datatypes,
+            search_columns=[search_col],
+            select_columns=SelectColumns(
+                default_selection=valid_cols,
+                cant_deselect=[search_col],
+                label="Select Columns to Display:",
+            ),
+            filter_columns=[],
+            hide_columns=[],
             interactive=False,
         )
 
-    missing_cols = [col for col in COLS if col not in dataframe.columns]
-    if missing_cols:
-        for col in missing_cols:
-            dataframe[col] = None
+    dataframe = dataframe[
+        [col for col in dataframe.columns if col is not None and isinstance(col, str) and col.strip() != ""]
+    ]
+
+    if dataframe.empty or len(dataframe.columns) == 0:
+        dataframe = pd.DataFrame(columns=valid_cols)
+
+    missing_cols = [col for col in valid_cols if col not in dataframe.columns]
+    for col in missing_cols:
+        dataframe[col] = None
+
+    dataframe = dataframe[valid_cols]
 
     column_to_type = {c.name: c.type for c in team_columns}
-    datatypes = [column_to_type.get(col, "str") for col in dataframe.columns]
+    datatypes = []
+    for col in dataframe.columns:
+        dtype = column_to_type.get(col, "str")
+        if not dtype or dtype == "":
+            dtype = "str"
+        datatypes.append(dtype)
 
     default_selection = [
-        str(c.name)
-        for c in team_columns
-        if getattr(c, "displayed_by_default", False) and c.name is not None and str(c.name) in dataframe.columns
+        c.name for c in team_columns if getattr(c, "displayed_by_default", False) and c.name in dataframe.columns
     ]
 
-    cant_deselect = [
-        str(c.name)
-        for c in team_columns
-        if getattr(c, "never_hidden", False) and c.name is not None and str(c.name) in dataframe.columns
-    ]
+    cant_deselect = [c.name for c in team_columns if getattr(c, "never_hidden", False) and c.name in dataframe.columns]
 
-    hide_cols = [
-        str(c.name)
-        for c in team_columns
-        if getattr(c, "hidden", False) and c.name is not None and str(c.name) in dataframe.columns
-    ]
+    hide_cols = [c.name for c in team_columns if getattr(c, "hidden", False) and c.name in dataframe.columns]
 
     search_cols = []
     if hasattr(TeamColumn, "team_name") and hasattr(TeamColumn.team_name, "name"):
         search_col_name = TeamColumn.team_name.name
-        if search_col_name is not None and str(search_col_name) in dataframe.columns:
-            search_cols = [str(search_col_name)]
-
-    default_selection = [c for c in default_selection if c is not None]
-    cant_deselect = [c for c in cant_deselect if c is not None]
-    hide_cols = [c for c in hide_cols if c is not None]
-    search_cols = [c for c in search_cols if c is not None]
+        if search_col_name and search_col_name in dataframe.columns:
+            search_cols = [search_col_name]
 
     return Leaderboard(
         value=dataframe,
@@ -163,29 +184,49 @@ def register_team_ui(team_name: str, num_teammates: int):
 
 
 def submit_csv_ui(token: str, csv_file):
+    updated_leaderboard_df = get_leaderboard_df(SUBMISSIONS_PATH, COLS)
+
     if not token or not token.strip():
-        return styled_error("Please provide your team token.")
+        return styled_error("Please provide your team token."), updated_leaderboard_df
 
     if csv_file is None:
-        return styled_error("Please upload a CSV file.")
+        return styled_error("Please upload a CSV file."), updated_leaderboard_df
 
     try:
         with open(csv_file.name, "r") as f:
             csv_content = f.read()
     except Exception as e:
-        return styled_error(f"Could not read CSV file: {str(e)}")
+        return styled_error(f"Could not read CSV file: {str(e)}"), updated_leaderboard_df
 
     success, message = submit_csv(token, csv_content)
 
+    updated_leaderboard_df = get_leaderboard_df(SUBMISSIONS_PATH, COLS)
+
     if success:
-        return styled_message(message)
+        return styled_message(message), updated_leaderboard_df
     else:
-        return styled_error(message)
+        return styled_error(message), updated_leaderboard_df
+
 
+background_image_path = os.path.abspath("assets/background.png")
+logo_image_path = os.path.abspath("assets/logo.png")
 
-demo = gr.Blocks(css=custom_css)
+demo = gr.Blocks(css=custom_css, theme=gr.themes.Soft())
 with demo:
-    gr.HTML(TITLE)
+    with gr.Row(elem_id="title-row"):
+        with gr.Column(scale=0, min_width=120):
+            gr.Image(
+                value=logo_image_path,
+                show_label=False,
+                container=False,
+                height=120,
+                width=120,
+                show_download_button=False,
+                show_fullscreen_button=False,
+                interactive=False,
+            )
+        with gr.Column(scale=1):
+            gr.HTML(TITLE)
     gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
 
     with gr.Tabs(elem_classes="tab-buttons") as tabs:
@@ -233,7 +274,7 @@ with demo:
                 gr.Markdown("## Submit Your Predictions", elem_classes="markdown-text")
                 gr.Markdown(
                     "Upload a CSV file with your predictions. The CSV must have two columns: "
-                    "`file_name` and `prediction`. Predictions should be binary (0/1 or 'real'/'fake').",
+                    "`index` and `prediction`. Predictions should be binary (0/1 or 'real'/'fake').",
                     elem_classes="markdown-text",
                 )
 
@@ -256,7 +297,7 @@ with demo:
                 submit_button.click(
                     submit_csv_ui,
                     [token_input, csv_file_input],
-                    submission_result,
+                    [submission_result, leaderboard],
                 )
 
                 with gr.Accordion("📊 Submission History", open=False):
@@ -264,36 +305,25 @@ with demo:
                         with gr.TabItem("✅ Accepted Submissions"):
                             accepted_table = gr.components.Dataframe(
                                 value=accepted_submissions_df,
-                                headers=SUBMISSION_COLS,
                                 datatype=SUBMISSION_TYPES,
                                 row_count=10,
                             )
                         with gr.TabItem("❌ Rejected Submissions"):
                             rejected_table = gr.components.Dataframe(
                                 value=rejected_submissions_df,
-                                headers=SUBMISSION_COLS,
                                 datatype=SUBMISSION_TYPES,
                                 row_count=10,
                             )
                         with gr.TabItem("📋 All Submissions"):
                             all_table = gr.components.Dataframe(
                                 value=all_submissions_df,
-                                headers=SUBMISSION_COLS,
                                 datatype=SUBMISSION_TYPES,
                                 row_count=10,
                             )
 
-    with gr.Row():
-        with gr.Accordion("📙 Citation", open=False):
-            citation_button = gr.Textbox(
-                value=CITATION_BUTTON_TEXT,
-                label=CITATION_BUTTON_LABEL,
-                lines=20,
-                elem_id="citation-button",
-                show_copy_button=True,
-            )
-
 scheduler = BackgroundScheduler()
 scheduler.add_job(restart_space, "interval", seconds=1800)
 scheduler.start()
-demo.queue(default_concurrency_limit=40).launch()
+demo.queue(default_concurrency_limit=40).launch(
+    allowed_paths=[background_image_path, logo_image_path],
+)

src/about.py

@@ -1,4 +1,4 @@
-TITLE = """<h1 align="center" id="space-title">Truth vs. Machine Hackathon Leaderboard</h1>"""
+TITLE = """<h1 id="space-title">Truth vs. Machine Hackathon Leaderboard</h1>"""
 
 INTRODUCTION_TEXT = """
 Welcome to the Truth vs. Machine Hackathon Leaderboard! This leaderboard tracks teams competing in an audio deepfake detection challenge. Teams submit predictions on audio samples to determine whether they are real or fake, and the leaderboard displays the best performance metrics for each team.
@@ -15,16 +15,16 @@ LLM_BENCHMARKS_TEXT = """
 
 ### 2. Prepare Your Predictions
 Create a CSV file with two columns:
-- `file_name`: The name of the audio file (must match the test set)
+- `index`: The index of the test sample (must match the test set)
 - `prediction`: Your prediction (binary: 0/1, or "real"/"fake")
 
 Example CSV format:
 ```csv
-file_name,prediction
-audio_001.wav,0
-audio_002.wav,1
-audio_003.wav,real
-audio_004.wav,fake
+index,prediction
+43555,0
+43556,1
+43557,real
+43558,fake
 ```
 
 ### 3. Submit Your Predictions
@@ -49,15 +49,15 @@ Your predictions are evaluated on:
 - True labels are kept private and not accessible to participants
 - You can submit multiple times - only your best scores count
 - Make sure your CSV file format is correct before submitting
-- File names in your CSV must exactly match the test set file names
+- Indices in your CSV must exactly match the test set indices
 """
 
 EVALUATION_QUEUE_TEXT = """
 ## Submission Guidelines
 
 ### CSV File Requirements
-- Must contain exactly two columns: `file_name` and `prediction`
-- `file_name` must match the test set file names exactly
+- Must contain exactly two columns: `index` and `prediction`
+- `index` must match the test set indices exactly
 - `prediction` must be binary: 0/1 or "real"/"fake"
 - No missing values allowed
 
@@ -72,7 +72,3 @@ Accepted formats for predictions:
 - Only submissions that improve your best scores are accepted
 - Rejected submissions are logged but don't update the leaderboard
 """
-
-CITATION_BUTTON_LABEL = "Copy the following snippet to cite these results"
-CITATION_BUTTON_TEXT = r"""
-"""

src/display/css_html_js.py

@@ -1,7 +1,32 @@
 custom_css = """
 
+body {background-image: file("./assets/background.png");}
+
+.gradio-container {
+    max-width: 1400px !important;
+    margin: 0 auto !important;
+}
+
+#title-row {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin: 20px auto;
+    gap: 15px;
+}
+
+#title-row img {
+    object-fit: contain;
+}
+
+#space-title {
+    text-align: center;
+    margin: 0;
+}
+
 .markdown-text {
     font-size: 16px !important;
+    text-align: center;
 }
 
 #models-to-add-text {

src/display/utils.py

@@ -2,7 +2,14 @@ from dataclasses import dataclass
 
 
 def fields(raw_class):
-    return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
+    from dataclasses import fields as dataclass_fields
+    from dataclasses import is_dataclass
+
+    if is_dataclass(raw_class):
+        df = dataclass_fields(raw_class)
+        if df:
+            return [getattr(raw_class, field.name) for field in df]
+    return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__" and not callable(v)]
 
 
 @dataclass
@@ -33,7 +40,7 @@ class SubmissionQueueColumn:
     status = ColumnContent("Status", "str", True)
 
 
-COLS = [c.name for c in fields(TeamColumn) if not c.hidden]
+COLS = [c.name for c in fields(TeamColumn) if hasattr(c, "hidden") and not c.hidden]
 
-SUBMISSION_COLS = [c.name for c in fields(SubmissionQueueColumn)]
-SUBMISSION_TYPES = [c.type for c in fields(SubmissionQueueColumn)]
+SUBMISSION_COLS = [c.name for c in fields(SubmissionQueueColumn) if hasattr(c, "name")]
+SUBMISSION_TYPES = [c.type for c in fields(SubmissionQueueColumn) if hasattr(c, "type")]

src/evaluation/compute_metrics.py

@@ -7,11 +7,11 @@ def compute_metrics(predictions_df: pd.DataFrame, true_labels: dict[str, int]) -
     y_pred = []
 
     for _, row in predictions_df.iterrows():
-        file_name = str(row["file_name"]).strip()
-        if file_name not in true_labels:
+        index_val = str(row["index"]).strip()
+        if index_val not in true_labels:
             continue
 
-        true_label = true_labels[file_name]
+        true_label = true_labels[index_val]
         pred_label = int(row["prediction"])
 
         y_true.append(true_label)

src/evaluation/load_labels.py

@@ -44,9 +44,9 @@ def load_true_labels() -> dict[str, int]:
 
                 try:
                     df = pd.read_csv(os.path.join(root, file))
-                    if "file_name" in df.columns and "label" in df.columns:
+                    if "index" in df.columns and "label" in df.columns:
                         for _, row in df.iterrows():
-                            labels[str(row["file_name"])] = int(row["label"])
+                            labels[str(row["index"])] = int(row["label"])
                 except Exception:
                     continue
 

src/submission/validate_csv.py

@@ -35,8 +35,8 @@ def validate_csv(csv_content: str, true_labels: dict[str, int]) -> tuple[bool, s
     except Exception as e:
         return False, f"Invalid CSV format: {str(e)}", None
 
-    if "file_name" not in df.columns:
-        return False, "CSV must contain 'file_name' column", None
+    if "index" not in df.columns:
+        return False, "CSV must contain 'index' column", None
 
     if "prediction" not in df.columns:
         return False, "CSV must contain 'prediction' column", None
@@ -44,8 +44,10 @@ def validate_csv(csv_content: str, true_labels: dict[str, int]) -> tuple[bool, s
     if df.empty:
         return False, "CSV is empty", None
 
-    if df["file_name"].isna().any():
-        return False, "file_name column contains missing values", None
+    df["index"] = df["index"].astype(float).astype(str)
+
+    if df["index"].isna().any():
+        return False, "index column contains missing values", None
 
     if df["prediction"].isna().any():
         return False, "prediction column contains missing values", None
@@ -54,7 +56,7 @@ def validate_csv(csv_content: str, true_labels: dict[str, int]) -> tuple[bool, s
     invalid_predictions = []
 
     for idx, row in df.iterrows():
-        file_name = str(row["file_name"]).strip()
+        index_val = str(row["index"]).strip()
         pred = normalize_prediction(row["prediction"])
 
         if pred is None:
@@ -67,15 +69,15 @@ def validate_csv(csv_content: str, true_labels: dict[str, int]) -> tuple[bool, s
 
     df["prediction"] = normalized_predictions
 
-    missing_files = []
-    for file_name in df["file_name"]:
-        if str(file_name) not in true_labels:
-            missing_files.append(str(file_name))
+    missing_indices = []
+    for index_val in df["index"]:
+        if str(index_val) not in true_labels:
+            missing_indices.append(str(index_val))
 
-    if missing_files:
+    if missing_indices:
         return (
             False,
-            f"Unknown file names found: {', '.join(missing_files[:5])}{'...' if len(missing_files) > 5 else ''}",
+            f"Unknown indices found: {', '.join(missing_indices[:5])}{'...' if len(missing_indices) > 5 else ''}",
             None,
         )