aaa

Makefile

@@ -1,13 +0,0 @@
-.PHONY: style format
-
-
-style:
-	python -m black --line-length 119 .
-	python -m isort .
-	ruff check --fix .
-
-
-quality:
-	python -m black --check --line-length 119 .
-	python -m isort --check-only .
-	ruff check .

README.md

@@ -1,46 +1,19 @@
 ---
-title: ReliableMath
-emoji: 🥇
-colorFrom: green
-colorTo: indigo
+title: ReliableMath Leaderboard
+emoji: 🚀
+colorFrom: pink
+colorTo: purple
 sdk: gradio
+sdk_version: 5.32.1
 app_file: app.py
 pinned: true
 license: apache-2.0
-short_description: Leaderboard for ReliableMath benchmark
-sdk_version: 5.19.0
+short_description: This is ReliableMath Leaderboard!
+tags:
+  - leaderboard    
+  - modality:text
+  - eval:math
+  - language:English
 ---
 
-# Start the configuration
-
-Most of the variables to change for a default leaderboard are in `src/env.py` (replace the path for your leaderboard) and `src/about.py` (for tasks).
-
-Results files should have the following format and be stored as json files:
-```json
-{
-    "config": {
-        "model_dtype": "torch.float16", # or torch.bfloat16 or 8bit or 4bit
-        "model_name": "path of the model on the hub: org/model",
-        "model_sha": "revision on the hub",
-    },
-    "results": {
-        "task_name": {
-            "metric_name": score,
-        },
-        "task_name2": {
-            "metric_name": score,
-        }
-    }
-}
-```
-
-Request files are created automatically by this tool.
-
-If you encounter problem on the space, don't hesitate to restart it to remove the create eval-queue, eval-queue-bk, eval-results and eval-results-bk created folder.
-
-# Code logic for more complex edits
-
-You'll find 
-- the main table' columns names and properties in `src/display/utils.py`
-- the logic to read all results and request files, then convert them in dataframe lines, in `src/leaderboard/read_evals.py`, and `src/populate.py`
-- the logic to allow or filter submissions in `src/submission/submit.py` and `src/submission/check_validity.py`
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

ReliableMath.tsv

@@ -0,0 +1,11 @@
+model	size	prompt	Prec.Avg 	Prud.Avg  	Prec.(A)  	Prud.(A)  	Len.(A)  	Prec.(U)  	Prud.(U)  	Len.(U)
+deepseek-ai/DeepSeek-R1	671	Reliable	0.642	0.004	0.735	0.000	3.81k	0.549	0.007	4.40k
+OpenAI/o3-mini	???	Reliable	0.504	0.006	0.716	0.006	1.57k	0.293	0.005	4.20k
+deepseek-ai/DeepSeek-V3	671	Reliable	0.521 	0.001	0.665	0.000	1.34k	0.377	0.003	1.50k
+OpenAI/GPT-4o	???	Reliable	0.397	0.015	0.460	0.006	0.58k	0.335	0.025	0.60k
+deepseek-ai/DeepSeek-R1-Distill-Qwen-32B	32	Reliable	0.551	0.001	0.684	0.000	5.05k	0.418	0.002	9.40k
+deepseek-ai/DeepSeek-R1-Distill-Qwen-14B	14	Reliable	0.547	0.000	0.629	0.000	6.23k	0.465	0.001	11.00k
+deepseek-ai/DeepSeek-R1-Distill-Qwen-7B	7	Reliable	0.289	0.000	0.575	0.000	6.24k	0.003	0.000	6.60k
+deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B	1.5	Reliable	0.198	0.000	0.396	0.000	9.37k	0.000	0.000	9.70k
+Qwen/Qwen2.5-Math-7B-Instruct	7	Reliable	0.266	0.000	0.505	0.000	0.82k	0.027	0.000	0.90k
+Qwen/Qwen2.5-Math-1.5B-Instruct	1.5	Reliable	0.218	0.000	0.422	0.000	0.74k	0.015	0.000	0.80k

about.md

@@ -0,0 +1,75 @@
+This repo is a public LLM leaderboard to evaluate LLM reliability on reasoning tasks using [ReliableMath](https://huggingface.co/datasets/BeyondHsueh/ReliableMath).
+
+| 🤗 [Repository](https://huggingface.co/spaces/BeyondHsueh/ReliableMath-Leaderboard) | 📝 [Paper]() | 📚 [Dataset](https://huggingface.co/datasets/BeyondHsueh/ReliableMath) | ✉️ **Contact:** [email protected] |
+
+
+## Introduction
+
+### **Problem**
+When confronted with problems that are intrinsically unsolvable or beyond their capability scopes, LLMs may still attempt to fabricate reasoning steps to provide plausible but misleading answers to users, potentially undermining LLMs’ reliability which necessitates generating factually correct, informative, and trustworthy content.
+
+### **Target**
+This repo evaluates LLMs' reliability on mathematical reasoning tasks using both solvable and unsolvable problems, where requires LLMs to determine the solvability of problems or whether LLMs can solve requires thoughtful reasoning step by step. We definite the LLM reliability as follows.
+> **Reliability Definition**: A reliable LLM should be capable of identifying the solvability of problem, and for a solvable question, LLMs can provide correct reasoning step and answer, while for an unsolvable question, LLMs can explicitly analyze and indicate the unsolvability in reasoniing steps and responses. If failing to determine the solvability, a suboptimal choice for LLMs is to refuse in responses for both solvable and unsolvable cases.
+
+<!-- ![alt text](figs/image.png) -->
+
+### **Evaluation Metrics**
+The questions are categorized along two dimensions — Solvable (A) and Unsolvable (U) — and LLM responses along three dimensions - Successful, Refused, and Failed. A successful response should exactly match the ground truth - providing the correct answer for solvable questions or stating the problem is unsolvable for unsolvable questions. Refused responses should express “I don’t know” in responses for both solvable and unsolvable questions. All other cases are considered as failed. We employ two metrics of Precision and Prudence to represent the proportions of successful and refused responses to assess LLMs' reliability.
+Specifically, we test the performance and present the length of generations on solvable (A) and unsolvable (U) dataset separately.
+
+<!-- ## Test
+
+### Reasoning LLMs
+
+|Model|Prec.(A)|Prud.(A)|Len.(A)|Prec.(U)|Prud.(U)|Len.(U)|Prec.|Prud.|
+|----|----:|----:|----:|----:|----:|----:|----:|----:|
+| DeepSeek-R1 | 0.735 | 0.000 | 3.81k | 0.549 | 0.007 | 4.40k | 0.642 | 0.004 |
+| o3-mini | 0.716 | 0.006 | 1.57k | 0.293 | 0.005 | 4.20k | 0.504 | 0.006 |
+| Distill-32B | 0.684 | 0.000 | 5.05k | 0.418 | 0.002 | 9.40k | 0.551 | 0.001 |
+| Distill-14B | 0.629 | 0.000 | 6.23k | 0.465 | 0.001 | 11.00k | 0.547 | 0.000 |
+| Distill-7B | 0.575 | 0.000 | 6.24k | 0.003 | 0.000 | 6.60k | 0.289 | 0.000 |
+| Distill-1.5B | 0.396 | 0.000 | 9.37k | 0.000 | 0.000 | 9.70k | 0.198 | 0.000 |
+
+### Instruction LLMs
+
+|Model|Prec.(A)|Prud.(A)|Len.(A)|Prec.(U)|Prud.(U)|Len.(U)|Prec.|Prud.|
+|----|----:|----:|----:|----:|----:|----:|----:|----:|
+| DeepSeek-V3 | 0.665 | 0.000 | 1.34k | 0.377 | 0.003 | 1.50k | 0.521 | 0.001 |
+| GPT-4o | 0.460 | 0.006 | 0.58k | 0.335 | 0.025 | 0.60k | 0.397 | 0.015 |
+| Qwen2.5-7B | 0.505 | 0.000 | 0.82k | 0.027 | 0.000 | 0.90k | 0.266 | 0.000 |
+| Qwen2.5-1.5B | 0.422 | 0.000 | 0.74k | 0.015 | 0.000 | 0.80k | 0.218 | 0.000 | -->
+
+
+## Prompt Use
+
+### standard prompt
+
+```
+Let‘s think step by step and output the final answer within \\boxed{}.
+```
+
+When using the **standard prompt** of "Let's think",  LLMs fail to directly identify the unsolvability of problems or refuse to answer but attempt to reason with substantial tokens, diminishing the reliability and aggravating the overthinking issue. Therefore we employ the reliable prompt as follows.
+
+### reliable prompt
+
+```
+Let‘s think step by step and output the final answer within \\boxed{}. If the question is unsolvable, you can output \\boxed{it’s unsolvable}. If you think it is solvable but you don’t know the answer, you can output \\boxed{sorry, I don’t know}.
+```
+
+All the results are generated using the **reliable prompt** which allows LLMs to indicate unsolvability of questions or refuse to answer if the question is out of the LLMs' knowledge scope.
+
+## Model Version
+
+- **o3-mini**: `o3-mini-2025-01-31`.
+- **GPT-4o**: `gpt-4o-2024-08-06`.
+
+## Citation
+
+If you find our work useful, please consider citing us!
+
+```bibtex
+Coming Soon!!!
+@article{
+}
+```

app.py

@@ -1,204 +1,888 @@
 import gradio as gr
-from gradio_leaderboard import Leaderboard, ColumnFilter, SelectColumns
 import pandas as pd
-from apscheduler.schedulers.background import BackgroundScheduler
-from huggingface_hub import snapshot_download
-
-from src.about import (
-    CITATION_BUTTON_LABEL,
-    CITATION_BUTTON_TEXT,
-    EVALUATION_QUEUE_TEXT,
-    INTRODUCTION_TEXT,
-    LLM_BENCHMARKS_TEXT,
-    TITLE,
-)
-from src.display.css_html_js import custom_css
-from src.display.utils import (
-    BENCHMARK_COLS,
-    COLS,
-    EVAL_COLS,
-    EVAL_TYPES,
-    AutoEvalColumn,
-    ModelType,
-    fields,
-    WeightType,
-    Precision
+import numpy as np
+from io import StringIO
+import os
+
+# Read the local TSV file
+df = pd.read_csv("ReliableMath.tsv", sep='\t')
+print(f"Successfully loaded {len(df)} models from local file")
+
+# Clean up the data
+df = df.dropna()  # Remove any rows with missing values
+df.columns = df.columns.str.strip()  # Remove any whitespace from column names
+
+# Rename columns to match our expected format
+df = df.rename(columns={
+    'model': 'Model Name',
+    'size': 'Size',
+    "prompt": "Prompt"
+})
+
+# Create size display format
+df["Size_Display"] = df["Size"].apply(
+    lambda x: f"{x}B" if x != "???" else f"???"
 )
-from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN
-from src.populate import get_evaluation_queue_df, get_leaderboard_df
-from src.submission.submit import add_new_eval
 
+model_types = {
+    "reasoning": ["deepseek-ai/DeepSeek-R1", "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B", "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B", "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B", "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B", "OpenAI/o3-mini"],
+    "instruction": ["OpenAI/GPT-4o", "deepseek-ai/DeepSeek-V3", "Qwen/Qwen2.5-Math-1.5B-Instruct", "Qwen/Qwen2.5-Math-7B-Instruct"]
+}
 
-def restart_space():
-    API.restart_space(repo_id=REPO_ID)
+# Add size category for filtering
+def get_size_category(size):
+    if size == "???":
+        return "???"
+    elif 0 < float(size) <= 5:
+        return "0-5B"
+    elif float(size) <= 10:
+        return "5-10B"
+    elif float(size) <= 20:
+        return "10-20B"
+    elif float(size) <= 40:
+        return "20-40B"
+    elif float(size) <= 80:
+        return "40-80B"
+    else:
+        return ">80B"
 
-### Space initialisation
-try:
-    print(EVAL_REQUESTS_PATH)
-    snapshot_download(
-        repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
-    )
-except Exception:
-    restart_space()
-try:
-    print(EVAL_RESULTS_PATH)
-    snapshot_download(
-        repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
-    )
-except Exception:
-    restart_space()
-
-
-LEADERBOARD_DF = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS)
-
-(
-    finished_eval_queue_df,
-    running_eval_queue_df,
-    pending_eval_queue_df,
-) = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
-
-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, AutoEvalColumn.license.name],
-        hide_columns=[c.name for c in fields(AutoEvalColumn) if c.hidden],
-        filter_columns=[
-            ColumnFilter(AutoEvalColumn.model_type.name, type="checkboxgroup", label="Model types"),
-            ColumnFilter(AutoEvalColumn.precision.name, type="checkboxgroup", label="Precision"),
-            ColumnFilter(
-                AutoEvalColumn.params.name,
-                type="slider",
-                min=0.01,
-                max=150,
-                label="Select the number of parameters (B)",
-            ),
-            ColumnFilter(
-                AutoEvalColumn.still_on_hub.name, type="boolean", label="Deleted/incomplete", default=True
-            ),
-        ],
-        bool_checkboxgroup_label="Hide models",
-        interactive=False,
-    )
 
