search-fix

.gitattributes

@@ -33,4 +33,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 scale-hf-logo.png filter=lfs diff=lfs merge=lfs -text
-gif.gif filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,22 +1,15 @@
+auto_evals/
 venv/
-.venv/
 __pycache__/
 .env
 .ipynb_checkpoints
 *ipynb
 .vscode/
-.DS_Store
-.ruff_cache/
-.python-version
-.profile_app.python
-*pstats
-*.lock
 
+gpt_4_evals/
+human_evals/
 eval-queue/
 eval-results/
-dynamic-info/
-downloads/
-model-votes/
-open-llm-leaderboard___contents/
+auto_evals/
 
 src/assets/model_counts.html

Makefile

@@ -1,18 +1,13 @@
-.PHONY: style format quality all
+.PHONY: style format
+
 
-# Applies code style fixes to the specified file or directory
 style:
-	@echo "Applying style fixes to $(file)"
-	ruff format $(file)
-	ruff check --fix $(file) --line-length 119
+	python -m black --line-length 119 .
+	python -m isort .
+	ruff check --fix .
 
-# Checks code quality for the specified file or directory
-quality:
-	@echo "Checking code quality for $(file)"
-	ruff check $(file) --line-length 119
 
-# Applies PEP8 formatting and checks the entire codebase
-all:
-	@echo "Formatting and checking the entire codebase"
-	ruff format .
-	ruff check --fix . --line-length 119
+quality:
+	python -m black --check --line-length 119 .
+	python -m isort --check-only .
+	ruff check .

README.md

@@ -1,25 +1,14 @@
 ---
-title: Open LLM Leaderboard 2
+title: Open LLM Leaderboard
 emoji: 🏆
 colorFrom: green
 colorTo: indigo
 sdk: gradio
-sdk_version: 4.36.1
+sdk_version: 3.43.2
 app_file: app.py
 pinned: true
 license: apache-2.0
-duplicated_from: open-llm-leaderboard/open_llm_leaderboard
-fullWidth: true
-startup_duration_timeout: 1h
-hf_oauth: true
-space_ci:
-  private: true
-  secrets:
-  - HF_TOKEN
-  - WEBHOOK_SECRET
-tags:
-- leaderboard
-short_description: Track, rank and evaluate open LLMs and chatbots
+duplicated_from: HuggingFaceH4/open_llm_leaderboard
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,328 +1,582 @@
+import json
 import os
-import logging
-import time
-import schedule
-import datetime
+from datetime import datetime, timezone
+
 import gradio as gr
-from threading import Thread
-import datasets
-from huggingface_hub import snapshot_download, WebhooksServer, WebhookPayload, RepoCard
-from gradio_leaderboard import Leaderboard, ColumnFilter, SelectColumns
+import pandas as pd
 from apscheduler.schedulers.background import BackgroundScheduler
+from huggingface_hub import HfApi
 
-# Start ephemeral Spaces on PRs (see config in README.md)
-from gradio_space_ci.webhook import IS_EPHEMERAL_SPACE, SPACE_ID, configure_space_ci
-
-from src.display.about import (
+from src.assets.css_html_js import custom_css, get_window_url_params
+from src.assets.text_content import (
     CITATION_BUTTON_LABEL,
     CITATION_BUTTON_TEXT,
     EVALUATION_QUEUE_TEXT,
-    FAQ_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,
+from src.display_models.get_model_metadata import DO_NOT_SUBMIT_MODELS, ModelType
+from src.display_models.modelcard_filter import check_model_card
+from src.display_models.utils import (
     AutoEvalColumn,
-    ModelType,
-    Precision,
-    WeightType,
+    EvalQueueColumn,
     fields,
-    EvalQueueColumn
+    styled_error,
+    styled_message,
+    styled_warning,
 )
-from src.envs import (
-    API,
-    EVAL_REQUESTS_PATH,
-    AGGREGATED_REPO,
-    HF_TOKEN,
-    QUEUE_REPO,
-    REPO_ID,
-    VOTES_REPO,
-    VOTES_PATH,
-    HF_HOME,
-)
-from src.populate import get_evaluation_queue_df, get_leaderboard_df
-from src.submission.submit import add_new_eval
-from src.tools.plots import create_metric_plot_obj, create_plot_df, create_scores_df
-from src.voting.vote_system import VoteManager, run_scheduler
+from src.load_from_hub import get_evaluation_queue_df, get_leaderboard_df, is_model_on_hub, load_all_info_from_hub
+from src.rate_limiting import user_submission_permission
+
+pd.set_option("display.precision", 1)
+
+# clone / pull the lmeh eval data
+H4_TOKEN = os.environ.get("H4_TOKEN", None)
+
+QUEUE_REPO = "open-llm-leaderboard/requests"
+RESULTS_REPO = "open-llm-leaderboard/results"
+
+PRIVATE_QUEUE_REPO = "open-llm-leaderboard/private-requests"
+PRIVATE_RESULTS_REPO = "open-llm-leaderboard/private-results"
+
+IS_PUBLIC = bool(os.environ.get("IS_PUBLIC", True))
 
-# Configure logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+EVAL_REQUESTS_PATH = "eval-queue"
+EVAL_RESULTS_PATH = "eval-results"
 
-# Start ephemeral Spaces on PRs (see config in README.md)
-from gradio_space_ci.webhook import IS_EPHEMERAL_SPACE, SPACE_ID, configure_space_ci
+EVAL_REQUESTS_PATH_PRIVATE = "eval-queue-private"
+EVAL_RESULTS_PATH_PRIVATE = "eval-results-private"
+
+api = HfApi(token=H4_TOKEN)
 
-# Convert the environment variable "LEADERBOARD_FULL_INIT" to a boolean value, defaulting to True if the variable is not set.
-# This controls whether a full initialization should be performed.
-DO_FULL_INIT = True # os.getenv("LEADERBOARD_FULL_INIT", "True") == "True"
-NEW_DATA_ON_LEADERBOARD = True
-LEADERBOARD_DF = None
 
 def restart_space():
-    API.restart_space(repo_id=REPO_ID, token=HF_TOKEN)
-
-
-def time_diff_wrapper(func):
-    def wrapper(*args, **kwargs):
-        start_time = time.time()
-        result = func(*args, **kwargs)
-        end_time = time.time()
-        diff = end_time - start_time
-        logging.info(f"Time taken for {func.__name__}: {diff} seconds")
-        return result
-
-    return wrapper
-
-
-@time_diff_wrapper
-def download_dataset(repo_id, local_dir, repo_type="dataset", max_attempts=3, backoff_factor=1.5):
-    """Download dataset with exponential backoff retries."""
-    attempt = 0
-    while attempt < max_attempts:
-        try:
-            logging.info(f"Downloading {repo_id} to {local_dir}")
-            snapshot_download(
-                repo_id=repo_id,
-                local_dir=local_dir,
-                repo_type=repo_type,
-                tqdm_class=None,
-                etag_timeout=30,
-                max_workers=8,
-            )
-            logging.info("Download successful")
-            return
-        except Exception as e:
-            wait_time = backoff_factor**attempt
-            logging.error(f"Error downloading {repo_id}: {e}, retrying in {wait_time}s")
-            time.sleep(wait_time)
-            attempt += 1
-    raise Exception(f"Failed to download {repo_id} after {max_attempts} attempts")
-
-def get_latest_data_leaderboard(leaderboard_initial_df = None):
-    global NEW_DATA_ON_LEADERBOARD
-    global LEADERBOARD_DF
-    if NEW_DATA_ON_LEADERBOARD:
-        print("Leaderboard updated at reload!")
-        leaderboard_dataset = datasets.load_dataset(
-            AGGREGATED_REPO, 
-            "default", 
-            split="train", 
-            cache_dir=HF_HOME, 
-            download_mode=datasets.DownloadMode.REUSE_DATASET_IF_EXISTS, # Uses the cached dataset 
-            verification_mode="no_checks"
-        )
-        LEADERBOARD_DF = get_leaderboard_df(
-            leaderboard_dataset=leaderboard_dataset, 
-            cols=COLS,
-            benchmark_cols=BENCHMARK_COLS,
+    api.restart_space(repo_id="HuggingFaceH4/open_llm_leaderboard", token=H4_TOKEN)
+
+
+# Rate limit variables
+RATE_LIMIT_PERIOD = 7
+RATE_LIMIT_QUOTA = 5
+
+# Column selection
+COLS = [c.name for c in fields(AutoEvalColumn) if not c.hidden]
+TYPES = [c.type for c in fields(AutoEvalColumn) if not c.hidden]
+COLS_LITE = [c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden]
+TYPES_LITE = [c.type for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden]
+
+if not IS_PUBLIC:
+    COLS.insert(2, AutoEvalColumn.precision.name)
+    TYPES.insert(2, AutoEvalColumn.precision.type)
+
+EVAL_COLS = [c.name for c in fields(EvalQueueColumn)]
+EVAL_TYPES = [c.type for c in fields(EvalQueueColumn)]
+
+BENCHMARK_COLS = [
+    c.name
+    for c in [
+        AutoEvalColumn.arc,
+        AutoEvalColumn.hellaswag,
+        AutoEvalColumn.mmlu,
+        AutoEvalColumn.truthfulqa,
+    ]
+]
+
+## LOAD INFO FROM HUB
+eval_queue, requested_models, eval_results, users_to_submission_dates = load_all_info_from_hub(
+    QUEUE_REPO, RESULTS_REPO, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH
+)
+
+if not IS_PUBLIC:
+    (eval_queue_private, requested_models_private, eval_results_private, _) = load_all_info_from_hub(
+        PRIVATE_QUEUE_REPO,
+        PRIVATE_RESULTS_REPO,
+        EVAL_REQUESTS_PATH_PRIVATE,
+        EVAL_RESULTS_PATH_PRIVATE,
+    )
+else:
+    eval_queue_private, eval_results_private = None, None
+
+original_df = get_leaderboard_df(eval_results, eval_results_private, COLS, BENCHMARK_COLS)
+models = original_df["model_name_for_query"].tolist()  # needed for model backlinks in their to the leaderboard
+
+to_be_dumped = f"models = {repr(models)}\n"
+
+leaderboard_df = original_df.copy()
+(
+    finished_eval_queue_df,
+    running_eval_queue_df,
+    pending_eval_queue_df,
+) = get_evaluation_queue_df(eval_queue, eval_queue_private, EVAL_REQUESTS_PATH, EVAL_COLS)
+
+
+## INTERACTION FUNCTIONS
+def add_new_eval(
+    model: str,
+    base_model: str,
+    revision: str,
+    precision: str,
+    private: bool,
+    weight_type: str,
+    model_type: str,
+):
+    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.")
+
+    # Is the user rate limited?
+    num_models_submitted_in_period = user_submission_permission(model, users_to_submission_dates, RATE_LIMIT_PERIOD)
+    if num_models_submitted_in_period > RATE_LIMIT_QUOTA:
+        error_msg = f"Organisation or user `{model.split('/')[0]}`"
+        error_msg += f"already has {num_models_submitted_in_period} model requests submitted to the leaderboard "
+        error_msg += f"in the last {RATE_LIMIT_PERIOD} days.\n"
+        error_msg += (
+            "Please wait a couple of days before resubmitting, so that everybody can enjoy using the leaderboard 🤗"
         )
-        NEW_DATA_ON_LEADERBOARD = False
+        return styled_error(error_msg)
+
+    # Did the model authors forbid its submission to the leaderboard?
+    if model in DO_NOT_SUBMIT_MODELS or base_model in DO_NOT_SUBMIT_MODELS:
+        return styled_warning("Model authors have requested that their model be not submitted on the leaderboard.")
+
+    # Does the model actually exist?
+    if revision == "":
+        revision = "main"
+
+    if weight_type in ["Delta", "Adapter"]:
+        base_model_on_hub, error = is_model_on_hub(base_model, revision)
+        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, revision)
+        if not model_on_hub:
+            return styled_error(f'Model "{model}" {error}')
+
+    # Were the model card and license filled?
+    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,
+        "private": private,
+        "precision": precision,
+        "weight_type": weight_type,
+        "status": "PENDING",
+        "submitted_time": current_time,
+        "model_type": model_type,
+    }
+
+    user_name = ""
+    model_path = model
+    if "/" in model:
+        user_name = model.split("/")[0]
+        model_path = model.split("/")[1]
+
+    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_{private}_{precision}_{weight_type}.json"
+
+    # Check for duplicate submission
+    if f"{model}_{revision}_{precision}" in requested_models:
+        return styled_warning("This model has been already submitted.")
+
+    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",
+    )
 
-    else:
-        LEADERBOARD_DF = leaderboard_initial_df
-
-    return LEADERBOARD_DF
-
-
-def get_latest_data_queue():
-    eval_queue_dfs = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
-    return eval_queue_dfs
-
-def init_space():
-    """Initializes the application space, loading only necessary data."""
-    if DO_FULL_INIT:
-        # These downloads only occur on full initialization
-        try:
-            download_dataset(QUEUE_REPO, EVAL_REQUESTS_PATH)
-            download_dataset(VOTES_REPO, VOTES_PATH)
-        except Exception:
-            restart_space()
-
-    # Always redownload the leaderboard DataFrame
-    global LEADERBOARD_DF
-    LEADERBOARD_DF = get_latest_data_leaderboard()
-
-    # Evaluation queue DataFrame retrieval is independent of initialization detail level
-    eval_queue_dfs = get_latest_data_queue()
-
-    return LEADERBOARD_DF, eval_queue_dfs
-
-# Initialize VoteManager
-vote_manager = VoteManager(VOTES_PATH, EVAL_REQUESTS_PATH, VOTES_REPO)
-
-
-# Schedule the upload_votes method to run every 15 minutes
-schedule.every(15).minutes.do(vote_manager.upload_votes)
-
-# Start the scheduler in a separate thread
-scheduler_thread = Thread(target=run_scheduler, args=(vote_manager,), daemon=True)
-scheduler_thread.start()
-
-# Calls the init_space function with the `full_init` parameter determined by the `do_full_init` variable.
-# This initializes various DataFrames used throughout the application, with the level of initialization detail controlled by the `do_full_init` flag.
-LEADERBOARD_DF, eval_queue_dfs = init_space()
-finished_eval_queue_df, running_eval_queue_df, pending_eval_queue_df = eval_queue_dfs
-
-
-# Data processing for plots now only on demand in the respective Gradio tab
-def load_and_create_plots():
-    plot_df = create_plot_df(create_scores_df(LEADERBOARD_DF))
-    return plot_df
-
-# Function to check if a user is logged in
-def check_login(profile: gr.OAuthProfile | None) -> bool:
-    if profile is None:
-        return False
-    return True
-
-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 or c.dummy],
-            label="Select Columns to Display:",
-        ),
-        search_columns=[AutoEvalColumn.model.name, AutoEvalColumn.fullname.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
-            ),
-            ColumnFilter(
-                AutoEvalColumn.merged.name, type="boolean", label="Merge/MoErge", default=True
-            ),
-            ColumnFilter(AutoEvalColumn.moe.name, type="boolean", label="MoE", default=False),
-            ColumnFilter(AutoEvalColumn.not_flagged.name, type="boolean", label="Flagged", default=True),
-            ColumnFilter(AutoEvalColumn.maintainers_highlight.name, type="boolean", label="Show only maintainer's highlight", default=False),
-        ],
-        bool_checkboxgroup_label="Hide models",
-        interactive=False,
+    # 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."
     )
 
-main_block = gr.Blocks(css=custom_css)
-with main_block:
-    with gr.Row(elem_id="header-row"):
-        gr.HTML(TITLE)
-    
+
+# Basics
+def change_tab(query_param: str):
+    query_param = query_param.replace("'", '"')
+    query_param = json.loads(query_param)
+
+    if isinstance(query_param, dict) and "tab" in query_param and query_param["tab"] == "evaluation":
+        return gr.Tabs.update(selected=1)
+    else:
+        return gr.Tabs.update(selected=0)
+
+
+# Searching and filtering
+def update_table(
+    hidden_df: pd.DataFrame,
+    current_columns_df: pd.DataFrame,
+    columns: list,
+    type_query: list,
+    precision_query: str,
+    size_query: list,
+    show_deleted: bool,
+    query: str,
+):
+    filtered_df = filter_models(hidden_df, type_query, size_query, precision_query, show_deleted)
+    final_df = []
+    if query != "":
+        queries = query.split(";")
+        for _q in queries:
+            if _q != "":
+                temp_filtered_df = search_table(filtered_df, _q)
+                if len(temp_filtered_df) > 0:
+                    final_df.append(temp_filtered_df)
+        if len(final_df) > 0:
+            filtered_df = pd.concat(final_df).drop_duplicates()
+    df = select_columns(filtered_df, columns)
+    return df
+
+
+def search_table(df: pd.DataFrame, query: str) -> pd.DataFrame:
+    return df[(df[AutoEvalColumn.dummy.name].str.contains(query, case=False))]
+
+
+def select_columns(df: pd.DataFrame, columns: list) -> pd.DataFrame:
+    always_here_cols = [
+        AutoEvalColumn.model_type_symbol.name,
+        AutoEvalColumn.model.name,
+    ]
+    # We use COLS to maintain sorting
+    filtered_df = df[
+        always_here_cols + [c for c in COLS if c in df.columns and c in columns] + [AutoEvalColumn.dummy.name]
+    ]
+    return filtered_df
+
+
+NUMERIC_INTERVALS = {
+    "Unknown": pd.Interval(-1, 0, closed="right"),
+    "< 1.5B": pd.Interval(0, 1.5, closed="right"),
+    "~3B": pd.Interval(1.5, 5, closed="right"),
+    "~7B": pd.Interval(6, 11, closed="right"),
+    "~13B": pd.Interval(12, 15, closed="right"),
+    "~35B": pd.Interval(16, 55, closed="right"),
+    "60B+": pd.Interval(55, 10000, closed="right"),
+}
+
+
+def filter_models(
+    df: pd.DataFrame, type_query: list, size_query: list, precision_query: list, show_deleted: bool
+) -> pd.DataFrame:
+    # Show all models
+    if show_deleted:
+        filtered_df = df
+    else:  # Show only still on the hub models
+        filtered_df = df[df[AutoEvalColumn.still_on_hub.name] == True]
+
+    type_emoji = [t[0] for t in type_query]
+    filtered_df = filtered_df[df[AutoEvalColumn.model_type_symbol.name].isin(type_emoji)]
+    filtered_df = filtered_df[df[AutoEvalColumn.precision.name].isin(precision_query + ["None"])]
+
+    numeric_interval = pd.IntervalIndex(sorted([NUMERIC_INTERVALS[s] for s in size_query]))
+    params_column = pd.to_numeric(df[AutoEvalColumn.params.name], errors="coerce")
+    mask = params_column.apply(lambda x: any(numeric_interval.contains(x)))
+    filtered_df = filtered_df.loc[mask]
+
+    return filtered_df
+
+
+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.Row():
+                with gr.Column():
+                    with gr.Row():
+                        search_bar = gr.Textbox(
+                            placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
+                            show_label=False,
+                            elem_id="search-bar",
+                        )
+                    with gr.Row():
+                        shown_columns = gr.CheckboxGroup(
+                            choices=[
+                                c
+                                for c in COLS
+                                if c
+                                not in [
+                                    AutoEvalColumn.dummy.name,
+                                    AutoEvalColumn.model.name,
+                                    AutoEvalColumn.model_type_symbol.name,
+                                    AutoEvalColumn.still_on_hub.name,
+                                ]
+                            ],
+                            value=[
+                                c
+                                for c in COLS_LITE
+                                if c
+                                not in [
+                                    AutoEvalColumn.dummy.name,
+                                    AutoEvalColumn.model.name,
+                                    AutoEvalColumn.model_type_symbol.name,
+                                    AutoEvalColumn.still_on_hub.name,
+                                ]
+                            ],
+                            label="Select columns to show",
+                            elem_id="column-select",
+                            interactive=True,
+                        )
+                    with gr.Row():
+                        deleted_models_visibility = gr.Checkbox(
+                            value=True, label="Show gated/private/deleted models", interactive=True
+                        )
+                with gr.Column(min_width=320):
+                    with gr.Box(elem_id="box-filter"):
+                        filter_columns_type = gr.CheckboxGroup(
+                            label="Model types",
+                            choices=[
+                                ModelType.PT.to_str(),
+                                ModelType.FT.to_str(),
+                                ModelType.IFT.to_str(),
+                                ModelType.RL.to_str(),
+                                ModelType.Unknown.to_str(),
+                            ],
+                            value=[
+                                ModelType.PT.to_str(),
+                                ModelType.FT.to_str(),
+                                ModelType.IFT.to_str(),
+                                ModelType.RL.to_str(),
+                                ModelType.Unknown.to_str(),
+                            ],
+                            interactive=True,
+                            elem_id="filter-columns-type",
+                        )
+                        filter_columns_precision = gr.CheckboxGroup(
+                            label="Precision",
+                            choices=["torch.float16", "torch.bfloat16", "torch.float32", "8bit", "4bit", "GPTQ"],
+                            value=["torch.float16", "torch.bfloat16", "torch.float32", "8bit", "4bit", "GPTQ"],
+                            interactive=True,
+                            elem_id="filter-columns-precision",
+                        )
+                        filter_columns_size = gr.CheckboxGroup(
+                            label="Model sizes",
+                            choices=list(NUMERIC_INTERVALS.keys()),
+                            value=list(NUMERIC_INTERVALS.keys()),
+                            interactive=True,
+                            elem_id="filter-columns-size",
+                        )
 
-        with gr.TabItem("🚀 Submit ", elem_id="llm-benchmark-tab-table", id=5):
+            leaderboard_table = gr.components.Dataframe(
+                value=leaderboard_df[
+                    [AutoEvalColumn.model_type_symbol.name, AutoEvalColumn.model.name]
+                    + shown_columns.value
+                    + [AutoEvalColumn.dummy.name]
+                ],
+                headers=[
+                    AutoEvalColumn.model_type_symbol.name,
+                    AutoEvalColumn.model.name,
+                ]
+                + shown_columns.value
+                + [AutoEvalColumn.dummy.name],
+                datatype=TYPES,
+                max_rows=None,
+                elem_id="leaderboard-table",
+                interactive=False,
+                visible=True,
+            )
+
+            # Dummy leaderboard for handling the case when the user uses backspace key
+            hidden_leaderboard_table_for_search = gr.components.Dataframe(
+                value=original_df,
+                headers=COLS,
+                datatype=TYPES,
+                max_rows=None,
+                visible=False,
+            )
+            search_bar.submit(
+                update_table,
+                [
+                    hidden_leaderboard_table_for_search,
+                    leaderboard_table,
+                    shown_columns,
+                    filter_columns_type,
+                    filter_columns_precision,
+                    filter_columns_size,
+                    deleted_models_visibility,
+                    search_bar,
+                ],
+                leaderboard_table,
+            )
+            shown_columns.change(
+                update_table,
+                [
+                    hidden_leaderboard_table_for_search,
+                    leaderboard_table,
+                    shown_columns,
+                    filter_columns_type,
+                    filter_columns_precision,
+                    filter_columns_size,
+                    deleted_models_visibility,
+                    search_bar,
+                ],
+                leaderboard_table,
+                queue=True,
+            )
+            filter_columns_type.change(
+                update_table,
+                [
+                    hidden_leaderboard_table_for_search,
+                    leaderboard_table,
+                    shown_columns,
+                    filter_columns_type,
+                    filter_columns_precision,
+                    filter_columns_size,
+                    deleted_models_visibility,
+                    search_bar,
+                ],
+                leaderboard_table,
+                queue=True,
+            )
+            filter_columns_precision.change(
+                update_table,
+                [
+                    hidden_leaderboard_table_for_search,
+                    leaderboard_table,
+                    shown_columns,
+                    filter_columns_type,
+                    filter_columns_precision,
+                    filter_columns_size,
+                    deleted_models_visibility,
+                    search_bar,
+                ],
+                leaderboard_table,
+                queue=True,
+            )
+            filter_columns_size.change(
+                update_table,
+                [
+                    hidden_leaderboard_table_for_search,
+                    leaderboard_table,
+                    shown_columns,
+                    filter_columns_type,
+                    filter_columns_precision,
+                    filter_columns_size,
+                    deleted_models_visibility,
+                    search_bar,
+                ],
+                leaderboard_table,
+                queue=True,
+            )
+            deleted_models_visibility.change(
+                update_table,
+                [
+                    hidden_leaderboard_table_for_search,
+                    leaderboard_table,
+                    shown_columns,
+                    filter_columns_type,
+                    filter_columns_precision,
+                    filter_columns_size,
+                    deleted_models_visibility,
+                    search_bar,
+                ],
+                leaderboard_table,
+                queue=True,
+            )
+        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,
+                                max_rows=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,
+                                max_rows=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,
+                                max_rows=5,
+                            )
             with gr.Row():
                 gr.Markdown("# ✉️✨ Submit your model here!", elem_classes="markdown-text")
 
             with gr.Row():
                 with gr.Column():
                     model_name_textbox = gr.Textbox(label="Model name")
-                    revision_name_textbox = gr.Textbox(label="Revision commit", placeholder="latest")
-                    with gr.Row():
-                        model_type = gr.Dropdown(
-                            choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
-                            label="Model type",
-                            multiselect=False,
-                            value=ModelType.FT.to_str(" : "),
-                            interactive=True,
-                        )
-                        chat_template_toggle = gr.Checkbox(
-                            label="Use chat template", 
-                            value=False,
-                            info="Is your model a chat model?",
-                        )
+                    revision_name_textbox = gr.Textbox(label="revision", placeholder="main")
+                    private = gr.Checkbox(False, label="Private", visible=not IS_PUBLIC)
+                    model_type = gr.Dropdown(
+                        choices=[
+                            ModelType.PT.to_str(" : "),
+                            ModelType.FT.to_str(" : "),
+                            ModelType.IFT.to_str(" : "),
+                            ModelType.RL.to_str(" : "),
+                        ],
+                        label="Model type",
+                        multiselect=False,
+                        value=None,
+                        interactive=True,
+                    )
 
                 with gr.Column():
                     precision = gr.Dropdown(
-                        choices=[i.value.name for i in Precision if i != Precision.Unknown],
+                        choices=["float16", "bfloat16", "8bit (LLM.int8)", "4bit (QLoRA / FP4)", "GPTQ"],
                         label="Precision",
                         multiselect=False,
                         value="float16",
                         interactive=True,
                     )
                     weight_type = gr.Dropdown(
-                        choices=[i.value.name for i in WeightType],
+                        choices=["Original", "Delta", "Adapter"],
                         label="Weights type",
                         multiselect=False,
                         value="Original",
                         interactive=True,
                     )
                     base_model_name_textbox = gr.Textbox(label="Base model (for delta or adapter weights)")
-            
-            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,
-                                interactive=False,
-                            )
-                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,
-                            interactive=False,
-                        )
-
-                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,
-                            interactive=False,
-                        )
 
             submit_button = gr.Button("Submit Eval")
             submission_result = gr.Markdown()
-
-            # The chat template checkbox update function
-            def update_chat_checkbox(model_type_value):
-                return ModelType.from_str(model_type_value) == ModelType.chat
-            
-            model_type.change(
-                fn=update_chat_checkbox,
-                inputs=[model_type],  # Pass the current checkbox value
-                outputs=chat_template_toggle,
-            )
-
             submit_button.click(
                 add_new_eval,
                 [
@@ -330,61 +584,13 @@ with main_block:
                     base_model_name_textbox,
                     revision_name_textbox,
                     precision,
+                    private,
                     weight_type,
                     model_type,
-                    chat_template_toggle,
                 ],
                 submission_result,
             )
 
-        # Ensure  the values in 'pending_eval_queue_df' are correct and ready for the DataFrame component
-        with gr.TabItem("🆙 Model Vote"):
-            with gr.Row():
-                gr.Markdown(
-                    "## Vote for the models which should be evaluated first! \nYou'll need to sign in with the button above first. All votes are recorded.", 
-                    elem_classes="markdown-text"
-                )
-                login_button = gr.LoginButton(elem_id="oauth-button")
-
-
-            with gr.Row():
-                pending_models = pending_eval_queue_df[EvalQueueColumn.model_name.name].to_list()
-
-                with gr.Column():
-                    selected_model = gr.Dropdown(
-                        choices=pending_models,
-                        label="Models",
-                        multiselect=False,
-                        value="str",
-                        interactive=True,
-                    )
-
-                    vote_button = gr.Button("Vote", variant="primary")
-
-            with gr.Row():
-                with gr.Accordion(
-                    f"Available models pending ({len(pending_eval_queue_df)})",
-                    open=True,
-                ):
-                    with gr.Row():
-                        pending_eval_table_votes = gr.components.Dataframe(
-                            value=vote_manager.create_request_vote_df(
-                                pending_eval_queue_df
-                            ),
-                            headers=EVAL_COLS,
-                            datatype=EVAL_TYPES,
-                            row_count=5,
-                            interactive=False
-                        )
-
-            # Set the click event for the vote button
-            vote_button.click(
-                vote_manager.add_vote,
-                inputs=[selected_model, pending_eval_table],
-                outputs=[pending_eval_table_votes]
-            )
-
-
     with gr.Row():
         with gr.Accordion("📙 Citation", open=False):
             citation_button = gr.Textbox(
@@ -392,81 +598,17 @@ with main_block:
                 label=CITATION_BUTTON_LABEL,
                 lines=20,
                 elem_id="citation-button",
-                show_copy_button=True,
-            )
-
-    main_block.load(fn=get_latest_data_leaderboard, inputs=[leaderboard], outputs=[leaderboard])
-    leaderboard.change(fn=get_latest_data_queue, inputs=None, outputs=[finished_eval_table, running_eval_table, pending_eval_table])
-    pending_eval_table.change(fn=vote_manager.create_request_vote_df, inputs=[pending_eval_table], outputs=[pending_eval_table_votes])
-
-main_block.queue(default_concurrency_limit=40)
-
-
-def enable_space_ci_and_return_server(ui: gr.Blocks) -> WebhooksServer:
-    # Taken from https://huggingface.co/spaces/Wauplin/gradio-space-ci/blob/075119aee75ab5e7150bf0814eec91c83482e790/src/gradio_space_ci/webhook.py#L61
-    # Compared to original, this one do not monkeypatch Gradio which allows us to define more webhooks.
-    # ht to Lucain!
-    if SPACE_ID is None:
-        print("Not in a Space: Space CI disabled.")
-        return WebhooksServer(ui=main_block)
-
-    if IS_EPHEMERAL_SPACE:
-        print("In an ephemeral Space: Space CI disabled.")
-        return WebhooksServer(ui=main_block)
-
-    card = RepoCard.load(repo_id_or_path=SPACE_ID, repo_type="space")
-    config = card.data.get("space_ci", {})
-    print(f"Enabling Space CI with config from README: {config}")
-
-    return configure_space_ci(
-        blocks=ui,
-        trusted_authors=config.get("trusted_authors"),
-        private=config.get("private", "auto"),
-        variables=config.get("variables", "auto"),
-        secrets=config.get("secrets"),
-        hardware=config.get("hardware"),
-        storage=config.get("storage"),
+            ).style(show_copy_button=True)
+
+    dummy = gr.Textbox(visible=False)
+    demo.load(
+        change_tab,
+        dummy,
+        tabs,
+        _js=get_window_url_params,
     )
 
-# Create webhooks server (with CI url if in Space and not ephemeral)
-webhooks_server = enable_space_ci_and_return_server(ui=main_block)
-
-# Add webhooks
-@webhooks_server.add_webhook
-def update_leaderboard(payload: WebhookPayload) -> None:
-    """Redownloads the leaderboard dataset each time it updates"""
-    if payload.repo.type == "dataset" and payload.event.action == "update":
-        global NEW_DATA_ON_LEADERBOARD
-        if NEW_DATA_ON_LEADERBOARD:
-            return
-        NEW_DATA_ON_LEADERBOARD = True
-
-        datasets.load_dataset(
-            AGGREGATED_REPO, 
-            "default", 
-            split="train", 
-            cache_dir=HF_HOME, 
-            download_mode=datasets.DownloadMode.FORCE_REDOWNLOAD, 
-            verification_mode="no_checks"
-        )
-
-# The below code is not used at the moment, as we can manage the queue file locally
-LAST_UPDATE_QUEUE = datetime.datetime.now()
-@webhooks_server.add_webhook    
-def update_queue(payload: WebhookPayload) -> None:
-    """Redownloads the queue dataset each time it updates"""
-    if payload.repo.type == "dataset" and payload.event.action == "update":
-        current_time = datetime.datetime.now()
-        global LAST_UPDATE_QUEUE
-        if current_time - LAST_UPDATE_QUEUE > datetime.timedelta(minutes=10):
-            print("Would have updated the queue")
-            # We only redownload is last update was more than 10 minutes ago, as the queue is 
-            # updated regularly and heavy to download
-            download_dataset(QUEUE_REPO, EVAL_REQUESTS_PATH)
-            LAST_UPDATE_QUEUE = datetime.datetime.now()
-
-webhooks_server.launch()
-
 scheduler = BackgroundScheduler()
-scheduler.add_job(restart_space, "interval", hours=3) # restarted every 3h as backup in case automatic updates are not working
-scheduler.start()
+scheduler.add_job(restart_space, "interval", seconds=1800)
+scheduler.start()
+demo.queue(concurrency_count=40).launch()

model_info_cache.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8fcaa2a3e1ac6a5559471547af5de4e3ccd49673ad5525890726e65cd90cfe62
+size 3620752

model_size_cache.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75d1f64589459eb64e3a50987bf05ed3656248102d1fe2f6c98a008020945840
+size 74321

src/tools/model_backlinks.py → models_backlinks.py