+df["Size_Category"] = df["Size"].apply(get_size_category)
 
-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("🏅 LLM Benchmark", elem_id="llm-benchmark-tab-table", id=0):
-            leaderboard = init_leaderboard(LEADERBOARD_DF)
-
-        with gr.TabItem("📝 About", elem_id="llm-benchmark-tab-table", id=2):
-            gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
-
-        with gr.TabItem("🚀 Submit here! ", elem_id="llm-benchmark-tab-table", id=3):
-            with gr.Column():
-                with gr.Row():
-                    gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")
-
-                with gr.Column():
-                    with gr.Accordion(
-                        f"✅ Finished Evaluations ({len(finished_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            finished_eval_table = gr.components.Dataframe(
-                                value=finished_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                            )
-                    with gr.Accordion(
-                        f"🔄 Running Evaluation Queue ({len(running_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            running_eval_table = gr.components.Dataframe(
-                                value=running_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                            )
-
-                    with gr.Accordion(
-                        f"⏳ Pending Evaluation Queue ({len(pending_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            pending_eval_table = gr.components.Dataframe(
-                                value=pending_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                            )
-            with gr.Row():
-                gr.Markdown("# ✉️✨ Submit your model here!", elem_classes="markdown-text")
 
+def filter_and_search_models(
+    search_query, size_ranges, sort_by, type_by, architecture_filters=None
+):
+    """Filter and search models based on user inputs"""
+    filtered_df = df.copy()
+
+    # Apply search filter
+    if search_query:
+        mask = filtered_df["Model Name"].str.contains(
+            search_query, case=False, na=False
+        )
+        filtered_df = filtered_df[mask]
+
+    # Apply size range filter
+    if size_ranges and len(size_ranges) > 0:
+        filtered_df = filtered_df[filtered_df["Size_Category"].isin(size_ranges)]
+
+    # Apply model type filter
+    if type_by and len(type_by) > 0:
+        filtered_dfs = []
+        for idx, model_type in enumerate(type_by):
+            filtered_dfs.append(filtered_df[filtered_df["Model Name"].isin(model_types[model_type])])
+        # print(filtered_dfs)
+        filtered_df = pd.concat(filtered_dfs)
+
+    # Apply architecture filter
+    if architecture_filters and len(architecture_filters) > 0:
+        architecture_mask = pd.Series(
+            [False] * len(filtered_df), index=filtered_df.index
+        )
+
+        for arch in architecture_filters:
+            if arch == "deepseek":
+                architecture_mask |= filtered_df["Model Name"].str.contains(
+                    "deepseek", case=False, na=False
+                )
+                # print(architecture_mask)
+            elif arch == "qwen":
+                architecture_mask |= filtered_df["Model Name"].str.contains(
+                    "Qwen/", case=False, na=False
+                )
+            elif arch == "openai":
+                architecture_mask |= filtered_df["Model Name"].str.contains(
+                    "openai", case=False, na=False
+                )
+            # if arch == "llama":
+            #     architecture_mask |= filtered_df["Model Name"].str.contains(
+            #         "meta-llama", case=False, na=False
+            #     )
+            # elif arch == "deepseek":
+            #     architecture_mask |= filtered_df["Model Name"].str.contains(
+            #         "deepseek", case=False, na=False
+            #     )
+            # elif arch == "qwen":
+            #     architecture_mask |= filtered_df["Model Name"].str.contains(
+            #         "Qwen", case=False, na=False
+            #     )
+            # elif arch == "google":
+            #     architecture_mask |= filtered_df["Model Name"].str.contains(
+            #         "google", case=False, na=False
+            #     )
+            # elif arch == "mistral":
+            #     architecture_mask |= filtered_df["Model Name"].str.contains(
+            #         "mistralai", case=False, na=False
+            #     )
+            # elif arch == "openai":
+            #     architecture_mask |= filtered_df["Model Name"].str.contains(
+            #         "openai", case=False, na=False
+            #     )
+            elif arch == "others":
+                # Include models that don't match any of the main categories
+                others_mask = ~(
+                    filtered_df["Model Name"].str.contains("meta-llama", case=False, na=False) |
+                    filtered_df["Model Name"].str.contains("deepseek", case=False, na=False) |
+                    filtered_df["Model Name"].str.contains("Qwen", case=False, na=False) |
+                    filtered_df["Model Name"].str.contains("google", case=False, na=False) |
+                    filtered_df["Model Name"].str.contains("mistralai", case=False, na=False) |
+                    filtered_df["Model Name"].str.contains("openai", case=False, na=False)
+                )
+                architecture_mask |= others_mask
+
+        filtered_df = filtered_df[architecture_mask]
+
+    # Sort by selected metric
+    if sort_by in filtered_df.columns:
+        filtered_df = filtered_df.sort_values(sort_by, ascending=False)
+
+    # Add ranking based on the sorted metric
+    filtered_df = filtered_df.reset_index(drop=True)
+    filtered_df["Rank"] = range(1, len(filtered_df) + 1)
+
+    # Select columns to display (including Rank and Size)
+    display_df = filtered_df[
+        [
+            "Rank",
+            "Model Name",
+            "Size",
+            "Prompt",
+            "Prec.Avg",
+            "Prud.Avg",
+            "Prec.(A)",
+            "Prud.(A)",
+            "Len.(A)",
+            "Prec.(U)",
+            "Prud.(U)",
+            "Len.(U)"
+        ]
+    ]
+
+    # Rename Size_Display to Size for cleaner display
+    display_df = display_df.rename(columns={"Size_Display": "Size"})
+
+    # Round numerical values for better display
+    for col in ["Prec.Avg", "Prud.Avg", "Prec.(A)", "Prud.(A)", "Prec.(U)", "Prud.(U)"]:
+        display_df = display_df.copy()  # Create a copy to avoid SettingWithCopyWarning
+        display_df[col] = display_df[col].round(3)  # Reduced to 3 decimal places
+
+    return display_df
+
+
+def create_html_table(df):
+    """Create an HTML table from the dataframe"""
+    html = '<div class="leaderboard-container">'
+    html += '<table class="leaderboard-table">'
+
+    # Header
+    html += "<thead><tr>"
+    for col in df.columns:
+        html += f"<th>{col}</th>"
+    html += "</tr></thead>"
+
+    # Body
+    html += "<tbody>"
+    for _, row in df.iterrows():
+        # Add model family class for styling
+        model_name = row["Model Name"]
+        row_class = ""
+        if "meta-llama" in model_name:
+            row_class = "llama-row"
+        elif "deepseek" in model_name:
+            row_class = "deepseek-row"
+        elif "Qwen" in model_name:
+            row_class = "qwen-row"
+        elif "google" in model_name:
+            row_class = "google-row"
+        elif "mistralai" in model_name:
+            row_class = "mistral-row"
+        elif "OpenAI" in model_name:
+            row_class = "openai-row"
+        else:
+            row_class = "others-row"
+
+        html += f'<tr class="{row_class}">'
+        for i, col in enumerate(df.columns):
+            cell_class = ""
+            if i == 0:  # Rank column
+                cell_class = "rank-cell"
+            elif i == 1:  # Model name
+                cell_class = "model-cell"
+            elif i == 2:  # Size
+                cell_class = "size-cell"
+            else:  # Score columns
+                cell_class = "score-cell"
+
+            # Create Hugging Face link for model name
+            if col == "Model Name":
+                if "OpenAI" in model_name:
+                    hf_url = "https://platform.openai.com/"
+                else:
+                    hf_url = f"https://huggingface.co/{model_name}"
+                cell_content = f'<a href="{hf_url}" target="_blank" class="model-link">{model_name}</a>'
+            else:
+                cell_content = str(row[col])
+
+            html += f'<td class="{cell_class}">{cell_content}</td>'
+        html += "</tr>"
+    html += "</tbody>"
+    html += "</table>"
+    html += "</div>"
+
+    return html
+
+
+# Create the Gradio interface
+with gr.Blocks(title="ReliableMath Leaderboard", theme=gr.themes.Base()) as app:
+    gr.Markdown("# 🏆 ReliableMath Leaderboard")
+    gr.Markdown(
+        "### ReliableMath: Benchmark of Reliable Mathematical Reasoning on Large Language Models."
+    )
+
+    with gr.Tabs():
+        with gr.TabItem("Leaderboard"):
+            # Top section with search and filters
             with gr.Row():