@@ -630,7 +630,7 @@ models = [
     "WizardLM/WizardMath-7B-V1.0",
     "Norquinal/llama-2-7b-claude-chat",
     "TheTravellingEngineer/llama2-7b-chat-hf-dpo",
-    "open-llm-leaderboard/starchat-beta",
+    "HuggingFaceH4/starchat-beta",
     "joehuangx/spatial-vicuna-7b-v1.5-LoRA",
     "conceptofmind/LLongMA-2-13b-16k",
     "tianyil1/denas-llama2",
@@ -1039,7 +1039,7 @@ models = [
     "bhenrym14/airoboros-33b-gpt4-1.4.1-PI-8192-fp16",
     "EleutherAI/gpt-neo-2.7B",
     "danielhanchen/open_llama_3b_600bt_preview",
-    "open-llm-leaderboard/starchat-alpha",
+    "HuggingFaceH4/starchat-alpha",
     "pythainlp/wangchanglm-7.5B-sft-en-sharded",
     "beaugogh/pythia-1.4b-deduped-sharegpt",
     "HWERI/pythia-1.4b-deduped-sharegpt",

pyproject.toml

@@ -1,15 +1,9 @@
 [tool.ruff]
-line-length = 120
-target-version = "py312"
-include = ["*.py", "*.pyi", "**/pyproject.toml", "*.ipynb"]
-ignore=["I","EM","FBT","TRY003","S101","D101","D102","D103","D104","D105","G004","D107","FA102"]
-fixable=["ALL"]
-select=["ALL"]
-
-[tool.ruff.lint]
+# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
 select = ["E", "F"]
-fixable = ["ALL"]
 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"
@@ -17,40 +11,3 @@ line_length = 119
 
 [tool.black]
 line-length = 119
-
-[tool.poetry]
-package-mode = false
-name = "open-llm-leaderboard"
-version = "0.1.0"
-description = ""
-authors = []
-readme = "README.md"
-
-[tool.poetry.dependencies]
-python = "3.12.1"
-apscheduler = "3.10.1"
-black = "23.11.0"
-click = "8.1.3"
-datasets = "2.14.5"
-huggingface-hub = ">=0.18.0"
-matplotlib = "3.8.4"
-numpy = "1.26.0"
-pandas = "2.2.2"
-plotly = "5.14.1"
-python-dateutil = "2.8.2"
-sentencepiece = "^0.2.0"
-tqdm = "4.65.0"
-transformers = "4.41.1"
-tokenizers = ">=0.15.0"
-gradio-space-ci = {git = "https://huggingface.co/spaces/Wauplin/gradio-space-ci", rev = "0.2.3"}
-isort = "^5.13.2"
-ruff = "^0.3.5"
-gradio-leaderboard = "0.0.8"
-gradio = {extras = ["oauth"], version = "^4.36.1"}
-requests = "^2.31.0"
-requests-oauthlib = "^1.3.1"
-schedule = "^1.2.2"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -1,23 +1,71 @@
+accelerate==0.23.0
+aiofiles==23.1.0
+aiohttp==3.8.4
+aiosignal==1.3.1
+altair==4.2.2
+anyio==3.6.2
 APScheduler==3.10.1
-black==23.11.0
+async-timeout==4.0.2
+attrs==23.1.0
+certifi==2022.12.7
+charset-normalizer==3.1.0
 click==8.1.3
-datasets==2.14.5
-huggingface-hub>=0.18.0
-matplotlib==3.8.4
-numpy==1.26.0
-pandas==2.2.2
+contourpy==1.0.7
+cycler==0.11.0
+datasets==2.12.0
+entrypoints==0.4
+fastapi==0.95.1
+ffmpy==0.3.0
+filelock==3.11.0
+fonttools==4.39.3
+frozenlist==1.3.3
+fsspec==2023.4.0
+gradio==3.43.2
+gradio-client==0.5.0
+h11==0.14.0
+httpcore==0.17.0
+httpx==0.24.0
+huggingface-hub==0.16.4
+idna==3.4
+Jinja2==3.1.2
+jsonschema==4.17.3
+kiwisolver==1.4.4
+linkify-it-py==2.0.0
+markdown-it-py==2.2.0
+MarkupSafe==2.1.2
+matplotlib==3.7.1
+mdit-py-plugins==0.3.3
+mdurl==0.1.2
+multidict==6.0.4
+numpy==1.24.2
+orjson==3.8.10
+packaging==23.1
+pandas==2.0.0
+Pillow==9.5.0
 plotly==5.14.1
+pyarrow==11.0.0
+pydantic==1.10.7
+pydub==0.25.1
+pyparsing==3.0.9
+pyrsistent==0.19.3
 python-dateutil==2.8.2
-sentencepiece
+python-multipart==0.0.6
+pytz==2023.3
+pytz-deprecation-shim==0.1.0.post0
+PyYAML==6.0
+requests==2.28.2
+semantic-version==2.10.0
+six==1.16.0
+sniffio==1.3.0
+starlette==0.26.1
+toolz==0.12.0
 tqdm==4.65.0
-transformers==4.41.1
-tokenizers>=0.15.0
-gradio-space-ci @ git+https://huggingface.co/spaces/Wauplin/gradio-space-ci@0.2.3 # CI !!!
-isort
-ruff
-gradio==4.31.0
-gradio[oauth]
-gradio_leaderboard==0.0.9
-requests==2.31.0
-requests-oauthlib== 1.3.1
-schedule == 1.2.2
+transformers@git+https://github.com/huggingface/transformers
+typing_extensions==4.5.0
+tzdata==2023.3
+tzlocal==4.3
+uc-micro-py==1.0.1
+urllib3==1.26.15
+uvicorn==0.21.1
+websockets==11.0.1
+yarl==1.8.2

src/{display → assets}/css_html_js.py

@@ -1,18 +1,5 @@
 custom_css = """
-/* Limit the width of the first AutoEvalColumn so that names don't expand too much */
-table td:first-child,
-table th:first-child {
-    max-width: 400px;
-    overflow: auto;
-    white-space: nowrap;
-}
 
-/* Full width space */
-.gradio-container {
-    max-width: 95% !important;
-}
-
-/* Text style and margins */
 .markdown-text {
     font-size: 16px !important;
 }
@@ -34,21 +21,54 @@ table th:first-child {
     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;
 }
 
+/* Hides the final AutoEvalColumn */
+#llm-benchmark-tab-table table td:last-child,
+#llm-benchmark-tab-table table th:last-child {
+    display: none;
+}
+
+/* Limit the width of the first AutoEvalColumn so that names don't expand too much */
+table td:first-child,
+table th:first-child {
+    max-width: 400px;
+    overflow: auto;
+    white-space: nowrap;
+}
+
 .tab-buttons button {
     font-size: 20px;
 }
 
-/* Filters style */
-#filter_type {
+#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;
@@ -56,53 +76,29 @@ table th:first-child {
 #filter_type label {
     display: flex;
 }
-#filter_type label > span {
+#filter_type label > span{
     margin-top: var(--spacing-lg);
     margin-right: 0.5em;
 }
-#filter_type label > .wrap {
+#filter_type label > .wrap{
     width: 103px;
 }
-#filter_type label > .wrap .wrap-inner {
+#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;
-}
-
-/* Header styles */
-#header-title {
-    text-align: left;
-    display: inline-block;
+#filter_type label > .wrap .wrap-inner input{
+    width: 1px
 }
-
-#header-row {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
+#filter-columns-type{
+    border:0;
+    padding:0.5;
 }
-
-#header-row .gradio-html {
-    flex-grow: 1;
+#filter-columns-size{
+    border:0;
+    padding:0.5;
 }
-
-#oauth-button {
-    height: auto;
-    min-width: max-content;
-    white-space: nowrap;
-    padding: 10px 20px;
-    border-radius: 4px;
+#box-filter > .form{
+    border: 0
 }
 """
 
@@ -112,4 +108,4 @@ get_window_url_params = """
         url_params = Object.fromEntries(params);
         return url_params;
     }
-    """
+    """

src/assets/hardcoded_evals.py

@@ -0,0 +1,40 @@
+from src.display_models.utils import AutoEvalColumn, model_hyperlink
+
+gpt4_values = {
+    AutoEvalColumn.model.name: model_hyperlink("https://arxiv.org/abs/2303.08774", "gpt4"),
+    AutoEvalColumn.revision.name: "tech report",
+    AutoEvalColumn.precision.name: None,
+    AutoEvalColumn.average.name: 84.3,
+    AutoEvalColumn.arc.name: 96.3,
+    AutoEvalColumn.hellaswag.name: 95.3,
+    AutoEvalColumn.mmlu.name: 86.4,
+    AutoEvalColumn.truthfulqa.name: 59.0,
+    AutoEvalColumn.dummy.name: "GPT-4",
+    AutoEvalColumn.model_type.name: "",
+}
+
+gpt35_values = {
+    AutoEvalColumn.model.name: model_hyperlink("https://arxiv.org/abs/2303.08774", "gpt3.5"),
+    AutoEvalColumn.revision.name: "tech report",
+    AutoEvalColumn.precision.name: None,
+    AutoEvalColumn.average.name: 71.9,
+    AutoEvalColumn.arc.name: 85.2,
+    AutoEvalColumn.hellaswag.name: 85.5,
+    AutoEvalColumn.mmlu.name: 70.0,
+    AutoEvalColumn.truthfulqa.name: 47.0,
+    AutoEvalColumn.dummy.name: "GPT-3.5",
+    AutoEvalColumn.model_type.name: "",
+}
+
+baseline = {
+    AutoEvalColumn.model.name: "<p>Baseline</p>",
+    AutoEvalColumn.revision.name: "N/A",
+    AutoEvalColumn.precision.name: None,
+    AutoEvalColumn.average.name: 25.0,
+    AutoEvalColumn.arc.name: 25.0,
+    AutoEvalColumn.hellaswag.name: 25.0,
+    AutoEvalColumn.mmlu.name: 25.0,
+    AutoEvalColumn.truthfulqa.name: 25.0,
+    AutoEvalColumn.dummy.name: "baseline",
+    AutoEvalColumn.model_type.name: "",
+}

src/{display/about.py → assets/text_content.py}

@@ -1,64 +1,52 @@
-from src.display.utils import ModelType
+from src.display_models.model_metadata_type import ModelType
 
-TITLE = """<h1 style="text-align:left;float:left; id="space-title">🤗 Open LLM Leaderboard</h1> <h3 style="text-align:left;float:left;> Track, rank and evaluate open LLMs and chatbots </h3>"""
+TITLE = """<h1 align="center" id="space-title">🤗 Open LLM Leaderboard</h1>"""
 
 INTRODUCTION_TEXT = """
-The previous Leaderboard version is live [here](https://huggingface.co/spaces/open-llm-leaderboard-old/open_llm_leaderboard) 📊  Feeling lost? Check out our [documentation](https://huggingface.co/docs/leaderboards/open_llm_leaderboard/about) 📄
-\n You'll notably find explanations on the evaluations we are using, reproducibility guidelines, best practices on how to submit a model, and our FAQ.
-"""
+📐 The 🤗 Open LLM Leaderboard aims to track, rank and evaluate open LLMs and chatbots.
 
-icons = f"""
-- {ModelType.PT.to_str(" : ")} model: new, base models, trained on a given text corpora using masked modelling
-- {ModelType.CPT.to_str(" : ")} model: new, base models, continuously trained on further corpus (which may include IFT/chat data) using masked modelling
-- {ModelType.FT.to_str(" : ")} model: pretrained models finetuned on more data
-- {ModelType.chat.to_str(" : ")} model: chat like fine-tunes, either using IFT (datasets of task instruction), RLHF or DPO (changing the model loss a bit with an added policy), etc
-- {ModelType.merges.to_str(" : ")} model: merges or MoErges, models which have been merged or fused without additional fine-tuning. 
+🤗 Submit a model for automated evaluation on the 🤗 GPU cluster on the "Submit" page!
+The leaderboard's backend runs the great [Eleuther AI Language Model Evaluation Harness](https://github.com/EleutherAI/lm-evaluation-harness) - read more details in the "About" page!
 """
-LLM_BENCHMARKS_TEXT = """
-## ABOUT
+
+LLM_BENCHMARKS_TEXT = f"""
+# Context
 With the plethora of large language models (LLMs) and chatbots being released week upon week, often with grandiose claims of their performance, it can be hard to filter out the genuine progress that is being made by the open-source community and which model is the current state of the art.
 
-🤗 Submit a model for automated evaluation on the 🤗 GPU cluster on the "Submit" page!
-The leaderboard's backend runs the great [Eleuther AI Language Model Evaluation Harness](https://github.com/EleutherAI/lm-evaluation-harness) - read more details below!
+## Icons
+{ModelType.PT.to_str(" : ")} model
+{ModelType.FT.to_str(" : ")} model
+{ModelType.IFT.to_str(" : ")} model
+{ModelType.RL.to_str(" : ")} model
+If there is no icon, we have not uploaded the information on the model yet, feel free to open an issue with the model information!
 
-### Tasks 
-📈 We evaluate models on 6 key benchmarks using the <a href="https://github.com/EleutherAI/lm-evaluation-harness" target="_blank">  Eleuther AI Language Model Evaluation Harness </a>, a unified framework to test generative language models on a large number of different evaluation tasks.
+🏴‍☠️ indicates that this model has been flagged by the community, and should probably be ignored! Clicking the icon will redirect you to the discussion about the model.
+(For ex, the model was trained on the evaluation data, and is therefore cheating on the leaderboard.)
+
+## How it works
+
+📈 We evaluate models on 4 key benchmarks using the <a href="https://github.com/EleutherAI/lm-evaluation-harness" target="_blank">  Eleuther AI Language Model Evaluation Harness </a>, a unified framework to test generative language models on a large number of different evaluation tasks.
 
 - <a href="https://arxiv.org/abs/1803.05457" target="_blank">  AI2 Reasoning Challenge </a> (25-shot) - a set of grade-school science questions.
 - <a href="https://arxiv.org/abs/1905.07830" target="_blank">  HellaSwag </a> (10-shot) - a test of commonsense inference, which is easy for humans (~95%) but challenging for SOTA models.
 - <a href="https://arxiv.org/abs/2009.03300" target="_blank">  MMLU </a>  (5-shot) - a test to measure a text model's multitask accuracy. The test covers 57 tasks including elementary mathematics, US history, computer science, law, and more.
-- <a href="https://arxiv.org/abs/2109.07958" target="_blank">  TruthfulQA </a> (0-shot) - a test to measure a model's propensity to reproduce falsehoods commonly found online. Note: TruthfulQA is technically a 6-shot task in the Harness because each example is prepended with 6 Q/A pairs, even in the 0-shot setting.
-- <a href="https://arxiv.org/abs/1907.10641" target="_blank">  Winogrande </a> (5-shot) - an adversarial and difficult Winograd benchmark at scale, for commonsense reasoning.
-- <a href="https://arxiv.org/abs/2110.14168" target="_blank">  GSM8k </a> (5-shot) - diverse grade school math word problems to measure a model's ability to solve multi-step mathematical reasoning problems.
+- <a href="https://arxiv.org/abs/2109.07958" target="_blank">  TruthfulQA </a> (0-shot) - a test to measure a model’s propensity to reproduce falsehoods commonly found online. Note: TruthfulQA in the Harness is actually a minima a 6-shots task, as it is prepended by 6 examples systematically, even when launched using 0 for the number of few-shot examples.
 
 For all these evaluations, a higher score is a better score.
 We chose these benchmarks as they test a variety of reasoning and general knowledge across a wide variety of fields in 0-shot and few-shot settings.
 
-### Results
+## Details and logs
 You can find:
 - detailed numerical results in the `results` Hugging Face dataset: https://huggingface.co/datasets/open-llm-leaderboard/results
-- details on the input/outputs for the models in the `details` of each model, which you can access by clicking the 📄 emoji after the model name
+- details on the input/outputs for the models in the `details` Hugging Face dataset: https://huggingface.co/datasets/open-llm-leaderboard/details
 - community queries and running status in the `requests` Hugging Face dataset: https://huggingface.co/datasets/open-llm-leaderboard/requests
 
-If a model's name contains "Flagged", this indicates it has been flagged by the community, and should probably be ignored! Clicking the link will redirect you to the discussion about the model.
-
----------------------------
-
-## REPRODUCIBILITY
-To reproduce our results, here are the commands you can run, using [this version](https://github.com/EleutherAI/lm-evaluation-harness/tree/b281b0921b636bc36ad05c0b0b0763bd6dd43463) of the Eleuther AI Harness:
-`python main.py --model=hf-causal-experimental --model_args="pretrained=<your_model>,use_accelerate=True,revision=<your_model_revision>"`
-` --tasks=<task_list> --num_fewshot=<n_few_shot> --batch_size=1 --output_path=<output_path>`
+## Reproducibility
+To reproduce our results, here is the commands you can run, using [this version](https://github.com/EleutherAI/lm-evaluation-harness/tree/b281b0921b636bc36ad05c0b0b0763bd6dd43463) of the Eleuther AI Harness:
+`python main.py --model=hf-causal --model_args="pretrained=<your_model>,use_accelerate=True,revision=<your_model_revision>"`
+` --tasks=<task_list> --num_fewshot=<n_few_shot> --batch_size=2 --output_path=<output_path>`
 
-```
-python main.py --model=hf-causal-experimental \
-    --model_args="pretrained=<your_model>,use_accelerate=True,revision=<your_model_revision>" \
-    --tasks=<task_list> \
-    --num_fewshot=<n_few_shot> \
-    --batch_size=1 \
-    --output_path=<output_path>
-```
-
-**Note:** We evaluate all models on a single node of 8 H100s, so the global batch size is 8 for each evaluation. If you don't use parallelism, adapt your batch size to fit.
+The total batch size we get for models which fit on one A100 node is 16 (8 GPUs * 2). If you don't use parallelism, adapt your batch size to fit.
 *You can expect results to vary slightly for different batch sizes because of padding.*
 
 The tasks and few shots parameters are:
@@ -66,122 +54,23 @@ The tasks and few shots parameters are:
 - HellaSwag: 10-shot, *hellaswag* (`acc_norm`)
 - TruthfulQA: 0-shot, *truthfulqa-mc* (`mc2`)
 - MMLU: 5-shot, *hendrycksTest-abstract_algebra,hendrycksTest-anatomy,hendrycksTest-astronomy,hendrycksTest-business_ethics,hendrycksTest-clinical_knowledge,hendrycksTest-college_biology,hendrycksTest-college_chemistry,hendrycksTest-college_computer_science,hendrycksTest-college_mathematics,hendrycksTest-college_medicine,hendrycksTest-college_physics,hendrycksTest-computer_security,hendrycksTest-conceptual_physics,hendrycksTest-econometrics,hendrycksTest-electrical_engineering,hendrycksTest-elementary_mathematics,hendrycksTest-formal_logic,hendrycksTest-global_facts,hendrycksTest-high_school_biology,hendrycksTest-high_school_chemistry,hendrycksTest-high_school_computer_science,hendrycksTest-high_school_european_history,hendrycksTest-high_school_geography,hendrycksTest-high_school_government_and_politics,hendrycksTest-high_school_macroeconomics,hendrycksTest-high_school_mathematics,hendrycksTest-high_school_microeconomics,hendrycksTest-high_school_physics,hendrycksTest-high_school_psychology,hendrycksTest-high_school_statistics,hendrycksTest-high_school_us_history,hendrycksTest-high_school_world_history,hendrycksTest-human_aging,hendrycksTest-human_sexuality,hendrycksTest-international_law,hendrycksTest-jurisprudence,hendrycksTest-logical_fallacies,hendrycksTest-machine_learning,hendrycksTest-management,hendrycksTest-marketing,hendrycksTest-medical_genetics,hendrycksTest-miscellaneous,hendrycksTest-moral_disputes,hendrycksTest-moral_scenarios,hendrycksTest-nutrition,hendrycksTest-philosophy,hendrycksTest-prehistory,hendrycksTest-professional_accounting,hendrycksTest-professional_law,hendrycksTest-professional_medicine,hendrycksTest-professional_psychology,hendrycksTest-public_relations,hendrycksTest-security_studies,hendrycksTest-sociology,hendrycksTest-us_foreign_policy,hendrycksTest-virology,hendrycksTest-world_religions* (average of all the results `acc`)
-- Winogrande: 5-shot, *winogrande* (`acc`)
-- GSM8k: 5-shot, *gsm8k* (`acc`)
-
-Side note on the baseline scores: 
-- for log-likelihood evaluation, we select the random baseline
-- for GSM8K, we select the score obtained in the paper after finetuning a 6B model on the full GSM8K training set for 50 epochs
 
----------------------------
-
-## RESOURCES
-
-### Quantization
+## Quantization
 To get more information about quantization, see:
 - 8 bits: [blog post](https://huggingface.co/blog/hf-bitsandbytes-integration), [paper](https://arxiv.org/abs/2208.07339)
 - 4 bits: [blog post](https://huggingface.co/blog/4bit-transformers-bitsandbytes), [paper](https://arxiv.org/abs/2305.14314)
 
-### Useful links
-- [Community resources](https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard/discussions/174)
-- [Collection of best models](https://huggingface.co/collections/open-llm-leaderboard/llm-leaderboard-best-models-652d6c7965a4619fb5c27a03)
-
-### Other cool leaderboards:
-- [LLM safety](https://huggingface.co/spaces/AI-Secure/llm-trustworthy-leaderboard)
-- [LLM performance](https://huggingface.co/spaces/optimum/llm-perf-leaderboard)
-
-
+## More resources
+If you still have questions, you can check our FAQ [here](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/179)!
+We also gather cool resources from the community, other teams, and other labs [here](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/174)!
 """
 
-FAQ_TEXT = """
-
-## SUBMISSIONS
-My model requires `trust_remote_code=True`, can I submit it?
-- *We only support models that have been integrated into a stable version of the `transformers` library for automatic submission, as we don't want to run possibly unsafe code on our cluster.*
-
-What about models of type X? 
-- *We only support models that have been integrated into a stable version of the `transformers` library for automatic submission.*
-
-How can I follow when my model is launched?
-- *You can look for its request file [here](https://huggingface.co/datasets/open-llm-leaderboard/requests) and follow the status evolution, or directly in the queues above the submit form.*
-
-My model disappeared from all the queues, what happened?
-- *A model disappearing from all the queues usually means that there has been a failure. You can check if that is the case by looking for your model [here](https://huggingface.co/datasets/open-llm-leaderboard/requests).*
-
-What causes an evaluation failure?
-- *Most of the failures we get come from problems in the submissions (corrupted files, config problems, wrong parameters selected for eval ...), so we'll be grateful if you first make sure you have followed the steps in `About`. However, from time to time, we have failures on our side (hardware/node failures, problems with an update of our backend, connectivity problems ending up in the results not being saved, ...).*
-
-How can I report an evaluation failure?
-- *As we store the logs for all models, feel free to create an issue, **where you link to the requests file of your model** (look for it [here](https://huggingface.co/datasets/open-llm-leaderboard/requests/tree/main)), so we can investigate! If the model failed due to a problem on our side, we'll relaunch it right away!* 
-*Note: Please do not re-upload your model under a different name, it will not help*
-
----------------------------
-
-## RESULTS
-What kind of information can I find?
-- *Let's imagine you are interested in the Yi-34B results. You have access to 3 different information categories:*
-      - *The [request file](https://huggingface.co/datasets/open-llm-leaderboard/requests/blob/main/01-ai/Yi-34B_eval_request_False_bfloat16_Original.json): it gives you information about the status of the evaluation*
-      - *The [aggregated results folder](https://huggingface.co/datasets/open-llm-leaderboard/results/tree/main/01-ai/Yi-34B): it gives you aggregated scores, per experimental run*
-      - *The [details dataset](https://huggingface.co/datasets/open-llm-leaderboard/details_01-ai__Yi-34B/tree/main): it gives you the full details (scores and examples for each task and a given model)*
-
-
-Why do models appear several times in the leaderboard? 
-- *We run evaluations with user-selected precision and model commit. Sometimes, users submit specific models at different commits and at different precisions (for example, in float16 and 4bit to see how quantization affects performance). You should be able to verify this by displaying the `precision` and `model sha` columns in the display. If, however, you see models appearing several times with the same precision and hash commit, this is not normal.*
-
-What is this concept of "flagging"?
-- *This mechanism allows users to report models that have unfair performance on the leaderboard. This contains several categories: exceedingly good results on the leaderboard because the model was (maybe accidentally) trained on the evaluation data, models that are copies of other models not attributed properly, etc.*
-
-My model has been flagged improperly, what can I do?
-- *Every flagged model has a discussion associated with it - feel free to plead your case there, and we'll see what to do together with the community.*
-
----------------------------
-
-## HOW TO SEARCH FOR A MODEL
-Search for models in the leaderboard by:
-1. Name, e.g., *model_name*
-2. Multiple names, separated by `;`, e.g., *model_name1;model_name2*
-3. License, prefix with `Hub License:...`, e.g., *Hub License: MIT*
-4. Combination of name and license, order is irrelevant, e.g., *model_name; Hub License: cc-by-sa-4.0*
-
----------------------------
-
-## EDITING SUBMISSIONS
-I upgraded my model and want to re-submit, how can I do that?
-- *Please open an issue with the precise name of your model, and we'll remove your model from the leaderboard so you can resubmit. You can also resubmit directly with the new commit hash!* 
-
-I need to rename my model, how can I do that?
-- *You can use @Weyaxi 's [super cool tool](https://huggingface.co/spaces/Weyaxi/open-llm-leaderboard-renamer) to request model name changes, then open a discussion where you link to the created pull request, and we'll check them and merge them as needed.*
-
----------------------------
-
-## OTHER
-Why do you differentiate between pretrained, continuously pretrained, fine-tuned, merges, etc?
-- *These different models do not play in the same categories, and therefore need to be separated for fair comparison. Base pretrained models are the most interesting for the community, as they are usually good models to fine-tune later on - any jump in performance from a pretrained model represents a true improvement on the SOTA. 
-Fine-tuned and IFT/RLHF/chat models usually have better performance, but the latter might be more sensitive to system prompts, which we do not cover at the moment in the Open LLM Leaderboard. 
-Merges and moerges have artificially inflated performance on test sets, which is not always explainable, and does not always apply to real-world situations.*
-
-What should I use the leaderboard for?
-- *We recommend using the leaderboard for 3 use cases: 1) getting an idea of the state of open pretrained models, by looking only at the ranks and score of this category; 2) experimenting with different fine-tuning methods, datasets, quantization techniques, etc, and comparing their score in a reproducible setup, and 3) checking the performance of a model of interest to you, wrt to other models of its category.*
-
-Why don't you display closed-source model scores? 
-- *This is a leaderboard for Open models, both for philosophical reasons (openness is cool) and for practical reasons: we want to ensure that the results we display are accurate and reproducible, but 1) commercial closed models can change their API thus rendering any scoring at a given time incorrect 2) we re-run everything on our cluster to ensure all models are run on the same setup and you can't do that for these models.*
-
-I have an issue with accessing the leaderboard through the Gradio API
-- *Since this is not the recommended way to access the leaderboard, we won't provide support for this, but you can look at tools provided by the community for inspiration!*
-
-I have another problem, help!
-- *Please open an issue in the discussion tab, and we'll do our best to help you in a timely manner :) *
-"""
-
-
-EVALUATION_QUEUE_TEXT = f"""
+EVALUATION_QUEUE_TEXT = """
 # Evaluation Queue for the 🤗 Open LLM Leaderboard
 
 Models added here will be automatically evaluated on the 🤗 cluster.
 
-## Don't forget to read the FAQ and the About tabs for more information!
-
-## First steps before submitting a model
+## Some good practices before submitting a model
 
 ### 1) Make sure you can load your model and tokenizer using AutoClasses:
 ```python
@@ -204,32 +93,21 @@ This is a leaderboard for Open LLMs, and we'd love for as many people as possibl
 ### 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
 
-### 5) Select the correct precision
-Not all models are converted properly from `float16` to `bfloat16`, and selecting the wrong precision can sometimes cause evaluation error (as loading a `bf16` model in `fp16` can sometimes generate NaNs, depending on the weight range).
-
-<b>Note:</b> Please be advised that when submitting, git <b>branches</b> and <b>tags</b> will be strictly tied to the <b>specific commit</b> present at the time of submission. This ensures revision consistency.
-## Model types
-{icons}
+## 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"""
-@misc{open-llm-leaderboard-v2,
-  author = {Clémentine Fourrier and Nathan Habib and Alina Lozovskaya and Konrad Szafer and Thomas Wolf},
-  title = {Open LLM Leaderboard v2},
-  year = {2024},
-  publisher = {Hugging Face},
-  howpublished = "\url{https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard}",
-}
-
-@misc{open-llm-leaderboard-v1,
-  author = {Edward Beeching and Clémentine Fourrier and Nathan Habib and Sheon Han and Nathan Lambert and Nazneen Rajani and Omar Sanseviero and Lewis Tunstall and Thomas Wolf},
-  title = {Open LLM Leaderboard (2023-2024)},
+@misc{open-llm-leaderboard,
+  author = {Edward Beeching, Clémentine Fourrier, Nathan Habib, Sheon Han, Nathan Lambert, Nazneen Rajani, Omar Sanseviero, Lewis Tunstall, Thomas Wolf},
+  title = {Open LLM Leaderboard},
   year = {2023},
   publisher = {Hugging Face},
-  howpublished = "\url{https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard}"
+  howpublished = "\url{https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard}"
 }
-
 @software{eval-harness,
   author       = {Gao, Leo and
                   Tow, Jonathan and
@@ -254,66 +132,37 @@ CITATION_BUTTON_TEXT = r"""
   publisher    = {Zenodo},
   version      = {v0.0.1},
   doi          = {10.5281/zenodo.5371628},
-  url          = {https://doi.org/10.5281/zenodo.5371628},
-}
-
-@misc{zhou2023instructionfollowingevaluationlargelanguage,
-  title={Instruction-Following Evaluation for Large Language Models},
-  author={Jeffrey Zhou and Tianjian Lu and Swaroop Mishra and Siddhartha Brahma and Sujoy Basu and Yi Luan and Denny Zhou and Le Hou},
-  year={2023},
-  eprint={2311.07911},
-  archivePrefix={arXiv},
-  primaryClass={cs.CL},
-  url={https://arxiv.org/abs/2311.07911},
-}
-
-@misc{suzgun2022challengingbigbenchtaskschainofthought,
-  title={Challenging BIG-Bench Tasks and Whether Chain-of-Thought Can Solve Them},
-  author={Mirac Suzgun and Nathan Scales and Nathanael Schärli and Sebastian Gehrmann and Yi Tay and Hyung Won Chung and Aakanksha Chowdhery and Quoc V. Le and Ed H. Chi and Denny Zhou and Jason Wei},
-  year={2022},
-  eprint={2210.09261},
-  archivePrefix={arXiv},
-  primaryClass={cs.CL},
-  url={https://arxiv.org/abs/2210.09261},
+  url          = {https://doi.org/10.5281/zenodo.5371628}
 }
-
-@misc{hendrycks2021measuringmathematicalproblemsolving,
-  title={Measuring Mathematical Problem Solving With the MATH Dataset},
-  author={Dan Hendrycks and Collin Burns and Saurav Kadavath and Akul Arora and Steven Basart and Eric Tang and Dawn Song and Jacob Steinhardt},
-  year={2021},
-  eprint={2103.03874},
-  archivePrefix={arXiv},
-  primaryClass={cs.LG},
-  url={https://arxiv.org/abs/2103.03874},
+@misc{clark2018think,
+      title={Think you have Solved Question Answering? Try ARC, the AI2 Reasoning Challenge},
+      author={Peter Clark and Isaac Cowhey and Oren Etzioni and Tushar Khot and Ashish Sabharwal and Carissa Schoenick and Oyvind Tafjord},
+      year={2018},
+      eprint={1803.05457},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI}
 }
-
-@misc{rein2023gpqagraduatelevelgoogleproofqa,
-  title={GPQA: A Graduate-Level Google-Proof Q&A Benchmark},
-  author={David Rein and Betty Li Hou and Asa Cooper Stickland and Jackson Petty and Richard Yuanzhe Pang and Julien Dirani and Julian Michael and Samuel R. Bowman},
-  year={2023},
-  eprint={2311.12022},
-  archivePrefix={arXiv},
-  primaryClass={cs.AI},
-  url={https://arxiv.org/abs/2311.12022},
+@misc{zellers2019hellaswag,
+      title={HellaSwag: Can a Machine Really Finish Your Sentence?},
+      author={Rowan Zellers and Ari Holtzman and Yonatan Bisk and Ali Farhadi and Yejin Choi},
+      year={2019},
+      eprint={1905.07830},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
 }
-
-@misc{sprague2024musrtestinglimitschainofthought,
-  title={MuSR: Testing the Limits of Chain-of-thought with Multistep Soft Reasoning},
-  author={Zayne Sprague and Xi Ye and Kaj Bostrom and Swarat Chaudhuri and Greg Durrett},
-  year={2024},
-  eprint={2310.16049},
-  archivePrefix={arXiv},
-  primaryClass={cs.CL},
-  url={https://arxiv.org/abs/2310.16049},
+@misc{hendrycks2021measuring,
+      title={Measuring Massive Multitask Language Understanding},
+      author={Dan Hendrycks and Collin Burns and Steven Basart and Andy Zou and Mantas Mazeika and Dawn Song and Jacob Steinhardt},
+      year={2021},
+      eprint={2009.03300},
+      archivePrefix={arXiv},
+      primaryClass={cs.CY}
 }
-
-@misc{wang2024mmluprorobustchallengingmultitask,
-  title={MMLU-Pro: A More Robust and Challenging Multi-Task Language Understanding Benchmark},
-  author={Yubo Wang and Xueguang Ma and Ge Zhang and Yuansheng Ni and Abhranil Chandra and Shiguang Guo and Weiming Ren and Aaran Arulraj and Xuan He and Ziyan Jiang and Tianle Li and Max Ku and Kai Wang and Alex Zhuang and Rongqi Fan and Xiang Yue and Wenhu Chen},
-  year={2024},
-  eprint={2406.01574},
-  archivePrefix={arXiv},
-  primaryClass={cs.CL},
-  url={https://arxiv.org/abs/2406.01574},
-}
-"""
+@misc{lin2022truthfulqa,
+      title={TruthfulQA: Measuring How Models Mimic Human Falsehoods},
+      author={Stephanie Lin and Jacob Hilton and Owain Evans},
+      year={2022},
+      eprint={2109.07958},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}"""

src/display/formatting.py

@@ -1,36 +0,0 @@
-from huggingface_hub import HfApi
-
-API = HfApi()
-
-
-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}"
-
-    details_model_name = model_name.replace("/", "__")
-    details_link = f"https://huggingface.co/datasets/open-llm-leaderboard/{details_model_name}-details"
-
-    return model_hyperlink(link, model_name) + "  " + model_hyperlink(details_link, "📑")
-
-
-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,260 +0,0 @@
-from dataclasses import dataclass, make_dataclass
-from enum import Enum
-import json
-import logging
-from datetime import datetime
-import pandas as pd
-
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-
-# Convert ISO 8601 dates to datetime objects for comparison
-def parse_iso8601_datetime(date_str):
-    if date_str.endswith('Z'):
-        date_str = date_str[:-1] + '+00:00'
-    return datetime.fromisoformat(date_str)
-
-def parse_datetime(datetime_str):
-    formats = [
-        "%Y-%m-%dT%H-%M-%S.%f",  # Format with dashes
-        "%Y-%m-%dT%H:%M:%S.%f",  # Standard format with colons
-        "%Y-%m-%dT%H %M %S.%f",  # Spaces as separator
-    ]
-
-    for fmt in formats:
-        try:
-            return datetime.strptime(datetime_str, fmt)
-        except ValueError:
-            continue
-    # in rare cases set unix start time for files with incorrect time (legacy files)
-    logging.error(f"No valid date format found for: {datetime_str}")
-    return datetime(1970, 1, 1)
-
-
-def load_json_data(file_path):
-    """Safely load JSON data from a file."""
-    try:
-        with open(file_path, "r") as file:
-            return json.load(file)
-    except json.JSONDecodeError:
-        print(f"Error reading JSON from {file_path}")
-        return None  # Or raise an exception
-
-
-def fields(raw_class):
-    return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
-
-
-@dataclass
-class Task:
-    benchmark: str
-    metric: str
-    col_name: str
-
-
-class Tasks(Enum):
-    ifeval = Task("leaderboard_ifeval", "strict_acc,none", "IFEval")
-    ifeval_raw = Task("leaderboard_ifeval", "strict_acc,none", "IFEval Raw")
-
-    bbh = Task("leaderboard_bbh", "acc_norm,none", "BBH")
-    bbh_raw = Task("leaderboard_bbh", "acc_norm,none", "BBH Raw")
-
-    math = Task("leaderboard_math_hard", "exact_match,none", "MATH Lvl 5")
-    math_raw = Task("leaderboard_math_hard", "exact_match,none", "MATH Lvl 5 Raw")
-
-    gpqa = Task("leaderboard_gpqa", "acc_norm,none", "GPQA")
-    gpqa_raw = Task("leaderboard_gpqa", "acc_norm,none", "GPQA Raw")
-
-    musr = Task("leaderboard_musr", "acc_norm,none", "MUSR")
-    musr_raw = Task("leaderboard_musr", "acc_norm,none", "MUSR Raw")
-
-    mmlu_pro = Task("leaderboard_mmlu_pro", "acc,none", "MMLU-PRO")
-    mmlu_pro_raw = Task("leaderboard_mmlu_pro", "acc,none", "MMLU-PRO Raw")
-
-
-# These classes are for user facing column names,
-# to avoid having to change them all around the code
-# when a modif is needed
-@dataclass(frozen=True)
-class ColumnContent:
-    name: str
-    type: str
-    displayed_by_default: bool
-    hidden: bool = False
-    never_hidden: bool = False
-    dummy: bool = False
-
-
-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:
-    displayed_by_default = not task.name.endswith("_raw")
-    auto_eval_column_dict.append([task.name, ColumnContent, ColumnContent(task.value.col_name, "number", displayed_by_default=displayed_by_default)])
-# 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(["merged", ColumnContent, ColumnContent("Not_Merged", "bool", 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, hidden=True)]
-)
-auto_eval_column_dict.append(["revision", ColumnContent, ColumnContent("Model sha", "str", False, False)])
-auto_eval_column_dict.append(["not_flagged", ColumnContent, ColumnContent("Flagged", "bool", False, hidden=True)])
-auto_eval_column_dict.append(["moe", ColumnContent, ColumnContent("MoE", "bool", False, hidden=True)])
-# to rename
-auto_eval_column_dict.append(["submission_date", ColumnContent, ColumnContent("submission_date", "date", False, hidden=True)])
-auto_eval_column_dict.append(["upload_to_hub", ColumnContent, ColumnContent("upload_to_hub", "date", False, hidden=True)])
-
-auto_eval_column_dict.append(["use_chat_template", ColumnContent, ColumnContent("Chat Template", "bool", False)])
-auto_eval_column_dict.append(["maintainers_highlight", ColumnContent, ColumnContent("Maintainer's Highlight", "bool", False, hidden=True)])
-
-# fullname structure: <user>/<model_name>
-auto_eval_column_dict.append(["fullname", ColumnContent, ColumnContent("fullname", "str", False, dummy=True)])
-
-# We use make dataclass to dynamically fill the scores from Tasks
-AutoEvalColumn = make_dataclass("AutoEvalColumn", auto_eval_column_dict, frozen=True)
-
-
-@dataclass(frozen=True)
-class EvalQueueColumn:  # Queue column
-    model_link = ColumnContent("model_link", "markdown", True)
-    model_name = ColumnContent("model_name", "str", True)
-    revision = ColumnContent("revision", "str", True)
-    #private = ColumnContent("private", "bool", True)  # Should not be displayed
-    precision = ColumnContent("precision", "str", True)
-    #weight_type = ColumnContent("weight_type", "str", "Original") # Might be confusing, to think about
-    status = ColumnContent("status", "str", True)
-
-
-# baseline_row = {
-#     AutoEvalColumn.model.name: "<p>Baseline</p>",
-#     AutoEvalColumn.revision.name: "N/A",
-#     AutoEvalColumn.precision.name: None,
-#     AutoEvalColumn.merged.name: False,
-#     AutoEvalColumn.average.name: 31.0,
-#     AutoEvalColumn.arc.name: 25.0,
-#     AutoEvalColumn.hellaswag.name: 25.0,
-#     AutoEvalColumn.mmlu.name: 25.0,
-#     AutoEvalColumn.truthfulqa.name: 25.0,
-#     AutoEvalColumn.winogrande.name: 50.0,
-#     AutoEvalColumn.gsm8k.name: 0.21,
-#     AutoEvalColumn.fullname.name: "baseline",
-#     AutoEvalColumn.model_type.name: "",
-#     AutoEvalColumn.not_flagged.name: False,
-# }
-
-# Average ⬆️ human baseline is 0.897 (source: averaging human baselines below)
-# ARC human baseline is 0.80 (source: https://lab42.global/arc/)
-# HellaSwag human baseline is 0.95 (source: https://deepgram.com/learn/hellaswag-llm-benchmark-guide)
-# MMLU human baseline is 0.898 (source: https://openreview.net/forum?id=d7KBjmI3GmQ)
-# TruthfulQA human baseline is 0.94(source: https://arxiv.org/pdf/2109.07958.pdf)
-# Winogrande: https://leaderboard.allenai.org/winogrande/submissions/public
-# GSM8K: paper
-# Define the human baselines
-# human_baseline_row = {
-#     AutoEvalColumn.model.name: "<p>Human performance</p>",
-#     AutoEvalColumn.revision.name: "N/A",
-#     AutoEvalColumn.precision.name: None,
-#     AutoEvalColumn.average.name: 92.75,
-#     AutoEvalColumn.merged.name: False,
-#     AutoEvalColumn.arc.name: 80.0,
-#     AutoEvalColumn.hellaswag.name: 95.0,
-#     AutoEvalColumn.mmlu.name: 89.8,
-#     AutoEvalColumn.truthfulqa.name: 94.0,
-#     AutoEvalColumn.winogrande.name: 94.0,
-#     AutoEvalColumn.gsm8k.name: 100,
-#     AutoEvalColumn.fullname.name: "human_baseline",
-#     AutoEvalColumn.model_type.name: "",
-#     AutoEvalColumn.not_flagged.name: False,
-# }
-
-
-@dataclass
-class ModelDetails:
-    name: str
-    symbol: str = ""  # emoji, only for the model type
-
-
-class ModelType(Enum):
-    PT = ModelDetails(name="🟢 pretrained", symbol="🟢")
-    CPT = ModelDetails(name="🟩 continuously pretrained", symbol="🟩")
-    FT = ModelDetails(name="🔶 fine-tuned on domain-specific datasets", symbol="🔶")
-    chat = ModelDetails(name="💬 chat models (RLHF, DPO, IFT, ...)", symbol="💬")
-    merges = ModelDetails(name="🤝 base merges and moerges", symbol="🤝")
-    Unknown = ModelDetails(name="❓ other", symbol="❓")
-
-    def to_str(self, separator=" "):
-        return f"{self.value.symbol}{separator}{self.value.name}"
-
-    @staticmethod
-    def from_str(m_type):
-        if any([k for k in m_type if k in ["fine-tuned","🔶", "finetuned"]]):
-            return ModelType.FT
-        if "continuously pretrained" in m_type or "🟩" in m_type:
-            return ModelType.CPT
-        if "pretrained" in m_type or "🟢" in m_type:
-            return ModelType.PT
-        if any([k in m_type for k in ["instruction-tuned", "RL-tuned", "chat", "🟦", "⭕", "💬"]]):
-            return ModelType.chat
-        if "merge" in m_type or "🤝" in m_type:
-            return ModelType.merges
-        return ModelType.Unknown
-
-
-class WeightType(Enum):
-    Adapter = ModelDetails("Adapter")
-    Original = ModelDetails("Original")
-    Delta = ModelDetails("Delta")
-
-
-class Precision(Enum):
-    float16 = ModelDetails("float16")
-    bfloat16 = ModelDetails("bfloat16")
-    qt_8bit = ModelDetails("8bit")
-    qt_4bit = ModelDetails("4bit")
-    qt_GPTQ = ModelDetails("GPTQ")
-    Unknown = ModelDetails("?")
-
-    @staticmethod
-    def from_str(precision):
-        if precision in ["torch.float16", "float16"]:
-            return Precision.float16
-        if precision in ["torch.bfloat16", "bfloat16"]:
-            return Precision.bfloat16
-        if precision in ["8bit"]:
-            return Precision.qt_8bit
-        if precision in ["4bit"]:
-            return Precision.qt_4bit
-        if precision in ["GPTQ", "None"]:
-            return Precision.qt_GPTQ
-        return Precision.Unknown
-
-
-# Column selection
-COLS = [c.name for c in fields(AutoEvalColumn)]
-TYPES = [c.type for c in fields(AutoEvalColumn)]
-
-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]
-
-NUMERIC_INTERVALS = {
-    "?": pd.Interval(-1, 0, closed="right"),
-    "~1.5": pd.Interval(0, 2, closed="right"),
-    "~3": pd.Interval(2, 4, closed="right"),
-    "~7": pd.Interval(4, 9, closed="right"),
-    "~13": pd.Interval(9, 20, closed="right"),
-    "~35": pd.Interval(20, 45, closed="right"),
-    "~60": pd.Interval(45, 70, closed="right"),
-    "70+": pd.Interval(70, 10000, closed="right"),
-}

src/display_models/get_model_metadata.py

@@ -0,0 +1,167 @@
+import glob
+import json
+import os
+import re
+import pickle
+from typing import List
+
+import huggingface_hub
+from huggingface_hub import HfApi
+from tqdm import tqdm
+from transformers import AutoModel, AutoConfig
+from accelerate import init_empty_weights
+
+from src.display_models.model_metadata_flags import DO_NOT_SUBMIT_MODELS, FLAGGED_MODELS
+from src.display_models.model_metadata_type import MODEL_TYPE_METADATA, ModelType, model_type_from_str
+from src.display_models.utils import AutoEvalColumn, model_hyperlink
+
+api = HfApi(token=os.environ.get("H4_TOKEN", None))
+
+
+def get_model_infos_from_hub(leaderboard_data: List[dict]):
+    # load cache from disk
+    try:
+        with open("model_info_cache.pkl", "rb") as f:
+            model_info_cache = pickle.load(f)
+    except (EOFError, FileNotFoundError):
+        model_info_cache = {}
+    try:
+        with open("model_size_cache.pkl", "rb") as f:
+            model_size_cache = pickle.load(f)
+    except (EOFError, FileNotFoundError):
+        model_size_cache = {}
+
+    for model_data in tqdm(leaderboard_data):
+        model_name = model_data["model_name_for_query"]
+
+        if model_name in model_info_cache:
+            model_info = model_info_cache[model_name]
+        else:
+            try:
+                model_info = api.model_info(model_name)
+                model_info_cache[model_name] = model_info
+            except huggingface_hub.utils._errors.RepositoryNotFoundError:
+                print("Repo not found!", model_name)
+                model_data[AutoEvalColumn.license.name] = None
+                model_data[AutoEvalColumn.likes.name] = None
+                if model_name not in model_size_cache:
+                    model_size_cache[model_name] = get_model_size(model_name, None)
+                model_data[AutoEvalColumn.params.name] = model_size_cache[model_name]
+
+        model_data[AutoEvalColumn.license.name] = get_model_license(model_info)
+        model_data[AutoEvalColumn.likes.name] = get_model_likes(model_info)
+        if model_name not in model_size_cache:
+            model_size_cache[model_name] = get_model_size(model_name, model_info)
+        model_data[AutoEvalColumn.params.name] = model_size_cache[model_name]
+
+    # save cache to disk in pickle format
+    with open("model_info_cache.pkl", "wb") as f:
+        pickle.dump(model_info_cache, f)
+    with open("model_size_cache.pkl", "wb") as f:
+        pickle.dump(model_size_cache, f)
+
+
+def get_model_license(model_info):
+    try:
+        return model_info.cardData["license"]
+    except Exception:
+        return "?"
+
+
+def get_model_likes(model_info):
+    return model_info.likes
+
+
+size_pattern = re.compile(r"(\d\.)?\d+(b|m)")
+
+
+def get_model_size(model_name, model_info):
+    # In billions
+    try:
+        return round(model_info.safetensors["total"] / 1e9, 3)
+    except AttributeError:
+        try:
+            config = AutoConfig.from_pretrained(model_name, trust_remote_code=False)
+            with init_empty_weights():
+                model = AutoModel.from_config(config, trust_remote_code=False)
+            return round(sum(p.numel() for p in model.parameters() if p.requires_grad) / 1e9, 3)
+        except (EnvironmentError, ValueError, KeyError):  # model config not found, likely private
+            try:
+                size_match = re.search(size_pattern, model_name.lower())
+                size = size_match.group(0)
+                return round(float(size[:-1]) if size[-1] == "b" else float(size[:-1]) / 1e3, 3)
+            except AttributeError:
+                return 0
+
+
+def get_model_type(leaderboard_data: List[dict]):
+    for model_data in leaderboard_data:
+        request_files = os.path.join(
+            "eval-queue",
+            model_data["model_name_for_query"] + "_eval_request_*" + ".json",
+        )
+        request_files = glob.glob(request_files)
+
+        # Select correct request file (precision)
+        request_file = ""
+        if len(request_files) == 1:
+            request_file = request_files[0]
+        elif len(request_files) > 1:
+            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"] == "FINISHED"
+                        and req_content["precision"] == model_data["Precision"].split(".")[-1]
+                    ):
+                        request_file = tmp_request_file
+
+        try:
+            with open(request_file, "r") as f:
+                request = json.load(f)
+            model_type = model_type_from_str(request["model_type"])
+            model_data[AutoEvalColumn.model_type.name] = model_type.value.name
+            model_data[AutoEvalColumn.model_type_symbol.name] = model_type.value.symbol  # + ("🔺" if is_delta else "")
+        except Exception:
+            if model_data["model_name_for_query"] in MODEL_TYPE_METADATA:
+                model_data[AutoEvalColumn.model_type.name] = MODEL_TYPE_METADATA[
+                    model_data["model_name_for_query"]
+                ].value.name
+                model_data[AutoEvalColumn.model_type_symbol.name] = MODEL_TYPE_METADATA[
+                    model_data["model_name_for_query"]
+                ].value.symbol  # + ("🔺" if is_delta else "")
+            else:
+                model_data[AutoEvalColumn.model_type.name] = ModelType.Unknown.value.name
+                model_data[AutoEvalColumn.model_type_symbol.name] = ModelType.Unknown.value.symbol
+
+
+def flag_models(leaderboard_data: List[dict]):
+    for model_data in leaderboard_data:
+        if model_data["model_name_for_query"] in FLAGGED_MODELS:
+            issue_num = FLAGGED_MODELS[model_data["model_name_for_query"]].split("/")[-1]
+            issue_link = model_hyperlink(
+                FLAGGED_MODELS[model_data["model_name_for_query"]],
+                f"See discussion #{issue_num}",
+            )
+            model_data[
+                AutoEvalColumn.model.name
+            ] = f"{model_data[AutoEvalColumn.model.name]} has been flagged! {issue_link}"
+
+
+def remove_forbidden_models(leaderboard_data: List[dict]):
+    indices_to_remove = []
+    for ix, model in enumerate(leaderboard_data):
+        if model["model_name_for_query"] in DO_NOT_SUBMIT_MODELS:
+            indices_to_remove.append(ix)
+
+    for ix in reversed(indices_to_remove):
+        leaderboard_data.pop(ix)
+    return leaderboard_data
+
+
+def apply_metadata(leaderboard_data: List[dict]):
+    leaderboard_data = remove_forbidden_models(leaderboard_data)
+    get_model_type(leaderboard_data)
+    get_model_infos_from_hub(leaderboard_data)
+    flag_models(leaderboard_data)

src/display_models/model_metadata_flags.py

@@ -0,0 +1,18 @@
+# Models which have been flagged by users as being problematic for a reason or another
+# (Model name to forum discussion link)
+FLAGGED_MODELS = {
+    "Voicelab/trurl-2-13b": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/202",
+    "deepnight-research/llama-2-70B-inst": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/207",
+    "Aspik101/trurl-2-13b-pl-instruct_unload": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/213",
+    "Fredithefish/ReasonixPajama-3B-HF": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/236",
+    "TigerResearch/tigerbot-7b-sft-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/237",
+    "gaodrew/gaodrew-gorgonzola-13b": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/215",
+    "AIDC-ai-business/Marcoroni-70B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/287",
+    "AIDC-ai-business/Marcoroni-13B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/287",
+    "AIDC-ai-business/Marcoroni-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/287",
+}
+
+# Models which have been requested by orgs to not be submitted on the leaderboard
+DO_NOT_SUBMIT_MODELS = [
+    "Voicelab/trurl-2-13b",  # trained on MMLU
+]

src/display_models/model_metadata_type.py

@@ -0,0 +1,555 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict
+
+
+@dataclass
+class ModelInfo:
+    name: str
+    symbol: str  # emoji
+
+
+class ModelType(Enum):
+    PT = ModelInfo(name="pretrained", symbol="🟢")
+    FT = ModelInfo(name="fine-tuned", symbol="🔶")
+    IFT = ModelInfo(name="instruction-tuned", symbol="⭕")
+    RL = ModelInfo(name="RL-tuned", symbol="🟦")
+    Unknown = ModelInfo(name="Unknown", symbol="?")
+
+    def to_str(self, separator=" "):
+        return f"{self.value.symbol}{separator}{self.value.name}"
+
+
+MODEL_TYPE_METADATA: Dict[str, ModelType] = {
+    "tiiuae/falcon-180B": ModelType.PT,
+    "tiiuae/falcon-180B-chat": ModelType.RL,
+    "microsoft/phi-1_5": ModelType.PT,
+    "Qwen/Qwen-7B": ModelType.PT,
+    "Qwen/Qwen-7B-Chat": ModelType.RL,
+    "notstoic/PygmalionCoT-7b": ModelType.IFT,
+    "aisquared/dlite-v1-355m": ModelType.IFT,
+    "aisquared/dlite-v1-1_5b": ModelType.IFT,
+    "aisquared/dlite-v1-774m": ModelType.IFT,
+    "aisquared/dlite-v1-124m": ModelType.IFT,
+    "aisquared/chopt-2_7b": ModelType.IFT,
+    "aisquared/dlite-v2-124m": ModelType.IFT,
+    "aisquared/dlite-v2-774m": ModelType.IFT,
+    "aisquared/dlite-v2-1_5b": ModelType.IFT,
+    "aisquared/chopt-1_3b": ModelType.IFT,
+    "aisquared/dlite-v2-355m": ModelType.IFT,
+    "augtoma/qCammel-13": ModelType.IFT,
+    "Aspik101/Llama-2-7b-hf-instruct-pl-lora_unload": ModelType.IFT,
+    "Aspik101/vicuna-7b-v1.3-instruct-pl-lora_unload": ModelType.IFT,
+    "TheBloke/alpaca-lora-65B-HF": ModelType.FT,
+    "TheBloke/tulu-7B-fp16": ModelType.IFT,
+    "TheBloke/guanaco-7B-HF": ModelType.FT,
+    "TheBloke/koala-7B-HF": ModelType.FT,
+    "TheBloke/wizardLM-7B-HF": ModelType.IFT,
+    "TheBloke/airoboros-13B-HF": ModelType.IFT,
+    "TheBloke/koala-13B-HF": ModelType.FT,
+    "TheBloke/Wizard-Vicuna-7B-Uncensored-HF": ModelType.FT,
+    "TheBloke/dromedary-65b-lora-HF": ModelType.IFT,
+    "TheBloke/wizardLM-13B-1.0-fp16": ModelType.IFT,
+    "TheBloke/WizardLM-13B-V1-1-SuperHOT-8K-fp16": ModelType.FT,
+    "TheBloke/Wizard-Vicuna-30B-Uncensored-fp16": ModelType.FT,
+    "TheBloke/wizard-vicuna-13B-HF": ModelType.IFT,
+    "TheBloke/UltraLM-13B-fp16": ModelType.IFT,
+    "TheBloke/OpenAssistant-FT-7-Llama-30B-HF": ModelType.FT,
+    "TheBloke/vicuna-13B-1.1-HF": ModelType.IFT,
+    "TheBloke/guanaco-13B-HF": ModelType.FT,
+    "TheBloke/guanaco-65B-HF": ModelType.FT,
+    "TheBloke/airoboros-7b-gpt4-fp16": ModelType.IFT,
+    "TheBloke/llama-30b-supercot-SuperHOT-8K-fp16": ModelType.IFT,
+    "TheBloke/Llama-2-13B-fp16": ModelType.PT,
+    "TheBloke/llama-2-70b-Guanaco-QLoRA-fp16": ModelType.FT,
+    "TheBloke/landmark-attention-llama7b-fp16": ModelType.IFT,
+    "TheBloke/Planner-7B-fp16": ModelType.IFT,
+    "TheBloke/Wizard-Vicuna-13B-Uncensored-HF": ModelType.FT,
+    "TheBloke/gpt4-alpaca-lora-13B-HF": ModelType.IFT,
+    "TheBloke/gpt4-x-vicuna-13B-HF": ModelType.IFT,
+    "TheBloke/gpt4-alpaca-lora_mlp-65B-HF": ModelType.IFT,
+    "TheBloke/tulu-13B-fp16": ModelType.IFT,
+    "TheBloke/VicUnlocked-alpaca-65B-QLoRA-fp16": ModelType.IFT,
+    "TheBloke/Llama-2-70B-fp16": ModelType.IFT,
+    "TheBloke/WizardLM-30B-fp16": ModelType.IFT,
+    "TheBloke/robin-13B-v2-fp16": ModelType.FT,
+    "TheBloke/robin-33B-v2-fp16": ModelType.FT,
+    "TheBloke/Vicuna-13B-CoT-fp16": ModelType.IFT,
+    "TheBloke/Vicuna-33B-1-3-SuperHOT-8K-fp16": ModelType.IFT,
+    "TheBloke/Wizard-Vicuna-30B-Superhot-8K-fp16": ModelType.FT,
+    "TheBloke/Nous-Hermes-13B-SuperHOT-8K-fp16": ModelType.IFT,
+    "TheBloke/GPlatty-30B-SuperHOT-8K-fp16": ModelType.FT,
+    "TheBloke/CAMEL-33B-Combined-Data-SuperHOT-8K-fp16": ModelType.IFT,
+    "TheBloke/Chinese-Alpaca-33B-SuperHOT-8K-fp16": ModelType.IFT,
+    "jphme/orca_mini_v2_ger_7b": ModelType.IFT,
+    "Ejafa/vicuna_7B_vanilla_1.1": ModelType.FT,
+    "kevinpro/Vicuna-13B-CoT": ModelType.IFT,
+    "AlekseyKorshuk/pygmalion-6b-vicuna-chatml": ModelType.FT,
+    "AlekseyKorshuk/chatml-pyg-v1": ModelType.FT,
+    "concedo/Vicuzard-30B-Uncensored": ModelType.FT,
+    "concedo/OPT-19M-ChatSalad": ModelType.FT,
+    "concedo/Pythia-70M-ChatSalad": ModelType.FT,
+    "digitous/13B-HyperMantis": ModelType.IFT,
+    "digitous/Adventien-GPTJ": ModelType.FT,
+    "digitous/Alpacino13b": ModelType.IFT,
+    "digitous/GPT-R": ModelType.IFT,
+    "digitous/Javelin-R": ModelType.IFT,
+    "digitous/Javalion-GPTJ": ModelType.IFT,
+    "digitous/Javalion-R": ModelType.IFT,
+    "digitous/Skegma-GPTJ": ModelType.FT,
+    "digitous/Alpacino30b": ModelType.IFT,
+    "digitous/Janin-GPTJ": ModelType.FT,
+    "digitous/Janin-R": ModelType.FT,
+    "digitous/Javelin-GPTJ": ModelType.FT,
+    "SaylorTwift/gpt2_test": ModelType.PT,
+    "anton-l/gpt-j-tiny-random": ModelType.FT,
+    "Andron00e/YetAnother_Open-Llama-3B-LoRA-OpenOrca": ModelType.FT,
+    "Lazycuber/pyg-instruct-wizardlm": ModelType.FT,
+    "Lazycuber/Janemalion-6B": ModelType.FT,
+    "IDEA-CCNL/Ziya-LLaMA-13B-Pretrain-v1": ModelType.FT,
+    "IDEA-CCNL/Ziya-LLaMA-13B-v1": ModelType.IFT,
+    "dsvv-cair/alpaca-cleaned-llama-30b-bf16": ModelType.FT,
+    "gpt2-medium": ModelType.PT,
+    "camel-ai/CAMEL-13B-Combined-Data": ModelType.IFT,
+    "camel-ai/CAMEL-13B-Role-Playing-Data": ModelType.FT,
+    "camel-ai/CAMEL-33B-Combined-Data": ModelType.IFT,
+    "PygmalionAI/pygmalion-6b": ModelType.FT,
+    "PygmalionAI/metharme-1.3b": ModelType.IFT,
+    "PygmalionAI/pygmalion-1.3b": ModelType.FT,
+    "PygmalionAI/pygmalion-350m": ModelType.FT,
+    "PygmalionAI/pygmalion-2.7b": ModelType.FT,
+    "medalpaca/medalpaca-7b": ModelType.FT,
+    "lilloukas/Platypus-30B": ModelType.IFT,
+    "lilloukas/GPlatty-30B": ModelType.FT,
+    "mncai/chatdoctor": ModelType.FT,
+    "chaoyi-wu/MedLLaMA_13B": ModelType.FT,
+    "LoupGarou/WizardCoder-Guanaco-15B-V1.0": ModelType.IFT,
+    "LoupGarou/WizardCoder-Guanaco-15B-V1.1": ModelType.FT,
+    "hakurei/instruct-12b": ModelType.IFT,
+    "hakurei/lotus-12B": ModelType.FT,
+    "shibing624/chinese-llama-plus-13b-hf": ModelType.IFT,
+    "shibing624/chinese-alpaca-plus-7b-hf": ModelType.IFT,
+    "shibing624/chinese-alpaca-plus-13b-hf": ModelType.IFT,
+    "mosaicml/mpt-7b-instruct": ModelType.IFT,
+    "mosaicml/mpt-30b-chat": ModelType.IFT,
+    "mosaicml/mpt-7b-storywriter": ModelType.FT,
+    "mosaicml/mpt-30b-instruct": ModelType.IFT,
+    "mosaicml/mpt-7b-chat": ModelType.IFT,
+    "mosaicml/mpt-30b": ModelType.PT,
+    "Corianas/111m": ModelType.IFT,
+    "Corianas/Quokka_1.3b": ModelType.IFT,
+    "Corianas/256_5epoch": ModelType.FT,
+    "Corianas/Quokka_256m": ModelType.IFT,
+    "Corianas/Quokka_590m": ModelType.IFT,
+    "Corianas/gpt-j-6B-Dolly": ModelType.FT,
+    "Corianas/Quokka_2.7b": ModelType.IFT,
+    "cyberagent/open-calm-7b": ModelType.FT,
+    "Aspik101/Nous-Hermes-13b-pl-lora_unload": ModelType.IFT,
+    "THUDM/chatglm2-6b": ModelType.IFT,
+    "MetaIX/GPT4-X-Alpasta-30b": ModelType.IFT,
+    "NYTK/PULI-GPTrio": ModelType.PT,
+    "EleutherAI/pythia-1.3b": ModelType.PT,
+    "EleutherAI/pythia-2.8b-deduped": ModelType.PT,
+    "EleutherAI/gpt-neo-125m": ModelType.PT,
+    "EleutherAI/pythia-160m": ModelType.PT,
+    "EleutherAI/gpt-neo-2.7B": ModelType.PT,
+    "EleutherAI/pythia-1b-deduped": ModelType.PT,
+    "EleutherAI/pythia-6.7b": ModelType.PT,
+    "EleutherAI/pythia-70m-deduped": ModelType.PT,
+    "EleutherAI/gpt-neox-20b": ModelType.PT,
+    "EleutherAI/pythia-1.4b-deduped": ModelType.PT,
+    "EleutherAI/pythia-2.7b": ModelType.PT,
+    "EleutherAI/pythia-6.9b-deduped": ModelType.PT,
+    "EleutherAI/pythia-70m": ModelType.PT,
+    "EleutherAI/gpt-j-6b": ModelType.PT,
+    "EleutherAI/pythia-12b-deduped": ModelType.PT,
+    "EleutherAI/gpt-neo-1.3B": ModelType.PT,
+    "EleutherAI/pythia-410m-deduped": ModelType.PT,
+    "EleutherAI/pythia-160m-deduped": ModelType.PT,
+    "EleutherAI/polyglot-ko-12.8b": ModelType.PT,
+    "EleutherAI/pythia-12b": ModelType.PT,
+    "roneneldan/TinyStories-33M": ModelType.PT,
+    "roneneldan/TinyStories-28M": ModelType.PT,
+    "roneneldan/TinyStories-1M": ModelType.PT,
+    "roneneldan/TinyStories-8M": ModelType.PT,
+    "roneneldan/TinyStories-3M": ModelType.PT,
+    "jerryjalapeno/nart-100k-7b": ModelType.FT,
+    "lmsys/vicuna-13b-v1.3": ModelType.IFT,
+    "lmsys/vicuna-7b-v1.3": ModelType.IFT,
+    "lmsys/vicuna-13b-v1.1": ModelType.IFT,
+    "lmsys/vicuna-13b-delta-v1.1": ModelType.IFT,
+    "lmsys/vicuna-7b-delta-v1.1": ModelType.IFT,
+    "abhiramtirumala/DialoGPT-sarcastic-medium": ModelType.FT,
+    "haonan-li/bactrian-x-llama-13b-merged": ModelType.IFT,
+    "Gryphe/MythoLogic-13b": ModelType.IFT,
+    "Gryphe/MythoBoros-13b": ModelType.IFT,
+    "pillowtalks-ai/delta13b": ModelType.FT,
+    "wannaphong/openthaigpt-0.1.0-beta-full-model_for_open_llm_leaderboard": ModelType.FT,
+    "bigscience/bloom-7b1": ModelType.PT,
+    "bigcode/tiny_starcoder_py": ModelType.PT,
+    "bigcode/starcoderplus": ModelType.FT,
+    "bigcode/gpt_bigcode-santacoder": ModelType.PT,
+    "bigcode/starcoder": ModelType.PT,
+    "Open-Orca/OpenOrca-Preview1-13B": ModelType.IFT,
+    "microsoft/DialoGPT-large": ModelType.FT,
+    "microsoft/DialoGPT-small": ModelType.FT,
+    "microsoft/DialoGPT-medium": ModelType.FT,
+    "microsoft/CodeGPT-small-py": ModelType.FT,
+    "Tincando/fiction_story_generator": ModelType.FT,
+    "Pirr/pythia-13b-deduped-green_devil": ModelType.FT,
+    "Aeala/GPT4-x-AlpacaDente2-30b": ModelType.FT,
+    "Aeala/GPT4-x-AlpacaDente-30b": ModelType.FT,
+    "Aeala/GPT4-x-Alpasta-13b": ModelType.FT,
+    "Aeala/VicUnlocked-alpaca-30b": ModelType.IFT,
+    "Tap-M/Luna-AI-Llama2-Uncensored": ModelType.FT,
+    "illuin/test-custom-llama": ModelType.FT,
+    "dvruette/oasst-llama-13b-2-epochs": ModelType.FT,
+    "dvruette/oasst-gpt-neox-20b-1000-steps": ModelType.FT,
+    "dvruette/llama-13b-pretrained-dropout": ModelType.PT,
+    "dvruette/llama-13b-pretrained": ModelType.PT,
+    "dvruette/llama-13b-pretrained-sft-epoch-1": ModelType.FT,
+    "dvruette/llama-13b-pretrained-sft-do2": ModelType.FT,
+    "dvruette/oasst-gpt-neox-20b-3000-steps": ModelType.FT,
+    "dvruette/oasst-pythia-12b-pretrained-sft": ModelType.FT,
+    "dvruette/oasst-pythia-6.9b-4000-steps": ModelType.FT,
+    "dvruette/gpt-neox-20b-full-precision": ModelType.FT,
+    "dvruette/oasst-llama-13b-1000-steps": ModelType.FT,
+    "openlm-research/open_llama_7b_700bt_preview": ModelType.PT,
+    "openlm-research/open_llama_7b": ModelType.PT,
+    "openlm-research/open_llama_7b_v2": ModelType.PT,
+    "openlm-research/open_llama_3b": ModelType.PT,
+    "openlm-research/open_llama_13b": ModelType.PT,
+    "openlm-research/open_llama_3b_v2": ModelType.PT,
+    "PocketDoc/Dans-PileOfSets-Mk1-llama-13b-merged": ModelType.IFT,
+    "GeorgiaTechResearchInstitute/galpaca-30b": ModelType.IFT,
+    "GeorgiaTechResearchInstitute/starcoder-gpteacher-code-instruct": ModelType.IFT,
+    "databricks/dolly-v2-7b": ModelType.IFT,
+    "databricks/dolly-v2-3b": ModelType.IFT,
+    "databricks/dolly-v2-12b": ModelType.IFT,
+    "Rachneet/gpt2-xl-alpaca": ModelType.FT,
+    "Locutusque/gpt2-conversational-or-qa": ModelType.FT,
+    "psyche/kogpt": ModelType.FT,
+    "NbAiLab/nb-gpt-j-6B-alpaca": ModelType.IFT,
+    "Mikael110/llama-2-7b-guanaco-fp16": ModelType.FT,
+    "Mikael110/llama-2-13b-guanaco-fp16": ModelType.FT,
+    "Fredithefish/CrimsonPajama": ModelType.IFT,
+    "Fredithefish/RedPajama-INCITE-Chat-3B-ShareGPT-11K": ModelType.FT,
+    "Fredithefish/ScarletPajama-3B-HF": ModelType.FT,
+    "Fredithefish/RedPajama-INCITE-Chat-3B-Instruction-Tuning-with-GPT-4": ModelType.IFT,
+    "acrastt/RedPajama-INCITE-Chat-Instruct-3B-V1": ModelType.IFT,
+    "eachadea/vicuna-13b-1.1": ModelType.FT,
+    "eachadea/vicuna-7b-1.1": ModelType.FT,
+    "eachadea/vicuna-13b": ModelType.FT,
+    "openaccess-ai-collective/wizard-mega-13b": ModelType.IFT,
+    "openaccess-ai-collective/manticore-13b": ModelType.IFT,
+    "openaccess-ai-collective/manticore-30b-chat-pyg-alpha": ModelType.IFT,
+    "openaccess-ai-collective/minotaur-13b": ModelType.IFT,
+    "openaccess-ai-collective/minotaur-13b-fixed": ModelType.IFT,
+    "openaccess-ai-collective/hippogriff-30b-chat": ModelType.IFT,
+    "openaccess-ai-collective/manticore-13b-chat-pyg": ModelType.IFT,
+    "pythainlp/wangchanglm-7.5B-sft-enth": ModelType.IFT,
+    "pythainlp/wangchanglm-7.5B-sft-en-sharded": ModelType.IFT,
+    "euclaise/gpt-neox-122m-minipile-digits": ModelType.FT,
+    "stabilityai/StableBeluga1-Delta": ModelType.IFT,
+    "stabilityai/stablelm-tuned-alpha-7b": ModelType.IFT,
+    "stabilityai/StableBeluga2": ModelType.IFT,
+    "stabilityai/StableBeluga-13B": ModelType.IFT,
+    "stabilityai/StableBeluga-7B": ModelType.IFT,
+    "stabilityai/stablelm-base-alpha-7b": ModelType.PT,
+    "stabilityai/stablelm-base-alpha-3b": ModelType.PT,
+    "stabilityai/stablelm-tuned-alpha-3b": ModelType.IFT,
+    "alibidaran/medical_transcription_generator": ModelType.FT,
+    "CalderaAI/30B-Lazarus": ModelType.IFT,
+    "CalderaAI/13B-BlueMethod": ModelType.IFT,
+    "CalderaAI/13B-Ouroboros": ModelType.IFT,
+    "KoboldAI/OPT-13B-Erebus": ModelType.FT,
+    "KoboldAI/GPT-J-6B-Janeway": ModelType.FT,
+    "KoboldAI/GPT-J-6B-Shinen": ModelType.FT,
+    "KoboldAI/fairseq-dense-2.7B": ModelType.PT,
+    "KoboldAI/OPT-6B-nerys-v2": ModelType.FT,
+    "KoboldAI/GPT-NeoX-20B-Skein": ModelType.FT,
+    "KoboldAI/PPO_Pygway-6b-Mix": ModelType.FT,
+    "KoboldAI/fairseq-dense-6.7B": ModelType.PT,
+    "KoboldAI/fairseq-dense-125M": ModelType.PT,
+    "KoboldAI/OPT-13B-Nerybus-Mix": ModelType.FT,
+    "KoboldAI/OPT-2.7B-Erebus": ModelType.FT,
+    "KoboldAI/OPT-350M-Nerys-v2": ModelType.FT,
+    "KoboldAI/OPT-2.7B-Nerys-v2": ModelType.FT,
+    "KoboldAI/OPT-2.7B-Nerybus-Mix": ModelType.FT,
+    "KoboldAI/OPT-13B-Nerys-v2": ModelType.FT,
+    "KoboldAI/GPT-NeoX-20B-Erebus": ModelType.FT,
+    "KoboldAI/OPT-6.7B-Erebus": ModelType.FT,
+    "KoboldAI/fairseq-dense-355M": ModelType.PT,
+    "KoboldAI/OPT-6.7B-Nerybus-Mix": ModelType.FT,
+    "KoboldAI/GPT-J-6B-Adventure": ModelType.FT,
+    "KoboldAI/OPT-350M-Erebus": ModelType.FT,
+    "KoboldAI/GPT-J-6B-Skein": ModelType.FT,
+    "KoboldAI/OPT-30B-Erebus": ModelType.FT,
+    "klosax/pythia-160m-deduped-step92k-193bt": ModelType.PT,
+    "klosax/open_llama_3b_350bt_preview": ModelType.PT,
+    "klosax/openllama-3b-350bt": ModelType.PT,
+    "klosax/pythia-70m-deduped-step44k-92bt": ModelType.PT,
+    "klosax/open_llama_13b_600bt_preview": ModelType.PT,
+    "klosax/open_llama_7b_400bt_preview": ModelType.PT,
+    "kfkas/Llama-2-ko-7b-Chat": ModelType.IFT,
+    "WeOpenML/Alpaca-7B-v1": ModelType.IFT,
+    "WeOpenML/PandaLM-Alpaca-7B-v1": ModelType.IFT,
+    "TFLai/gpt2-turkish-uncased": ModelType.FT,
+    "ehartford/WizardLM-13B-Uncensored": ModelType.IFT,
+    "ehartford/dolphin-llama-13b": ModelType.IFT,
+    "ehartford/Wizard-Vicuna-30B-Uncensored": ModelType.FT,
+    "ehartford/WizardLM-30B-Uncensored": ModelType.IFT,
+    "ehartford/Wizard-Vicuna-13B-Uncensored": ModelType.FT,
+    "ehartford/WizardLM-7B-Uncensored": ModelType.IFT,
+    "ehartford/based-30b": ModelType.FT,
+    "ehartford/Wizard-Vicuna-7B-Uncensored": ModelType.FT,
+    "wahaha1987/llama_7b_sharegpt94k_fastchat": ModelType.FT,
+    "wahaha1987/llama_13b_sharegpt94k_fastchat": ModelType.FT,
+    "OpenAssistant/oasst-sft-1-pythia-12b": ModelType.FT,
+    "OpenAssistant/stablelm-7b-sft-v7-epoch-3": ModelType.IFT,
+    "OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5": ModelType.FT,
+    "OpenAssistant/pythia-12b-sft-v8-2.5k-steps": ModelType.IFT,
+    "OpenAssistant/pythia-12b-sft-v8-7k-steps": ModelType.IFT,
+    "OpenAssistant/pythia-12b-pre-v8-12.5k-steps": ModelType.IFT,
+    "OpenAssistant/llama2-13b-orca-8k-3319": ModelType.IFT,
+    "junelee/wizard-vicuna-13b": ModelType.FT,
+    "BreadAi/gpt-YA-1-1_160M": ModelType.PT,
+    "BreadAi/MuseCan": ModelType.PT,
+    "BreadAi/MusePy-1-2": ModelType.PT,
+    "BreadAi/DiscordPy": ModelType.PT,
+    "BreadAi/PM_modelV2": ModelType.PT,
+    "BreadAi/gpt-Youtube": ModelType.PT,
+    "BreadAi/StoryPy": ModelType.FT,
+    "julianweng/Llama-2-7b-chat-orcah": ModelType.FT,
+    "AGI-inc/lora_moe_7b_baseline": ModelType.FT,
+    "AGI-inc/lora_moe_7b": ModelType.FT,
+    "togethercomputer/GPT-NeoXT-Chat-Base-20B": ModelType.IFT,
+    "togethercomputer/RedPajama-INCITE-Chat-7B-v0.1": ModelType.IFT,
+    "togethercomputer/RedPajama-INCITE-Instruct-7B-v0.1": ModelType.IFT,
+    "togethercomputer/RedPajama-INCITE-7B-Base": ModelType.PT,
+    "togethercomputer/RedPajama-INCITE-7B-Instruct": ModelType.IFT,
+    "togethercomputer/RedPajama-INCITE-Base-3B-v1": ModelType.PT,
+    "togethercomputer/Pythia-Chat-Base-7B": ModelType.IFT,
+    "togethercomputer/RedPajama-INCITE-Base-7B-v0.1": ModelType.PT,
+    "togethercomputer/GPT-JT-6B-v1": ModelType.IFT,
+    "togethercomputer/GPT-JT-6B-v0": ModelType.IFT,
+    "togethercomputer/RedPajama-INCITE-Chat-3B-v1": ModelType.IFT,
+    "togethercomputer/RedPajama-INCITE-7B-Chat": ModelType.IFT,
+    "togethercomputer/RedPajama-INCITE-Instruct-3B-v1": ModelType.IFT,
+    "Writer/camel-5b-hf": ModelType.IFT,
+    "Writer/palmyra-base": ModelType.PT,
+    "MBZUAI/LaMini-GPT-1.5B": ModelType.IFT,
+    "MBZUAI/lamini-cerebras-111m": ModelType.IFT,
+    "MBZUAI/lamini-neo-1.3b": ModelType.IFT,
+    "MBZUAI/lamini-cerebras-1.3b": ModelType.IFT,
+    "MBZUAI/lamini-cerebras-256m": ModelType.IFT,
+    "MBZUAI/LaMini-GPT-124M": ModelType.IFT,
+    "MBZUAI/lamini-neo-125m": ModelType.IFT,
+    "TehVenom/DiffMerge-DollyGPT-Pygmalion": ModelType.FT,
+    "TehVenom/PPO_Shygmalion-6b": ModelType.FT,
+    "TehVenom/Dolly_Shygmalion-6b-Dev_V8P2": ModelType.FT,
+    "TehVenom/Pygmalion_AlpacaLora-7b": ModelType.FT,
+    "TehVenom/PPO_Pygway-V8p4_Dev-6b": ModelType.FT,
+    "TehVenom/Dolly_Malion-6b": ModelType.FT,
+    "TehVenom/PPO_Shygmalion-V8p4_Dev-6b": ModelType.FT,
+    "TehVenom/ChanMalion": ModelType.FT,
+    "TehVenom/GPT-J-Pyg_PPO-6B": ModelType.IFT,
+    "TehVenom/Pygmalion-13b-Merged": ModelType.FT,
+    "TehVenom/Metharme-13b-Merged": ModelType.IFT,
+    "TehVenom/Dolly_Shygmalion-6b": ModelType.FT,
+    "TehVenom/GPT-J-Pyg_PPO-6B-Dev-V8p4": ModelType.IFT,
+    "georgesung/llama2_7b_chat_uncensored": ModelType.FT,
+    "vicgalle/gpt2-alpaca": ModelType.IFT,
+    "vicgalle/alpaca-7b": ModelType.FT,
+    "vicgalle/gpt2-alpaca-gpt4": ModelType.IFT,
+    "facebook/opt-350m": ModelType.PT,
+    "facebook/opt-125m": ModelType.PT,
+    "facebook/xglm-4.5B": ModelType.PT,
+    "facebook/opt-2.7b": ModelType.PT,
+    "facebook/opt-6.7b": ModelType.PT,
+    "facebook/galactica-30b": ModelType.PT,
+    "facebook/opt-13b": ModelType.PT,
+    "facebook/opt-66b": ModelType.PT,
+    "facebook/xglm-7.5B": ModelType.PT,
+    "facebook/xglm-564M": ModelType.PT,
+    "facebook/opt-30b": ModelType.PT,
+    "golaxy/gogpt-7b": ModelType.FT,
+    "golaxy/gogpt2-7b": ModelType.FT,
+    "golaxy/gogpt-7b-bloom": ModelType.FT,
+    "golaxy/gogpt-3b-bloom": ModelType.FT,
+    "psmathur/orca_mini_v2_7b": ModelType.IFT,
+    "psmathur/orca_mini_7b": ModelType.IFT,
+    "psmathur/orca_mini_3b": ModelType.IFT,
+    "psmathur/orca_mini_v2_13b": ModelType.IFT,
+    "gpt2-xl": ModelType.PT,
+    "lxe/Cerebras-GPT-2.7B-Alpaca-SP": ModelType.FT,
+    "Monero/Manticore-13b-Chat-Pyg-Guanaco": ModelType.FT,
+    "Monero/WizardLM-Uncensored-SuperCOT-StoryTelling-30b": ModelType.IFT,
+    "Monero/WizardLM-13b-OpenAssistant-Uncensored": ModelType.IFT,
+    "Monero/WizardLM-30B-Uncensored-Guanaco-SuperCOT-30b": ModelType.IFT,
+    "jzjiao/opt-1.3b-rlhf": ModelType.FT,
+    "HuggingFaceH4/starchat-beta": ModelType.IFT,
+    "KnutJaegersberg/gpt-2-xl-EvolInstruct": ModelType.IFT,
+    "KnutJaegersberg/megatron-GPT-2-345m-EvolInstruct": ModelType.IFT,
+    "KnutJaegersberg/galactica-orca-wizardlm-1.3b": ModelType.IFT,
+    "openchat/openchat_8192": ModelType.IFT,
+    "openchat/openchat_v2": ModelType.IFT,
+    "openchat/openchat_v2_w": ModelType.IFT,
+    "ausboss/llama-13b-supercot": ModelType.IFT,
+    "ausboss/llama-30b-supercot": ModelType.IFT,
+    "Neko-Institute-of-Science/metharme-7b": ModelType.IFT,
+    "Neko-Institute-of-Science/pygmalion-7b": ModelType.FT,
+    "SebastianSchramm/Cerebras-GPT-111M-instruction": ModelType.IFT,
+    "victor123/WizardLM-13B-1.0": ModelType.IFT,
+    "OpenBuddy/openbuddy-openllama-13b-v7-fp16": ModelType.FT,
+    "OpenBuddy/openbuddy-llama2-13b-v8.1-fp16": ModelType.FT,
+    "OpenBuddyEA/openbuddy-llama-30b-v7.1-bf16": ModelType.FT,
+    "baichuan-inc/Baichuan-7B": ModelType.PT,
+    "tiiuae/falcon-40b-instruct": ModelType.IFT,
+    "tiiuae/falcon-40b": ModelType.PT,
+    "tiiuae/falcon-7b": ModelType.PT,
+    "YeungNLP/firefly-llama-13b": ModelType.FT,
+    "YeungNLP/firefly-llama-13b-v1.2": ModelType.FT,
+    "YeungNLP/firefly-llama2-13b": ModelType.FT,
+    "YeungNLP/firefly-ziya-13b": ModelType.FT,
+    "shaohang/Sparse0.5_OPT-1.3": ModelType.FT,
+    "xzuyn/Alpacino-SuperCOT-13B": ModelType.IFT,
+    "xzuyn/MedicWizard-7B": ModelType.FT,
+    "xDAN-AI/xDAN_13b_l2_lora": ModelType.FT,
+    "beomi/KoAlpaca-Polyglot-5.8B": ModelType.FT,
+    "beomi/llama-2-ko-7b": ModelType.IFT,
+    "Salesforce/codegen-6B-multi": ModelType.PT,
+    "Salesforce/codegen-16B-nl": ModelType.PT,
+    "Salesforce/codegen-6B-nl": ModelType.PT,
+    "ai-forever/rugpt3large_based_on_gpt2": ModelType.FT,
+    "gpt2-large": ModelType.PT,
+    "frank098/orca_mini_3b_juniper": ModelType.FT,
+    "frank098/WizardLM_13B_juniper": ModelType.FT,
+    "FPHam/Free_Sydney_13b_HF": ModelType.FT,
+    "huggingface/llama-13b": ModelType.PT,
+    "huggingface/llama-7b": ModelType.PT,
+    "huggingface/llama-65b": ModelType.PT,
+    "huggingface/llama-30b": ModelType.PT,
+    "Henk717/chronoboros-33B": ModelType.IFT,
+    "jondurbin/airoboros-13b-gpt4-1.4": ModelType.IFT,
+    "jondurbin/airoboros-7b": ModelType.IFT,
+    "jondurbin/airoboros-7b-gpt4": ModelType.IFT,
+    "jondurbin/airoboros-7b-gpt4-1.1": ModelType.IFT,
+    "jondurbin/airoboros-7b-gpt4-1.2": ModelType.IFT,
+    "jondurbin/airoboros-7b-gpt4-1.3": ModelType.IFT,
+    "jondurbin/airoboros-7b-gpt4-1.4": ModelType.IFT,
+    "jondurbin/airoboros-l2-7b-gpt4-1.4.1": ModelType.IFT,
+    "jondurbin/airoboros-l2-13b-gpt4-1.4.1": ModelType.IFT,
+    "jondurbin/airoboros-l2-70b-gpt4-1.4.1": ModelType.IFT,
+    "jondurbin/airoboros-13b": ModelType.IFT,
+    "jondurbin/airoboros-33b-gpt4-1.4": ModelType.IFT,
+    "jondurbin/airoboros-33b-gpt4-1.2": ModelType.IFT,
+    "jondurbin/airoboros-65b-gpt4-1.2": ModelType.IFT,
+    "ariellee/SuperPlatty-30B": ModelType.IFT,
+    "danielhanchen/open_llama_3b_600bt_preview": ModelType.FT,
+    "cerebras/Cerebras-GPT-256M": ModelType.PT,
+    "cerebras/Cerebras-GPT-1.3B": ModelType.PT,
+    "cerebras/Cerebras-GPT-13B": ModelType.PT,
+    "cerebras/Cerebras-GPT-2.7B": ModelType.PT,
+    "cerebras/Cerebras-GPT-111M": ModelType.PT,
+    "cerebras/Cerebras-GPT-6.7B": ModelType.PT,
+    "Yhyu13/oasst-rlhf-2-llama-30b-7k-steps-hf": ModelType.RL,
+    "Yhyu13/llama-30B-hf-openassitant": ModelType.FT,
+    "NousResearch/Nous-Hermes-Llama2-13b": ModelType.IFT,
+    "NousResearch/Nous-Hermes-llama-2-7b": ModelType.IFT,
+    "NousResearch/Redmond-Puffin-13B": ModelType.IFT,
+    "NousResearch/Nous-Hermes-13b": ModelType.IFT,
+    "project-baize/baize-v2-7b": ModelType.IFT,
+    "project-baize/baize-v2-13b": ModelType.IFT,
+    "LLMs/WizardLM-13B-V1.0": ModelType.FT,
+    "LLMs/AlpacaGPT4-7B-elina": ModelType.FT,
+    "wenge-research/yayi-7b": ModelType.FT,
+    "wenge-research/yayi-7b-llama2": ModelType.FT,
+    "wenge-research/yayi-13b-llama2": ModelType.FT,
+    "yhyhy3/open_llama_7b_v2_med_instruct": ModelType.IFT,
+    "llama-anon/instruct-13b": ModelType.IFT,
+    "huggingtweets/jerma985": ModelType.FT,
+    "huggingtweets/gladosystem": ModelType.FT,
+    "huggingtweets/bladeecity-jerma985": ModelType.FT,
+    "huggyllama/llama-13b": ModelType.PT,
+    "huggyllama/llama-65b": ModelType.PT,
+    "FabbriSimo01/Facebook_opt_1.3b_Quantized": ModelType.PT,
+    "upstage/Llama-2-70b-instruct": ModelType.IFT,
+    "upstage/Llama-2-70b-instruct-1024": ModelType.IFT,
+    "upstage/llama-65b-instruct": ModelType.IFT,
+    "upstage/llama-30b-instruct-2048": ModelType.IFT,
+    "upstage/llama-30b-instruct": ModelType.IFT,
+    "WizardLM/WizardLM-13B-1.0": ModelType.IFT,
+    "WizardLM/WizardLM-13B-V1.1": ModelType.IFT,
+    "WizardLM/WizardLM-13B-V1.2": ModelType.IFT,
+    "WizardLM/WizardLM-30B-V1.0": ModelType.IFT,
+    "WizardLM/WizardCoder-15B-V1.0": ModelType.IFT,
+    "gpt2": ModelType.PT,
+    "keyfan/vicuna-chinese-replication-v1.1": ModelType.IFT,
+    "nthngdy/pythia-owt2-70m-100k": ModelType.FT,
+    "nthngdy/pythia-owt2-70m-50k": ModelType.FT,
+    "quantumaikr/KoreanLM-hf": ModelType.FT,
+    "quantumaikr/open_llama_7b_hf": ModelType.FT,
+    "quantumaikr/QuantumLM-70B-hf": ModelType.IFT,
+    "MayaPH/FinOPT-Lincoln": ModelType.FT,
+    "MayaPH/FinOPT-Franklin": ModelType.FT,
+    "MayaPH/GodziLLa-30B": ModelType.IFT,
+    "MayaPH/GodziLLa-30B-plus": ModelType.IFT,
+    "MayaPH/FinOPT-Washington": ModelType.FT,
+    "ogimgio/gpt-neo-125m-neurallinguisticpioneers": ModelType.FT,
+    "layoric/llama-2-13b-code-alpaca": ModelType.FT,
+    "CobraMamba/mamba-gpt-3b": ModelType.FT,
+    "CobraMamba/mamba-gpt-3b-v2": ModelType.FT,
+    "CobraMamba/mamba-gpt-3b-v3": ModelType.FT,
+    "timdettmers/guanaco-33b-merged": ModelType.FT,
+    "elinas/chronos-33b": ModelType.IFT,
+    "heegyu/RedTulu-Uncensored-3B-0719": ModelType.IFT,
+    "heegyu/WizardVicuna-Uncensored-3B-0719": ModelType.IFT,
+    "heegyu/WizardVicuna-3B-0719": ModelType.IFT,
+    "meta-llama/Llama-2-7b-chat-hf": ModelType.RL,
+    "meta-llama/Llama-2-7b-hf": ModelType.PT,
+    "meta-llama/Llama-2-13b-chat-hf": ModelType.RL,
+    "meta-llama/Llama-2-13b-hf": ModelType.PT,
+    "meta-llama/Llama-2-70b-chat-hf": ModelType.RL,
+    "meta-llama/Llama-2-70b-hf": ModelType.PT,
+    "xhyi/PT_GPTNEO350_ATG": ModelType.FT,
+    "h2oai/h2ogpt-gm-oasst1-en-1024-20b": ModelType.FT,
+    "h2oai/h2ogpt-gm-oasst1-en-1024-open-llama-7b-preview-400bt": ModelType.FT,
+    "h2oai/h2ogpt-oig-oasst1-512-6_9b": ModelType.IFT,
+    "h2oai/h2ogpt-oasst1-512-12b": ModelType.IFT,
+    "h2oai/h2ogpt-oig-oasst1-256-6_9b": ModelType.IFT,
+    "h2oai/h2ogpt-gm-oasst1-en-2048-open-llama-7b-preview-300bt": ModelType.FT,
+    "h2oai/h2ogpt-oasst1-512-20b": ModelType.IFT,
+    "h2oai/h2ogpt-gm-oasst1-en-2048-open-llama-7b-preview-300bt-v2": ModelType.FT,
+    "h2oai/h2ogpt-gm-oasst1-en-1024-12b": ModelType.FT,
+    "h2oai/h2ogpt-gm-oasst1-multilang-1024-20b": ModelType.FT,
+    "bofenghuang/vigogne-13b-instruct": ModelType.IFT,
+    "bofenghuang/vigogne-13b-chat": ModelType.FT,
+    "bofenghuang/vigogne-2-7b-instruct": ModelType.IFT,
+    "bofenghuang/vigogne-7b-instruct": ModelType.IFT,
+    "bofenghuang/vigogne-7b-chat": ModelType.FT,
+    "Vmware/open-llama-7b-v2-open-instruct": ModelType.IFT,
+    "VMware/open-llama-0.7T-7B-open-instruct-v1.1": ModelType.IFT,
+    "ewof/koishi-instruct-3b": ModelType.IFT,
+    "gywy/llama2-13b-chinese-v1": ModelType.FT,
+    "GOAT-AI/GOAT-7B-Community": ModelType.FT,
+    "psyche/kollama2-7b": ModelType.FT,
+    "TheTravellingEngineer/llama2-7b-hf-guanaco": ModelType.FT,
+    "beaugogh/pythia-1.4b-deduped-sharegpt": ModelType.FT,
+    "augtoma/qCammel-70-x": ModelType.IFT,
+    "Lajonbot/Llama-2-7b-chat-hf-instruct-pl-lora_unload": ModelType.IFT,
+    "anhnv125/pygmalion-6b-roleplay": ModelType.FT,
+    "64bits/LexPodLM-13B": ModelType.FT,
+}
+
+
+def model_type_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

src/display_models/modelcard_filter.py

@@ -0,0 +1,26 @@
+import huggingface_hub
+from huggingface_hub import ModelCard
+
+
+# ht to @Wauplin, thank you for the snippet!
+# See https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/317
+def check_model_card(repo_id: str) -> tuple[bool, str]:
+    # Returns operation status, and error message
+    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, ""

src/display_models/read_results.py

@@ -0,0 +1,153 @@
+import json
+import os
+from dataclasses import dataclass
+from typing import Dict, List, Tuple
+
+import dateutil
+import numpy as np
+
+from src.display_models.utils import AutoEvalColumn, make_clickable_model
+
+METRICS = ["acc_norm", "acc_norm", "acc", "mc2"]
+BENCHMARKS = ["arc:challenge", "hellaswag", "hendrycksTest", "truthfulqa:mc"]
+BENCH_TO_NAME = {
+    "arc:challenge": AutoEvalColumn.arc.name,
+    "hellaswag": AutoEvalColumn.hellaswag.name,
+    "hendrycksTest": AutoEvalColumn.mmlu.name,
+    "truthfulqa:mc": AutoEvalColumn.truthfulqa.name,
+}
+
+
+@dataclass
+class EvalResult:
+    eval_name: str
+    org: str
+    model: str
+    revision: str
+    results: dict
+    precision: str = ""
+    model_type: str = ""
+    weight_type: str = "Original"
+    date: str = ""
+
+    def to_dict(self):
+        from src.load_from_hub import is_model_on_hub
+
+        if self.org is not None:
+            base_model = f"{self.org}/{self.model}"
+        else:
+            base_model = f"{self.model}"
+        data_dict = {}
+
+        data_dict["eval_name"] = self.eval_name  # not a column, just a save name
+        data_dict["weight_type"] = self.weight_type  # not a column, just a save name
+        data_dict[AutoEvalColumn.precision.name] = self.precision
+        data_dict[AutoEvalColumn.model_type.name] = self.model_type
+        data_dict[AutoEvalColumn.model.name] = make_clickable_model(base_model)
+        data_dict[AutoEvalColumn.dummy.name] = base_model
+        data_dict[AutoEvalColumn.revision.name] = self.revision
+        data_dict[AutoEvalColumn.average.name] = sum([v for k, v in self.results.items()]) / 4.0
+        data_dict[AutoEvalColumn.still_on_hub.name] = (
+            is_model_on_hub(base_model, self.revision)[0] or base_model == "baseline"
+        )
+
+        for benchmark in BENCHMARKS:
+            if benchmark not in self.results.keys():
+                self.results[benchmark] = None
+
+        for k, v in BENCH_TO_NAME.items():
+            data_dict[v] = self.results[k]
+
+        return data_dict
+
+
+def parse_eval_result(json_filepath: str) -> Tuple[str, list[dict]]:
+    with open(json_filepath) as fp:
+        data = json.load(fp)
+
+    for mmlu_k in ["harness|hendrycksTest-abstract_algebra|5", "hendrycksTest-abstract_algebra"]:
+        if mmlu_k in data["versions"] and data["versions"][mmlu_k] == 0:
+            return None, []  # we skip models with the wrong version
+
+    try:
+        config = data["config"]
+    except KeyError:
+        config = data["config_general"]
+    model = config.get("model_name", None)
+    if model is None:
+        model = config.get("model_args", None)
+
+    model_sha = config.get("model_sha", "")
+    model_split = model.split("/", 1)
+
+    precision = config.get("model_dtype")
+
+    model = model_split[-1]
+
+    if len(model_split) == 1:
+        org = None
+        model = model_split[0]
+        result_key = f"{model}_{precision}"
+    else:
+        org = model_split[0]
+        model = model_split[1]
+        result_key = f"{org}_{model}_{precision}"
+
+    eval_results = []
+    for benchmark, metric in zip(BENCHMARKS, METRICS):
+        accs = np.array([v.get(metric, None) for k, v in data["results"].items() if benchmark in k])
+        if accs.size == 0 or any([acc is None for acc in accs]):
+            continue
+        mean_acc = np.mean(accs) * 100.0
+        eval_results.append(
+            EvalResult(
+                eval_name=result_key,
+                org=org,
+                model=model,
+                revision=model_sha,
+                results={benchmark: mean_acc},
+                precision=precision,  # todo model_type=, weight_type=
+                date=config.get("submission_date"),
+            )
+        )
+
+    return result_key, eval_results
+
+
+def get_eval_results() -> List[EvalResult]:
+    json_filepaths = []
+
+    for root, dir, files in os.walk("eval-results"):
+        # 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
+        # store results by precision maybe?
+        try:
+            files.sort(key=lambda x: x.removesuffix(".json").removeprefix("results_")[:-7])
+        except dateutil.parser._parser.ParserError:
+            files = [files[-1]]
+
+        # up_to_date = files[-1]
+        for file in files:
+            json_filepaths.append(os.path.join(root, file))
+
+    eval_results = {}
+    for json_filepath in json_filepaths:
+        result_key, results = parse_eval_result(json_filepath)
+        for eval_result in results:
+            if result_key in eval_results.keys():
+                eval_results[result_key].results.update(eval_result.results)
+            else:
+                eval_results[result_key] = eval_result
+
+    eval_results = [v for v in eval_results.values()]
+
+    return eval_results
+
+
+def get_eval_results_dicts() -> List[Dict]:
+    eval_results = get_eval_results()
+
+    return [e.to_dict() for e in eval_results]

src/display_models/utils.py

@@ -0,0 +1,146 @@
+import os
+from dataclasses import dataclass
+
+from huggingface_hub import HfApi
+
+API = HfApi()
+
+
+# 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
+
+
+def fields(raw_class):
+    return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
+
+
+@dataclass(frozen=True)
+class AutoEvalColumn:  # Auto evals column
+    model_type_symbol = ColumnContent("T", "str", True)
+    model = ColumnContent("Model", "markdown", True)
+    average = ColumnContent("Average ⬆️", "number", True)
+    arc = ColumnContent("ARC", "number", True)
+    hellaswag = ColumnContent("HellaSwag", "number", True)
+    mmlu = ColumnContent("MMLU", "number", True)
+    truthfulqa = ColumnContent("TruthfulQA", "number", True)
+    model_type = ColumnContent("Type", "str", False)
+    precision = ColumnContent("Precision", "str", False)  # , True)
+    license = ColumnContent("Hub License", "str", False)
+    params = ColumnContent("#Params (B)", "number", False)
+    likes = ColumnContent("Hub ❤️", "number", False)
+    still_on_hub = ColumnContent("Available on the hub", "bool", False)
+    revision = ColumnContent("Model sha", "str", False, False)
+    dummy = ColumnContent(
+        "model_name_for_query", "str", True
+    )  # dummy col to implement search bar (hidden by custom CSS)
+
+
+@dataclass(frozen=True)
+class EloEvalColumn:  # Elo evals column
+    model = ColumnContent("Model", "markdown", True)
+    gpt4 = ColumnContent("GPT-4 (all)", "number", True)
+    human_all = ColumnContent("Human (all)", "number", True)
+    human_instruct = ColumnContent("Human (instruct)", "number", True)
+    human_code_instruct = ColumnContent("Human (code-instruct)", "number", True)
+
+
+@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)
+
+
+LLAMAS = [
+    "huggingface/llama-7b",
+    "huggingface/llama-13b",
+    "huggingface/llama-30b",
+    "huggingface/llama-65b",
+]
+
+
+KOALA_LINK = "https://huggingface.co/TheBloke/koala-13B-HF"
+VICUNA_LINK = "https://huggingface.co/lmsys/vicuna-13b-delta-v1.1"
+OASST_LINK = "https://huggingface.co/OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5"
+DOLLY_LINK = "https://huggingface.co/databricks/dolly-v2-12b"
+MODEL_PAGE = "https://huggingface.co/models"
+LLAMA_LINK = "https://ai.facebook.com/blog/large-language-model-llama-meta-ai/"
+VICUNA_LINK = "https://huggingface.co/CarperAI/stable-vicuna-13b-delta"
+ALPACA_LINK = "https://crfm.stanford.edu/2023/03/13/alpaca.html"
+
+
+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}"
+
+    if model_name in LLAMAS:
+        link = LLAMA_LINK
+        model_name = model_name.split("/")[1]
+    elif model_name == "HuggingFaceH4/stable-vicuna-13b-2904":
+        link = VICUNA_LINK
+        model_name = "stable-vicuna-13b"
+    elif model_name == "HuggingFaceH4/llama-7b-ift-alpaca":
+        link = ALPACA_LINK
+        model_name = "alpaca-13b"
+    if model_name == "dolly-12b":
+        link = DOLLY_LINK
+    elif model_name == "vicuna-13b":
+        link = VICUNA_LINK
+    elif model_name == "koala-13b":
+        link = KOALA_LINK
+    elif model_name == "oasst-12b":
+        link = OASST_LINK
+
+    details_model_name = model_name.replace("/", "__")
+    details_link = f"https://huggingface.co/datasets/open-llm-leaderboard/details_{details_model_name}"
+
+    if not bool(os.getenv("DEBUG", "False")):
+        # We only add these checks when not debugging, as they are extremely slow
+        print(f"details_link: {details_link}")
+        try:
+            check_path = list(
+                API.list_files_info(
+                    repo_id=f"open-llm-leaderboard/details_{details_model_name}",
+                    paths="README.md",
+                    repo_type="dataset",
+                )
+            )
+            print(f"check_path: {check_path}")
+        except Exception as err:
+            # No details repo for this model
+            print(f"No details repo for this model: {err}")
+            return model_hyperlink(link, model_name)
+
+    return model_hyperlink(link, model_name) + "  " + model_hyperlink(details_link, "📑")
+
+
+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/envs.py

@@ -1,32 +0,0 @@
-import os
-from huggingface_hub import HfApi
-
-# clone / pull the lmeh eval data
-HF_TOKEN = os.environ.get("HF_TOKEN", None)
-
-REPO_ID = "open-llm-leaderboard/open_llm_leaderboard"
-QUEUE_REPO = "open-llm-leaderboard/requests"
-AGGREGATED_REPO = "open-llm-leaderboard/contents"
-VOTES_REPO = "open-llm-leaderboard/votes"
-
-HF_HOME = os.getenv("HF_HOME", ".")
-
-# Check HF_HOME write access
-print(f"Initial HF_HOME set to: {HF_HOME}")
-
-if not os.access(HF_HOME, os.W_OK):
-    print(f"No write access to HF_HOME: {HF_HOME}. Resetting to current directory.")
-    HF_HOME = "."
-    os.environ["HF_HOME"] = HF_HOME
-else:
-    print("Write access confirmed for HF_HOME")
-
-VOTES_PATH = os.path.join(HF_HOME, "model-votes")
-EVAL_REQUESTS_PATH = os.path.join(HF_HOME, "eval-queue")
-
-# Rate limit variables
-RATE_LIMIT_PERIOD = 7
-RATE_LIMIT_QUOTA = 5
-HAS_HIGHER_RATE_LIMIT = []
-
-API = HfApi(token=HF_TOKEN)

src/leaderboard/filter_models.py

@@ -1,75 +0,0 @@
-from src.display.formatting import model_hyperlink
-from src.display.utils import AutoEvalColumn
-
-
-# Models which have been flagged by users as being problematic for a reason or another
-# (Model name to forum discussion link)
-# None for the v2 so far!
-FLAGGED_MODELS = {}
-
-# Models which have been requested by orgs to not be submitted on the leaderboard
-DO_NOT_SUBMIT_MODELS = [
-    "Voicelab/trurl-2-13b",  # trained on MMLU
-    "TigerResearch/tigerbot-70b-chat",  # per authors request
-    "TigerResearch/tigerbot-70b-chat-v2",  # per authors request
-    "TigerResearch/tigerbot-70b-chat-v4-4k",  # per authors request
-]
-
-
-def flag_models(leaderboard_data: list[dict]):
-    """Flags models based on external criteria or flagged status."""
-    for model_data in leaderboard_data:
-        # Skip flagging if maintainers_highlight is True
-        if model_data.get(AutoEvalColumn.maintainers_highlight.name, False):
-            model_data[AutoEvalColumn.not_flagged.name] = True
-            continue
-
-        # If a model is not flagged, use its "fullname" as a key
-        if model_data[AutoEvalColumn.not_flagged.name]:
-            flag_key = model_data[AutoEvalColumn.fullname.name]
-        else:
-            flag_key = None
-
-        # Reverse the logic: Check for non-flagged models instead
-        if flag_key in FLAGGED_MODELS:
-            issue_num = FLAGGED_MODELS[flag_key].split("/")[-1]
-            issue_link = model_hyperlink(
-                FLAGGED_MODELS[flag_key],
-                f"See discussion #{issue_num}",
-            )
-            model_data[AutoEvalColumn.model.name] = (
-                f"{model_data[AutoEvalColumn.model.name]} has been flagged! {issue_link}"
-            )
-            model_data[AutoEvalColumn.not_flagged.name] = False
-        else:
-            model_data[AutoEvalColumn.not_flagged.name] = True
-
-
-def remove_forbidden_models(leaderboard_data: list[dict]):
-    """Removes models from the leaderboard based on the DO_NOT_SUBMIT list."""
-    indices_to_remove = []
-    for ix, model in enumerate(leaderboard_data):
-        if model[AutoEvalColumn.fullname.name] in DO_NOT_SUBMIT_MODELS:
-            indices_to_remove.append(ix)
-
-    # Remove the models from the list
-    for ix in reversed(indices_to_remove):
-        leaderboard_data.pop(ix)
-    return leaderboard_data
-
-"""
-def remove_forbidden_models(leaderboard_data):
-    #Removes models from the leaderboard based on the DO_NOT_SUBMIT list.
-    indices_to_remove = []
-    for ix, row in leaderboard_data.iterrows():
-        if row[AutoEvalColumn.fullname.name] in DO_NOT_SUBMIT_MODELS:
-            indices_to_remove.append(ix)
-
-    # Remove the models from the list
-    return leaderboard_data.drop(indices_to_remove)
-"""
-
-
-def filter_models_flags(leaderboard_data: list[dict]):
-    leaderboard_data = remove_forbidden_models(leaderboard_data)
-    flag_models(leaderboard_data)

src/load_from_hub.py

@@ -0,0 +1,152 @@
+import json
+import os
+
+import pandas as pd
+from huggingface_hub import Repository
+from transformers import AutoConfig
+from collections import defaultdict
+
+from src.assets.hardcoded_evals import baseline, gpt4_values, gpt35_values
+from src.display_models.get_model_metadata import apply_metadata
+from src.display_models.read_results import get_eval_results_dicts, make_clickable_model
+from src.display_models.utils import AutoEvalColumn, EvalQueueColumn, has_no_nan_values
+
+IS_PUBLIC = bool(os.environ.get("IS_PUBLIC", True))
+
+
+def get_all_requested_models(requested_models_dir: str) -> set[str]:
+    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
+
+
+def load_all_info_from_hub(QUEUE_REPO: str, RESULTS_REPO: str, QUEUE_PATH: str, RESULTS_PATH: str) -> list[Repository]:
+    eval_queue_repo = None
+    eval_results_repo = None
+    requested_models = None
+
+    print("Pulling evaluation requests and results.")
+
+    eval_queue_repo = Repository(
+        local_dir=QUEUE_PATH,
+        clone_from=QUEUE_REPO,
+        repo_type="dataset",
+    )
+    eval_queue_repo.git_pull()
+
+    eval_results_repo = Repository(
+        local_dir=RESULTS_PATH,
+        clone_from=RESULTS_REPO,
+        repo_type="dataset",
+    )
+    eval_results_repo.git_pull()
+
+    requested_models, users_to_submission_dates = get_all_requested_models("eval-queue")
+
+    return eval_queue_repo, requested_models, eval_results_repo, users_to_submission_dates
+
+
+def get_leaderboard_df(
+    eval_results: Repository, eval_results_private: Repository, cols: list, benchmark_cols: list
+) -> pd.DataFrame:
+    if eval_results:
+        print("Pulling evaluation results for the leaderboard.")
+        eval_results.git_pull()
+    if eval_results_private:
+        print("Pulling evaluation results for the leaderboard.")
+        eval_results_private.git_pull()
+
+    all_data = get_eval_results_dicts()
+
+    if not IS_PUBLIC:
+        all_data.append(gpt4_values)
+        all_data.append(gpt35_values)
+
+    all_data.append(baseline)
+    apply_metadata(all_data)  # Populate model type based on known hardcoded values in `metadata.py`
+
+    df = pd.DataFrame.from_records(all_data)
+    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(
+    eval_queue: Repository, eval_queue_private: Repository, save_path: str, cols: list
+) -> list[pd.DataFrame]:
+    if eval_queue:
+        print("Pulling changes for the evaluation queue.")
+        eval_queue.git_pull()
+    if eval_queue_private:
+        print("Pulling changes for the evaluation queue.")
+        eval_queue_private.git_pull()
+
+    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 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]
+
+
+def is_model_on_hub(model_name: str, revision: str) -> bool:
+    try:
+        AutoConfig.from_pretrained(model_name, revision=revision, trust_remote_code=False)
+        return True, None
+
+    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.",
+        )
+
+    except Exception as e:
+        print(f"Could not get the model config from the hub.: {e}")
+        return False, "was not found on hub!"

src/populate.py

@@ -1,54 +0,0 @@
-import pathlib
-import pandas as pd
-from datasets import Dataset
-from src.display.formatting import has_no_nan_values, make_clickable_model
-from src.display.utils import AutoEvalColumn, EvalQueueColumn
-from src.leaderboard.filter_models import filter_models_flags
-from src.display.utils import load_json_data
-
-
-def _process_model_data(entry, model_name_key="model", revision_key="revision"):
-    """Enrich model data with clickable links and revisions."""
-    entry[EvalQueueColumn.model_name.name] = entry.get(model_name_key, "")
-    entry[EvalQueueColumn.model_link.name] = make_clickable_model(entry.get(model_name_key, ""))
-    entry[EvalQueueColumn.revision.name] = entry.get(revision_key, "main")
-    return entry
-
-
-def get_evaluation_queue_df(save_path, cols):
-    """Generate dataframes for pending, running, and finished evaluation entries."""
-    save_path = pathlib.Path(save_path)
-    all_evals = []
-
-    for path in save_path.rglob("*.json"):
-        data = load_json_data(path)
-        if data:
-            all_evals.append(_process_model_data(data))
-
-    # Organizing data by status
-    status_map = {
-        "PENDING": ["PENDING", "RERUN"],
-        "RUNNING": ["RUNNING"],
-        "FINISHED": ["FINISHED", "PENDING_NEW_EVAL"],
-    }
-    status_dfs = {status: [] for status in status_map}
-    for eval_data in all_evals:
-        for status, extra_statuses in status_map.items():
-            if eval_data["status"] in extra_statuses:
-                status_dfs[status].append(eval_data)
-
-    return tuple(pd.DataFrame(status_dfs[status], columns=cols) for status in ["FINISHED", "RUNNING", "PENDING"])
-
-
-def get_leaderboard_df(leaderboard_dataset: Dataset, cols: list, benchmark_cols: list):
-    """Retrieve and process leaderboard data."""
-    all_data_json = leaderboard_dataset.to_dict()
-    num_items = leaderboard_dataset.num_rows
-    all_data_json_list = [{k: all_data_json[k][ix] for k in all_data_json.keys()} for ix in range(num_items)]
-    filter_models_flags(all_data_json_list)
-
-    df = pd.DataFrame.from_records(all_data_json_list)
-    df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
-    df = df[cols].round(decimals=2)
-    df = df[has_no_nan_values(df, benchmark_cols)]
-    return df

src/rate_limiting.py

@@ -0,0 +1,13 @@
+from datetime import datetime, timezone, timedelta
+
+
+def user_submission_permission(submission_name, users_to_submission_dates, rate_limit_period):
+    org_or_user, _ = submission_name.split("/")
+    if org_or_user not in users_to_submission_dates:
+        return 0
+    submission_dates = sorted(users_to_submission_dates[org_or_user])
+
+    time_limit = (datetime.now(timezone.utc) - timedelta(days=rate_limit_period)).strftime("%Y-%m-%dT%H:%M:%SZ")
+    submissions_after_timelimit = [d for d in submission_dates if d > time_limit]
+
+    return len(submissions_after_timelimit)

src/submission/check_validity.py

@@ -1,183 +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, get_safetensors_metadata
-from transformers import AutoConfig, AutoTokenizer
-
-from src.display.utils import parse_iso8601_datetime
-from src.envs import HAS_HIGHER_RATE_LIMIT
-
-
-# ht to @Wauplin, thank you for the snippet!
-# See https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard/discussions/317
-def check_model_card(repo_id: str) -> tuple[bool, str]:
-    # Returns operation status, and error message
-    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.", None
-
-    # 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."
-                ),
-                None,
-            )
-
-    # Enforce card content
-    if len(card.text) < 200:
-        return False, "Please add a description to your model card, it is too short.", None
-
-    return True, "", card
-
-
-def is_model_on_hub(
-    model_name: str, revision: str, token: str = None, trust_remote_code=False, test_tokenizer=False
-) -> tuple[bool, str, AutoConfig]:
-    try:
-        config = AutoConfig.from_pretrained(
-            model_name, revision=revision, trust_remote_code=trust_remote_code, token=token
-        )  # , force_download=True)
-        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:
-                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:
-        if "You are trying to access a gated repo." in str(e):
-            return True, "uses a gated model.", None
-        return False, f"was not found or misconfigured on the hub! Error raised was {e.args[0]}", None
-
-
-def get_model_size(model_info: ModelInfo, precision: str):
-    size_pattern = re.compile(r"(\d+\.)?\d+(b|m)")
-    safetensors = None
-    try:
-        safetensors = get_safetensors_metadata(model_info.id)
-    except Exception as e:
-        print(e)
-
-    if safetensors is not None:
-        model_size = round(sum(safetensors.parameter_count.values()) / 1e9, 3)
-    else:
-        try:
-            size_match = re.search(size_pattern, model_info.id.lower())
-            model_size = size_match.group(0)
-            model_size = round(float(model_size[:-1]) if model_size[-1] == "b" else float(model_size[:-1]) / 1e3, 3)
-        except AttributeError:
-            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.id.lower()) else 1
-    model_size = size_factor * model_size
-    return model_size
-
-
-def get_model_arch(model_info: ModelInfo):
-    return model_info.config.get("architectures", "Unknown")
-
-
-def user_submission_permission(org_or_user, users_to_submission_dates, rate_limit_period, rate_limit_quota):
-    # Increase quota first if user has higher limits
-    if org_or_user in HAS_HIGHER_RATE_LIMIT:
-        rate_limit_quota *= 2
-
-    if org_or_user not in users_to_submission_dates:
-        return True, ""
-
-    submission_dates = sorted(users_to_submission_dates[org_or_user])
-    time_limit = datetime.now(timezone.utc) - timedelta(days=rate_limit_period)
-
-    submissions_after_timelimit = [
-        parse_iso8601_datetime(d) for d in submission_dates
-        if parse_iso8601_datetime(d) > time_limit
-    ]
-
-    num_models_submitted_in_period = len(submissions_after_timelimit)
-
-    # Use >= to correctly enforce the rate limit
-    if num_models_submitted_in_period >= rate_limit_quota:
-        error_msg = f"Organisation or user `{org_or_user}` already has {num_models_submitted_in_period} model requests submitted in the last {rate_limit_period} days.\n"
-        error_msg += "Please wait a couple of days before resubmitting, so that everybody can enjoy using the leaderboard 🤗"
-        return False, error_msg
-
-    return True, ""
-
-
-def already_submitted_models(requested_models_dir: str) -> set[str]:
-    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
-
-
-def get_model_tags(model_card, model: str):
-    is_merge_from_metadata = False
-    is_moe_from_metadata = False
-
-    tags = []
-    if model_card is None:
-        return tags
-    if model_card.data.tags:
-        is_merge_from_metadata = any(
-            [tag in model_card.data.tags for tag in ["merge", "moerge", "mergekit", "lazymergekit"]]
-        )
-        is_moe_from_metadata = any([tag in model_card.data.tags for tag in ["moe", "moerge"]])
-
-    is_merge_from_model_card = any(
-        keyword in model_card.text.lower() for keyword in ["merged model", "merge model", "moerge"]
-    )
-    if is_merge_from_model_card or is_merge_from_metadata:
-        tags.append("merge")
-    is_moe_from_model_card = any(keyword in model_card.text.lower() for keyword in ["moe", "mixtral"])
-    # Hardcoding because of gating problem
-    if "Qwen/Qwen1.5-32B" in model:
-        is_moe_from_model_card = False
-    is_moe_from_name = "moe" in model.lower().replace("/", "-").replace("_", "-").split("-")
-    if is_moe_from_model_card or is_moe_from_name or is_moe_from_metadata:
-        tags.append("moe")
-
-    return tags

src/submission/submit.py

@@ -1,186 +0,0 @@
-import json
-import os
-from datetime import datetime, timezone
-
-from dataclasses import dataclass
-from transformers import AutoConfig
-
-from src.display.formatting import styled_error, styled_message, styled_warning
-from src.envs import (
-    API,
-    EVAL_REQUESTS_PATH,
-    HF_TOKEN,
-    QUEUE_REPO,
-    RATE_LIMIT_PERIOD,
-    RATE_LIMIT_QUOTA,
-)
-from src.leaderboard.filter_models import DO_NOT_SUBMIT_MODELS
-from src.submission.check_validity import (
-    already_submitted_models,
-    check_model_card,
-    get_model_size,
-    is_model_on_hub,
-    user_submission_permission,
-)
-
-REQUESTED_MODELS = None
-USERS_TO_SUBMISSION_DATES = None
-
-@dataclass
-class ModelSizeChecker:
-    model: str
-    precision: str
-    model_size_in_b: float
-
-    def get_precision_factor(self):
-        if self.precision in ["float16", "bfloat16"]:
-            return 1
-        elif self.precision == "8bit":
-            return 2
-        elif self.precision == "4bit":
-            return 4
-        elif self.precision == "GPTQ":
-            config = AutoConfig.from_pretrained(self.model)
-            num_bits = int(config.quantization_config["bits"])
-            bits_to_precision_factor = {2: 8, 3: 6, 4: 4, 8: 2}
-            return bits_to_precision_factor.get(num_bits, 1)
-        else:
-            raise Exception(f"Unknown precision {self.precision}.")
-
-    def can_evaluate(self):
-        precision_factor = self.get_precision_factor()
-        return self.model_size_in_b <= 140 * precision_factor
-
-def add_new_eval(
-    model: str,
-    base_model: str,
-    revision: str,
-    precision: str,
-    weight_type: str,
-    model_type: str,
-    use_chat_template: bool,
-):
-    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.")
-
-    # Is the user rate limited?
-    if user_name != "":
-        user_can_submit, error_msg = user_submission_permission(
-            user_name, USERS_TO_SUBMISSION_DATES, RATE_LIMIT_PERIOD, RATE_LIMIT_QUOTA
-        )
-        if not user_can_submit:
-            return styled_error(error_msg)
-
-    # Did the model authors forbid its submission to the leaderboard?
-    if model in DO_NOT_SUBMIT_MODELS or base_model in DO_NOT_SUBMIT_MODELS:
-        return styled_warning("Model authors have requested that their model be not submitted on the leaderboard.")
-
-    # Does the model actually exist?
-    if revision == "":
-        revision = "main"
-    try:
-        model_info = API.model_info(repo_id=model, revision=revision)
-    except Exception as e:
-        return styled_error("Could not get your model information. Please fill it up properly.")
-
-    # Check model size early
-    model_size = get_model_size(model_info=model_info, precision=precision)
-    
-    # First check: Absolute size limit for float16 and bfloat16
-    if precision in ["float16", "bfloat16"] and model_size > 100:
-        return styled_error(f"Sadly, models larger than 100B parameters cannot be submitted in {precision} precision at this time. "
-                            f"Your model size: {model_size:.2f}B parameters.")
-
-    # Second check: Precision-adjusted size limit for 8bit, 4bit, and GPTQ
-    if precision in ["8bit", "4bit", "GPTQ"]:
-        size_checker = ModelSizeChecker(model=model, precision=precision, model_size_in_b=model_size)
-        
-        if not size_checker.can_evaluate():
-            precision_factor = size_checker.get_precision_factor()
-            max_size = 140 * precision_factor
-            return styled_error(f"Sadly, models this big ({model_size:.2f}B parameters) cannot be evaluated automatically "
-                                f"at the moment on our cluster. The maximum size for {precision} precision is {max_size:.2f}B parameters.")
-
-    architecture = "?"
-    # 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="main", token=HF_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, model_config = is_model_on_hub(model_name=model, revision=model_info.sha, test_tokenizer=True)
-        if not model_on_hub or model_config is None:
-            return styled_error(f'Model "{model}" {error}')
-        if model_config is not None:
-            architectures = getattr(model_config, "architectures", None)
-            if architectures:
-                architecture = ";".join(architectures)
-
-    # Were the model card and license filled?
-    try:
-        model_info.cardData["license"]
-    except Exception:
-        return styled_error("Please select a license for your model")
-
-    modelcard_OK, error_msg, model_card = 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": model_info.sha, # force to use the exact model commit 
-        "precision": precision,
-        "params": model_size,
-        "architectures": architecture,
-        "weight_type": weight_type,
-        "status": "PENDING",
-        "submitted_time": current_time,
-        "model_type": model_type,
-        "job_id": -1,
-        "job_start_time": None,
-        "use_chat_template": use_chat_template,
-    }
-
-    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."
-    )

src/tools/create_request_file.py

@@ -1,92 +0,0 @@
-import json
-import os
-import pprint
-from datetime import datetime, timezone
-
-import click
-from colorama import Fore
-from huggingface_hub import HfApi, snapshot_download
-
-from src.display.utils import ModelType, WeightType
-from src.submission.check_validity import get_model_size
-
-EVAL_REQUESTS_PATH = "eval-queue"
-QUEUE_REPO = "open-llm-leaderboard/requests"
-
-precisions = ("float16", "bfloat16", "8bit (LLM.int8)", "4bit (QLoRA / FP4)", "GPTQ")
-model_types = [e.name for e in ModelType]
-weight_types = [e.name for e in WeightType]
-
-
-def main():
-    api = HfApi()
-    current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-    snapshot_download(repo_id=QUEUE_REPO, revision="main", local_dir=EVAL_REQUESTS_PATH, repo_type="dataset")
-
-    model_name = click.prompt("Enter model name")
-    revision = click.prompt("Enter revision", default="main")
-    precision = click.prompt("Enter precision", default="float16", type=click.Choice(precisions))
-    model_type = click.prompt("Enter model type", type=click.Choice(model_types))
-    weight_type = click.prompt("Enter weight type", default="Original", type=click.Choice(weight_types))
-    base_model = click.prompt("Enter base model", default="")
-    status = click.prompt("Enter status", default="FINISHED")
-
-    try:
-        model_info = api.model_info(repo_id=model_name, revision=revision)
-    except Exception as e:
-        print(f"{Fore.RED}Could not find model info for {model_name} on the Hub\n{e}{Fore.RESET}")
-        return 1
-
-    model_size = get_model_size(model_info=model_info, precision=precision)
-
-    try:
-        license = model_info.cardData["license"]
-    except Exception:
-        license = "?"
-
-    eval_entry = {
-        "model": model_name,
-        "base_model": base_model,
-        "revision": model_info.sha, # force to use the exact model commit 
-        "private": False,
-        "precision": precision,
-        "weight_type": weight_type,
-        "status": status,
-        "submitted_time": current_time,
-        "model_type": model_type,
-        "likes": model_info.likes,
-        "params": model_size,
-        "license": license,
-    }
-
-    user_name = ""
-    model_path = model_name
-    if "/" in model_name:
-        user_name = model_name.split("/")[0]
-        model_path = model_name.split("/")[1]
-
-    pprint.pprint(eval_entry)
-
-    if click.confirm("Do you want to continue? This request file will be pushed to the hub"):
-        click.echo("continuing...")
-
-        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))
-
-        api.upload_file(
-            path_or_fileobj=out_path,
-            path_in_repo=out_path.split(f"{EVAL_REQUESTS_PATH}/")[1],
-            repo_id=QUEUE_REPO,
-            repo_type="dataset",
-            commit_message=f"Add {model_name} to eval queue",
-        )
-    else:
-        click.echo("aborting...")
-
-
-if __name__ == "__main__":
-    main()

src/tools/plots.py

@@ -1,152 +0,0 @@
-import numpy as np
-import pandas as pd
-import plotly.express as px
-from plotly.graph_objs import Figure
-
-from src.display.utils import BENCHMARK_COLS, AutoEvalColumn, Task, Tasks
-# from src.display.utils import human_baseline_row as HUMAN_BASELINE
-from src.leaderboard.filter_models import FLAGGED_MODELS
-
-
-def create_scores_df(results_df: list[dict]) -> pd.DataFrame:
-    """
-    Generates a DataFrame containing the maximum scores until each date.
-
-    :param results_df: A DataFrame containing result information including metric scores and dates.
-    :return: A new DataFrame containing the maximum scores until each date for every metric.
-    """
-    # Step 1: Ensure 'date' is in datetime format and sort the DataFrame by it
-    results_df["date"] = pd.to_datetime(results_df["date"], format="mixed", utc=True)
-    results_df.sort_values(by="date", inplace=True)
-
-    # Step 2: Initialize the scores dictionary
-    scores = {k: [] for k in BENCHMARK_COLS + [AutoEvalColumn.average.name]}
-
-    # Step 3: Iterate over the rows of the DataFrame and update the scores dictionary
-    for task in [t.value for t in Tasks] + [Task("Average", "avg", AutoEvalColumn.average.name)]:
-        current_max = 0
-        last_date = ""
-        column = task.col_name
-        for _, row in results_df.iterrows():
-            current_model = row[AutoEvalColumn.fullname.name]
-            # We ignore models that are flagged/no longer on the hub/not finished
-            to_ignore = (
-                not row[AutoEvalColumn.still_on_hub.name]
-                or not row[AutoEvalColumn.not_flagged.name]
-                or current_model in FLAGGED_MODELS
-            )
-            if to_ignore:
-                continue
-
-            current_date = row[AutoEvalColumn.date.name]
-            current_score = row[task.col_name]
-
-            if current_score > current_max:
-                if current_date == last_date and len(scores[column]) > 0:
-                    scores[column][-1] = {"model": current_model, "date": current_date, "score": current_score}
-                else:
-                    scores[column].append({"model": current_model, "date": current_date, "score": current_score})
-                current_max = current_score
-                last_date = current_date
-
-    # Step 4: Return all dictionaries as DataFrames
-    return {k: pd.DataFrame(v) for k, v in scores.items()}
-
-
-def create_plot_df(scores_df: dict[str : pd.DataFrame]) -> pd.DataFrame:
-    """
-    Transforms the scores DataFrame into a new format suitable for plotting.
-
-    :param scores_df: A DataFrame containing metric scores and dates.
-    :return: A new DataFrame reshaped for plotting purposes.
-    """
-    # Initialize the list to store DataFrames
-    dfs = []
-    # Iterate over the cols and create a new DataFrame for each column
-    for col in BENCHMARK_COLS + [AutoEvalColumn.average.name]:
-        d = scores_df[col].reset_index(drop=True)
-        d["task"] = col
-        dfs.append(d)
-
-    # Concatenate all the created DataFrames
-    concat_df = pd.concat(dfs, ignore_index=True)
-
-    # # Sort values by 'date'
-    # concat_df.sort_values(by="date", inplace=True)
-    # concat_df.reset_index(drop=True, inplace=True)
-    # return concat_df
-
-
-def create_metric_plot_obj(df: pd.DataFrame, metrics: list[str], title: str) -> Figure:
-    """
-    Create a Plotly figure object with lines representing different metrics
-    and horizontal dotted lines representing human baselines.
-
-    :param df: The DataFrame containing the metric values, names, and dates.
-    :param metrics: A list of strings representing the names of the metrics
-                    to be included in the plot.
-    :param title: A string representing the title of the plot.
-    :return: A Plotly figure object with lines representing metrics and
-             horizontal dotted lines representing human baselines.
-    """
-
-    # Filter the DataFrame based on the specified metrics
-    df = df[df["task"].isin(metrics)]
-
-    # Filter the human baselines based on the specified metrics
-    filtered_human_baselines = {k: v for k, v in HUMAN_BASELINE.items() if k in metrics}
-
-    # Create a line figure using plotly express with specified markers and custom data
-    fig = px.line(
-        df,
-        x="date",
-        y="score",
-        color="task",
-        markers=True,
-        custom_data=["task", "score", "model"],
-        title=title,
-    )
-
-    # Update hovertemplate for better hover interaction experience
-    fig.update_traces(
-        hovertemplate="<br>".join(
-            [
-                "Model Name: %{customdata[2]}",
-                "Metric Name: %{customdata[0]}",
-                "Date: %{x}",
-                "Metric Value: %{y}",
-            ]
-        )
-    )
-
-    # Update the range of the y-axis
-    fig.update_layout(yaxis_range=[0, 100])
-
-    # Create a dictionary to hold the color mapping for each metric
-    metric_color_mapping = {}
-
-    # Map each metric name to its color in the figure
-    for trace in fig.data:
-        metric_color_mapping[trace.name] = trace.line.color
-
-    # Iterate over filtered human baselines and add horizontal lines to the figure
-    for metric, value in filtered_human_baselines.items():
-        color = metric_color_mapping.get(metric, "blue")  # Retrieve color from mapping; default to blue if not found
-        location = "top left" if metric == "HellaSwag" else "bottom left"  # Set annotation position
-        # Add horizontal line with matched color and positioned annotation
-        fig.add_hline(
-            y=value,
-            line_dash="dot",
-            annotation_text=f"{metric} human baseline",
-            annotation_position=location,
-            annotation_font_size=10,
-            annotation_font_color=color,
-            line_color=color,
-        )
-
-    return fig
-
-
-# Example Usage:
-# human_baselines dictionary is defined.
-# chart = create_metric_plot_obj(scores_df, ["ARC", "HellaSwag", "MMLU", "TruthfulQA"], human_baselines, "Graph Title")

src/voting/vote_system.py

@@ -1,151 +0,0 @@
-import json
-import logging
-import pathlib
-import pandas as pd
-import gradio as gr
-import schedule
-import time
-from datetime import datetime, timezone
-from src.display.utils import EvalQueueColumn
-
-from src.envs import API
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class VoteManager:
-    def __init__(self, votes_path, eval_requests_path, repo_id):
-        self.votes_path = votes_path
-        self.eval_requests_path = eval_requests_path
-        self.repo_id = repo_id
-        self.vote_dataset = self.read_vote_dataset()
-        self.vote_check_set = self.make_check_set(self.vote_dataset)
-        self.votes_to_upload = []
-
-    def init_vote_dataset(self):
-        self.vote_dataset = self.read_vote_dataset()
-        self.vote_check_set = self.make_check_set(self.vote_dataset)
-
-    def read_vote_dataset(self):
-        result = []
-        votes_file = pathlib.Path(self.votes_path) / "votes_data.jsonl"
-        if votes_file.exists():
-            with open(votes_file, "r") as f:
-                for line in f:
-                    data = json.loads(line.strip())
-                    result.append(data)
-        result = pd.DataFrame(result)
-        return result
-
-    def make_check_set(self, vote_dataset: pd.DataFrame):
-        result = list()
-        for row in vote_dataset.itertuples(index=False, name='vote'):
-            result.append((row.model, row.revision, row.username))
-        return set(result)
-    
-    def get_model_revision(self, selected_model: str) -> str:
-        """Fetch the revision for the given model from the request files."""
-        for user_folder in pathlib.Path(self.eval_requests_path).iterdir():
-            if user_folder.is_dir():
-                for file in user_folder.glob("*.json"):
-                    with open(file, "r") as f:
-                        data = json.load(f)
-                        if data.get("model") == selected_model:
-                            return data.get("revision", "main")
-        return "main"
-
-    def create_request_vote_df(self, pending_models_df: gr.Dataframe):
-        if pending_models_df.empty or not "model_name" in pending_models_df.columns:
-            return pending_models_df
-        self.vote_dataset = self.read_vote_dataset()
-        vote_counts = self.vote_dataset.groupby(['model', 'revision']).size().reset_index(name='vote_count')
-
-        pending_models_df_votes = pd.merge(
-            pending_models_df, 
-            vote_counts, 
-            left_on=["model_name", 'revision'], 
-            right_on=['model', 'revision'], 
-            how='left'
-        )
-        # Filling empty votes
-        pending_models_df_votes['vote_count'] = pending_models_df_votes['vote_count'].fillna(0)
-        pending_models_df_votes = pending_models_df_votes.sort_values(by=["vote_count", "model_name"], ascending=[False, True])
-        # Removing useless columns
-        pending_models_df_votes = pending_models_df_votes.drop(["model_name", "model"], axis=1)
-        return pending_models_df_votes
-
-    # Function to be called when a user votes for a model
-    def add_vote(
-            self,
-            selected_model: str,
-            pending_models_df: gr.Dataframe,
-            profile: gr.OAuthProfile | None
-        ):
-        logger.debug(f"Type of list before usage: {type(list)}")
-        # model_name, revision, user_id, timestamp
-        if selected_model in ["str", ""]:
-            gr.Warning("No model selected")
-            return
-        
-        if profile is None:
-            gr.Warning("Hub Login required")
-            return
-
-        vote_username = profile.username
-        model_revision = self.get_model_revision(selected_model)
-        
-        # tuple (immutable) for checking than already voted for model
-        check_tuple = (selected_model, model_revision, vote_username)
-        if check_tuple in self.vote_check_set:
-            gr.Warning("Already voted for this model")
-            return
-        
-        current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-        vote_obj = {
-            "model": selected_model,
-            "revision": model_revision,
-            "username": vote_username,
-            "timestamp": current_time
-        }
-
-        # Append the vote to the JSONL file
-        try:
-            votes_file = pathlib.Path(self.votes_path) / "votes_data.jsonl"
-            with open(votes_file, "a") as f:
-                f.write(json.dumps(vote_obj) + "\n")
-            logger.info(f"Vote added locally: {vote_obj}")
-
-            self.votes_to_upload.append(vote_obj)
-        except Exception as e:
-            logger.error(f"Failed to write vote to file: {e}")
-            gr.Warning("Failed to record vote. Please try again")
-            return
-        
-        self.vote_check_set.add(check_tuple)
-        gr.Info(f"Voted for {selected_model}")
-
-        return self.create_request_vote_df(pending_models_df)
-
-    def upload_votes(self):
-        if self.votes_to_upload:
-            votes_file = pathlib.Path(self.votes_path) / "votes_data.jsonl"
-            try:
-                with open(votes_file, "rb") as f:
-                    API.upload_file(
-                        path_or_fileobj=f,
-                        path_in_repo="votes_data.jsonl",
-                        repo_id=self.repo_id,
-                        repo_type="dataset",
-                        commit_message="Updating votes_data.jsonl with new votes",
-                    )
-                logger.info("Votes uploaded to votes repository")
-                self.votes_to_upload.clear()
-            except Exception as e:
-                logger.error(f"Failed to upload votes to repository: {e}")
-
-def run_scheduler(vote_manager):
-    while True:
-        schedule.run_pending()
-        time.sleep(1)

tests/submission/test_user_submission_permission.py

@@ -1,98 +0,0 @@
-import unittest
-from unittest.mock import patch
-from datetime import datetime, timedelta, timezone
-
-from src.submission.check_validity import user_submission_permission
-from src.envs import RATE_LIMIT_PERIOD, RATE_LIMIT_QUOTA
-
-class TestUserSubmissionPermission(unittest.TestCase):
-
-    def setUp(self):
-        self.user_name = "test_user"
-        self.rate_limit_period = RATE_LIMIT_PERIOD
-        self.rate_limit_quota = RATE_LIMIT_QUOTA
-        self.fixed_now = datetime(2023, 6, 1, 12, 0, 0, tzinfo=timezone.utc)
-        # Submission dates that simulate various test cases
-        self.users_to_submission_dates = {
-            "test_user": [
-                (self.fixed_now - timedelta(days=1)).isoformat(),
-                (self.fixed_now - timedelta(days=2)).isoformat(),
-                (self.fixed_now - timedelta(days=3)).isoformat(),
-                (self.fixed_now - timedelta(days=4)).isoformat(),
-            ]
-        }
-
-    @staticmethod
-    def fixed_datetime_now(tz=None):
-        return datetime(2023, 6, 1, 12, 0, 0, tzinfo=timezone.utc)
-
-    @patch('src.submission.check_validity.datetime')
-    def test_user_below_quota(self, mock_datetime):
-        mock_datetime.now.side_effect = self.fixed_datetime_now
-        mock_datetime.fromisoformat = datetime.fromisoformat
-        allowed, message = user_submission_permission(
-            self.user_name, self.users_to_submission_dates, self.rate_limit_period, self.rate_limit_quota
-        )
-        self.assertTrue(allowed)
-
-    @patch('src.submission.check_validity.datetime')
-    def test_user_at_quota(self, mock_datetime):
-        mock_datetime.now.side_effect = self.fixed_datetime_now
-        mock_datetime.fromisoformat = datetime.fromisoformat
-        
-        # Add one more submission to reach the quota
-        self.users_to_submission_dates["test_user"].append(self.fixed_now.isoformat())
-        
-        allowed, message = user_submission_permission(
-            self.user_name, self.users_to_submission_dates, self.rate_limit_period, self.rate_limit_quota
-        )
-        self.assertFalse(allowed)
-        expected_message = (
-            f"Organisation or user `{self.user_name}` already has {self.rate_limit_quota} model requests submitted "
-            f"in the last {self.rate_limit_period} days.\n"
-            "Please wait a couple of days before resubmitting, so that everybody can enjoy using the leaderboard 🤗"
-        )
-        self.assertEqual(message, expected_message)
-
-    @patch('src.submission.check_validity.datetime')
-    def test_user_above_quota(self, mock_datetime):
-        mock_datetime.now.side_effect = self.fixed_datetime_now
-        mock_datetime.fromisoformat = datetime.fromisoformat
-        # Add more than quota submissions
-        for _ in range(self.rate_limit_quota + 1):
-            self.users_to_submission_dates["test_user"].append(self.fixed_now.isoformat())
-        allowed, message = user_submission_permission(
-            self.user_name, self.users_to_submission_dates, self.rate_limit_period, self.rate_limit_quota
-        )
-        self.assertFalse(allowed)
-
-    def test_user_no_previous_submissions(self):
-        allowed, message = user_submission_permission(
-            "new_user", self.users_to_submission_dates, self.rate_limit_period, self.rate_limit_quota
-        )
-        self.assertTrue(allowed)
-
-    @patch('src.submission.check_validity.HAS_HIGHER_RATE_LIMIT', ["specific_user"])
-    @patch('src.submission.check_validity.datetime')
-    def test_user_higher_rate_limit(self, mock_datetime):
-        mock_datetime.now.side_effect = self.fixed_datetime_now
-        mock_datetime.fromisoformat = datetime.fromisoformat
-        self.users_to_submission_dates["specific_user"] = [self.fixed_now.isoformat()] * (self.rate_limit_quota + 1)
-        allowed, message = user_submission_permission(
-            "specific_user", self.users_to_submission_dates, self.rate_limit_period, self.rate_limit_quota
-        )
-        self.assertTrue(allowed)
-
-    @patch('src.submission.check_validity.datetime')
-    def test_submission_just_outside_window(self, mock_datetime):
-        mock_datetime.now.side_effect = self.fixed_datetime_now
-        mock_datetime.fromisoformat = datetime.fromisoformat
-        old_submission = (self.fixed_now - timedelta(days=self.rate_limit_period, seconds=1)).isoformat()
-        self.users_to_submission_dates["test_user"] = [old_submission]
-        allowed, message = user_submission_permission(
-            self.user_name, self.users_to_submission_dates, self.rate_limit_period, self.rate_limit_quota
-        )
-        self.assertTrue(allowed)
-
-if __name__ == '__main__':
-    unittest.main()