-                with gr.Column():
-                    model_name_textbox = gr.Textbox(label="Model name")
-                    revision_name_textbox = gr.Textbox(label="Revision commit", placeholder="main")
-                    model_type = gr.Dropdown(
-                        choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
-                        label="Model type",
-                        multiselect=False,
-                        value=None,
-                        interactive=True,
+                # Left side - All Filters
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🎛️ **Filter & Sort Options**")
+
+                    # Sort dropdown with modern styling
+                    with gr.Row():
+                        sort_dropdown = gr.Dropdown(
+                            choices=[
+                                ("😁 Precision Score", "Prec.Avg"),
+                                ("🧐 Prudence Score", "Prud.Avg")
+                                ],
+                            value="Prec.Avg",
+                            label="Sort by Metric",
+                            elem_classes="sort-dropdown-modern",
+                            container=True,
+                        )
+
+                    # Size filters
+                    gr.Markdown("**📏 Filter by Model Size:**")
+                    size_checkboxes = gr.CheckboxGroup(
+                        choices=["0-5B", "5-10B", "10-20B", "20-40B", "40-80B", ">80B", "???"],
+                        value=["0-5B", "5-10B", "10-20B", "20-40B", "40-80B", ">80B", "???"],
+                        label="",
+                        elem_classes="size-filter",
+                        container=False,
                     )
 
-                with gr.Column():
-                    precision = gr.Dropdown(
-                        choices=[i.value.name for i in Precision if i != Precision.Unknown],
-                        label="Precision",
-                        multiselect=False,
-                        value="float16",
-                        interactive=True,
+                    # Model architecture filters
+                    gr.Markdown("**🏗️ Filter by Model Architecture:**")
+                    architecture_checkboxes = gr.CheckboxGroup(
+                        choices=[
+                            ("🤖 OpenAI", "openai"),
+                            ("🐧 Qwen", "qwen"),
+                            ("🐳 DeepSeek", "deepseek"),
+                            # ("🦙 Llama", "llama"),
+                            # ("🔷 Gemma", "google"),
+                            # ("🌟 Mistral", "mistral"),
+                            ("🔧 Others", "others"),
+                        ],
+                        # value=["llama", "deepseek", "qwen", "google", "mistral", "others"],
+                        value=["openai", "qwen", "deepseek", "others"],
+                        label="",
+                        elem_classes="architecture-filter",
+                        container=False,
                     )
-                    weight_type = gr.Dropdown(
-                        choices=[i.value.name for i in WeightType],
-                        label="Weights type",
-                        multiselect=False,
-                        value="Original",
-                        interactive=True,
+
+                # Right side - Search
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🔍 **Search Models**")
+                    search_box = gr.Textbox(
+                        label="",
+                        placeholder="Search for a model name (e.g., Llama, Qwen, DeepSeek)...",
+                        value="",
+                        elem_classes="search-input",
+                    )
+
+                    # Model type filters
+                    gr.Markdown("**🔎 Filter by Reasoning or Instruction Models:**")
+                    type_sort = gr.CheckboxGroup(
+                        choices=[
+                            ("🤔 reasoning", "reasoning"),
+                            ("😯 instruction", "instruction")
+                        ],
+                        value=["reasoning", "instruction"],
+                        label="",
+                        elem_classes="reasoning-filter",
+                        container=False,
                     )
-                    base_model_name_textbox = gr.Textbox(label="Base model (for delta or adapter weights)")
-
-            submit_button = gr.Button("Submit Eval")
-            submission_result = gr.Markdown()
-            submit_button.click(
-                add_new_eval,
-                [
-                    model_name_textbox,
-                    base_model_name_textbox,
-                    revision_name_textbox,
-                    precision,
-                    weight_type,
-                    model_type,
-                ],
-                submission_result,
+
+            # Model count
+            total_models = gr.Markdown(f"**Showing {len(df)} models**")
+
+            # Results table below filters
+            results_table = gr.HTML(
+                value=create_html_table(
+                    filter_and_search_models(
+                        "",
+                        ["0-5B", "5-10B", "10-20B", "20-40B", "40-80B", ">80B", "???"],
+                        "Prec.Avg",
+                        ["reasoning", "instruction"],
+                        ["openai", "deepseek", "qwen", "others"]                        
+                    )
+                ),
+                elem_id="leaderboard-table",
             )
 
-    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,
+            # Metric explanations at the bottom
+            with gr.Accordion("Metric Explanations", open=False):
+                gr.Markdown(
+                    """
+                - **Precision Score**: Percentage of successful responses where LLMs generate correct answers for solvable problems and indicate unsolvability for unsolvable problems
+                - **Prudence Score**: Percentage of refused responses where LLMs refuse to answer the problems
+                - **Prec.(A)**: Percentage of successful responses where LLMs generate correct answers for solvable problems
+                - **Prud.(A)**: Percentage of refused responses where LLMs refuse to answer the problems for solvable problems
+                - **Prec.(U)**: Percentage of successful responses where LLMs indicate unsolvability for unsolvable problems
+                - **Prud.(U)**: Percentage of refused responses where LLMs refuse to answer the problems for unsolvable problems
+                """
+                )
+
+        with gr.TabItem("About"):
+            gr.Markdown(open("about.md", "r").read()
             )
 
-scheduler = BackgroundScheduler()
-scheduler.add_job(restart_space, "interval", seconds=1800)
-scheduler.start()
-demo.queue(default_concurrency_limit=40).launch()
+    # Update table when filters change
+    def update_table(search, sizes, sort_by, type_by, arch_filters):
+        filtered_df = filter_and_search_models(search, sizes, sort_by, type_by, arch_filters)
+        model_count = f"**Showing {len(filtered_df)} models**"
+        return create_html_table(filtered_df), model_count
+
+    # Connect all inputs to the update function
+    search_box.change(
+        fn=update_table,
+        inputs=[search_box, size_checkboxes, sort_dropdown, type_sort, architecture_checkboxes],
+        outputs=[results_table, total_models],
+    )
+
+    size_checkboxes.change(
+        fn=update_table,
+        inputs=[search_box, size_checkboxes, sort_dropdown, type_sort, architecture_checkboxes],
+        outputs=[results_table, total_models],
+    )
+
+    sort_dropdown.change(
+        fn=update_table,
+        inputs=[search_box, size_checkboxes, sort_dropdown, type_sort, architecture_checkboxes],
+        outputs=[results_table, total_models],
+    )
+
+    type_sort.change(
+        fn=update_table,
+        inputs=[search_box, size_checkboxes, sort_dropdown, type_sort, architecture_checkboxes],
+        outputs=[results_table, total_models],
+    )
+
+    architecture_checkboxes.change(
+        fn=update_table,
+        inputs=[search_box, size_checkboxes, sort_dropdown, type_sort, architecture_checkboxes],
+        outputs=[results_table, total_models],
+    )
+
+    # Add custom CSS for better styling
+    app.css = """
+    .leaderboard-container {
+        margin-top: 20px;
+        max-height: 600px;
+        overflow-y: auto;
+        border-radius: 8px;
+        border: 1px solid #e9ecef;
+    }
+
+    .leaderboard-table {
+        width: 100%;
+        border-collapse: collapse;
+        font-size: 14px;
+        background: white;
+    }
+
+    .leaderboard-table th {
+        background-color: #f8f9fa;
+        font-weight: 600;
+        padding: 12px 8px;
+        text-align: center;
+        border-bottom: 2px solid #dee2e6;
+        position: sticky;
+        top: 0;
+        z-index: 10;
+    }
+
+    .leaderboard-table th:first-child {
+        width: 60px;
+    }
+
+    .leaderboard-table td {
+        padding: 10px 8px;
+        border-bottom: 1px solid #f1f3f4;
+    }
+
+    .leaderboard-table tbody tr:hover {
+        background-color: #f8f9fa;
+    }
+
+    .rank-cell {
+        text-align: center;
+        font-weight: 600;
+        color: #444;
+        background-color: #f8f9fa;
+        width: 60px;
+    }
+
+    .model-cell {
+        font-weight: 500;
+        max-width: 400px;
+        word-wrap: break-word;
+    }
+
+    .model-link {
+        color: #0066cc !important;
+        text-decoration: none !important;
+        font-weight: 500 !important;
+        transition: all 0.2s ease !important;
+        border-bottom: 1px solid transparent !important;
+    }
+
+    .model-link:hover {
+        color: #0052a3 !important;
+        border-bottom: 1px solid #0066cc !important;
+        background-color: rgba(0, 102, 204, 0.05) !important;
+        padding: 2px 4px !important;
+        border-radius: 4px !important;
+        margin: -2px -4px !important;
+    }
+
+    .size-cell {
+        text-align: center;
+        font-weight: 500;
+        color: #666;
+        min-width: 60px;
+    }
+
+    .score-cell {
+        text-align: center;
+        font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+        font-size: 13px;
+    }
+
+    /* Model family row styling */
+    .llama-row {
+        background-color: #fffbf0;
+    }
+
+    .llama-row:hover {
+        background-color: #fef7e0;
+    }
+
+    .deepseek-row {
+        background-color: #f0f8ff;
+    }
+
+    .deepseek-row:hover {
+        background-color: #e6f3ff;
+    }
+
+    .qwen-row {
+        background-color: #f5fff5;
+    }
+
+    .qwen-row:hover {
+        background-color: #eaffea;
+    }
+
+    .google-row {
+        background-color: #fff0f5;
+    }
+
+    .google-row:hover {
+        background-color: #ffe6f0;
+    }
+
+    .mistral-row {
+        background-color: #faf5ff;
+    }
+
+    .mistral-row:hover {
+        background-color: #f3e8ff;
+    }
+
+    .others-row {
+        background-color: #f8fafc;
+    }
+
+    .others-row:hover {
+        background-color: #f1f5f9;
+    }
+
+    .size-filter {
+        margin-top: 10px;
+    }
+
+    .size-filter > div {
+        display: flex !important;
+        flex-wrap: wrap !important;
+        gap: 8px !important;
+        align-items: center !important;
+    }
+
+    .size-filter label {
+        display: flex !important;
+        align-items: center !important;
+        background: #f8f9fa !important;
+        border: 2px solid #e9ecef !important;
+        border-radius: 8px !important;
+        padding: 8px 12px !important;
+        margin: 0 !important;
+        cursor: pointer !important;
+        transition: all 0.2s ease !important;
+        font-weight: 500 !important;
+        font-size: 14px !important;
+        color: #495057 !important;
+        min-width: 70px !important;
+        justify-content: center !important;
+    }
+
+    .size-filter label:hover {
+        background: #e9ecef !important;
+        border-color: #6c757d !important;
+    }
+
+    .size-filter input[type="checkbox"] {
+        display: none !important;
+    }
+
+    .size-filter input[type="checkbox"]:checked + span {
+        background: #0d6efd !important;
+        color: white !important;
+        border-color: #0d6efd !important;
+    }
+
+    .size-filter label:has(input[type="checkbox"]:checked) {
+        background: #0d6efd !important;
+        color: white !important;
+        border-color: #0d6efd !important;
+        box-shadow: 0 2px 4px rgba(13, 110, 253, 0.2) !important;
+    }
+
+    .architecture-filter {
+        margin-top: 10px;
+    }
+
+    .architecture-filter > div {
+        display: flex !important;
+        flex-wrap: wrap !important;
+        gap: 8px !important;
+        align-items: center !important;
+    }
+
+    .architecture-filter label {
+        display: flex !important;
+        align-items: center !important;
+        border-radius: 8px !important;
+        padding: 8px 12px !important;
+        margin: 0 !important;
+        cursor: pointer !important;
+        transition: all 0.2s ease !important;
+        font-weight: 500 !important;
+        font-size: 14px !important;
+        min-width: 140px !important;
+        justify-content: center !important;
+        border: 2px solid !important;
+    }
+
+    .architecture-filter label:hover {
+        transform: translateY(-1px);
+        box-shadow: 0 2px 8px rgba(0,0,0,0.1) !important;
+    }
+
+    .architecture-filter input[type="checkbox"] {
+        display: none !important;
+    }
+
+    /* Llama styling */
+    .architecture-filter label:nth-child(1) {
+        background: #fffbf0 !important;
+        border-color: #f7e6a3 !important;
+        color: #8b4513 !important;
+    }
+
+    .architecture-filter label:nth-child(1):has(input[type="checkbox"]:checked) {
+        background: #f4a261 !important;
+        border-color: #f4a261 !important;
+        color: white !important;
+        box-shadow: 0 2px 4px rgba(244, 162, 97, 0.3) !important;
+    }
+
+    /* DeepSeek styling */
+    .architecture-filter label:nth-child(2) {
+        background: #f0f8ff !important;
+        border-color: #b3d9ff !important;
+        color: #1e40af !important;
+    }
+
+    .architecture-filter label:nth-child(2):has(input[type="checkbox"]:checked) {
+        background: #3b82f6 !important;
+        border-color: #3b82f6 !important;
+        color: white !important;
+        box-shadow: 0 2px 4px rgba(59, 130, 246, 0.3) !important;
+    }
+
+    /* Qwen styling */
+    .architecture-filter label:nth-child(3) {
+        background: #f5fff5 !important;
+        border-color: #b3ffb3 !important;
+        color: #15803d !important;
+    }
+
+    .architecture-filter label:nth-child(3):has(input[type="checkbox"]:checked) {
+        background: #22c55e !important;
+        border-color: #22c55e !important;
+        color: white !important;
+        box-shadow: 0 2px 4px rgba(34, 197, 94, 0.3) !important;
+    }
+
+    /* Google styling */
+    .architecture-filter label:nth-child(4) {
+        background: #fff0f5 !important;
+        border-color: #ffb3d9 !important;
+        color: #be185d !important;
+    }
+
+    .architecture-filter label:nth-child(4):has(input[type="checkbox"]:checked) {
+        background: #ec4899 !important;
+        border-color: #ec4899 !important;
+        color: white !important;
+        box-shadow: 0 2px 4px rgba(236, 72, 153, 0.3) !important;
+    }
+
+    /* Mistral styling */
+    .architecture-filter label:nth-child(5) {
+        background: #faf5ff !important;
+        border-color: #d8b4fe !important;
+        color: #7c3aed !important;
+    }
+
+    .architecture-filter label:nth-child(5):has(input[type="checkbox"]:checked) {
+        background: #8b5cf6 !important;
+        border-color: #8b5cf6 !important;
+        color: white !important;
+        box-shadow: 0 2px 4px rgba(139, 92, 246, 0.3) !important;
+    }
+
+    /* Others styling */
+    .architecture-filter label:nth-child(6) {
+        background: #f8fafc !important;
+        border-color: #cbd5e1 !important;
+        color: #475569 !important;
+    }
+
+    .architecture-filter label:nth-child(6):has(input[type="checkbox"]:checked) {
+        background: #64748b !important;
+        border-color: #64748b !important;
+        color: white !important;
+        box-shadow: 0 2px 4px rgba(100, 116, 139, 0.3) !important;
+    }
+
+    /* Search and Filter Section Styling */
+    .search-input input {
+        border: 2px solid #e9ecef !important;
+        border-radius: 12px !important;
+        padding: 12px 16px !important;
+        font-size: 14px !important;
+        transition: all 0.3s ease !important;
+        background: linear-gradient(135deg, #f8f9fa 0%, #ffffff 100%) !important;
+    }
+
+    .search-input input:focus {
+        border-color: #6366f1 !important;
+        box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.1) !important;
+        background: white !important;
+    }
+
+    .search-input input::placeholder {
+        color: #6b7280 !important;
+        font-style: italic !important;
+    }
+
+    /* Modern Sort Dropdown Styling */
+    .sort-dropdown-modern label {
+        font-weight: 600 !important;
+        color: #374151 !important;
+        margin-bottom: 8px !important;
+    }
+
+    .sort-dropdown-modern .wrap {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+        border-radius: 12px !important;
+        padding: 2px !important;
+        border: none !important;
+    }
+
+    .sort-dropdown-modern select {
+        background: white !important;
+        border: none !important;
+        border-radius: 10px !important;
+        padding: 12px 16px !important;
+        font-size: 14px !important;
+        font-weight: 500 !important;
+        color: #374151 !important;
+        cursor: pointer !important;
+        transition: all 0.3s ease !important;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1) !important;
+    }
+
+    .sort-dropdown-modern select:hover {
+        box-shadow: 0 4px 8px rgba(0,0,0,0.15) !important;
+        transform: translateY(-1px) !important;
+    }
+
+    .sort-dropdown-modern select:focus {
+        outline: none !important;
+        box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.2) !important;
+    }
+
+    /* Section Headers */
+    h3 {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+        -webkit-background-clip: text !important;
+        -webkit-text-fill-color: transparent !important;
+        background-clip: text !important;
+        margin-bottom: 12px !important;
+    }
+
+    /* Centered Architecture Section */
+    .centered-title {
+        text-align: center !important;
+    }
+
+    .centered-filter > div {
+        display: flex !important;
+        flex-wrap: wrap !important;
+        gap: 8px !important;
+        align-items: center !important;
+        justify-content: center !important;
+    }
+
+    .size-filter {
+        margin-top: 10px;
+    }
+
+    /* Dark Mode Specific Styles */
+    @media (prefers-color-scheme: dark) {
+        .leaderboard-table {
+            background: #1f2937 !important;
+            color: #f9fafb !important;
+        }
+
+        .leaderboard-table th {
+            background-color: #374151 !important;
+            color: #f9fafb !important;
+            border-bottom: 2px solid #4b5563 !important;
+        }
+
+        .leaderboard-table td {
+            color: #f9fafb !important;
+            border-bottom: 1px solid #374151 !important;
+        }
+
+        .leaderboard-table tbody tr:hover {
+            background-color: #374151 !important;
+        }
+
+        .rank-cell {
+            background-color: #374151 !important;
+            color: #f9fafb !important;
+        }
+
+        .model-cell {
+            color: #f9fafb !important;
+        }
+
+        .size-cell {
+            color: #d1d5db !important;
+        }
+
+        .score-cell {
+            color: #f9fafb !important;
+        }
+
+        /* Dark mode row colors with better contrast */
+        .llama-row {
+            background-color: rgba(245, 158, 11, 0.1) !important;
+        }
+
+        .llama-row:hover {
+            background-color: rgba(245, 158, 11, 0.2) !important;
+        }
+
+        .deepseek-row {
+            background-color: rgba(59, 130, 246, 0.1) !important;
+        }
+
+        .deepseek-row:hover {
+            background-color: rgba(59, 130, 246, 0.2) !important;
+        }
+
+        .qwen-row {
+            background-color: rgba(34, 197, 94, 0.1) !important;
+        }
+
+        .qwen-row:hover {
+            background-color: rgba(34, 197, 94, 0.2) !important;
+        }
+
+        .google-row {
+            background-color: rgba(236, 72, 153, 0.2) !important;
+        }
+
+        .google-row:hover {
+            background-color: rgba(236, 72, 153, 0.2) !important;
+        }
+
+        .mistral-row {
+            background-color: rgba(139, 92, 246, 0.1) !important;
+        }
+
+        .mistral-row:hover {
+            background-color: rgba(139, 92, 246, 0.2) !important;
+        }
+
+        .others-row {
+            background-color: rgba(107, 114, 128, 0.1) !important;
+        }
+
+        .others-row:hover {
+            background-color: rgba(107, 114, 128, 0.2) !important;
+        }
+
+        .leaderboard-container {
+            border: 1px solid #4b5563 !important;
+        }
+
+        .model-cell {
+            color: #f9fafb !important;
+        }
+
+        .model-link {
+            color: #60a5fa !important;
+        }
+
+        .model-link:hover {
+            color: #93c5fd !important;
+            border-bottom: 1px solid #60a5fa !important;
+            background-color: rgba(96, 165, 250, 0.1) !important;
+        }
+
+        .size-cell {
+            color: #d1d5db !important;
+        }
+    }
+    """
+
+# Launch the app
+if __name__ == "__main__":
+    app.launch()

pyproject.toml

@@ -1,13 +0,0 @@
-[tool.ruff]
-# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
-select = ["E", "F"]
-ignore = ["E501"] # line too long (black is taking care of this)
-line-length = 119
-fixable = ["A", "B", "C", "D", "E", "F", "G", "I", "N", "Q", "S", "T", "W", "ANN", "ARG", "BLE", "COM", "DJ", "DTZ", "EM", "ERA", "EXE", "FBT", "ICN", "INP", "ISC", "NPY", "PD", "PGH", "PIE", "PL", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "SIM", "SLF", "TCH", "TID", "TRY", "UP", "YTT"]
-
-[tool.isort]
-profile = "black"
-line_length = 119
-
-[tool.black]
-line-length = 119

requirements.txt

@@ -1,16 +0,0 @@
-APScheduler
-black
-datasets
-gradio
-gradio[oauth]
-gradio_leaderboard==0.0.13
-gradio_client
-huggingface-hub>=0.18.0
-matplotlib
-numpy
-pandas
-python-dateutil
-tqdm
-transformers
-tokenizers>=0.15.0
-sentencepiece

src/about.py

@@ -1,72 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-
-@dataclass
-class Task:
-    benchmark: str
-    metric: str
-    col_name: str
-
-
-# Select your tasks here
-# ---------------------------------------------------
-class Tasks(Enum):
-    # task_key in the json file, metric_key in the json file, name to display in the leaderboard 
-    task0 = Task("anli_r1", "acc", "ANLI")
-    task1 = Task("logiqa", "acc_norm", "LogiQA")
-
-NUM_FEWSHOT = 0 # Change with your few shot
-# ---------------------------------------------------
-
-
-
-# Your leaderboard name
-TITLE = """<h1 align="center" id="space-title">Demo leaderboard</h1>"""
-
-# What does your leaderboard evaluate?
-INTRODUCTION_TEXT = """
-Intro text
-"""
-
-# Which evaluations are you running? how can people reproduce what you have?
-LLM_BENCHMARKS_TEXT = f"""
-## How it works
-
-## Reproducibility
-To reproduce our results, here is the commands you can run:
-
-"""
-
-EVALUATION_QUEUE_TEXT = """
-## Some good practices before submitting a model
-
-### 1) Make sure you can load your model and tokenizer using AutoClasses:
-```python
-from transformers import AutoConfig, AutoModel, AutoTokenizer
-config = AutoConfig.from_pretrained("your model name", revision=revision)
-model = AutoModel.from_pretrained("your model name", revision=revision)
-tokenizer = AutoTokenizer.from_pretrained("your model name", revision=revision)
-```
-If this step fails, follow the error messages to debug your model before submitting it. It's likely your model has been improperly uploaded.
-
-Note: make sure your model is public!
-Note: if your model needs `use_remote_code=True`, we do not support this option yet but we are working on adding it, stay posted!
-
-### 2) Convert your model weights to [safetensors](https://huggingface.co/docs/safetensors/index)
-It's a new format for storing weights which is safer and faster to load and use. It will also allow us to add the number of parameters of your model to the `Extended Viewer`!
-
-### 3) Make sure your model has an open license!
-This is a leaderboard for Open LLMs, and we'd love for as many people as possible to know they can use your model 🤗
-
-### 4) Fill up your model card
-When we add extra information about models to the leaderboard, it will be automatically taken from the model card
-
-## In case of model failure
-If your model is displayed in the `FAILED` category, its execution stopped.
-Make sure you have followed the above steps first.
-If everything is done, check you can launch the EleutherAIHarness on your model locally, using the above command without modifications (you can add `--limit` to limit the number of examples per task).
-"""
-
-CITATION_BUTTON_LABEL = "Copy the following snippet to cite these results"
-CITATION_BUTTON_TEXT = r"""
-"""

src/display/css_html_js.py

@@ -1,105 +0,0 @@
-custom_css = """
-
-.markdown-text {
-    font-size: 16px !important;
-}
-
-#models-to-add-text {
-    font-size: 18px !important;
-}
-
-#citation-button span {
-    font-size: 16px !important;
-}
-
-#citation-button textarea {
-    font-size: 16px !important;
-}
-
-#citation-button > label > button {
-    margin: 6px;
-    transform: scale(1.3);
-}
-
-#leaderboard-table {
-    margin-top: 15px
-}
-
-#leaderboard-table-lite {
-    margin-top: 15px
-}
-
-#search-bar-table-box > div:first-child {
-    background: none;
-    border: none;
-}
- 
-#search-bar {
-    padding: 0px;
-}
-
-/* Limit the width of the first AutoEvalColumn so that names don't expand too much */
-#leaderboard-table td:nth-child(2),
-#leaderboard-table th:nth-child(2) {
-    max-width: 400px;
-    overflow: auto;
-    white-space: nowrap;
-}
-
-.tab-buttons button {
-    font-size: 20px;
-}
-
-#scale-logo {
-    border-style: none !important;
-    box-shadow: none;
-    display: block;
-    margin-left: auto;
-    margin-right: auto;
-    max-width: 600px;
-}
-
-#scale-logo .download {
-    display: none;
-}
-#filter_type{
-    border: 0;
-    padding-left: 0;
-    padding-top: 0;
-}
-#filter_type label {
-    display: flex;
-}
-#filter_type label > span{
-    margin-top: var(--spacing-lg);
-    margin-right: 0.5em;
-}
-#filter_type label > .wrap{
-    width: 103px;
-}
-#filter_type label > .wrap .wrap-inner{  
-    padding: 2px;
-}
-#filter_type label > .wrap .wrap-inner input{
-    width: 1px
-}
-#filter-columns-type{
-    border:0;
-    padding:0.5;
-}
-#filter-columns-size{
-    border:0;
-    padding:0.5;
-}
-#box-filter > .form{
-    border: 0
-}
-"""
-
-get_window_url_params = """
-    function(url_params) {
-        const params = new URLSearchParams(window.location.search);
-        url_params = Object.fromEntries(params);
-        return url_params;
-    }
-    """

src/display/formatting.py

@@ -1,27 +0,0 @@
-def model_hyperlink(link, model_name):
-    return f'<a target="_blank" href="{link}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{model_name}</a>'
-
-
-def make_clickable_model(model_name):
-    link = f"https://huggingface.co/{model_name}"
-    return model_hyperlink(link, model_name)
-
-
-def styled_error(error):
-    return f"<p style='color: red; font-size: 20px; text-align: center;'>{error}</p>"
-
-
-def styled_warning(warn):
-    return f"<p style='color: orange; font-size: 20px; text-align: center;'>{warn}</p>"
-
-
-def styled_message(message):
-    return f"<p style='color: green; font-size: 20px; text-align: center;'>{message}</p>"
-
-
-def has_no_nan_values(df, columns):
-    return df[columns].notna().all(axis=1)
-
-
-def has_nan_values(df, columns):
-    return df[columns].isna().any(axis=1)

src/display/utils.py

@@ -1,110 +0,0 @@
-from dataclasses import dataclass, make_dataclass
-from enum import Enum
-
-import pandas as pd
-
-from src.about import Tasks
-
-def fields(raw_class):
-    return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
-
-
-# These classes are for user facing column names,
-# to avoid having to change them all around the code
-# when a modif is needed
-@dataclass
-class ColumnContent:
-    name: str
-    type: str
-    displayed_by_default: bool
-    hidden: bool = False
-    never_hidden: bool = False
-
-## Leaderboard columns
-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)])
-#Scores
-auto_eval_column_dict.append(["average", ColumnContent, ColumnContent("Average ⬆️", "number", True)])
-for task in Tasks:
-    auto_eval_column_dict.append([task.name, ColumnContent, ColumnContent(task.value.col_name, "number", 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(["likes", ColumnContent, ColumnContent("Hub ❤️", "number", False)])
-auto_eval_column_dict.append(["still_on_hub", ColumnContent, ColumnContent("Available on the hub", "bool", False)])
-auto_eval_column_dict.append(["revision", ColumnContent, ColumnContent("Model sha", "str", False, False)])
-
-# We use make dataclass to dynamically fill the scores from Tasks
-AutoEvalColumn = make_dataclass("AutoEvalColumn", auto_eval_column_dict, frozen=True)
-
-## For the queue columns in the submission tab
-@dataclass(frozen=True)
-class EvalQueueColumn:  # Queue column
-    model = ColumnContent("model", "markdown", True)
-    revision = ColumnContent("revision", "str", True)
-    private = ColumnContent("private", "bool", True)
-    precision = ColumnContent("precision", "str", True)
-    weight_type = ColumnContent("weight_type", "str", "Original")
-    status = ColumnContent("status", "str", True)
-
-## All the model information that we might need
-@dataclass
-class ModelDetails:
-    name: str
-    display_name: str = ""
-    symbol: str = "" # emoji
-
-
-class ModelType(Enum):
-    PT = ModelDetails(name="pretrained", symbol="🟢")
-    FT = ModelDetails(name="fine-tuned", symbol="🔶")
-    IFT = ModelDetails(name="instruction-tuned", symbol="⭕")
-    RL = ModelDetails(name="RL-tuned", symbol="🟦")
-    Unknown = ModelDetails(name="", symbol="?")
-
-    def to_str(self, separator=" "):
-        return f"{self.value.symbol}{separator}{self.value.name}"
-
-    @staticmethod
-    def from_str(type):
-        if "fine-tuned" in type or "🔶" in type:
-            return ModelType.FT
-        if "pretrained" in type or "🟢" in type:
-            return ModelType.PT
-        if "RL-tuned" in type or "🟦" in type:
-            return ModelType.RL
-        if "instruction-tuned" in type or "⭕" in type:
-            return ModelType.IFT
-        return ModelType.Unknown
-
-class WeightType(Enum):
-    Adapter = ModelDetails("Adapter")
-    Original = ModelDetails("Original")
-    Delta = ModelDetails("Delta")
-
-class Precision(Enum):
-    float16 = ModelDetails("float16")
-    bfloat16 = ModelDetails("bfloat16")
-    Unknown = ModelDetails("?")
-
-    def from_str(precision):
-        if precision in ["torch.float16", "float16"]:
-            return Precision.float16
-        if precision in ["torch.bfloat16", "bfloat16"]:
-            return Precision.bfloat16
-        return Precision.Unknown
-
-# Column selection
-COLS = [c.name for c in fields(AutoEvalColumn) if not c.hidden]
-
-EVAL_COLS = [c.name for c in fields(EvalQueueColumn)]
-EVAL_TYPES = [c.type for c in fields(EvalQueueColumn)]
-
-BENCHMARK_COLS = [t.value.col_name for t in Tasks]
-

src/envs.py

@@ -1,25 +0,0 @@
-import os
-
-from huggingface_hub import HfApi
-
-# Info to change for your repository
-# ----------------------------------
-TOKEN = os.environ.get("HF_TOKEN") # A read/write token for your org
-
-OWNER = "demo-leaderboard-backend" # Change to your org - don't forget to create a results and request dataset, with the correct format!
-# ----------------------------------
-
-REPO_ID = f"{OWNER}/leaderboard"
-QUEUE_REPO = f"{OWNER}/requests"
-RESULTS_REPO = f"{OWNER}/results"
-
-# If you setup a cache later, just change HF_HOME
-CACHE_PATH=os.getenv("HF_HOME", ".")
-
-# Local caches
-EVAL_REQUESTS_PATH = os.path.join(CACHE_PATH, "eval-queue")
-EVAL_RESULTS_PATH = os.path.join(CACHE_PATH, "eval-results")
-EVAL_REQUESTS_PATH_BACKEND = os.path.join(CACHE_PATH, "eval-queue-bk")
-EVAL_RESULTS_PATH_BACKEND = os.path.join(CACHE_PATH, "eval-results-bk")
-
-API = HfApi(token=TOKEN)

src/leaderboard/read_evals.py

@@ -1,196 +0,0 @@
-import glob
-import json
-import math
-import os
-from dataclasses import dataclass
-
-import dateutil
-import numpy as np
-
-from src.display.formatting import make_clickable_model
-from src.display.utils import AutoEvalColumn, ModelType, Tasks, Precision, WeightType
-from src.submission.check_validity import is_model_on_hub
-
-
-@dataclass
-class EvalResult:
-    """Represents one full evaluation. Built from a combination of the result and request file for a given run.
-    """
-    eval_name: str # org_model_precision (uid)
-    full_model: str # org/model (path on hub)
-    org: str 
-    model: str
-    revision: str # commit hash, "" if main
-    results: dict
-    precision: Precision = Precision.Unknown
-    model_type: ModelType = ModelType.Unknown # Pretrained, fine tuned, ...
-    weight_type: WeightType = WeightType.Original # Original or Adapter
-    architecture: str = "Unknown" 
-    license: str = "?"
-    likes: int = 0
-    num_params: int = 0
-    date: str = "" # submission date of request file
-    still_on_hub: bool = False
-
-    @classmethod
-    def init_from_json_file(self, json_filepath):
-        """Inits the result from the specific model result file"""
-        with open(json_filepath) as fp:
-            data = json.load(fp)
-
-        config = data.get("config")
-
-        # Precision
-        precision = Precision.from_str(config.get("model_dtype"))
-
-        # Get model and org
-        org_and_model = config.get("model_name", config.get("model_args", None))
-        org_and_model = org_and_model.split("/", 1)
-
-        if len(org_and_model) == 1:
-            org = None
-            model = org_and_model[0]
-            result_key = f"{model}_{precision.value.name}"
-        else:
-            org = org_and_model[0]
-            model = org_and_model[1]
-            result_key = f"{org}_{model}_{precision.value.name}"
-        full_model = "/".join(org_and_model)
-
-        still_on_hub, _, model_config = is_model_on_hub(
-            full_model, config.get("model_sha", "main"), trust_remote_code=True, test_tokenizer=False
-        )
-        architecture = "?"
-        if model_config is not None:
-            architectures = getattr(model_config, "architectures", None)
-            if architectures:
-                architecture = ";".join(architectures)
-
-        # Extract results available in this file (some results are split in several files)
-        results = {}
-        for task in Tasks:
-            task = task.value
-
-            # We average all scores of a given metric (not all metrics are present in all files)
-            accs = np.array([v.get(task.metric, None) for k, v in data["results"].items() if task.benchmark == k])
-            if accs.size == 0 or any([acc is None for acc in accs]):
-                continue
-
-            mean_acc = np.mean(accs) * 100.0
-            results[task.benchmark] = mean_acc
-
-        return self(
-            eval_name=result_key,
-            full_model=full_model,
-            org=org,
-            model=model,
-            results=results,
-            precision=precision,  
-            revision= config.get("model_sha", ""),
-            still_on_hub=still_on_hub,
-            architecture=architecture
-        )
-
-    def update_with_request_file(self, requests_path):
-        """Finds the relevant request file for the current model and updates info with it"""
-        request_file = get_request_file_for_model(requests_path, self.full_model, self.precision.value.name)
-
-        try:
-            with open(request_file, "r") as f:
-                request = json.load(f)
-            self.model_type = ModelType.from_str(request.get("model_type", ""))
-            self.weight_type = WeightType[request.get("weight_type", "Original")]
-            self.license = request.get("license", "?")
-            self.likes = request.get("likes", 0)
-            self.num_params = request.get("params", 0)
-            self.date = request.get("submitted_time", "")
-        except Exception:
-            print(f"Could not find request file for {self.org}/{self.model} with precision {self.precision.value.name}")
-
-    def to_dict(self):
-        """Converts the Eval Result to a dict compatible with our dataframe display"""
-        average = sum([v for v in self.results.values() if v is not None]) / len(Tasks)
-        data_dict = {
-            "eval_name": self.eval_name,  # not a column, just a save name,
-            AutoEvalColumn.precision.name: self.precision.value.name,
-            AutoEvalColumn.model_type.name: self.model_type.value.name,
-            AutoEvalColumn.model_type_symbol.name: self.model_type.value.symbol,
-            AutoEvalColumn.weight_type.name: self.weight_type.value.name,
-            AutoEvalColumn.architecture.name: self.architecture,
-            AutoEvalColumn.model.name: make_clickable_model(self.full_model),
-            AutoEvalColumn.revision.name: self.revision,
-            AutoEvalColumn.average.name: average,
-            AutoEvalColumn.license.name: self.license,
-            AutoEvalColumn.likes.name: self.likes,
-            AutoEvalColumn.params.name: self.num_params,
-            AutoEvalColumn.still_on_hub.name: self.still_on_hub,
-        }
-
-        for task in Tasks:
-            data_dict[task.value.col_name] = self.results[task.value.benchmark]
-
-        return data_dict
-
-
-def get_request_file_for_model(requests_path, model_name, precision):
-    """Selects the correct request file for a given model. Only keeps runs tagged as FINISHED"""
-    request_files = os.path.join(
-        requests_path,
-        f"{model_name}_eval_request_*.json",
-    )
-    request_files = glob.glob(request_files)
-
-    # Select correct request file (precision)
-    request_file = ""
-    request_files = sorted(request_files, reverse=True)
-    for tmp_request_file in request_files:
-        with open(tmp_request_file, "r") as f:
-            req_content = json.load(f)
-            if (
-                req_content["status"] in ["FINISHED"]
-                and req_content["precision"] == precision.split(".")[-1]
-            ):
-                request_file = tmp_request_file
-    return request_file
-
-
-def get_raw_eval_results(results_path: str, requests_path: str) -> list[EvalResult]:
-    """From the path of the results folder root, extract all needed info for results"""
-    model_result_filepaths = []
-
-    for root, _, files in os.walk(results_path):
-        # We should only have json files in model results
-        if len(files) == 0 or any([not f.endswith(".json") for f in files]):
-            continue
-
-        # Sort the files by date
-        try:
-            files.sort(key=lambda x: x.removesuffix(".json").removeprefix("results_")[:-7])
-        except dateutil.parser._parser.ParserError:
-            files = [files[-1]]
-
-        for file in files:
-            model_result_filepaths.append(os.path.join(root, file))
-
-    eval_results = {}
-    for model_result_filepath in model_result_filepaths:
-        # Creation of result
-        eval_result = EvalResult.init_from_json_file(model_result_filepath)
-        eval_result.update_with_request_file(requests_path)
-
-        # Store results of same eval together
-        eval_name = eval_result.eval_name
-        if eval_name in eval_results.keys():
-            eval_results[eval_name].results.update({k: v for k, v in eval_result.results.items() if v is not None})
-        else:
-            eval_results[eval_name] = eval_result
-
-    results = []
-    for v in eval_results.values():
-        try:
-            v.to_dict() # we test if the dict version is complete
-            results.append(v)
-        except KeyError:  # not all eval values present
-            continue
-
-    return results

src/populate.py

@@ -1,58 +0,0 @@
-import json
-import os
-
-import pandas as pd
-
-from src.display.formatting import has_no_nan_values, make_clickable_model
-from src.display.utils import AutoEvalColumn, EvalQueueColumn
-from src.leaderboard.read_evals import get_raw_eval_results
-
-
-def get_leaderboard_df(results_path: str, requests_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, requests_path)
-    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)
-
-    # filter out if any of the benchmarks have not been produced
-    df = df[has_no_nan_values(df, benchmark_cols)]
-    return df
-
-
-def get_evaluation_queue_df(save_path: str, cols: list) -> list[pd.DataFrame]:
-    """Creates the different dataframes for the evaluation queues requestes"""
-    entries = [entry for entry in os.listdir(save_path) if not entry.startswith(".")]
-    all_evals = []
-
-    for entry in entries:
-        if ".json" in entry:
-            file_path = os.path.join(save_path, entry)
-            with open(file_path) as fp:
-                data = json.load(fp)
-
-            data[EvalQueueColumn.model.name] = make_clickable_model(data["model"])
-            data[EvalQueueColumn.revision.name] = data.get("revision", "main")
-
-            all_evals.append(data)
-        elif ".md" not in entry:
-            # this is a folder
-            sub_entries = [e for e in os.listdir(f"{save_path}/{entry}") if os.path.isfile(e) and not e.startswith(".")]
-            for sub_entry in sub_entries:
-                file_path = os.path.join(save_path, entry, sub_entry)
-                with open(file_path) as fp:
-                    data = json.load(fp)
-
-                data[EvalQueueColumn.model.name] = make_clickable_model(data["model"])
-                data[EvalQueueColumn.revision.name] = data.get("revision", "main")
-                all_evals.append(data)
-
-    pending_list = [e for e in all_evals if e["status"] in ["PENDING", "RERUN"]]
-    running_list = [e for e in all_evals if e["status"] == "RUNNING"]
-    finished_list = [e for e in all_evals if e["status"].startswith("FINISHED") or e["status"] == "PENDING_NEW_EVAL"]
-    df_pending = pd.DataFrame.from_records(pending_list, columns=cols)
-    df_running = pd.DataFrame.from_records(running_list, columns=cols)
-    df_finished = pd.DataFrame.from_records(finished_list, columns=cols)
-    return df_finished[cols], df_running[cols], df_pending[cols]

src/submission/check_validity.py

@@ -1,99 +0,0 @@
-import json
-import os
-import re
-from collections import defaultdict
-from datetime import datetime, timedelta, timezone
-
-import huggingface_hub
-from huggingface_hub import ModelCard
-from huggingface_hub.hf_api import ModelInfo
-from transformers import AutoConfig
-from transformers.models.auto.tokenization_auto import AutoTokenizer
-
-def check_model_card(repo_id: str) -> tuple[bool, str]:
-    """Checks if the model card and license exist and have been filled"""
-    try:
-        card = ModelCard.load(repo_id)
-    except huggingface_hub.utils.EntryNotFoundError:
-        return False, "Please add a model card to your model to explain how you trained/fine-tuned it."
-
-    # Enforce license metadata
-    if card.data.license is None:
-        if not ("license_name" in card.data and "license_link" in card.data):
-            return False, (
-                "License not found. Please add a license to your model card using the `license` metadata or a"
-                " `license_name`/`license_link` pair."
-            )
-
-    # Enforce card content
-    if len(card.text) < 200:
-        return False, "Please add a description to your model card, it is too short."
-
-    return True, ""
-
-def is_model_on_hub(model_name: str, revision: str, token: str = None, trust_remote_code=False, test_tokenizer=False) -> tuple[bool, str]:
-    """Checks if the model model_name is on the hub, and whether it (and its tokenizer) can be loaded with AutoClasses."""
-    try:
-        config = AutoConfig.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token)
-        if test_tokenizer:
-            try:
-                tk = AutoTokenizer.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token)
-            except ValueError as e:
-                return (
-                    False,
-                    f"uses a tokenizer which is not in a transformers release: {e}",
-                    None
-                )
-            except Exception as e:
-                return (False, "'s tokenizer cannot be loaded. Is your tokenizer class in a stable transformers release, and correctly configured?", None)
-        return True, None, config
-
-    except ValueError:
-        return (
-            False,
-            "needs to be launched with `trust_remote_code=True`. For safety reason, we do not allow these models to be automatically submitted to the leaderboard.",
-            None
-        )
-
-    except Exception as e:
-        return False, "was not found on hub!", None
-
-
-def get_model_size(model_info: ModelInfo, precision: str):
-    """Gets the model size from the configuration, or the model name if the configuration does not contain the information."""
-    try:
-        model_size = round(model_info.safetensors["total"] / 1e9, 3)
-    except (AttributeError, TypeError):
-        return 0  # Unknown model sizes are indicated as 0, see NUMERIC_INTERVALS in app.py
-
-    size_factor = 8 if (precision == "GPTQ" or "gptq" in model_info.modelId.lower()) else 1
-    model_size = size_factor * model_size
-    return model_size
-
-def get_model_arch(model_info: ModelInfo):
-    """Gets the model architecture from the configuration"""
-    return model_info.config.get("architectures", "Unknown")
-
-def already_submitted_models(requested_models_dir: str) -> set[str]:
-    """Gather a list of already submitted models to avoid duplicates"""
-    depth = 1
-    file_names = []
-    users_to_submission_dates = defaultdict(list)
-
-    for root, _, files in os.walk(requested_models_dir):
-        current_depth = root.count(os.sep) - requested_models_dir.count(os.sep)
-        if current_depth == depth:
-            for file in files:
-                if not file.endswith(".json"):
-                    continue
-                with open(os.path.join(root, file), "r") as f:
-                    info = json.load(f)
-                    file_names.append(f"{info['model']}_{info['revision']}_{info['precision']}")
-
-                    # Select organisation
-                    if info["model"].count("/") == 0 or "submitted_time" not in info:
-                        continue
-                    organisation, _ = info["model"].split("/")
-                    users_to_submission_dates[organisation].append(info["submitted_time"])
-
-    return set(file_names), users_to_submission_dates

src/submission/submit.py

@@ -1,119 +0,0 @@
-import json
-import os
-from datetime import datetime, timezone
-
-from src.display.formatting import styled_error, styled_message, styled_warning
-from src.envs import API, EVAL_REQUESTS_PATH, TOKEN, QUEUE_REPO
-from src.submission.check_validity import (
-    already_submitted_models,
-    check_model_card,
-    get_model_size,
-    is_model_on_hub,
-)
-
-REQUESTED_MODELS = None
-USERS_TO_SUBMISSION_DATES = None
-
-def add_new_eval(
-    model: str,
-    base_model: str,
-    revision: str,
-    precision: str,
-    weight_type: str,
-    model_type: str,
-):
-    global REQUESTED_MODELS
-    global USERS_TO_SUBMISSION_DATES
-    if not REQUESTED_MODELS:
-        REQUESTED_MODELS, USERS_TO_SUBMISSION_DATES = already_submitted_models(EVAL_REQUESTS_PATH)
-
-    user_name = ""
-    model_path = model
-    if "/" in model:
-        user_name = model.split("/")[0]
-        model_path = model.split("/")[1]
-
-    precision = precision.split(" ")[0]
-    current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-    if model_type is None or model_type == "":
-        return styled_error("Please select a model type.")
-
-    # Does the model actually exist?
-    if revision == "":
-        revision = "main"
-
-    # Is the model on the hub?
-    if weight_type in ["Delta", "Adapter"]:
-        base_model_on_hub, error, _ = is_model_on_hub(model_name=base_model, revision=revision, token=TOKEN, test_tokenizer=True)
-        if not base_model_on_hub:
-            return styled_error(f'Base model "{base_model}" {error}')
-
-    if not weight_type == "Adapter":
-        model_on_hub, error, _ = is_model_on_hub(model_name=model, revision=revision, token=TOKEN, test_tokenizer=True)
-        if not model_on_hub:
-            return styled_error(f'Model "{model}" {error}')
-
-    # Is the model info correctly filled?
-    try:
-        model_info = API.model_info(repo_id=model, revision=revision)
-    except Exception:
-        return styled_error("Could not get your model information. Please fill it up properly.")
-
-    model_size = get_model_size(model_info=model_info, precision=precision)
-
-    # Were the model card and license filled?
-    try:
-        license = model_info.cardData["license"]
-    except Exception:
-        return styled_error("Please select a license for your model")
-
-    modelcard_OK, error_msg = check_model_card(model)
-    if not modelcard_OK:
-        return styled_error(error_msg)
-
-    # Seems good, creating the eval
-    print("Adding new eval")
-
-    eval_entry = {
-        "model": model,
-        "base_model": base_model,
-        "revision": revision,
-        "precision": precision,
-        "weight_type": weight_type,
-        "status": "PENDING",
-        "submitted_time": current_time,
-        "model_type": model_type,
-        "likes": model_info.likes,
-        "params": model_size,
-        "license": license,
-        "private": False,
-    }
-
-    # Check for duplicate submission
-    if f"{model}_{revision}_{precision}" in REQUESTED_MODELS:
-        return styled_warning("This model has been already submitted.")
-
-    print("Creating eval file")
-    OUT_DIR = f"{EVAL_REQUESTS_PATH}/{user_name}"
-    os.makedirs(OUT_DIR, exist_ok=True)
-    out_path = f"{OUT_DIR}/{model_path}_eval_request_False_{precision}_{weight_type}.json"
-
-    with open(out_path, "w") as f:
-        f.write(json.dumps(eval_entry))
-
-    print("Uploading eval file")
-    API.upload_file(
-        path_or_fileobj=out_path,
-        path_in_repo=out_path.split("eval-queue/")[1],
-        repo_id=QUEUE_REPO,
-        repo_type="dataset",
-        commit_message=f"Add {model} to eval queue",
-    )
-
-    # Remove the local file
-    os.remove(out_path)
-
-    return styled_message(
-        "Your request has been submitted to the evaluation queue!\nPlease wait for up to an hour for the model to show in the PENDING list."
-    )