[MLP-1479] Init Neubla LLM Evaluation Board

.gitignore

@@ -0,0 +1,12 @@
+venv/
+__pycache__/
+.env
+.ipynb_checkpoints
+*ipynb
+.vscode/
+
+eval-queue/
+eval-results/
+dynamic-info/
+
+src/assets/model_counts.html

.pre-commit-config.yaml

@@ -0,0 +1,53 @@
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+default_language_version:
+  python: python3
+
+ci:
+  autofix_prs: true
+  autoupdate_commit_msg: '[pre-commit.ci] pre-commit suggestions'
+  autoupdate_schedule: quarterly
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+      - id: check-yaml
+      - id: check-case-conflict
+      - id: detect-private-key
+      - id: check-added-large-files
+        args: ['--maxkb=1000']
+      - id: requirements-txt-fixer
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+        name: Format imports
+
+  - repo: https://github.com/psf/black
+    rev: 22.12.0
+    hooks:
+      - id: black
+        name: Format code
+        additional_dependencies: ['click==8.0.2']
+
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    # Ruff version.
+    rev: 'v0.0.267'
+    hooks:
+      - id: ruff

Makefile

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

app.py

@@ -0,0 +1,369 @@
+import gradio as gr
+import pandas as pd
+from apscheduler.schedulers.background import BackgroundScheduler
+from huggingface_hub import snapshot_download
+from gradio_space_ci import enable_space_ci
+
+from src.display.about import (
+    INTRODUCTION_TEXT,
+    LLM_BENCHMARKS_TEXT,
+    CITATION_BUTTON_LABEL,
+    CITATION_BUTTON_TEXT,
+    TITLE,
+)
+from src.display.css_html_js import custom_css
+from src.display.utils import (
+    BENCHMARK_COLS,
+    COLS,
+    EVAL_COLS,
+    EVAL_TYPES,
+    NUMERIC_INTERVALS,
+    TYPES,
+    AutoEvalColumn,
+    ModelType,
+    fields,
+    WeightType,
+    Precision,
+)
+from src.envs import API, EVAL_RESULTS_PATH, RESULTS_REPO, REPO_ID, HF_TOKEN
+from src.populate import get_leaderboard_df
+
+# from src.tools.collections import update_collections
+from src.tools.plots import (
+    create_metric_plot_obj,
+    create_plot_df,
+    create_scores_df,
+)
+
+# Start ephemeral Spaces on PRs (see config in README.md)
+# enable_space_ci()
+
+
+def restart_space():
+    API.restart_space(repo_id=REPO_ID, token=HF_TOKEN)
+
+
+def init_space():
+
+    try:
+        print(EVAL_RESULTS_PATH)
+        snapshot_download(
+            repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30
+        )
+    except Exception:
+        pass
+
+    raw_data, original_df = get_leaderboard_df(
+        results_path=EVAL_RESULTS_PATH, cols=COLS, benchmark_cols=BENCHMARK_COLS
+    )
+    # update_collections(original_df.copy())
+    leaderboard_df = original_df.copy()
+
+    plot_df = create_plot_df(create_scores_df(raw_data))
+
+    return leaderboard_df, original_df, plot_df
+
+
+leaderboard_df, original_df, plot_df = init_space()
+
+
+# Searching and filtering
+def update_table(
+    hidden_df: pd.DataFrame,
+    columns: list,
+    type_query: list,
+    weight_precision_query: str,
+    activation_precision_query: str,
+    size_query: list,
+    hide_models: list,
+    query: str,
+):
+    filtered_df = filter_models(
+        df=hidden_df,
+        type_query=type_query,
+        size_query=size_query,
+        weight_precision_query=weight_precision_query,
+        activation_precision_query=activation_precision_query,
+        hide_models=hide_models,
+    )
+    filtered_df = filter_queries(query, filtered_df)
+    df = select_columns(filtered_df, columns)
+    return df
+
+
+def load_query(request: gr.Request):  # triggered only once at startup => read query parameter if it exists
+    query = request.query_params.get("query") or ""
+    return (
+        query,
+        query,
+    )  # return one for the "search_bar", one for a hidden component that triggers a reload only if value has changed
+
+
+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 = [c.name for c in fields(AutoEvalColumn) if c.never_hidden]
+    dummy_col = [AutoEvalColumn.dummy.name]
+    # 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] + dummy_col]
+    return filtered_df
+
+
+def filter_queries(query: str, filtered_df: pd.DataFrame):
+    """Added by Abishek"""
+    final_df = []
+    if query != "":
+        queries = [q.strip() for q in query.split(";")]
+        for _q in queries:
+            _q = _q.strip()
+            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)
+            filtered_df = filtered_df.drop_duplicates(
+                subset=[
+                    AutoEvalColumn.model.name,
+                    AutoEvalColumn.weight_precision.name,
+                    AutoEvalColumn.activation_precision.name,
+                    AutoEvalColumn.revision.name,
+                ]
+            )
+
+    return filtered_df
+
+
+def filter_models(
+    df: pd.DataFrame,
+    type_query: list,
+    size_query: list,
+    weight_precision_query: list,
+    activation_precision_query: list,
+    hide_models: list,
+) -> pd.DataFrame:
+    # Show all models
+    if "Private or deleted" in hide_models:
+        filtered_df = df[df[AutoEvalColumn.still_on_hub.name] == True]
+    else:
+        filtered_df = df
+
+    if "Contains a merge/moerge" in hide_models:
+        filtered_df = filtered_df[filtered_df[AutoEvalColumn.merged.name] == False]
+
+    if "MoE" in hide_models:
+        filtered_df = filtered_df[filtered_df[AutoEvalColumn.moe.name] == False]
+
+    if "Flagged" in hide_models:
+        filtered_df = filtered_df[filtered_df[AutoEvalColumn.flagged.name] == False]
+
+    type_emoji = [t[0] for t in type_query]
+    filtered_df = filtered_df.loc[df[AutoEvalColumn.model_type_symbol.name].isin(type_emoji)]
+    filtered_df = filtered_df.loc[df[AutoEvalColumn.weight_precision.name].isin(weight_precision_query + ["None"])]
+    filtered_df = filtered_df.loc[
+        df[AutoEvalColumn.activation_precision.name].isin(activation_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
+
+
+leaderboard_df = filter_models(
+    df=leaderboard_df,
+    type_query=[t.to_str(" : ") for t in ModelType],
+    size_query=list(NUMERIC_INTERVALS.keys()),
+    weight_precision_query=[i.value.name for i in Precision],
+    activation_precision_query=[i.value.name for i in Precision],
+    hide_models=["Private or deleted", "Contains a merge/moerge", "Flagged"],  # Deleted, merges, flagged, MoEs
+)
+
+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):
+            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.name
+                                for c in fields(AutoEvalColumn)
+                                if not c.hidden and not c.never_hidden and not c.dummy
+                            ],
+                            value=[
+                                c.name
+                                for c in fields(AutoEvalColumn)
+                                if c.displayed_by_default and not c.hidden and not c.never_hidden
+                            ],
+                            label="Select columns to show",
+                            elem_id="column-select",
+                            interactive=True,
+                        )
+                    with gr.Row():
+                        hide_models = gr.CheckboxGroup(
+                            label="Hide models",
+                            choices=["Private or deleted", "Contains a merge/moerge", "Flagged", "MoE"],
+                            value=["Private or deleted", "Contains a merge/moerge", "Flagged"],
+                            interactive=True,
+                        )
+                with gr.Column(min_width=320):
+                    # with gr.Box(elem_id="box-filter"):
+                    filter_columns_type = gr.CheckboxGroup(
+                        label="Model types",
+                        choices=[t.to_str() for t in ModelType],
+                        value=[t.to_str() for t in ModelType],
+                        interactive=True,
+                        elem_id="filter-columns-type",
+                    )
+                    filter_columns_weight_precision = gr.CheckboxGroup(
+                        label="Weight Precision",
+                        choices=[i.value.name for i in Precision],
+                        value=[i.value.name for i in Precision],
+                        interactive=True,
+                        elem_id="filter-columns-weight-precision",
+                    )
+                    filter_columns_activation_precision = gr.CheckboxGroup(
+                        label="Activation Precision",
+                        choices=[i.value.name for i in Precision],
+                        value=[i.value.name for i in Precision],
+                        interactive=True,
+                        elem_id="filter-columns-activation-precision",
+                    )
+                    filter_columns_size = gr.CheckboxGroup(
+                        label="Model sizes (in billions of parameters)",
+                        choices=list(NUMERIC_INTERVALS.keys()),
+                        value=list(NUMERIC_INTERVALS.keys()),
+                        interactive=True,
+                        elem_id="filter-columns-size",
+                    )
+
+            leaderboard_table = gr.components.Dataframe(
+                value=leaderboard_df[
+                    [c.name for c in fields(AutoEvalColumn) if c.never_hidden]
+                    + shown_columns.value
+                    + [AutoEvalColumn.dummy.name]
+                ],
+                headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
+                datatype=TYPES,
+                elem_id="leaderboard-table",
+                interactive=False,
+                visible=True,
+                # column_widths=["2%", "33%"]
+            )
+
+            # Dummy leaderboard for handling the case when the user uses backspace key
+            hidden_leaderboard_table_for_search = gr.components.Dataframe(
+                value=original_df[COLS],
+                headers=COLS,
+                datatype=TYPES,
+                visible=False,
+            )
+            search_bar.submit(
+                update_table,
+                [
+                    hidden_leaderboard_table_for_search,
+                    shown_columns,
+                    filter_columns_type,
+                    filter_columns_weight_precision,
+                    filter_columns_activation_precision,
+                    filter_columns_size,
+                    hide_models,
+                    search_bar,
+                ],
+                leaderboard_table,
+            )
+
+            # Define a hidden component that will trigger a reload only if a query parameter has been set
+            hidden_search_bar = gr.Textbox(value="", visible=False)
+            hidden_search_bar.change(
+                update_table,
+                [
+                    hidden_leaderboard_table_for_search,
+                    shown_columns,
+                    filter_columns_type,
+                    filter_columns_weight_precision,
+                    filter_columns_activation_precision,
+                    filter_columns_size,
+                    hide_models,
+                    search_bar,
+                ],
+                leaderboard_table,
+            )
+            # Check query parameter once at startup and update search bar + hidden component
+            demo.load(load_query, inputs=[], outputs=[search_bar, hidden_search_bar])
+
+            for selector in [
+                shown_columns,
+                filter_columns_type,
+                filter_columns_weight_precision,
+                filter_columns_activation_precision,
+                filter_columns_size,
+                hide_models,
+            ]:
+                selector.change(
+                    update_table,
+                    [
+                        hidden_leaderboard_table_for_search,
+                        shown_columns,
+                        filter_columns_type,
+                        filter_columns_weight_precision,
+                        filter_columns_activation_precision,
+                        filter_columns_size,
+                        hide_models,
+                        search_bar,
+                    ],
+                    leaderboard_table,
+                    queue=True,
+                )
+
+        with gr.TabItem("📈 Metrics through time", elem_id="llm-benchmark-tab-table", id=4):
+            with gr.Row():
+                with gr.Column():
+                    chart = create_metric_plot_obj(
+                        plot_df,
+                        [AutoEvalColumn.average.name],
+                        title="Average of Top Scores and Human Baseline Over Time (from last update)",
+                    )
+                    gr.Plot(value=chart, min_width=500)
+                with gr.Column():
+                    chart = create_metric_plot_obj(
+                        plot_df,
+                        BENCHMARK_COLS,
+                        title="Top Scores and Human Baseline Over Time (from last update)",
+                    )
+                    gr.Plot(value=chart, min_width=500)
+        with gr.TabItem("📝 About", elem_id="llm-benchmark-tab-table", id=2):
+            gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
+
+    with gr.Row():
+        with gr.Accordion("📙 Citation", open=False):
+            citation_button = gr.Textbox(
+                value=CITATION_BUTTON_TEXT,
+                label=CITATION_BUTTON_LABEL,
+                lines=20,
+                elem_id="citation-button",
+                show_copy_button=True,
+            )
+
+scheduler = BackgroundScheduler()
+scheduler.add_job(restart_space, "interval", seconds=10800)  # restarted every 3h
+scheduler.start()
+
+demo.queue(default_concurrency_limit=40).launch()

pyproject.toml

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

requirements.txt

@@ -0,0 +1,18 @@
+APScheduler==3.10.1
+black==23.11.0
+click==8.1.3
+datasets==2.14.5
+gradio==4.9.0
+gradio_client==0.7.2
+huggingface-hub>=0.18.0
+matplotlib==3.7.1
+numpy==1.24.2
+pandas==2.0.0
+plotly==5.14.1
+python-dateutil==2.8.2
+requests==2.28.2
+sentencepiece
+tqdm==4.65.0
+transformers==4.37.0
+tokenizers>=0.15.0
+gradio-space-ci @ git+https://huggingface.co/spaces/Wauplin/[email protected] # CI !!!

src/display/about.py

@@ -0,0 +1,267 @@
+from src.display.utils import ModelType
+
+TITLE = """<h1 align="center" id="space-title">Neubla LLM Evaluation Board</h1>"""
+
+INTRODUCTION_TEXT = """
+📐 The Neubla LLM Evaluation Board aims to track, rank and evaluate compressed open LLMs.
+
+🤗 Submit a model for automated evaluation on the 🤗 GPU cluster on the [NMOF](https://github.com/NeublaCorp/neubla_mlp/tree/develop/src/ml/pytorch/model_optimizer)!
+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 = 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.
+
+## How it works
+
+📈 We evaluate models on 7 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 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.
+- <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.
+
+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.
+
+## Details and logs
+You can find:
+- detailed numerical results in the `results` Hugging Face dataset: https://huggingface.co/datasets/NMOF-evaluation-board/results
+
+## Reproducibility
+To reproduce our results, here is the commands you can run, using [this version](https://github.com/EleutherAI/lm-evaluation-harness/tree/v0.4.1) of the Eleuther AI Harness:
+`lm_eval --model=hf --model_args="pretrained=<your_model>,parallelize=True,revision=<your_model_revision>"`
+` --tasks=<task_list> --num_fewshot=<n_few_shot> --batch_size=1 --output_path=<output_path>`
+
+The total batch size we get for models which fit on one A6000 node is 8 (8 GPUs * 1). 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:
+- ARC: 25-shot, *arc-challenge* (`acc_norm`)
+- HellaSwag: 10-shot, *hellaswag* (`acc_norm`)
+- TruthfulQA: 0-shot, *truthfulqa-mc* (`mc2`)
+- MMLU: 5-shot, *mmlu_abstract_algebra,mmlu_anatomy,mmlu_astronomy,mmlu_business_ethics,mmlu_clinical_knowledge,mmlu_college_biology,mmlu_college_chemistry,mmlu_college_computer_science,mmlu_college_mathematics,mmlu_college_medicine,mmlu_college_physics,mmlu_computer_security,mmlu_conceptual_physics,mmlu_econometrics,mmlu_electrical_engineering,mmlu_elementary_mathematics,mmlu_formal_logic,mmlu_global_facts,mmlu_high_school_biology,mmlu_high_school_chemistry,mmlu_high_school_computer_science,mmlu_high_school_european_history,mmlu_high_school_geography,mmlu_high_school_government_and_politics,mmlu_high_school_macroeconomics,mmlu_high_school_mathematics,mmlu_high_school_microeconomics,mmlu_high_school_physics,mmlu_high_school_psychology,mmlu_high_school_statistics,mmlu_high_school_us_history,mmlu_high_school_world_history,mmlu_human_aging,mmlu_human_sexuality,mmlu_international_law,mmlu_jurisprudence,mmlu_logical_fallacies,mmlu_machine_learning,mmlu_management,mmlu_marketing,mmlu_medical_genetics,mmlu_miscellaneous,mmlu_moral_disputes,mmlu_moral_scenarios,mmlu_nutrition,mmlu_philosophy,mmlu_prehistory,mmlu_professional_accounting,mmlu_professional_law,mmlu_professional_medicine,mmlu_professional_psychology,mmlu_public_relations,mmlu_security_studies,mmlu_sociology,mmlu_us_foreign_policy,mmlu_virology,mmlu_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
+
+## Icons
+- {ModelType.PT.to_str(" : ")} model: new, base models, trained on a given corpora
+- {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. 
+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!
+
+"Flagged" indicates that this model has been flagged by the community, and should probably be ignored! Clicking the link will redirect you to the discussion about the model.
+
+## Quantization
+
+### Weight Quantization
+
+- INT4 Quantization (GPTQ, AWQ, ...)
+- FP8 Quantization
+- INT8 Quantization (SmoothQuant, Outlier Suppression+, ...)
+
+### Activation Quantization
+
+- FP8 Quantization
+- INT8 Quantization (SmoothQuant, Outlier Suppression+, ...)
+
+"""
+
+FAQ_TEXT = """
+---------------------------
+# FAQ
+Below are some common questions - if this FAQ does not answer you, feel free to create a new issue, and we'll take care of it as soon as we can! 
+
+## 1) Submitting a model
+My model requires `trust_remote_code=True`, can I submit it?
+- *We only support models that have been integrated in a stable version of the `transformers` library for automatic submission, as we don't want to run possibly unsage code on our cluster.*
+
+What about models of type X? 
+- *We only support models that have been integrated in 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, problem with an update of our backend, connectivity problem 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*
+
+## 2) Model 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 time with the same precision and hash commit, this is not normal.*
+
+What is this concept of "flagging"?
+- *This mechanism allows user 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 copy of other models not atrributed 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.*
+
+## 3) Editing a submission
+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.*
+
+## 4) Other
+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 about 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!*
+"""
+
+
+EVALUATION_QUEUE_TEXT = """
+# Evaluation Queue for the 🤗 Open LLM Leaderboard
+
+Models added here will be automatically evaluated on the 🤗 cluster.
+
+## First steps before submitting a model
+
+### 1) Make sure you can load your model and tokenizer using AutoClasses:
+```python
+from transformers import AutoConfig, AutoModel, AutoTokenizer
+config = AutoConfig.from_pretrained("your model name", revision=revision)
+model = AutoModel.from_pretrained("your model name", revision=revision)
+tokenizer = AutoTokenizer.from_pretrained("your model name", revision=revision)
+```
+If this step fails, follow the error messages to debug your model before submitting it. It's likely your model has been improperly uploaded.
+
+Note: make sure your model is public!
+Note: if your model needs `use_remote_code=True`, we do not support this option yet but we are working on adding it, stay posted!
+
+### 2) Convert your model weights to [safetensors](https://huggingface.co/docs/safetensors/index)
+It's a new format for storing weights which is safer and faster to load and use. It will also allow us to add the number of parameters of your model to the `Extended Viewer`!
+
+### 3) Make sure your model has an open license!
+This is a leaderboard for Open LLMs, and we'd love for as many people as possible to know they can use your model 🤗
+
+### 4) Fill up your model card
+When we add extra information about models to the leaderboard, it will be automatically taken from the model card
+
+### 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).
+
+## 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 command in the About tab under "Reproducibility" with all arguments specified (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{neubla-llm-evaluation-board,
+  author = {Minho Park and Jinsol Kim and Youngmin Joo and Byonghwa Oh and Raegeun Park and Junsang Park and Jihun Oh and Minwook Ahn},
+  title = {Neubla LLM Evaluation Board},
+  year = {2024},
+  publisher = {Neubla Corporation},
+  howpublished = "\url{https://huggingface.co/spaces/Neubla/neubla-llm-evaluation-board}"
+}
+@software{eval-harness,
+  author       = {Gao, Leo and
+                  Tow, Jonathan and
+                  Biderman, Stella and
+                  Black, Sid and
+                  DiPofi, Anthony and
+                  Foster, Charles and
+                  Golding, Laurence and
+                  Hsu, Jeffrey and
+                  McDonell, Kyle and
+                  Muennighoff, Niklas and
+                  Phang, Jason and
+                  Reynolds, Laria and
+                  Tang, Eric and
+                  Thite, Anish and
+                  Wang, Ben and
+                  Wang, Kevin and
+                  Zou, Andy},
+  title        = {A framework for few-shot language model evaluation},
+  month        = sep,
+  year         = 2021,
+  publisher    = {Zenodo},
+  version      = {v0.0.1},
+  doi          = {10.5281/zenodo.5371628},
+  url          = {https://doi.org/10.5281/zenodo.5371628}
+}
+@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{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{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{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}
+}
+@misc{DBLP:journals/corr/abs-1907-10641,
+      title={{WINOGRANDE:} An Adversarial Winograd Schema Challenge at Scale},
+      author={Keisuke Sakaguchi and Ronan Le Bras and Chandra Bhagavatula and Yejin Choi},
+      year={2019},
+      eprint={1907.10641},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{DBLP:journals/corr/abs-2110-14168,
+      title={Training Verifiers to Solve Math Word Problems},
+      author={Karl Cobbe and
+                  Vineet Kosaraju and
+                  Mohammad Bavarian and
+                  Mark Chen and
+                  Heewoo Jun and
+                  Lukasz Kaiser and
+                  Matthias Plappert and
+                  Jerry Tworek and
+                  Jacob Hilton and
+                  Reiichiro Nakano and
+                  Christopher Hesse and
+                  John Schulman},
+      year={2021},
+      eprint={2110.14168},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+"""

src/display/css_html_js.py

@@ -0,0 +1,97 @@
+custom_css = """
+/* 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;
+}
+
+/* Full width space */
+.gradio-container {
+  max-width: 95%!important;
+}
+
+/* Text style and margins */
+.markdown-text {
+    font-size: 16px !important;
+}
+
+#models-to-add-text {
+    font-size: 18px !important;
+}
+
+#citation-button span {
+    font-size: 16px !important;
+}
+
+#citation-button textarea {
+    font-size: 16px !important;
+}
+
+#citation-button > label > button {
+    margin: 6px;
+    transform: scale(1.3);
+}
+
+#search-bar-table-box > div:first-child {
+    background: none;
+    border: none;
+}
+ 
+#search-bar {
+    padding: 0px;
+}
+
+.tab-buttons button {
+    font-size: 20px;
+}
+
+/* Filters style */
+#filter_type{
+    border: 0;
+    padding-left: 0;
+    padding-top: 0;
+}
+#filter_type label {
+    display: flex;
+}
+#filter_type label > span{
+    margin-top: var(--spacing-lg);
+    margin-right: 0.5em;
+}
+#filter_type label > .wrap{
+    width: 103px;
+}
+#filter_type label > .wrap .wrap-inner{  
+    padding: 2px;
+}
+#filter_type label > .wrap .wrap-inner input{
+    width: 1px
+}
+#filter-columns-type{
+    border:0;
+    padding:0.5;
+}
+#filter-columns-size{
+    border:0;
+    padding:0.5;
+}
+#box-filter > .form{
+    border: 0
+}
+"""
+
+get_window_url_params = """
+    function(url_params) {
+        const params = new URLSearchParams(window.location.search);
+        url_params = Object.fromEntries(params);
+        return url_params;
+    }
+    """

src/display/formatting.py

@@ -0,0 +1,40 @@
+import os
+from datetime import datetime, timezone
+
+from huggingface_hub import HfApi
+from huggingface_hub.hf_api import ModelInfo
+
+
+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("/", "__")
+
+    return model_hyperlink(link, model_name)
+
+
+def styled_error(error):
+    return f"<p style='color: red; font-size: 20px; text-align: center;'>{error}</p>"
+
+
+def styled_warning(warn):
+    return f"<p style='color: orange; font-size: 20px; text-align: center;'>{warn}</p>"
+
+
+def styled_message(message):
+    return f"<p style='color: green; font-size: 20px; text-align: center;'>{message}</p>"
+
+
+def has_no_nan_values(df, columns):
+    return df[columns].notna().all(axis=1)
+
+
+def has_nan_values(df, columns):
+    return df[columns].isna().any(axis=1)

src/display/utils.py

@@ -0,0 +1,202 @@
+from dataclasses import dataclass, make_dataclass
+from enum import Enum
+from altair import Column
+
+import pandas as pd
+
+
+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):
+    arc = Task("arc_challenge", "acc_norm", "ARC")
+    hellaswag = Task("hellaswag", "acc_norm", "HellaSwag")
+    mmlu = Task("mmlu", "acc", "MMLU")
+    truthfulqa = Task("truthfulqa_mc2", "acc", "TruthfulQA")
+    winogrande = Task("winogrande", "acc", "Winogrande")
+    gsm8k = Task("gsm8k", "exact_match,get-answer", "GSM8K")
+
+
+# These classes are for user facing column names,
+# to avoid having to change them all around the code
+# when a modif is needed
+@dataclass
+class ColumnContent:
+    name: str
+    type: str
+    displayed_by_default: bool
+    hidden: bool = False
+    never_hidden: bool = False
+    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:
+    auto_eval_column_dict.append([task.name, ColumnContent, ColumnContent(task.value.col_name, "number", True)])
+# Model information
+auto_eval_column_dict.append(["model_type", ColumnContent, ColumnContent("Type", "str", False)])
+auto_eval_column_dict.append(["architecture", ColumnContent, ColumnContent("Architecture", "str", False)])
+auto_eval_column_dict.append(["weight_type", ColumnContent, ColumnContent("Weight type", "str", False, True)])
+auto_eval_column_dict.append(["weight_precision", ColumnContent, ColumnContent("Weight Precision", "str", False)])
+auto_eval_column_dict.append(
+    ["activation_precision", ColumnContent, ColumnContent("Activation Precision", "str", False)]
+)
+auto_eval_column_dict.append(["merged", ColumnContent, ColumnContent("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(["flagged", ColumnContent, ColumnContent("Flagged", "bool", False, hidden=True)])
+auto_eval_column_dict.append(["moe", ColumnContent, ColumnContent("MoE", "bool", False, hidden=True)])
+# Dummy column for the search bar (hidden by the custom CSS)
+auto_eval_column_dict.append(["dummy", ColumnContent, ColumnContent("model_name_for_query", "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 = ColumnContent("model", "markdown", True)
+    revision = ColumnContent("revision", "str", True)
+    private = ColumnContent("private", "bool", True)
+    weight_precision = ColumnContent("weight_precision", "str", True)
+    activation_precision = ColumnContent("activation_precision", "str", True)
+    weight_type = ColumnContent("weight_type", "str", "Original")
+    status = ColumnContent("status", "str", True)
+
+
+baseline_row = {
+    AutoEvalColumn.model.name: "<p>Baseline</p>",
+    AutoEvalColumn.revision.name: "N/A",
+    AutoEvalColumn.weight_precision.name: None,
+    AutoEvalColumn.activation_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.dummy.name: "baseline",
+    AutoEvalColumn.model_type.name: "",
+    AutoEvalColumn.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.weight_precision.name: None,
+    AutoEvalColumn.activation_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.dummy.name: "human_baseline",
+    AutoEvalColumn.model_type.name: "",
+    AutoEvalColumn.flagged.name: False,
+}
+
+
+@dataclass
+class ModelDetails:
+    name: str
+    symbol: str = ""  # emoji, only for the model type
+
+
+class ModelType(Enum):
+    PT = ModelDetails(name="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="", symbol="?")
+
+    def to_str(self, separator=" "):
+        return f"{self.value.symbol}{separator}{self.value.name}"
+
+    @staticmethod
+    def from_str(type):
+        if "fine-tuned" in type or "🔶" in type:
+            return ModelType.FT
+        if "pretrained" in type or "🟢" in type:
+            return ModelType.PT
+        if any([k in type for k in ["instruction-tuned", "RL-tuned", "chat", "🟦", "⭕", "💬"]]):
+            return ModelType.chat
+        if "merge" in type or "🤝" in type:
+            return ModelType.merges
+        return ModelType.Unknown
+
+
+class WeightType(Enum):
+    Adapter = ModelDetails("Adapter")
+    Original = ModelDetails("Original")
+    Delta = ModelDetails("Delta")
+
+
+class Precision(Enum):
+    float32 = ModelDetails("float32")
+    float16 = ModelDetails("float16")
+    bfloat16 = ModelDetails("bfloat16")
+    int4 = ModelDetails("int4")
+    Unknown = ModelDetails("?")
+
+    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 ["int4"]:
+            return Precision.int4
+        if precision in ["torch.float32", "float32"]:
+            return Precision.float32
+        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/envs.py

@@ -0,0 +1,15 @@
+import os
+
+from huggingface_hub import HfApi
+
+# clone / pull the lmeh eval data
+HF_TOKEN = os.environ.get("HF_TOKEN", None)
+
+RESULTS_REPO = "NMOF-evaluation-board/results"
+REPO_ID = "NMOF-evaluation-board/llm-evaluation-boards"
+CACHE_PATH = os.getenv("HF_HOME", ".")
+
+EVAL_RESULTS_PATH = os.path.join(CACHE_PATH, "eval-results")
+
+
+API = HfApi()

src/leaderboard/filter_models.py

@@ -0,0 +1,166 @@
+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)
+FLAGGED_MODELS = {
+    "merged": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "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",
+    "fblgit/una-xaberius-34b-v1beta": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/444",
+    "jan-hq/trinity-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "rwitz2/go-bruins-v2.1.1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "rwitz2/go-bruins-v2.1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "GreenNode/GreenNodeLM-v3olet-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "GreenNode/GreenNodeLM-7B-v4leo": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "GreenNode/LeoScorpius-GreenNode-7B-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "viethq188/LeoScorpius-7B-Chat-DPO": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "GreenNode/GreenNodeLM-7B-v2leo": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "janai-hq/trinity-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "ignos/LeoScorpius-GreenNode-Alpaca-7B-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "fblgit/una-cybertron-7b-v3-OMA": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "mncai/mistral-7b-dpo-merge-v1.1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "mncai/mistral-7b-dpo-v6": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "Toten5/LeoScorpius-GreenNode-7B-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "GreenNode/GreenNodeLM-7B-v1olet":  "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "quantumaikr/quantum-dpo-v0.1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "quantumaikr/quantum-v0.01": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "quantumaikr/quantum-trinity-v0.1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "mncai/mistral-7b-dpo-v5": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "cookinai/BruinHermes": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "jan-ai/Pandora-10.7B-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "v1olet/v1olet_marcoroni-go-bruins-merge-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "v1olet/v1olet_merged_dpo_7B_v3": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "rwitz2/pee": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "zyh3826 / GML-Mistral-merged-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/503",
+    "dillfrescott/trinity-medium": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/474",
+    "udkai/Garrulus": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/526",
+    "dfurman/GarrulusMarcoro-7B-v0.1": "https://huggingface.co/dfurman/GarrulusMarcoro-7B-v0.1/discussions/1",
+    "udkai/Turdus": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/548",
+    "eren23/slerp-test-turdus-beagle": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/548",
+    "abideen/NexoNimbus-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/548",
+    "alnrg2arg/test2_3": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/548",
+    "nfaheem/Marcoroni-7b-DPO-Merge": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/548",
+    "CultriX/MergeTrix-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/548",
+    "liminerity/Blur-7b-v1.21": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/548",
+    # Merges not indicated
+    "gagan3012/MetaModelv2": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "gagan3012/MetaModelv3": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "kyujinpy/Sakura-SOLRCA-Math-Instruct-DPO-v2": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "kyujinpy/Sakura-SOLAR-Instruct-DPO-v2": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "kyujinpy/Sakura-SOLRCA-Math-Instruct-DPO-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "kyujinpy/Sakura-SOLRCA-Instruct-DPO": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "fblgit/LUNA-SOLARkrautLM-Instruct": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "perlthoughts/Marcoroni-8x7B-v3-MoE": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "rwitz/go-bruins-v2": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "rwitz/go-bruins": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Walmart-the-bag/Solar-10.7B-Cato": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "aqweteddy/mistral_tv-neural-marconroni": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "NExtNewChattingAI/shark_tank_ai_7_b": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Q-bert/MetaMath-Cybertron": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "OpenPipe/mistral-ft-optimized-1227": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "perlthoughts/Falkor-7b": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "v1olet/v1olet_merged_dpo_7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Ba2han/BruinsV2-OpHermesNeu-11B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "DopeorNope/You_can_cry_Snowman-13B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "PistachioAlt/Synatra-MCS-7B-v0.3-RP-Slerp": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Weyaxi/MetaMath-una-cybertron-v2-bf16-Ties": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Weyaxi/OpenHermes-2.5-neural-chat-7b-v3-2-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "perlthoughts/Falkor-8x7B-MoE": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "elinas/chronos007-70b": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Weyaxi/MetaMath-NeuralHermes-2.5-Mistral-7B-Linear": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Weyaxi/MetaMath-neural-chat-7b-v3-2-Ties": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "diffnamehard/Mistral-CatMacaroni-slerp-uncensored-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Weyaxi/neural-chat-7b-v3-1-OpenHermes-2.5-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Weyaxi/MetaMath-NeuralHermes-2.5-Mistral-7B-Ties": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Walmart-the-bag/Misted-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "garage-bAInd/Camel-Platypus2-70B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "Weyaxi/OpenOrca-Zephyr-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "uukuguy/speechless-mistral-7b-dare-0.85": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/510",
+    "DopeorNope/SOLARC-M-10.7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/511",
+    "cloudyu/Mixtral_11Bx2_MoE_19B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/511",
+    "DopeorNope/SOLARC-MOE-10.7Bx6 ": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/511",
+    "DopeorNope/SOLARC-MOE-10.7Bx4": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/511",
+    "gagan3012/MetaModelv2 ": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/511",
+    "udkai/Turdus": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "kodonho/Solar-OrcaDPO-Solar-Instruct-SLERP": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "kodonho/SolarM-SakuraSolar-SLERP": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "Yhyu13/LMCocktail-10.7B-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "mlabonne/NeuralMarcoro14-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "Neuronovo/neuronovo-7B-v0.2": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "ryandt/MusingCaterpillar": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "Neuronovo/neuronovo-7B-v0.3": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "SanjiWatsuki/Lelantos-DPO-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "bardsai/jaskier-7b-dpo": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "cookinai/OpenCM-14": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "bardsai/jaskier-7b-dpo-v2": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "jan-hq/supermario-v2": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",    
+    # MoErges
+    "cloudyu/Yi-34Bx2-MoE-60B":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "cloudyu/Mixtral_34Bx2_MoE_60B":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "gagan3012/MetaModel_moe":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "macadeliccc/SOLAR-math-2x10.7b-v0.2":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "cloudyu/Mixtral_7Bx2_MoE":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "macadeliccc/SOLAR-math-2x10.7b":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "macadeliccc/Orca-SOLAR-4x10.7b":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "macadeliccc/piccolo-8x7b":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "cloudyu/Mixtral_7Bx4_MOE_24B":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "macadeliccc/laser-dolphin-mixtral-2x7b-dpo":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    "macadeliccc/polyglot-math-4x7b":"https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/540",
+    # Other - contamination mostly
+    "DopeorNope/COKAL-v1-70B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/566",
+    "CultriX/MistralTrix-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/556",
+}
+
+# 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]):
+    for model_data in leaderboard_data:
+        # Merges and moes are flagged automatically
+        if model_data[AutoEvalColumn.flagged.name] == True:
+            flag_key = "merged"
+        else:
+            flag_key = model_data["model_name_for_query"]
+
+        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.flagged.name] = True
+        else:
+            model_data[AutoEvalColumn.flagged.name] = False
+
+
+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 filter_models_flags(leaderboard_data: list[dict]):
+    leaderboard_data = remove_forbidden_models(leaderboard_data)
+    flag_models(leaderboard_data)

src/leaderboard/read_evals.py

@@ -0,0 +1,229 @@
+import glob
+import json
+import math
+import os
+from dataclasses import dataclass
+
+import dateutil
+import numpy as np
+
+from huggingface_hub import ModelCard
+
+from src.display.formatting import make_clickable_model
+from src.display.utils import AutoEvalColumn, ModelType, Tasks, Precision, WeightType
+
+
+@dataclass
+class EvalResult:
+    # Also see src.display.utils.AutoEvalColumn for what will be displayed.
+    eval_name: str  # org_model_precision (uid)
+    full_model: str  # org/model (path on hub)
+    org: str
+    model: str
+    revision: str  # commit hash, "" if main
+    results: dict
+    weight_precision: Precision = Precision.Unknown
+    activation_precision: Precision = Precision.Unknown
+    model_type: ModelType = ModelType.Unknown  # Pretrained, fine tuned, ...
+    weight_type: WeightType = WeightType.Original  # Original or Adapter
+    architecture: str = "Unknown"  # From config file
+    license: str = "?"
+    likes: int = 0
+    num_params: int = 0
+    date: str = ""  # submission date of request file
+    still_on_hub: bool = True
+    is_merge: bool = False
+    flagged: bool = False
+    status: str = "FINISHED"
+    tags: list = None
+
+    @classmethod
+    def init_from_json_file(self, json_filepath):
+        """Inits the result from the specific model result file"""
+        with open(json_filepath) as fp:
+            data = json.load(fp)
+
+        # We manage the legacy config format
+        config = data.get("config_general")
+
+        try:
+            model_type = ModelType.from_str(config.get("model_type", "Unknown"))
+            weight_type = WeightType[config.get("weight_type", "Original")]
+            num_params = config.get("params", 0)
+            date = os.path.basename(json_filepath).removesuffix(".json").removeprefix("result_")
+            architecture = config.get("architectures", "Unknown")
+            tags = config.get("model_tag", None)
+        except Exception as e:
+            self.status = "FAILED"
+            print(f"Could not find request file for {self.org}/{self.model}")
+
+        # Precision
+        weight_precision = Precision.from_str(config.get("weight_precision"))
+        activation_precision = Precision.from_str(config.get("activation_precision"))
+
+        # Get model and org
+        org_and_model = config.get("model")
+        org_and_model = org_and_model.split("/", 1)
+
+        if len(org_and_model) == 1:
+            org = None
+            model = org_and_model[0]
+            result_key = f"{model}_W{weight_precision.value.name}A{activation_precision.value.name}"
+        else:
+            org = org_and_model[0]
+            model = org_and_model[1]
+            result_key = f"{org}_{model}_W{weight_precision.value.name}A{activation_precision.value.name}"
+        full_model = "/".join(org_and_model)
+
+        # Extract results available in this file (some results are split in several files)
+        results = {}
+        for task in Tasks:
+            task = task.value
+            # We skip old mmlu entries
+            # Some truthfulQA values are NaNs
+            if task.benchmark == "truthfulqa_mc2" and "truthfulqa_mc2|0" in data["results"]:
+                if math.isnan(float(data["results"]["truthfulqa_mc2|0"][task.metric])):
+                    results[task.benchmark] = 0.0
+                    continue
+
+            # We average all scores of a given metric (mostly for mmlu)
+            if task.benchmark == "mmlu":
+                accs = np.array([data["results"].get(task.benchmark).get(task.metric, None)])
+            else:
+                accs = np.array([v.get(task.metric, None) for k, v in data["results"].items() if task.benchmark in k])
+            if accs.size == 0 or any([acc is None for acc in accs]):
+                continue
+
+            mean_acc = np.mean(accs) * 100.0
+            results[task.benchmark] = mean_acc
+
+        return self(
+            eval_name=result_key,
+            full_model=full_model,
+            org=org,
+            model=model,
+            results=results,
+            weight_precision=weight_precision,
+            activation_precision=activation_precision,
+            revision=config.get("model_sha", ""),
+            model_type=model_type,
+            weight_type=weight_type,
+            num_params=num_params,
+            date=date,
+            architecture=architecture,
+            tags=tags,
+        )
+
+    # def update_with_request_file(self, requests_path):
+    #     """Finds the relevant request file for the current model and updates info with it"""
+    #     request_file = get_request_file_for_model(requests_path, self.full_model, self.precision.value.name)
+
+    # try:
+    #     with open(request_file, "r") as f:
+    #         request = json.load(f)
+    #     self.model_type = ModelType.from_str(request.get("model_type", "Unknown"))
+    #     self.weight_type = WeightType[request.get("weight_type", "Original")]
+    #     self.num_params = request.get("params", 0)
+    #     self.date = request.get("submitted_time", "")
+    #     self.architecture = request.get("architectures", "Unknown")
+    #     self.status = request.get("status", "FAILED")
+    # except Exception as e:
+    #     self.status = "FAILED"
+    #     print(f"Could not find request file for {self.org}/{self.model}")
+
+    # def update_with_dynamic_file_dict(self, file_dict):
+    #     self.license = file_dict.get("license", "?")
+    #     self.likes = file_dict.get("likes", 0)
+    #     self.still_on_hub = file_dict["still_on_hub"]
+    #     self.flagged = any("flagged" in tag for tag in file_dict["tags"])
+    #     self.tags = file_dict["tags"]
+
+    def to_dict(self):
+        """Converts the Eval Result to a dict compatible with our dataframe display"""
+        average = sum([v for v in self.results.values() if v is not None]) / len(Tasks)
+        data_dict = {
+            "eval_name": self.eval_name,  # not a column, just a save name,
+            AutoEvalColumn.weight_precision.name: self.weight_precision.value.name,
+            AutoEvalColumn.activation_precision.name: self.activation_precision.value.name,
+            AutoEvalColumn.model_type.name: self.model_type.value.name,
+            AutoEvalColumn.model_type_symbol.name: self.model_type.value.symbol,
+            AutoEvalColumn.weight_type.name: self.weight_type.value.name,
+            AutoEvalColumn.architecture.name: self.architecture,
+            AutoEvalColumn.model.name: make_clickable_model(self.full_model),
+            AutoEvalColumn.dummy.name: self.full_model,
+            AutoEvalColumn.revision.name: self.revision,
+            AutoEvalColumn.average.name: average,
+            AutoEvalColumn.license.name: self.license,
+            AutoEvalColumn.likes.name: self.likes,
+            AutoEvalColumn.params.name: self.num_params,
+            AutoEvalColumn.still_on_hub.name: self.still_on_hub,
+            AutoEvalColumn.merged.name: "merge" in self.tags if self.tags else False,
+            AutoEvalColumn.moe.name: ("moe" in self.tags if self.tags else False) or "moe" in self.full_model.lower(),
+            AutoEvalColumn.flagged.name: self.flagged,
+        }
+
+        for task in Tasks:
+            data_dict[task.value.col_name] = self.results[task.value.benchmark]
+
+        return data_dict
+
+
+# def get_request_file_for_model(requests_path, model_name, precision):
+#     """Selects the correct request file for a given model. Only keeps runs tagged as FINISHED"""
+#     request_files = os.path.join(
+#         requests_path,
+#         f"{model_name}_eval_request_*.json",
+#     )
+#     request_files = glob.glob(request_files)
+
+#     # Select correct request file (precision)
+#     request_file = ""
+#     request_files = sorted(request_files, reverse=True)
+#     for tmp_request_file in request_files:
+#         with open(tmp_request_file, "r") as f:
+#             req_content = json.load(f)
+#             if req_content["status"] in ["FINISHED"] and req_content["precision"] == precision.split(".")[-1]:
+#                 request_file = tmp_request_file
+#     return request_file
+
+
+def get_raw_eval_results(results_path: str) -> list[EvalResult]:
+    """From the path of the results folder root, extract all needed info for results"""
+    model_result_filepaths = []
+
+    for root, _, files in os.walk(results_path):
+        # We should only have json files in model results
+        if len(files) == 0 or any([not f.endswith(".json") for f in files]):
+            continue
+
+        # Sort the files by date
+        try:
+            files.sort(key=lambda x: x.removesuffix(".json").removeprefix("result_")[:-7])
+        except dateutil.parser._parser.ParserError:
+            files = [files[-1]]
+
+        for file in files:
+            model_result_filepaths.append(os.path.join(root, file))
+
+    eval_results = {}
+    for model_result_filepath in model_result_filepaths:
+        # Creation of result
+        eval_result = EvalResult.init_from_json_file(model_result_filepath)
+
+        # Store results of same eval together
+        eval_name = eval_result.eval_name
+        if eval_name in eval_results.keys():
+            eval_results[eval_name].results.update({k: v for k, v in eval_result.results.items() if v is not None})
+        else:
+            eval_results[eval_name] = eval_result
+
+    results = []
+    for v in eval_results.values():
+        try:
+            if v.status == "FINISHED":
+                v.to_dict()  # we test if the dict version is complete
+                results.append(v)
+        except KeyError:  # not all eval values present
+            continue
+
+    return results

src/populate.py

@@ -0,0 +1,24 @@
+import json
+import os
+
+import pandas as pd
+
+from src.display.formatting import has_no_nan_values, make_clickable_model
+from src.display.utils import AutoEvalColumn, EvalQueueColumn, baseline_row
+from src.leaderboard.filter_models import filter_models_flags
+from src.leaderboard.read_evals import get_raw_eval_results
+
+
+def get_leaderboard_df(results_path: str, cols: list, benchmark_cols: list) -> pd.DataFrame:
+    raw_data = get_raw_eval_results(results_path=results_path)
+    all_data_json = [v.to_dict() for v in raw_data]
+    all_data_json.append(baseline_row)
+    filter_models_flags(all_data_json)
+
+    df = pd.DataFrame.from_records(all_data_json)
+    df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
+    df = df[cols].round(decimals=2)
+
+    # filter out if any of the benchmarks have not been produced
+    df = df[has_no_nan_values(df, benchmark_cols)]
+    return raw_data, df

src/scripts/create_request_file.py

@@ -0,0 +1,92 @@
+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.submission.check_validity import get_model_size
+from src.display.utils import ModelType, WeightType
+
+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": revision,
+        "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/scripts/update_all_request_files_bu.py

@@ -0,0 +1,93 @@
+from huggingface_hub import ModelFilter, snapshot_download
+from huggingface_hub import ModelCard
+
+import json
+import time
+
+from src.submission.check_validity import is_model_on_hub, check_model_card, get_model_tags
+from src.envs import API
+
+def update_models(file_path, models):
+    """
+    Search through all JSON files in the specified root folder and its subfolders,
+    and update the likes key in JSON dict from value of input dict
+    """
+    with open(file_path, "r") as f:
+        model_infos = json.load(f)
+        for model_id, data in model_infos.items():
+            if model_id not in models:
+                data['still_on_hub'] = False
+                data['likes'] = 0
+                data['downloads'] = 0
+                data['created_at'] = ""
+                continue
+
+            model_cfg = models[model_id]
+            data['likes'] = model_cfg.likes
+            data['downloads'] = model_cfg.downloads
+            data['created_at'] = str(model_cfg.created_at)
+            #data['params'] = get_model_size(model_cfg, data['precision'])
+            data['license'] = model_cfg.card_data.license if model_cfg.card_data is not None else ""
+
+            # Is the model still on the hub?
+            model_name = model_id
+            if model_cfg.card_data is not None and model_cfg.card_data.base_model is not None:
+                if isinstance(model_cfg.card_data.base_model, str):
+                    model_name = model_cfg.card_data.base_model # for adapters, we look at the parent model
+            still_on_hub, _, _ = is_model_on_hub(
+                model_name=model_name, revision=data.get("revision"), trust_remote_code=True, test_tokenizer=False, token=H4_TOKEN
+            )
+            # If the model doesn't have a model card or a license, we consider it's deleted
+            if still_on_hub:
+                try:
+                    status, _, model_card = check_model_card(model_id)
+                    if status is False:
+                        still_on_hub = False
+                except Exception:
+                    model_card = None
+                    still_on_hub = False
+            data['still_on_hub'] = still_on_hub
+
+            tags = get_model_tags(model_card, model_id) if still_on_hub else []
+
+            data["tags"] = tags
+
+    with open(file_path, 'w') as f:
+        json.dump(model_infos, f, indent=2)
+
+def update_dynamic_files():
+    """ This will only update metadata for models already linked in the repo, not add missing ones.
+    """
+    snapshot_download(
+        repo_id=DYNAMIC_INFO_REPO, local_dir=DYNAMIC_INFO_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30
+    )
+
+    print("UPDATE_DYNAMIC: Loaded snapshot")
+    # Get models
+    start = time.time()
+
+    models = list(API.list_models(
+        filter=ModelFilter(task="text-generation"),
+        full=False,
+        cardData=True,
+        fetch_config=True,
+    ))
+    id_to_model = {model.id : model for model in models}
+
+    print(f"UPDATE_DYNAMIC: Downloaded list of models in {time.time() - start:.2f} seconds")
+
+    start = time.time()
+
+    update_models(DYNAMIC_INFO_FILE_PATH, id_to_model)
+
+    print(f"UPDATE_DYNAMIC: updated in {time.time() - start:.2f} seconds")
+
+    API.upload_file(
+        path_or_fileobj=DYNAMIC_INFO_FILE_PATH,
+        path_in_repo=DYNAMIC_INFO_FILE_PATH.split("/")[-1],
+        repo_id=DYNAMIC_INFO_REPO,
+        repo_type="dataset",
+        commit_message=f"Daily request file update.",
+    )
+    print(f"UPDATE_DYNAMIC: pushed to hub")
+

src/submission/check_validity.py

@@ -0,0 +1,172 @@
+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
+
+
+# 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.", 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 as e:
+                return (
+                    False,
+                    "'s tokenizer cannot be loaded. Is your tokenizer class in a stable transformers release, and correctly configured?",
+                    None,
+                )
+        return True, None, config
+
+    except ValueError as e:
+        return (
+            False,
+            "needs to be launched with `trust_remote_code=True`. For safety reason, we do not allow these models to be automatically submitted to the leaderboard.",
+            None,
+        )
+
+    except Exception as e:
+        return False, "was not found on hub!", None
+
+
+def get_model_size(model_info: ModelInfo, precision: str):
+    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 as e:
+            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):
+    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)).strftime("%Y-%m-%dT%H:%M:%SZ")
+    submissions_after_timelimit = [d for d in submission_dates if d > time_limit]
+
+    num_models_submitted_in_period = len(submissions_after_timelimit)
+
+    if num_models_submitted_in_period > rate_limit_quota:
+        error_msg = f"Organisation or user `{org_or_user}`"
+        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 🤗"
+        )
+        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 = "merge" in model_card.data.tags
+        is_moe_from_metadata = "moe" in model_card.data.tags
+    merge_keywords = ["merged model", "merge model"]
+    # If the model is a merge but not saying it in the metadata, we flag it
+    is_merge_from_model_card = any(keyword in model_card.text.lower() for keyword in merge_keywords)
+    if is_merge_from_model_card or is_merge_from_metadata:
+        tags.append("merge")
+        if not is_merge_from_metadata:
+            tags.append("flagged:undisclosed_merge")
+    moe_keywords = ["moe", "mixtral"]
+    is_moe_from_model_card = any(keyword in model_card.text.lower() for keyword in moe_keywords)
+    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")
+        # We no longer tag undisclosed MoEs
+        # if not is_moe_from_metadata:
+        #    tags.append("flagged:undisclosed_moe")
+
+    return tags

src/submission/submit.py

@@ -0,0 +1,182 @@
+import json
+import os
+from datetime import datetime, timezone
+
+from huggingface_hub import ModelCard, snapshot_download
+
+from src.display.formatting import styled_error, styled_message, styled_warning
+from src.envs import API, EVAL_REQUESTS_PATH, DYNAMIC_INFO_PATH, DYNAMIC_INFO_FILE_PATH, DYNAMIC_INFO_REPO, H4_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,
+    get_model_tags
+)
+
+REQUESTED_MODELS = None
+USERS_TO_SUBMISSION_DATES = None
+
+def add_new_eval(
+    model: str,
+    base_model: str,
+    revision: str,
+    precision: str,
+    private: bool,
+    weight_type: str,
+    model_type: str,
+):
+    global REQUESTED_MODELS
+    global USERS_TO_SUBMISSION_DATES
+    if not REQUESTED_MODELS:
+        REQUESTED_MODELS, USERS_TO_SUBMISSION_DATES = already_submitted_models(EVAL_REQUESTS_PATH)
+
+    user_name = ""
+    model_path = model
+    if "/" in model:
+        user_name = model.split("/")[0]
+        model_path = model.split("/")[1]
+
+    precision = precision.split(" ")[0]
+    current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    if model_type is None or model_type == "":
+        return styled_error("Please select a model type.")
+
+    # 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"
+
+    # Is the model on the hub?
+    if weight_type in ["Delta", "Adapter"]:
+        base_model_on_hub, error, _ = is_model_on_hub(model_name=base_model, revision=revision, token=H4_TOKEN, test_tokenizer=True)
+        if not base_model_on_hub:
+            return styled_error(f'Base model "{base_model}" {error}')
+
+    architecture = "?"
+    downloads = 0
+    created_at = ""
+    if not weight_type == "Adapter":
+        model_on_hub, error, model_config = is_model_on_hub(model_name=model, revision=revision, test_tokenizer=True)
+        if not model_on_hub:
+            return styled_error(f'Model "{model}" {error}')
+        if model_config is not None:
+            architectures = getattr(model_config, "architectures", None)
+            if architectures:
+                architecture = ";".join(architectures)
+            downloads = getattr(model_config, 'downloads', 0)
+            created_at = getattr(model_config, 'created_at', '')
+
+
+
+    # Is the model info correctly filled?
+    try:
+        model_info = API.model_info(repo_id=model, revision=revision)
+    except Exception:
+        return styled_error("Could not get your model information. Please fill it up properly.")
+
+    model_size = get_model_size(model_info=model_info, precision=precision)
+
+    # Were the model card and license filled?
+    try:
+        license = model_info.cardData["license"]
+    except Exception:
+        return styled_error("Please select a license for your model")
+
+    modelcard_OK, error_msg, model_card = check_model_card(model)
+    if not modelcard_OK:
+        return styled_error(error_msg)
+    
+    tags = get_model_tags(model_card, model)
+
+    # Seems good, creating the eval
+    print("Adding new eval")
+
+    eval_entry = {
+        "model": model,
+        "base_model": base_model,
+        "revision": revision,
+        "private": private,
+        "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,
+    }
+
+    supplementary_info = {
+        "likes": model_info.likes,
+        "license": license,
+        "still_on_hub": True,
+        "tags": tags,
+        "downloads": downloads, 
+        "created_at": created_at
+    }
+
+    # Check for duplicate submission
+    if f"{model}_{revision}_{precision}" in REQUESTED_MODELS:
+        return styled_warning("This model has been already submitted.")
+
+    print("Creating eval file")
+    OUT_DIR = f"{EVAL_REQUESTS_PATH}/{user_name}"
+    os.makedirs(OUT_DIR, exist_ok=True)
+    out_path = f"{OUT_DIR}/{model_path}_eval_request_{private}_{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",
+    )
+
+    # We want to grab the latest version of the submission file to not accidentally overwrite it
+    snapshot_download(
+        repo_id=DYNAMIC_INFO_REPO, local_dir=DYNAMIC_INFO_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30
+    )
+
+    with open(DYNAMIC_INFO_FILE_PATH) as f:
+        all_supplementary_info = json.load(f)
+
+    all_supplementary_info[model] = supplementary_info
+    with open(DYNAMIC_INFO_FILE_PATH, "w") as f:
+        json.dump(all_supplementary_info, f, indent=2)
+
+    API.upload_file(
+        path_or_fileobj=DYNAMIC_INFO_FILE_PATH,
+        path_in_repo=DYNAMIC_INFO_FILE_PATH.split("/")[-1],
+        repo_id=DYNAMIC_INFO_REPO,
+        repo_type="dataset",
+        commit_message=f"Add {model} to dynamic info 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/collections.py

@@ -0,0 +1,11 @@
+import pandas as pd
+
+# Specific intervals for the collections
+intervals = {
+    "1B": pd.Interval(0, 1.5, closed="right"),
+    "3B": pd.Interval(2.5, 3.5, closed="neither"),
+    "7B": pd.Interval(6, 8, closed="neither"),
+    "13B": pd.Interval(10, 14, closed="neither"),
+    "30B": pd.Interval(25, 35, closed="neither"),
+    "65B": pd.Interval(60, 70, closed="neither"),
+}

src/tools/model_backlinks.py

@@ -0,0 +1,1309 @@
+models = [
+    "uni-tianyan/Uni-TianYan",
+    "fangloveskari/ORCA_LLaMA_70B_QLoRA",
+    "garage-bAInd/Platypus2-70B-instruct",
+    "upstage/Llama-2-70b-instruct-v2",
+    "fangloveskari/Platypus_QLoRA_LLaMA_70b",
+    "yeontaek/llama-2-70B-ensemble-v5",
+    "TheBloke/Genz-70b-GPTQ",
+    "TheBloke/Platypus2-70B-Instruct-GPTQ",
+    "psmathur/model_007",
+    "yeontaek/llama-2-70B-ensemble-v4",
+    "psmathur/orca_mini_v3_70b",
+    "ehartford/Samantha-1.11-70b",
+    "MayaPH/GodziLLa2-70B",
+    "psmathur/model_007_v2",
+    "chargoddard/MelangeA-70b",
+    "ehartford/Samantha-1.1-70b",
+    "psmathur/model_009",
+    "upstage/Llama-2-70b-instruct",
+    "yeontaek/llama-2-70B-ensemble-v7",
+    "yeontaek/llama-2-70B-ensemble-v6",
+    "chargoddard/MelangeB-70b",
+    "yeontaek/llama-2-70B-ensemble-v3",
+    "chargoddard/MelangeC-70b",
+    "garage-bAInd/Camel-Platypus2-70B",
+    "yeontaek/llama-2-70B-ensemble-v2",
+    "garage-bAInd/Camel-Platypus2-70B",
+    "migtissera/Synthia-70B-v1.2",
+    "v2ray/LLaMA-2-Wizard-70B-QLoRA",
+    "quantumaikr/llama-2-70b-fb16-orca-chat-10k",
+    "v2ray/LLaMA-2-Wizard-70B-QLoRA",
+    "stabilityai/StableBeluga2",
+    "quantumaikr/llama-2-70b-fb16-guanaco-1k",
+    "garage-bAInd/Camel-Platypus2-70B",
+    "migtissera/Synthia-70B-v1.1",
+    "migtissera/Synthia-70B",
+    "psmathur/model_101",
+    "augtoma/qCammel70",
+    "augtoma/qCammel-70",
+    "augtoma/qCammel-70v1",
+    "augtoma/qCammel-70x",
+    "augtoma/qCammel-70-x",
+    "jondurbin/airoboros-l2-70b-gpt4-1.4.1",
+    "dfurman/llama-2-70b-dolphin-peft",
+    "jondurbin/airoboros-l2-70b-2.1",
+    "TheBloke/llama-2-70b-Guanaco-QLoRA-fp16",
+    "quantumaikr/QuantumLM-llama2-70B-Korean-LoRA",
+    "quantumaikr/quantumairk-llama-2-70B-instruct",
+    "psmathur/model_420",
+    "psmathur/model_51",
+    "garage-bAInd/Camel-Platypus2-70B",
+    "TheBloke/Airoboros-L2-70B-2.1-GPTQ",
+    "OpenAssistant/llama2-70b-oasst-sft-v10",
+    "garage-bAInd/Platypus2-70B",
+    "liuxiang886/llama2-70B-qlora-gpt4",
+    "upstage/llama-65b-instruct",
+    "quantumaikr/llama-2-70b-fb16-korean",
+    "NousResearch/Nous-Hermes-Llama2-70b",
+    "v2ray/LLaMA-2-Jannie-70B-QLoRA",
+    "jondurbin/airoboros-l2-70b-gpt4-m2.0",
+    "jondurbin/airoboros-l2-70b-gpt4-m2.0",
+    "OpenAssistant/llama2-70b-oasst-sft-v10",
+    "yeontaek/llama-2-70B-ensemble-v8",
+    "jondurbin/airoboros-l2-70b-gpt4-2.0",
+    "jarradh/llama2_70b_chat_uncensored",
+    "WizardLM/WizardMath-70B-V1.0",
+    "jordiclive/Llama-2-70b-oasst-1-200",
+    "WizardLM/WizardMath-70B-V1.0",
+    "jondurbin/airoboros-l2-70b-gpt4-2.0",
+    "OpenLemur/lemur-70b-chat-v1",
+    "tiiuae/falcon-180B",
+    "tiiuae/falcon-180B",
+    "stabilityai/StableBeluga1-Delta",
+    "psmathur/model_42_70b",
+    "psmathur/test_42_70b",
+    "TheBloke/fiction.live-Kimiko-V2-70B-fp16",
+    "tiiuae/falcon-180B",
+    "WizardLM/WizardMath-70B-V1.0",
+    "tiiuae/falcon-180B-chat",
+    "jondurbin/airoboros-l2-70b-gpt4-2.0",
+    "ehartford/samantha-1.1-llama-33b",
+    "ajibawa-2023/scarlett-33b",
+    "ddobokki/Llama-2-70b-orca-200k",
+    "TheBloke/gpt4-alpaca-lora_mlp-65B-HF",
+    "tiiuae/falcon-180B-chat",
+    "tiiuae/falcon-180B-chat",
+    "tiiuae/falcon-180B",
+    "TheBloke/Lemur-70B-Chat-v1-GPTQ",
+    "NousResearch/Nous-Puffin-70B",
+    "WizardLM/WizardLM-70B-V1.0",
+    "WizardLM/WizardMath-70B-V1.0",
+    "meta-llama/Llama-2-70b-hf",
+    "TheBloke/Llama-2-70B-fp16",
+    "Weyaxi/llama-2-alpacagpt4-1000step",
+    "WizardLM/WizardLM-70B-V1.0",
+    "simsim314/WizardLM-70B-V1.0-HF",
+    "simsim314/WizardLM-70B-V1.0-HF",
+    "WizardLM/WizardLM-70B-V1.0",
+    "openbmb/UltraLM-65b",
+    "psmathur/model_420_preview",
+    "WizardLM/WizardLM-70B-V1.0",
+    "simsim314/WizardLM-70B-V1.0-HF",
+    "OpenBuddy/openbuddy-llama2-70b-v10.1-bf16",
+    "upstage/llama-30b-instruct-2048",
+    "jondurbin/airoboros-65b-gpt4-1.2",
+    "TheBloke/guanaco-65B-HF",
+    "jondurbin/airoboros-65b-gpt4-1.3",
+    "meta-llama/Llama-2-70b-chat-hf",
+    "ValiantLabs/ShiningValiant",
+    "Faradaylab/Aria-70B",
+    "lilloukas/GPlatty-30B",
+    "TheBloke/VicUnlocked-alpaca-65B-QLoRA-fp16",
+    "jondurbin/airoboros-65b-gpt4-1.4-peft",
+    "jondurbin/airoboros-65b-gpt4-1.4",
+    "jondurbin/airoboros-65b-gpt4-2.0",
+    "TheBloke/WizardLM-70B-V1.0-GPTQ",
+    "TheBloke/WizardLM-70B-V1.0-GPTQ",
+    "ariellee/SuperPlatty-30B",
+    "jondurbin/airoboros-65b-gpt4-1.4",
+    "jondurbin/airoboros-65b-gpt4-2.0",
+    "yeontaek/llama-2-70b-IA3-guanaco",
+    "CalderaAI/30B-Lazarus",
+    "Aspik101/trurl-2-13b-pl-instruct_unload",
+    "ehartford/WizardLM-33B-V1.0-Uncensored",
+    "ehartford/WizardLM-33B-V1.0-Uncensored",
+    "OpenBuddy/openbuddy-llama-65b-v8-bf16",
+    "Aspik101/llama-30b-instruct-2048-PL-lora",
+    "h2oai/h2ogpt-research-oasst1-llama-65b",
+    "Aspik101/llama-30b-instruct-2048-PL-lora",
+    "CalderaAI/30B-Epsilon",
+    "Aspik101/llama-30b-2048-instruct-PL-lora_unload",
+    "jondurbin/airoboros-65b-gpt4-m2.0",
+    "jondurbin/airoboros-65b-gpt4-m2.0",
+    "Aeala/Alpaca-elina-65b",
+    "TheBloke/robin-65b-v2-fp16",
+    "TheBloke/gpt4-alpaca-lora-30b-HF",
+    "TheBloke/Llama-2-70B-chat-GPTQ",
+    "upstage/llama-30b-instruct",
+    "OpenLemur/lemur-70b-v1",
+    "lmsys/vicuna-33b-v1.3",
+    "ausboss/llama-30b-supercot",
+    "ai-business/Luban-13B",
+    "Henk717/airochronos-33B",
+    "lmsys/vicuna-33b-v1.3",
+    "Henk717/airochronos-33B",
+    "bavest/fin-llama-33b-merged",
+    "jondurbin/airoboros-33b-gpt4-1.4",
+    "YeungNLP/firefly-llama-30b",
+    "Aspik101/30B-Lazarus-instruct-PL-lora_unload",
+    "uukuguy/speechless-llama2-luban-orca-platypus-13b",
+    "xxyyy123/test_merge_p_ov1_w0.66_w0.5_n1",
+    "jondurbin/airoboros-33b-gpt4-1.2",
+    "TheBloke/alpaca-lora-65B-HF",
+    "bofenghuang/vigogne-33b-instruct",
+    "yeontaek/llama-2-13B-ensemble-v5",
+    "garage-bAInd/Platypus-30B",
+    "Open-Orca/OpenOrca-Platypus2-13B",
+    "kajdun/viwaai-30b_v4",
+    "lilloukas/Platypus-30B",
+    "Open-Orca/OpenOrca-Platypus2-13B",
+    "Henk717/chronoboros-33B",
+    "jondurbin/airoboros-33b-2.1",
+    "HiTZ/alpaca-lora-65b-en-pt-es-ca",
+    "quantumaikr/QuantumLM-70B-hf",
+    "uukuguy/speechless-llama2-13b",
+    "uukuguy/speechless-llama2-hermes-orca-platypus-13b",
+    "openaccess-ai-collective/manticore-30b-chat-pyg-alpha",
+    "LLMs/WizardLM-30B-V1.0",
+    "TheBloke/WizardLM-30B-fp16",
+    "openaccess-ai-collective/hippogriff-30b-chat",
+    "concedo/Vicuzard-30B-Uncensored",
+    "TFLai/OpenOrca-Platypus2-13B-QLoRA-0.80-epoch",
+    "huggingface/llama-65b",
+    "huggyllama/llama-65b",
+    "gaodrew/gaodrew-llama-30b-instruct-2048-Open-Platypus-100steps",
+    "uukuguy/speechless-llama2-hermes-orca-platypus-wizardlm-13b",
+    "Sao10K/Mythical-Destroyer-V2-L2-13B",
+    "camel-ai/CAMEL-33B-Combined-Data",
+    "dsvv-cair/alpaca-cleaned-llama-30b-bf16",
+    "MetaIX/GPT4-X-Alpasta-30b",
+    "garage-bAInd/Stable-Platypus2-13B",
+    "TFLai/Luban-Platypus2-13B-QLora-0.80-epoch",
+    "TheBloke/OpenOrca-Platypus2-13B-GPTQ",
+    "IkariDev/Athena-tmp",
+    "OpenBuddyEA/openbuddy-llama-30b-v7.1-bf16",
+    "OpenBuddyEA/openbuddy-llama-30b-v7.1-bf16",
+    "Open-Orca/OpenOrcaxOpenChat-Preview2-13B",
+    "psmathur/model_007_13b_v2",
+    "Aspik101/Vicuzard-30B-Uncensored-instruct-PL-lora_unload",
+    "jondurbin/airoboros-33b-gpt4-m2.0",
+    "Sao10K/Mythical-Destroyer-L2-13B",
+    "TheBloke/Wizard-Vicuna-30B-Uncensored-fp16",
+    "ehartford/Wizard-Vicuna-30B-Uncensored",
+    "TFLai/Nova-13B",
+    "TheBloke/robin-33B-v2-fp16",
+    "totally-not-an-llm/PuddleJumper-13b",
+    "Aeala/VicUnlocked-alpaca-30b",
+    "Yhyu13/oasst-rlhf-2-llama-30b-7k-steps-hf",
+    "jondurbin/airoboros-33b-gpt4",
+    "jondurbin/airoboros-33b-gpt4-m2.0",
+    "tiiuae/falcon-40b-instruct",
+    "psmathur/orca_mini_v3_13b",
+    "Aeala/GPT4-x-AlpacaDente-30b",
+    "MayaPH/GodziLLa-30B",
+    "jondurbin/airoboros-33b-gpt4-m2.0",
+    "TFLai/SpeechlessV1-Nova-13B",
+    "yeontaek/llama-2-13B-ensemble-v4",
+    "ajibawa-2023/carl-33b",
+    "jondurbin/airoboros-33b-gpt4-2.0",
+    "TFLai/Stable-Platypus2-13B-QLoRA-0.80-epoch",
+    "jondurbin/airoboros-33b-gpt4-1.3",
+    "TehVenom/oasst-sft-6-llama-33b-xor-MERGED-16bit",
+    "TFLai/OrcaMini-Platypus2-13B-QLoRA-0.80-epoch",
+    "jondurbin/airoboros-33b-gpt4-2.0",
+    "chargoddard/Chronorctypus-Limarobormes-13b",
+    "jondurbin/airoboros-33b-gpt4-1.3",
+    "Open-Orca/OpenOrca-Platypus2-13B",
+    "FelixChao/vicuna-33b-coder",
+    "FelixChao/vicuna-33b-coder",
+    "Gryphe/MythoMix-L2-13b",
+    "Aeala/Enterredaas-33b",
+    "yeontaek/llama-2-13B-ensemble-v1",
+    "TFLai/OpenOrcaPlatypus2-Platypus2-13B-QLora-0.80-epoch",
+    "TFLai/Ensemble5-Platypus2-13B-QLora-0.80-epoch",
+    "yeontaek/llama-2-13B-ensemble-v3",
+    "TFLai/MythoMix-Platypus2-13B-QLoRA-0.80-epoch",
+    "yihan6324/llama2-13b-instructmining-40k-sharegpt",
+    "timdettmers/guanaco-33b-merged",
+    "TFLai/EnsembleV5-Nova-13B",
+    "circulus/Llama-2-13b-orca-v1",
+    "Undi95/ReMM-SLERP-L2-13B",
+    "Gryphe/MythoMax-L2-13b",
+    "stabilityai/StableBeluga-13B",
+    "circulus/Llama-2-13b-orca-v1",
+    "ehartford/WizardLM-30B-Uncensored",
+    "The-Face-Of-Goonery/huginnv1.2",
+    "TheBloke/OpenOrcaxOpenChat-Preview2-13B-GPTQ",
+    "Sao10K/Stheno-L2-13B",
+    "bofenghuang/vigogne-2-13b-instruct",
+    "The-Face-Of-Goonery/Huginn-13b-FP16",
+    "grimpep/L2-MythoMax22b-instruct-Falseblock",
+    "TFLai/Nous-Hermes-Platypus2-13B-QLoRA-0.80-epoch",
+    "yeontaek/Platypus2xOpenOrca-13B-IA3-v4",
+    "yeontaek/Platypus2xOpenOrca-13B-IA3",
+    "yeontaek/Platypus2xOpenOrca-13B-IA3-ensemble",
+    "Open-Orca/LlongOrca-13B-16k",
+    "Sao10K/Stheno-Inverted-L2-13B",
+    "garage-bAInd/Camel-Platypus2-13B",
+    "digitous/Alpacino30b",
+    "NousResearch/Nous-Hermes-Llama2-13b",
+    "yeontaek/Platypus2xOpenOrca-13B-IA3-v3",
+    "TFLai/MythicalDestroyerV2-Platypus2-13B-QLora-0.80-epoch",
+    "TheBloke/VicUnlocked-30B-LoRA-HF",
+    "Undi95/Nous-Hermes-13B-Code",
+    "The-Face-Of-Goonery/Chronos-Beluga-v2-13bfp16",
+    "NousResearch/Nous-Hermes-Llama2-13b",
+    "Monero/WizardLM-Uncensored-SuperCOT-StoryTelling-30b",
+    "TheBloke/Wizard-Vicuna-30B-Uncensored-GPTQ",
+    "Open-Orca/OpenOrcaxOpenChat-Preview2-13B",
+    "Austism/chronos-hermes-13b-v2",
+    "yeontaek/Platypus2xOpenOrca-13B-IA3-v2.1",
+    "yeontaek/Platypus2xOpenOrca-13B-IA3-v2",
+    "Gryphe/MythoLogic-L2-13b",
+    "augtoma/qCammel-13",
+    "YeungNLP/firefly-llama2-13b-v1.2",
+    "Aspik101/StableBeluga-13B-instruct-PL-lora_unload",
+    "andreaskoepf/llama2-13b-megacode2_min100",
+    "rombodawg/LosslessMegaCoder-llama2-13b-mini",
+    "yulan-team/YuLan-Chat-2-13b-fp16",
+    "elinas/chronos-33b",
+    "YeungNLP/firefly-llama2-13b",
+    "Sao10K/Medusa-13b",
+    "OptimalScale/robin-65b-v2-delta",
+    "minlik/chinese-alpaca-33b-merged",
+    "OpenAssistant/llama2-13b-megacode2-oasst",
+    "TheBloke/OpenAssistant-SFT-7-Llama-30B-HF",
+    "Undi95/UndiMix-v1-13b",
+    "ehartford/Samantha-1.11-13b",
+    "beaugogh/Llama2-13b-sharegpt4",
+    "Aeala/GPT4-x-AlpacaDente2-30b",
+    "luffycodes/nash-vicuna-13b-v1dot5-ep2-w-rag-w-simple",
+    "WizardLM/WizardLM-13B-V1.1",
+    "uukuguy/speechless-orca-platypus-coig-lite-2k-0.6e-13b",
+    "huggyllama/llama-30b",
+    "Undi95/ReMM-L2-13B-PIPPA",
+    "Undi95/ReMM-L2-13B",
+    "gaodrew/gaodrew-gorgonzola-13b",
+    "lmsys/vicuna-13b-v1.5",
+    "yeontaek/Platypus2xOpenOrca-13B-LoRa",
+    "Yhyu13/llama-30B-hf-openassitant",
+    "huggingface/llama-30b",
+    "lmsys/vicuna-13b-v1.5",
+    "TFLai/Athena-Platypus2-13B-QLora-0.80-epoch",
+    "TheBloke/dromedary-65b-lora-HF",
+    "yeontaek/llama-2-13b-Beluga-QLoRA",
+    "The-Face-Of-Goonery/Huginn-13b-V4",
+    "The-Face-Of-Goonery/Huginn-13b-v4.5",
+    "The-Face-Of-Goonery/Huginn-v3-13b",
+    "tiiuae/falcon-40b",
+    "WhoTookMyAmogusNickname/NewHope_HF_not_official",
+    "gaodrew/OpenOrca-Platypus2-13B-thera-1250",
+    "SLAM-group/NewHope",
+    "garage-bAInd/Platypus2-13B",
+    "migtissera/Synthia-13B",
+    "elinas/chronos-13b-v2",
+    "mosaicml/mpt-30b-chat",
+    "CHIH-HUNG/llama-2-13b-OpenOrca_5w",
+    "uukuguy/speechless-hermes-coig-lite-13b",
+    "TheBloke/tulu-30B-fp16",
+    "uukuguy/speechless-hermes-coig-lite-13b",
+    "xDAN-AI/xDAN_13b_l2_lora",
+    "lmsys/vicuna-13b-v1.5-16k",
+    "openchat/openchat_v3.1",
+    "CHIH-HUNG/llama-2-13b-dolphin_5w",
+    "Aspik101/vicuna-13b-v1.5-PL-lora_unload",
+    "Undi95/MLewd-L2-13B",
+    "ehartford/minotaur-llama2-13b-qlora",
+    "kajdun/iubaris-13b-v3",
+    "TFLai/Limarp-Platypus2-13B-QLoRA-0.80-epoch",
+    "openchat/openchat_v3.1",
+    "uukuguy/speechless-orca-platypus-coig-lite-4k-0.6e-13b",
+    "ziqingyang/chinese-alpaca-2-13b",
+    "TFLai/Airboros2.1-Platypus2-13B-QLora-0.80-epoch",
+    "yeontaek/llama-2-13b-Guanaco-QLoRA",
+    "lmsys/vicuna-13b-v1.5-16k",
+    "ehartford/based-30b",
+    "kingbri/airolima-chronos-grad-l2-13B",
+    "openchat/openchat_v3.2",
+    "uukuguy/speechless-orca-platypus-coig-lite-4k-0.5e-13b",
+    "yeontaek/Platypus2-13B-LoRa",
+    "kingbri/chronolima-airo-grad-l2-13B",
+    "openchat/openchat_v3.2",
+    "TFLai/PuddleJumper-Platypus2-13B-QLoRA-0.80-epoch",
+    "shareAI/llama2-13b-Chinese-chat",
+    "ehartford/WizardLM-1.0-Uncensored-Llama2-13b",
+    "Aspik101/Redmond-Puffin-13B-instruct-PL-lora_unload",
+    "yeontaek/llama-2-13B-ensemble-v6",
+    "WizardLM/WizardLM-13B-V1.2",
+    "TheBloke/WizardLM-13B-V1.1-GPTQ",
+    "bhenrym14/airophin-13b-pntk-16k-fp16",
+    "ehartford/WizardLM-1.0-Uncensored-Llama2-13b",
+    "Mikael110/llama-2-13b-guanaco-fp16",
+    "yeontaek/airoboros-2.1-llama-2-13B-QLoRa",
+    "CalderaAI/13B-Legerdemain-L2",
+    "grimpep/llama2-22b-wizard_vicuna",
+    "grimpep/llama2-22B-GPLATTY",
+    "bhenrym14/airophin-13b-pntk-16k-fp16",
+    "yeontaek/llama-2-13b-QLoRA",
+    "OpenAssistant/llama2-13b-orca-8k-3319",
+    "TheBloke/WizardLM-13B-V1-1-SuperHOT-8K-fp16",
+    "duliadotio/dulia-13b-8k-alpha",
+    "Undi95/LewdEngine",
+    "OpenBuddy/openbuddy-llama2-13b-v8.1-fp16",
+    "CHIH-HUNG/llama-2-13b-open_orca_20w",
+    "bhenrym14/airoboros-33b-gpt4-1.4.1-lxctx-PI-16384-fp16",
+    "FlagAlpha/Llama2-Chinese-13b-Chat",
+    "LLMs/WizardLM-13B-V1.0",
+    "chansung/gpt4-alpaca-lora-13b-decapoda-1024",
+    "TheBloke/wizardLM-13B-1.0-fp16",
+    "digitous/13B-Chimera",
+    "yeontaek/Platypus2xOpenOrcaxGuanaco-13B-LoRa",
+    "jondurbin/airoboros-l2-13b-2.1",
+    "Monero/WizardLM-30B-Uncensored-Guanaco-SuperCOT-30b",
+    "TheBloke/UltraLM-13B-fp16",
+    "openaccess-ai-collective/minotaur-13b-fixed",
+    "NousResearch/Redmond-Puffin-13B",
+    "KoboldAI/LLaMA2-13B-Holomax",
+    "Lajonbot/WizardLM-13B-V1.2-PL-lora_unload",
+    "yeontaek/Platypus2-13B-LoRa-v2",
+    "TheBloke/airoboros-13B-HF",
+    "jondurbin/airoboros-13b",
+    "jjaaaww/posi_13b",
+    "CoolWP/llama-2-13b-guanaco-fp16",
+    "yeontaek/Platypus2-13B-QLoRa",
+    "h2oai/h2ogpt-research-oig-oasst1-512-30b",
+    "dfurman/llama-2-13b-guanaco-peft",
+    "NousResearch/Redmond-Puffin-13B",
+    "pe-nlp/llama-2-13b-platypus-vicuna-wizard",
+    "CHIH-HUNG/llama-2-13b-dolphin_20w",
+    "NousResearch/Nous-Hermes-13b",
+    "NobodyExistsOnTheInternet/GiftedConvo13bLoraNoEconsE4",
+    "ehartford/Wizard-Vicuna-13B-Uncensored",
+    "TheBloke/Wizard-Vicuna-13B-Uncensored-HF",
+    "openchat/openchat_v3.2_super",
+    "bhenrym14/airophin-v2-13b-PI-8k-fp16",
+    "openaccess-ai-collective/manticore-13b",
+    "The-Face-Of-Goonery/Huginn-22b-Prototype",
+    "jphme/Llama-2-13b-chat-german",
+    "grimpep/llama2-28B-Airo03",
+    "TheBloke/Kimiko-v2-13B-fp16",
+    "FPHam/Free_Sydney_13b_HF",
+    "lmsys/vicuna-13b-v1.3",
+    "FelixChao/llama2-13b-math1.1",
+    "CalderaAI/13B-BlueMethod",
+    "meta-llama/Llama-2-13b-chat-hf",
+    "deepse/CodeUp-Llama-2-13b-chat-hf",
+    "WizardLM/WizardMath-13B-V1.0",
+    "WizardLM/WizardMath-13B-V1.0",
+    "HyperbeeAI/Tulpar-7b-v0",
+    "xxyyy123/test_qkvo_adptor",
+    "xxyyy123/mc_data_30k_from_platpus_orca_7b_10k_v1_lora_qkvo_rank14_v2",
+    "openchat/openchat_v2_w",
+    "FelixChao/llama2-13b-math1.1",
+    "psmathur/orca_mini_v3_7b",
+    "TehVenom/Metharme-13b-Merged",
+    "xxyyy123/10k_v1_lora_qkvo_rank14_v3",
+    "OpenAssistant/llama2-13b-orca-v2-8k-3166",
+    "openaccess-ai-collective/wizard-mega-13b",
+    "jondurbin/airoboros-13b-gpt4-1.4",
+    "jondurbin/airoboros-13b-gpt4-1.4-fp16",
+    "Monero/Manticore-13b-Chat-Pyg-Guanaco",
+    "FelixChao/llama2-13b-math1.2",
+    "chargoddard/platypus-2-22b-relora",
+    "FelixChao/llama2-13b-math1.2",
+    "Gryphe/MythoBoros-13b",
+    "CalderaAI/13B-Ouroboros",
+    "OpenAssistant/llama2-13b-orca-v2-8k-3166",
+    "heegyu/LIMA2-13b-hf",
+    "digitous/13B-HyperMantis",
+    "Gryphe/MythoLogic-13b",
+    "TheBloke/Airoboros-L2-13B-2.1-GPTQ",
+    "chargoddard/platypus2-22b-relora",
+    "openchat/openchat_v2",
+    "yeontaek/Platypus2-13B-IA3",
+    "stabilityai/StableBeluga-7B",
+    "circulus/Llama-2-7b-orca-v1",
+    "budecosystem/genz-13b-v2",
+    "TheBloke/gpt4-x-vicuna-13B-HF",
+    "NobodyExistsOnTheInternet/GiftedConvo13bLoraNoEcons",
+    "zarakiquemparte/zarafusionex-1.1-l2-7b",
+    "Lajonbot/tableBeluga-7B-instruct-pl-lora_unload",
+    "jondurbin/airoboros-13b-gpt4",
+    "gaodrew/gaodrew-gorgonzola-13b",
+    "jondurbin/airoboros-13b-gpt4-1.1",
+    "TheBloke/gpt4-alpaca-lora-13B-HF",
+    "zarakiquemparte/zarablendex-vq-l2-7b",
+    "openaccess-ai-collective/manticore-13b-chat-pyg",
+    "Lajonbot/Llama-2-13b-hf-instruct-pl-lora_unload",
+    "NobodyExistsOnTheInternet/PuffedLIMA13bQLORA",
+    "xxyyy123/10k_v1_lora_qkvo_rank28_v2",
+    "jondurbin/airoboros-l2-13b-gpt4-1.4.1",
+    "dhmeltzer/Llama-2-13b-hf-eli5-wiki-1024_r_64_alpha_16",
+    "NobodyExistsOnTheInternet/PuffedConvo13bLoraE4",
+    "yihan6324/llama2-7b-instructmining-40k-sharegpt",
+    "CHIH-HUNG/llama-2-13b-Open_Platypus_and_ccp_2.6w",
+    "Aeala/GPT4-x-Alpasta-13b",
+    "psmathur/orca_mini_v2_13b",
+    "YeungNLP/firefly-llama-13b",
+    "psmathur/orca_mini_v2_13b",
+    "zarakiquemparte/zarafusionix-l2-7b",
+    "yihan6324/llama2-7b-instructmining-60k-sharegpt",
+    "yihan6324/llama-2-7b-instructmining-60k-sharegpt",
+    "layoric/llama-2-13b-code-alpaca",
+    "bofenghuang/vigogne-13b-instruct",
+    "Lajonbot/vicuna-13b-v1.3-PL-lora_unload",
+    "lvkaokao/llama2-7b-hf-chat-lora-v3",
+    "ehartford/dolphin-llama-13b",
+    "YeungNLP/firefly-llama-13b-v1.2",
+    "TheBloke/Kimiko-13B-fp16",
+    "kevinpro/Vicuna-13B-CoT",
+    "eachadea/vicuna-13b-1.1",
+    "pillowtalks-ai/delta13b",
+    "TheBloke/vicuna-13B-1.1-HF",
+    "TheBloke/Vicuna-13B-CoT-fp16",
+    "lmsys/vicuna-13b-delta-v1.1",
+    "lmsys/vicuna-13b-v1.1",
+    "xxyyy123/20k_v1_lora_qkvo_rank14_v2",
+    "TheBloke/guanaco-13B-HF",
+    "TheBloke/vicuna-13b-v1.3.0-GPTQ",
+    "edor/Stable-Platypus2-mini-7B",
+    "totally-not-an-llm/EverythingLM-13b-V2-16k",
+    "zarakiquemparte/zaraxe-l2-7b",
+    "beaugogh/Llama2-7b-openorca-mc-v2",
+    "TheBloke/Nous-Hermes-13B-SuperHOT-8K-fp16",
+    "quantumaikr/QuantumLM",
+    "jondurbin/airoboros-13b-gpt4-1.2",
+    "TheBloke/robin-13B-v2-fp16",
+    "TFLai/llama-2-13b-4bit-alpaca-gpt4",
+    "yihan6324/llama2-7b-instructmining-orca-40k",
+    "dvruette/oasst-llama-13b-2-epochs",
+    "Open-Orca/LlongOrca-7B-16k",
+    "Aspik101/Nous-Hermes-13b-pl-lora_unload",
+    "ehartford/Samantha-1.11-CodeLlama-34b",
+    "nkpz/llama2-22b-chat-wizard-uncensored",
+    "bofenghuang/vigogne-13b-chat",
+    "beaugogh/Llama2-7b-openorca-mc-v1",
+    "OptimalScale/robin-13b-v2-delta",
+    "pe-nlp/llama-2-13b-vicuna-wizard",
+    "chargoddard/llama2-22b",
+    "gywy/llama2-13b-chinese-v1",
+    "frank098/Wizard-Vicuna-13B-juniper",
+    "IGeniusDev/llama13B-quant8-testv1-openorca-customdataset",
+    "CHIH-HUNG/llama-2-13b-huangyt_Fintune_1_17w-gate_up_down_proj",
+    "eachadea/vicuna-13b",
+    "yihan6324/llama2-7b-instructmining-orca-90k",
+    "chargoddard/llama2-22b-blocktriangular",
+    "luffycodes/mcq-vicuna-13b-v1.5",
+    "Yhyu13/chimera-inst-chat-13b-hf",
+    "luffycodes/mcq-vicuna-13b-v1.5",
+    "chargoddard/ypotryll-22b-epoch2-qlora",
+    "totally-not-an-llm/EverythingLM-13b-16k",
+    "luffycodes/mcq-hal-vicuna-13b-v1.5",
+    "openaccess-ai-collective/minotaur-13b",
+    "IGeniusDev/llama13B-quant8-testv1-openorca-customdataset",
+    "chargoddard/llama2-22b-blocktriangular",
+    "TFLai/Platypus2-13B-QLoRA-0.80-epoch",
+    "meta-llama/Llama-2-13b-hf",
+    "CHIH-HUNG/llama-2-13b-huangyt_FINETUNE2_3w-gate_up_down_proj",
+    "luffycodes/mcq-hal-vicuna-13b-v1.5",
+    "TheBloke/Llama-2-13B-fp16",
+    "TaylorAI/Flash-Llama-13B",
+    "shareAI/bimoGPT-llama2-13b",
+    "wahaha1987/llama_13b_sharegpt94k_fastchat",
+    "openchat/openchat_8192",
+    "CHIH-HUNG/llama-2-13b-huangyt_Fintune_1_17w-q_k_v_o_proj",
+    "dvruette/llama-13b-pretrained-sft-do2",
+    "CHIH-HUNG/llama-2-13b-alpaca-test",
+    "OpenBuddy/openbuddy-llama2-13b-v11.1-bf16",
+    "CHIH-HUNG/llama-2-13b-FINETUNE2_TEST_2.2w",
+    "project-baize/baize-v2-13b",
+    "jondurbin/airoboros-l2-13b-gpt4-m2.0",
+    "yeontaek/Platypus2xOpenOrca-13B-LoRa-v2",
+    "CHIH-HUNG/llama-2-13b-huangyt_FINETUNE2_3w",
+    "xzuyn/Alpacino-SuperCOT-13B",
+    "jondurbin/airoboros-l2-13b-gpt4-2.0",
+    "aiplanet/effi-13b",
+    "clibrain/Llama-2-13b-ft-instruct-es",
+    "CHIH-HUNG/llama-2-13b-huangyt_Fintune_1_17w",
+    "bofenghuang/vigogne-2-7b-instruct",
+    "CHIH-HUNG/llama-2-13b-huangyt_FINETUNE2_3w-q_k_v_o_proj",
+    "bofenghuang/vigogne-2-7b-chat",
+    "aiplanet/effi-13b",
+    "haonan-li/bactrian-x-llama-13b-merged",
+    "beaugogh/Llama2-7b-sharegpt4",
+    "HWERI/Llama2-7b-sharegpt4",
+    "jondurbin/airoboros-13b-gpt4-1.3",
+    "jondurbin/airoboros-c34b-2.1",
+    "junelee/wizard-vicuna-13b",
+    "TheBloke/wizard-vicuna-13B-HF",
+    "Open-Orca/OpenOrca-Preview1-13B",
+    "TheBloke/h2ogpt-oasst1-512-30B-HF",
+    "TheBloke/Llama-2-13B-GPTQ",
+    "camel-ai/CAMEL-13B-Combined-Data",
+    "lmsys/vicuna-7b-v1.5",
+    "lmsys/vicuna-7b-v1.5-16k",
+    "lmsys/vicuna-7b-v1.5",
+    "ausboss/llama-13b-supercot",
+    "TheBloke/tulu-13B-fp16",
+    "NousResearch/Nous-Hermes-llama-2-7b",
+    "jlevin/guanaco-13b-llama-2",
+    "lmsys/vicuna-7b-v1.5-16k",
+    "dvruette/llama-13b-pretrained",
+    "nkpz/llama2-22b-daydreamer-v3",
+    "dvruette/llama-13b-pretrained-dropout",
+    "jondurbin/airoboros-l2-13b-2.1",
+    "LLMs/Stable-Vicuna-13B",
+    "64bits/LexPodLM-13B",
+    "lizhuang144/llama_mirror_13b_v1.0",
+    "TheBloke/stable-vicuna-13B-HF",
+    "zarakiquemparte/zaraxls-l2-7b",
+    "TheBloke/Llama-2-13B-GPTQ",
+    "Kiddyz/testlm-3",
+    "migtissera/Synthia-7B",
+    "zarakiquemparte/zarablend-l2-7b",
+    "mosaicml/mpt-30b-instruct",
+    "PocketDoc/Dans-PileOfSets-Mk1-llama-13b-merged",
+    "vonjack/Qwen-LLaMAfied-HFTok-7B-Chat",
+    "l3utterfly/llama2-7b-layla",
+    "Lajonbot/vicuna-7b-v1.5-PL-lora_unload",
+    "heegyu/LIMA-13b-hf",
+    "frank098/WizardLM_13B_juniper",
+    "ashercn97/manatee-7b",
+    "chavinlo/gpt4-x-alpaca",
+    "PocketDoc/Dans-PersonalityEngine-13b",
+    "ehartford/WizardLM-1.0-Uncensored-CodeLlama-34b",
+    "digitous/Alpacino13b",
+    "edor/Hermes-Platypus2-mini-7B",
+    "lvkaokao/llama2-7b-hf-chat-lora-v2",
+    "Kiddyz/testlm-1-1",
+    "Kiddyz/testlm",
+    "Kiddyz/testlm-1",
+    "Kiddyz/testlm2",
+    "radm/Philosophy-Platypus2-13b",
+    "aiplanet/effi-13b",
+    "Harshvir/Llama-2-7B-physics",
+    "YeungNLP/firefly-ziya-13b",
+    "LinkSoul/Chinese-Llama-2-7b",
+    "PeanutJar/LLaMa-2-PeanutButter_v10-7B",
+    "OpenBuddy/openbuddy-llama2-13b-v11-bf16",
+    "StudentLLM/Alpagasus-2-13B-QLoRA-pipeline",
+    "meta-llama/Llama-2-13b-hf",
+    "WizardLM/WizardCoder-Python-34B-V1.0",
+    "dvruette/llama-13b-pretrained-sft-epoch-1",
+    "camel-ai/CAMEL-13B-Role-Playing-Data",
+    "ziqingyang/chinese-llama-2-13b",
+    "rombodawg/LosslessMegaCoder-llama2-7b-mini",
+    "TheBloke/koala-13B-HF",
+    "lmsys/vicuna-7b-delta-v1.1",
+    "eachadea/vicuna-7b-1.1",
+    "Ejafa/vicuna_7B_vanilla_1.1",
+    "lvkaokao/llama2-7b-hf-chat-lora",
+    "OpenBuddy/openbuddy-atom-13b-v9-bf16",
+    "Norquinal/llama-2-7b-claude-chat-rp",
+    "Danielbrdz/Barcenas-7b",
+    "heegyu/WizardVicuna2-13b-hf",
+    "meta-llama/Llama-2-7b-chat-hf",
+    "PeanutJar/LLaMa-2-PeanutButter_v14-7B",
+    "PeanutJar/LLaMa-2-PeanutButter_v4-7B",
+    "davzoku/cria-llama2-7b-v1.3",
+    "OpenBuddy/openbuddy-atom-13b-v9-bf16",
+    "lvkaokao/llama2-7b-hf-instruction-lora",
+    "Tap-M/Luna-AI-Llama2-Uncensored",
+    "ehartford/Samantha-1.11-7b",
+    "WizardLM/WizardCoder-Python-34B-V1.0",
+    "TheBloke/Manticore-13B-Chat-Pyg-Guanaco-SuperHOT-8K-GPTQ",
+    "Mikael110/llama-2-7b-guanaco-fp16",
+    "garage-bAInd/Platypus2-7B",
+    "PeanutJar/LLaMa-2-PeanutButter_v18_B-7B",
+    "mosaicml/mpt-30b",
+    "garage-bAInd/Platypus2-7B",
+    "huggingface/llama-13b",
+    "dvruette/oasst-llama-13b-1000-steps",
+    "jordiclive/gpt4all-alpaca-oa-codealpaca-lora-13b",
+    "huggyllama/llama-13b",
+    "Voicelab/trurl-2-7b",
+    "TFLai/llama-13b-4bit-alpaca",
+    "gywy/llama2-13b-chinese-v2",
+    "lmsys/longchat-13b-16k",
+    "Aspik101/trurl-2-7b-pl-instruct_unload",
+    "WizardLM/WizardMath-7B-V1.0",
+    "Norquinal/llama-2-7b-claude-chat",
+    "TheTravellingEngineer/llama2-7b-chat-hf-dpo",
+    "HuggingFaceH4/starchat-beta",
+    "joehuangx/spatial-vicuna-7b-v1.5-LoRA",
+    "conceptofmind/LLongMA-2-13b-16k",
+    "tianyil1/denas-llama2",
+    "lmsys/vicuna-7b-v1.3",
+    "conceptofmind/LLongMA-2-13b-16k",
+    "openchat/opencoderplus",
+    "ajibawa-2023/scarlett-7b",
+    "dhmeltzer/llama-7b-SFT_eli5_wiki65k_1024_r_64_alpha_16_merged",
+    "psyche/kollama2-7b-v2",
+    "heegyu/LIMA2-7b-hf",
+    "dhmeltzer/llama-7b-SFT-qlora-eli5-wiki_DPO_ds_RM_top_2_1024_r_64_alpha_16",
+    "abhishek/llama2guanacotest",
+    "jondurbin/airoboros-l2-7b-2.1",
+    "llama-anon/instruct-13b",
+    "FelixChao/vicuna-7B-physics",
+    "Aspik101/Llama-2-7b-hf-instruct-pl-lora_unload",
+    "shibing624/chinese-alpaca-plus-13b-hf",
+    "davzoku/cria-llama2-7b-v1.3_peft",
+    "quantumaikr/llama-2-7b-hf-guanaco-1k",
+    "togethercomputer/Llama-2-7B-32K-Instruct",
+    "sia-ai/llama-2-7b-1-percent-open-orca-1000-steps-v0",
+    "TheTravellingEngineer/llama2-7b-hf-guanaco",
+    "Lajonbot/Llama-2-7b-chat-hf-instruct-pl-lora_unload",
+    "jondurbin/airoboros-l2-7b-gpt4-1.4.1",
+    "wahaha1987/llama_7b_sharegpt94k_fastchat",
+    "FelixChao/vicuna-7B-chemical",
+    "TinyPixel/llama2-7b-oa",
+    "chaoyi-wu/MedLLaMA_13B",
+    "edor/Platypus2-mini-7B",
+    "RoversX/llama-2-7b-hf-small-shards-Samantha-V1-SFT",
+    "venkycs/llama-v2-7b-32kC-Security",
+    "psyche/kollama2-7b",
+    "Fredithefish/Guanaco-7B-Uncensored",
+    "TheTravellingEngineer/llama2-7b-chat-hf-guanaco",
+    "ehartford/WizardLM-13B-Uncensored",
+    "PocketDoc/Dans-CreepingSenseOfDoom",
+    "wenge-research/yayi-7b-llama2",
+    "georgesung/llama2_7b_chat_uncensored",
+    "TinyPixel/llama2-7b-instruct",
+    "quantumaikr/QuantumLM-7B",
+    "xzuyn/MedicWizard-7B",
+    "wenge-research/yayi-7b-llama2",
+    "TinyPixel/lima-test",
+    "elyza/ELYZA-japanese-Llama-2-7b-instruct",
+    "lgaalves/llama-2-7b-hf_open-platypus",
+    "ziqingyang/chinese-alpaca-2-7b",
+    "TehVenom/Pygmalion-Vicuna-1.1-7b",
+    "meta-llama/Llama-2-7b-hf",
+    "bongchoi/test-llama2-7b",
+    "TaylorAI/Flash-Llama-7B",
+    "TheTravellingEngineer/llama2-7b-chat-hf-v2",
+    "TheTravellingEngineer/llama2-7b-chat-hf-v4",
+    "kashif/stack-llama-2",
+    "PeanutJar/LLaMa-2-PeanutButter_v18_A-7B",
+    "ToolBench/ToolLLaMA-7b-LoRA",
+    "Monero/WizardLM-13b-OpenAssistant-Uncensored",
+    "TheTravellingEngineer/llama2-7b-chat-hf-v2",
+    "TheTravellingEngineer/llama2-7b-chat-hf-v4",
+    "mrm8488/llama-2-coder-7b",
+    "elyza/ELYZA-japanese-Llama-2-7b-fast-instruct",
+    "clibrain/Llama-2-7b-ft-instruct-es",
+    "medalpaca/medalpaca-7b",
+    "TheBloke/tulu-7B-fp16",
+    "OpenBuddy/openbuddy-openllama-13b-v7-fp16",
+    "TaylorAI/FLAN-Llama-7B-2_Llama2-7B-Flash_868_full_model",
+    "Aspik101/vicuna-7b-v1.3-instruct-pl-lora_unload",
+    "jondurbin/airoboros-l2-7b-gpt4-2.0",
+    "dhmeltzer/llama-7b-SFT_ds_eli5_1024_r_64_alpha_16_merged",
+    "GOAT-AI/GOAT-7B-Community",
+    "AtomEchoAI/AtomGPT_56k",
+    "julianweng/Llama-2-7b-chat-orcah",
+    "TehVenom/Pygmalion-13b-Merged",
+    "jondurbin/airoboros-7b-gpt4-1.1",
+    "dhmeltzer/llama-7b-SFT_ds_wiki65k_1024_r_64_alpha_16_merged",
+    "bofenghuang/vigogne-7b-chat",
+    "lmsys/longchat-7b-v1.5-32k",
+    "jondurbin/airoboros-l2-7b-gpt4-m2.0",
+    "synapsoft/Llama-2-7b-chat-hf-flan2022-1.2M",
+    "jondurbin/airoboros-7b-gpt4-1.4",
+    "Charlie911/vicuna-7b-v1.5-lora-mctaco",
+    "yihan6324/instructmining-platypus-15k",
+    "meta-llama/Llama-2-7b-hf",
+    "TheTravellingEngineer/llama2-7b-chat-hf-v3",
+    "quantumaikr/KoreanLM-hf",
+    "openthaigpt/openthaigpt-1.0.0-alpha-7b-chat-ckpt-hf",
+    "TheBloke/Llama-2-7B-GPTQ",
+    "TheBloke/Llama-2-7B-GPTQ",
+    "LLMs/AlpacaGPT4-7B-elina",
+    "ehartford/Wizard-Vicuna-7B-Uncensored",
+    "TheBloke/Wizard-Vicuna-7B-Uncensored-HF",
+    "TheTravellingEngineer/llama2-7b-chat-hf-v3",
+    "golaxy/gowizardlm",
+    "ehartford/dolphin-llama2-7b",
+    "CHIH-HUNG/llama-2-7b-dolphin_10w-test",
+    "mncai/chatdoctor",
+    "psyche/kollama2-7b-v3",
+    "jondurbin/airoboros-7b-gpt4",
+    "jondurbin/airoboros-7b",
+    "TheBloke/airoboros-7b-gpt4-fp16",
+    "mosaicml/mpt-7b-8k-chat",
+    "elyza/ELYZA-japanese-Llama-2-7b",
+    "bofenghuang/vigogne-7b-instruct",
+    "jxhong/CAlign-alpaca-7b",
+    "golaxy/goims",
+    "jondurbin/airoboros-7b-gpt4-1.2",
+    "jphme/orca_mini_v2_ger_7b",
+    "psmathur/orca_mini_v2_7b",
+    "notstoic/PygmalionCoT-7b",
+    "golaxy/gogpt2-13b",
+    "golaxy/gogpt2-13b-chat",
+    "togethercomputer/LLaMA-2-7B-32K",
+    "TheBloke/wizardLM-7B-HF",
+    "keyfan/vicuna-chinese-replication-v1.1",
+    "golaxy/gogpt2-7b",
+    "aiplanet/effi-7b",
+    "arver/llama7b-qlora",
+    "titan087/OpenLlama13B-Guanaco",
+    "chavinlo/alpaca-native",
+    "project-baize/baize-healthcare-lora-7B",
+    "AlpinDale/pygmalion-instruct",
+    "openlm-research/open_llama_13b",
+    "jondurbin/airoboros-7b-gpt4-1.3",
+    "elyza/ELYZA-japanese-Llama-2-7b-fast",
+    "jondurbin/airoboros-gpt-3.5-turbo-100k-7b",
+    "uukuguy/speechless-codellama-orca-13b",
+    "bigcode/starcoderplus",
+    "TheBloke/guanaco-7B-HF",
+    "Neko-Institute-of-Science/metharme-7b",
+    "TigerResearch/tigerbot-7b-base",
+    "golaxy/gogpt-7b",
+    "togethercomputer/LLaMA-2-7B-32K",
+    "yhyhy3/open_llama_7b_v2_med_instruct",
+    "ajibawa-2023/carl-7b",
+    "stabilityai/stablelm-base-alpha-7b-v2",
+    "conceptofmind/LLongMA-2-7b-16k",
+    "TehVenom/Pygmalion_AlpacaLora-7b",
+    "jondurbin/airoboros-7b-gpt4-1.4.1-qlora",
+    "wannaphong/openthaigpt-0.1.0-beta-full-model_for_open_llm_leaderboard",
+    "ausboss/llama7b-wizardlm-unfiltered",
+    "project-baize/baize-v2-7b",
+    "LMFlow/Robin-v2",
+    "HanningZhang/Robin-v2",
+    "LMFlow/Robin-7b-v2",
+    "OptimalScale/robin-7b-v2-delta",
+    "uukuguy/speechless-codellama-platypus-13b",
+    "jerryjalapeno/nart-100k-7b",
+    "wenge-research/yayi-13b-llama2",
+    "fireballoon/baichuan-vicuna-chinese-7b",
+    "jlevin/guanaco-unchained-llama-2-7b",
+    "csitfun/llama-7b-logicot",
+    "DevaMalla/llama7b_alpaca_1gpu_bf16",
+    "WeOpenML/PandaLM-Alpaca-7B-v1",
+    "illuin/test-custom-llama",
+    "yeontaek/WizardCoder-Python-13B-LoRa",
+    "ashercn97/giraffe-7b",
+    "mosaicml/mpt-7b-chat",
+    "abhishek/autotrain-llama-alpaca-peft-52508123785",
+    "Neko-Institute-of-Science/pygmalion-7b",
+    "TFLai/llama-7b-4bit-alpaca",
+    "huggingface/llama-7b",
+    "TheBloke/Planner-7B-fp16",
+    "shibing624/chinese-llama-plus-13b-hf",
+    "AGI-inc/lora_moe_7b_baseline",
+    "DevaMalla/llama-base-7b",
+    "AGI-inc/lora_moe_7b",
+    "togethercomputer/GPT-JT-6B-v0",
+    "ehartford/WizardLM-7B-Uncensored",
+    "shibing624/chinese-alpaca-plus-7b-hf",
+    "beomi/llama-2-ko-7b",
+    "mosaicml/mpt-7b-8k-instruct",
+    "Enno-Ai/ennodata-7b",
+    "mosaicml/mpt-7b-instruct",
+    "facebook/opt-iml-max-30b",
+    "WeOpenML/Alpaca-7B-v1",
+    "TheBloke/Project-Baize-v2-7B-GPTQ",
+    "codellama/CodeLlama-13b-Instruct-hf",
+    "TheBloke/CodeLlama-13B-Instruct-fp16",
+    "facebook/galactica-30b",
+    "FreedomIntelligence/phoenix-inst-chat-7b",
+    "openlm-research/open_llama_7b_v2",
+    "GeorgiaTechResearchInstitute/galpaca-30b",
+    "THUDM/chatglm2-6b",
+    "togethercomputer/GPT-JT-6B-v1",
+    "TheBloke/koala-7B-HF",
+    "nathan0/mpt_delta_tuned_model_v3",
+    "nathan0/mpt_delta_tuned_model_v2",
+    "GeorgiaTechResearchInstitute/galpaca-30b",
+    "JosephusCheung/Guanaco",
+    "shareAI/CodeLLaMA-chat-13b-Chinese",
+    "TigerResearch/tigerbot-7b-sft",
+    "Writer/InstructPalmyra-20b",
+    "OpenAssistant/codellama-13b-oasst-sft-v10",
+    "bigscience/bloomz-7b1-mt",
+    "nathan0/mpt_delta_tuned_model_v3",
+    "VMware/open-llama-7b-open-instruct",
+    "baichuan-inc/Baichuan-7B",
+    "anas-awadalla/mpt-7b",
+    "mosaicml/mpt-7b",
+    "bigscience/bloomz-7b1",
+    "ziqingyang/chinese-llama-2-7b",
+    "OpenAssistant/codellama-13b-oasst-sft-v10",
+    "wenge-research/yayi-7b",
+    "tiiuae/falcon-7b",
+    "togethercomputer/RedPajama-INCITE-Instruct-7B-v0.1",
+    "togethercomputer/RedPajama-INCITE-7B-Instruct",
+    "TheBloke/landmark-attention-llama7b-fp16",
+    "togethercomputer/GPT-JT-Moderation-6B",
+    "h2oai/h2ogpt-gm-oasst1-en-1024-20b",
+    "dvruette/gpt-neox-20b-full-precision",
+    "TehVenom/Moderator-Chan_GPT-JT-6b",
+    "dvruette/oasst-gpt-neox-20b-1000-steps",
+    "AlekseyKorshuk/pygmalion-6b-vicuna-chatml",
+    "facebook/opt-66b",
+    "Salesforce/codegen-16B-nl",
+    "Vmware/open-llama-7b-v2-open-instruct",
+    "mosaicml/mpt-7b-storywriter",
+    "acrastt/Marx-3B-V2",
+    "openlm-research/open_llama_7b",
+    "Fredithefish/ReasonixPajama-3B-HF",
+    "togethercomputer/GPT-NeoXT-Chat-Base-20B",
+    "psmathur/orca_mini_13b",
+    "RWKV/rwkv-raven-14b",
+    "h2oai/h2ogpt-oasst1-512-20b",
+    "acrastt/Marx-3B",
+    "klosax/open_llama_13b_600bt_preview",
+    "synapsoft/Llama-2-7b-hf-flan2022-1.2M",
+    "OpenAssistant/oasst-sft-1-pythia-12b",
+    "golaxy/gogpt-7b-bloom",
+    "Writer/palmyra-large",
+    "psmathur/orca_mini_7b",
+    "dvruette/oasst-pythia-12b-6000-steps",
+    "NousResearch/CodeLlama-13b-hf",
+    "codellama/CodeLlama-13b-hf",
+    "h2oai/h2ogpt-gm-oasst1-multilang-1024-20b",
+    "VMware/open-llama-0.7T-7B-open-instruct-v1.1",
+    "dvruette/oasst-pythia-12b-flash-attn-5000-steps",
+    "dvruette/oasst-gpt-neox-20b-3000-steps",
+    "RobbeD/OpenLlama-Platypus-3B",
+    "facebook/opt-30b",
+    "acrastt/Puma-3B",
+    "OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5",
+    "dvruette/oasst-pythia-12b-pretrained-sft",
+    "digitous/GPT-R",
+    "acrastt/Griffin-3B",
+    "togethercomputer/RedPajama-INCITE-Base-7B-v0.1",
+    "togethercomputer/RedPajama-INCITE-7B-Base",
+    "CobraMamba/mamba-gpt-3b-v3",
+    "Danielbrdz/CodeBarcenas-7b",
+    "l3utterfly/open-llama-3b-v2-layla",
+    "CobraMamba/mamba-gpt-3b-v2",
+    "OpenAssistant/pythia-12b-sft-v8-7k-steps",
+    "KoboldAI/GPT-NeoX-20B-Erebus",
+    "RobbeD/Orca-Platypus-3B",
+    "h2oai/h2ogpt-gm-oasst1-en-1024-12b",
+    "OpenAssistant/pythia-12b-sft-v8-2.5k-steps",
+    "AlekseyKorshuk/chatml-pyg-v1",
+    "togethercomputer/RedPajama-INCITE-Chat-7B-v0.1",
+    "togethercomputer/RedPajama-INCITE-7B-Chat",
+    "digitous/Javelin-R",
+    "dvruette/oasst-pythia-12b-reference",
+    "EleutherAI/gpt-neox-20b",
+    "KoboldAI/fairseq-dense-13B",
+    "OpenAssistant/pythia-12b-sft-v8-rlhf-2k-steps",
+    "codellama/CodeLlama-7b-Instruct-hf",
+    "digitous/Javelin-GPTJ",
+    "KoboldAI/GPT-NeoX-20B-Skein",
+    "digitous/Javalion-R",
+    "h2oai/h2ogpt-oasst1-512-12b",
+    "acrastt/Bean-3B",
+    "KoboldAI/GPT-J-6B-Skein",
+    "nomic-ai/gpt4all-j",
+    "databricks/dolly-v2-12b",
+    "TehVenom/Dolly_Shygmalion-6b-Dev_V8P2",
+    "databricks/dolly-v2-7b",
+    "Aspik101/WizardVicuna-Uncensored-3B-instruct-PL-lora_unload",
+    "digitous/Adventien-GPTJ",
+    "openlm-research/open_llama_3b_v2",
+    "RWKV/rwkv-4-14b-pile",
+    "Lazycuber/Janemalion-6B",
+    "OpenAssistant/pythia-12b-pre-v8-12.5k-steps",
+    "digitous/Janin-R",
+    "kfkas/Llama-2-ko-7b-Chat",
+    "heegyu/WizardVicuna-Uncensored-3B-0719",
+    "h2oai/h2ogpt-gm-oasst1-en-1024-open-llama-7b-preview-400bt",
+    "TaylorAI/Flash-Llama-3B",
+    "kfkas/Llama-2-ko-7b-Chat",
+    "digitous/Skegma-GPTJ",
+    "digitous/Javalion-GPTJ",
+    "Pirr/pythia-13b-deduped-green_devil",
+    "TehVenom/PPO_Shygmalion-V8p4_Dev-6b",
+    "dvruette/oasst-pythia-6.9b-4000-steps",
+    "heegyu/WizardVicuna-3B-0719",
+    "psmathur/orca_mini_3b",
+    "OpenAssistant/galactica-6.7b-finetuned",
+    "frank098/orca_mini_3b_juniper",
+    "PygmalionAI/pygmalion-6b",
+    "TehVenom/PPO_Pygway-V8p4_Dev-6b",
+    "TFLai/gpt-neox-20b-4bit-alpaca",
+    "Corianas/gpt-j-6B-Dolly",
+    "TehVenom/Dolly_Shygmalion-6b",
+    "digitous/Janin-GPTJ",
+    "TehVenom/GPT-J-Pyg_PPO-6B-Dev-V8p4",
+    "EleutherAI/gpt-j-6b",
+    "KoboldAI/GPT-J-6B-Shinen",
+    "TehVenom/Dolly_Malion-6b",
+    "TehVenom/ChanMalion",
+    "Salesforce/codegen-6B-nl",
+    "Fredithefish/RedPajama-INCITE-Chat-3B-Instruction-Tuning-with-GPT-4",
+    "KoboldAI/GPT-J-6B-Janeway",
+    "togethercomputer/RedPajama-INCITE-Chat-3B-v1",
+    "togethercomputer/Pythia-Chat-Base-7B",
+    "heegyu/RedTulu-Uncensored-3B-0719",
+    "KoboldAI/PPO_Pygway-6b-Mix",
+    "KoboldAI/OPT-13B-Erebus",
+    "KoboldAI/fairseq-dense-6.7B",
+    "EleutherAI/pythia-12b-deduped",
+    "pszemraj/pythia-6.9b-HC3",
+    "Fredithefish/Guanaco-3B-Uncensored-v2",
+    "facebook/opt-13b",
+    "TehVenom/GPT-J-Pyg_PPO-6B",
+    "EleutherAI/pythia-6.9b-deduped",
+    "Devio/test-1400",
+    "Fredithefish/Guanaco-3B-Uncensored",
+    "codellama/CodeLlama-7b-hf",
+    "acrastt/RedPajama-INCITE-Chat-Instruct-3B-V1",
+    "Fredithefish/ScarletPajama-3B-HF",
+    "KoboldAI/OPT-13B-Nerybus-Mix",
+    "YeungNLP/firefly-bloom-7b1",
+    "DanielSc4/RedPajama-INCITE-Chat-3B-v1-RL-LoRA-8bit-test1",
+    "klosax/open_llama_7b_400bt_preview",
+    "KoboldAI/OPT-13B-Nerys-v2",
+    "TehVenom/PPO_Shygmalion-6b",
+    "amazon/LightGPT",
+    "KnutJaegersberg/black_goo_recipe_c",
+    "NousResearch/CodeLlama-7b-hf",
+    "togethercomputer/RedPajama-INCITE-Instruct-3B-v1",
+    "heegyu/WizardVicuna-open-llama-3b-v2",
+    "bigscience/bloom-7b1",
+    "Devio/test-22B",
+    "RWKV/rwkv-raven-7b",
+    "hakurei/instruct-12b",
+    "CobraMamba/mamba-gpt-3b",
+    "KnutJaegersberg/black_goo_recipe_a",
+    "acrastt/OmegLLaMA-3B",
+    "codellama/CodeLlama-7b-Instruct-hf",
+    "h2oai/h2ogpt-oig-oasst1-512-6_9b",
+    "KoboldAI/OPT-6.7B-Erebus",
+    "facebook/opt-6.7b",
+    "KnutJaegersberg/black_goo_recipe_d",
+    "KnutJaegersberg/LLongMA-3b-LIMA",
+    "KnutJaegersberg/black_goo_recipe_b",
+    "KoboldAI/OPT-6.7B-Nerybus-Mix",
+    "health360/Healix-3B",
+    "EleutherAI/pythia-12b",
+    "Fredithefish/RedPajama-INCITE-Chat-3B-ShareGPT-11K",
+    "GeorgiaTechResearchInstitute/galactica-6.7b-evol-instruct-70k",
+    "h2oai/h2ogpt-oig-oasst1-256-6_9b",
+    "ikala/bloom-zh-3b-chat",
+    "Taekyoon/llama2-ko-7b-test",
+    "anhnv125/pygmalion-6b-roleplay",
+    "TehVenom/DiffMerge_Pygmalion_Main-onto-V8P4",
+    "KoboldAI/OPT-6B-nerys-v2",
+    "Lazycuber/pyg-instruct-wizardlm",
+    "Devio/testC",
+    "KoboldAI/OPT-30B-Erebus",
+    "Fredithefish/CrimsonPajama",
+    "togethercomputer/RedPajama-INCITE-Base-3B-v1",
+    "bigscience/bloomz-3b",
+    "conceptofmind/Open-LLongMA-3b",
+    "RWKV/rwkv-4-7b-pile",
+    "openlm-research/open_llama_3b",
+    "ewof/koishi-instruct-3b",
+    "DanielSc4/RedPajama-INCITE-Chat-3B-v1-FT-LoRA-8bit-test1",
+    "cerebras/Cerebras-GPT-13B",
+    "EleutherAI/pythia-6.7b",
+    "aisquared/chopt-2_7b",
+    "Azure99/blossom-v1-3b",
+    "PSanni/Deer-3b",
+    "bertin-project/bertin-gpt-j-6B-alpaca",
+    "OpenBuddy/openbuddy-openllama-3b-v10-bf16",
+    "KoboldAI/fairseq-dense-2.7B",
+    "ehartford/CodeLlama-34b-Instruct-hf",
+    "codellama/CodeLlama-34b-Instruct-hf",
+    "TheBloke/CodeLlama-34B-Instruct-fp16",
+    "h2oai/h2ogpt-gm-oasst1-en-2048-open-llama-7b-preview-300bt-v2",
+    "openlm-research/open_llama_7b_700bt_preview",
+    "NbAiLab/nb-gpt-j-6B-alpaca",
+    "KoboldAI/OPT-2.7B-Erebus",
+    "Writer/camel-5b-hf",
+    "EleutherAI/pythia-2.7b",
+    "facebook/xglm-7.5B",
+    "EleutherAI/pythia-2.8b-deduped",
+    "klosax/open_llama_3b_350bt_preview",
+    "klosax/openllama-3b-350bt",
+    "KoboldAI/OPT-2.7B-Nerybus-Mix",
+    "KoboldAI/GPT-J-6B-Adventure",
+    "cerebras/Cerebras-GPT-6.7B",
+    "TFLai/pythia-2.8b-4bit-alpaca",
+    "facebook/opt-2.7b",
+    "KoboldAI/OPT-2.7B-Nerys-v2",
+    "bigscience/bloom-3b",
+    "Devio/test100",
+    "RWKV/rwkv-raven-3b",
+    "Azure99/blossom-v2-3b",
+    "codellama/CodeLlama-34b-Python-hf",
+    "bhenrym14/airoboros-33b-gpt4-1.4.1-PI-8192-fp16",
+    "EleutherAI/gpt-neo-2.7B",
+    "danielhanchen/open_llama_3b_600bt_preview",
+    "HuggingFaceH4/starchat-alpha",
+    "pythainlp/wangchanglm-7.5B-sft-en-sharded",
+    "beaugogh/pythia-1.4b-deduped-sharegpt",
+    "HWERI/pythia-1.4b-deduped-sharegpt",
+    "OpenAssistant/stablelm-7b-sft-v7-epoch-3",
+    "codellama/CodeLlama-7b-Python-hf",
+    "aisquared/chopt-1_3b",
+    "PygmalionAI/metharme-1.3b",
+    "Linly-AI/Chinese-LLaMA-2-13B-hf",
+    "chargoddard/llama-2-34b-uncode",
+    "RWKV/rwkv-4-3b-pile",
+    "pythainlp/wangchanglm-7.5B-sft-enth",
+    "MBZUAI/LaMini-GPT-1.5B",
+    "Writer/palmyra-base",
+    "KoboldAI/fairseq-dense-1.3B",
+    "EleutherAI/pythia-1.4b-deduped",
+    "MBZUAI/lamini-neo-1.3b",
+    "h2oai/h2ogpt-gm-oasst1-en-2048-open-llama-7b-preview-300bt",
+    "sartmis1/starcoder-finetune-openapi",
+    "MayaPH/opt-flan-iml-6.7b",
+    "facebook/xglm-4.5B",
+    "WizardLM/WizardCoder-15B-V1.0",
+    "facebook/opt-iml-max-1.3b",
+    "stabilityai/stablelm-tuned-alpha-7b",
+    "aisquared/dlite-v2-1_5b",
+    "stabilityai/stablelm-base-alpha-7b",
+    "sartmis1/starcoder-finetune-selfinstruct",
+    "lizhuang144/starcoder_mirror",
+    "bigcode/starcoder",
+    "TheBloke/CodeLlama-34B-Python-fp16",
+    "open-llm-leaderboard/bloomz-1b7-4bit-alpaca-auto-eval-adapter-applied",
+    "ehartford/CodeLlama-34b-Python-hf",
+    "codellama/CodeLlama-7b-Python-hf",
+    "GeorgiaTechResearchInstitute/starcoder-gpteacher-code-instruct",
+    "LoupGarou/WizardCoder-Guanaco-15B-V1.0",
+    "golaxy/gogpt-3b-bloom",
+    "EleutherAI/pythia-1.3b",
+    "codellama/CodeLlama-13b-Python-hf",
+    "hakurei/lotus-12B",
+    "NYTK/PULI-GPTrio",
+    "facebook/opt-1.3b",
+    "TheBloke/CodeLlama-13B-Python-fp16",
+    "codellama/CodeLlama-13b-Python-hf",
+    "RWKV/rwkv-raven-1b5",
+    "PygmalionAI/pygmalion-2.7b",
+    "bigscience/bloom-1b7",
+    "gpt2-xl",
+    "LoupGarou/WizardCoder-Guanaco-15B-V1.1",
+    "RWKV/rwkv-4-1b5-pile",
+    "codellama/CodeLlama-34b-hf",
+    "NousResearch/CodeLlama-34b-hf",
+    "rinna/bilingual-gpt-neox-4b-8k",
+    "lxe/Cerebras-GPT-2.7B-Alpaca-SP",
+    "cerebras/Cerebras-GPT-2.7B",
+    "jzjiao/opt-1.3b-rlhf",
+    "EleutherAI/gpt-neo-1.3B",
+    "aisquared/dlite-v1-1_5b",
+    "Corianas/Quokka_2.7b",
+    "MrNJK/gpt2-xl-sft",
+    "facebook/galactica-1.3b",
+    "aisquared/dlite-v2-774m",
+    "EleutherAI/pythia-1b-deduped",
+    "Kunhao/pile-7b-250b-tokens",
+    "w601sxs/b1ade-1b",
+    "rinna/bilingual-gpt-neox-4b",
+    "shaohang/SparseOPT-1.3B",
+    "shaohang/Sparse0.5_OPT-1.3",
+    "EleutherAI/polyglot-ko-12.8b",
+    "Salesforce/codegen-6B-multi",
+    "bigscience/bloom-1b1",
+    "TFLai/gpt-neo-1.3B-4bit-alpaca",
+    "FabbriSimo01/Bloom_1b_Quantized",
+    "MBZUAI/LaMini-GPT-774M",
+    "Locutusque/gpt2-large-conversational",
+    "Devio/test-3b",
+    "stabilityai/stablelm-tuned-alpha-3b",
+    "PygmalionAI/pygmalion-1.3b",
+    "KoboldAI/fairseq-dense-355M",
+    "Rachneet/gpt2-xl-alpaca",
+    "gpt2-large",
+    "Mikivis/gpt2-large-lora-sft",
+    "stabilityai/stablelm-base-alpha-3b",
+    "gpt2-medium",
+    "Kunhao/pile-7b",
+    "aisquared/dlite-v1-774m",
+    "aisquared/dlite-v2-355m",
+    "YeungNLP/firefly-bloom-2b6-v2",
+    "KnutJaegersberg/gpt-2-xl-EvolInstruct",
+    "KnutJaegersberg/galactica-orca-wizardlm-1.3b",
+    "cerebras/Cerebras-GPT-1.3B",
+    "FabbriSimo01/Cerebras_1.3b_Quantized",
+    "facebook/xglm-1.7B",
+    "EleutherAI/pythia-410m-deduped",
+    "TheBloke/GPlatty-30B-SuperHOT-8K-fp16",
+    "DataLinguistic/DataLinguistic-34B-V1.0",
+    "Corianas/Quokka_1.3b",
+    "TheTravellingEngineer/bloom-560m-RLHF-v2",
+    "Corianas/1.3b",
+    "RWKV/rwkv-4-430m-pile",
+    "porkorbeef/Llama-2-13b-sf",
+    "xhyi/PT_GPTNEO350_ATG",
+    "TheBloke/Wizard-Vicuna-13B-Uncensored-GPTQ",
+    "bigscience/bloomz-560m",
+    "TheBloke/medalpaca-13B-GPTQ-4bit",
+    "TheBloke/Vicuna-33B-1-3-SuperHOT-8K-fp16",
+    "aisquared/dlite-v1-355m",
+    "uukuguy/speechless-codellama-orca-airoboros-13b-0.10e",
+    "yhyhy3/med-orca-instruct-33b",
+    "TheBloke/Wizard-Vicuna-30B-Superhot-8K-fp16",
+    "TheTravellingEngineer/bloom-1b1-RLHF",
+    "MBZUAI/lamini-cerebras-1.3b",
+    "IDEA-CCNL/Ziya-LLaMA-13B-Pretrain-v1",
+    "TheBloke/WizardLM-7B-uncensored-GPTQ",
+    "TheBloke/EverythingLM-13B-16K-GPTQ",
+    "quantumaikr/open_llama_7b_hf",
+    "TheBloke/chronos-wizardlm-uc-scot-st-13B-GPTQ",
+    "TheBloke/WizardLM-30B-Uncensored-GPTQ",
+    "IDEA-CCNL/Ziya-LLaMA-13B-v1",
+    "Phind/Phind-CodeLlama-34B-v1",
+    "robowaifudev/megatron-gpt2-345m",
+    "MayaPH/GodziLLa-30B-instruct",
+    "TheBloke/CAMEL-33B-Combined-Data-SuperHOT-8K-fp16",
+    "uukuguy/speechless-codellama-orca-platypus-13b-0.10e",
+    "doas/test2",
+    "BreadAi/PM_modelV2",
+    "bigcode/santacoder",
+    "TheBloke/wizard-vicuna-13B-GPTQ",
+    "porkorbeef/Llama-2-13b",
+    "TehVenom/DiffMerge-DollyGPT-Pygmalion",
+    "PygmalionAI/pygmalion-350m",
+    "TheBloke/orca_mini_v3_7B-GPTQ",
+    "TheBloke/WizardLM-Uncensored-SuperCOT-StoryTelling-30B-GPTQ",
+    "TheBloke/WizardLM-30B-GPTQ",
+    "bigscience/bloom-560m",
+    "TFLai/gpt2-turkish-uncased",
+    "TheBloke/guanaco-33B-GPTQ",
+    "TheBloke/openchat_v2_openorca_preview-GPTQ",
+    "porkorbeef/Llama-2-13b-public",
+    "TheBloke/LongChat-13B-GPTQ",
+    "yhyhy3/med-orca-instruct-33b",
+    "TheBloke/airoboros-33B-gpt4-1-4-SuperHOT-8K-fp16",
+    "TheBloke/Chinese-Alpaca-33B-SuperHOT-8K-fp16",
+    "MayaPH/FinOPT-Franklin",
+    "TheBloke/WizardLM-33B-V1.0-Uncensored-GPTQ",
+    "TheBloke/Project-Baize-v2-13B-GPTQ",
+    "malhajar/Platypus2-70B-instruct-4bit-gptq",
+    "KoboldAI/OPT-350M-Erebus",
+    "rishiraj/bloom-560m-guanaco",
+    "Panchovix/WizardLM-33B-V1.0-Uncensored-SuperHOT-8k",
+    "doas/test5",
+    "vicgalle/alpaca-7b",
+    "beomi/KoAlpaca-Polyglot-5.8B",
+    "Phind/Phind-CodeLlama-34B-Python-v1",
+    "timdettmers/guanaco-65b-merged",
+    "TheBloke/wizard-mega-13B-GPTQ",
+    "MayaPH/GodziLLa-30B-plus",
+    "TheBloke/Platypus-30B-SuperHOT-8K-fp16",
+    "facebook/opt-350m",
+    "KoboldAI/OPT-350M-Nerys-v2",
+    "TheBloke/robin-33B-v2-GPTQ",
+    "jaspercatapang/Echidna-30B",
+    "TheBloke/llama-30b-supercot-SuperHOT-8K-fp16",
+    "marcchew/test1",
+    "Harshvir/LaMini-Neo-1.3B-Mental-Health_lora",
+    "golaxy/gogpt-560m",
+    "TheBloke/orca_mini_13B-GPTQ",
+    "Panchovix/airoboros-33b-gpt4-1.2-SuperHOT-8k",
+    "Aspik101/tulu-7b-instruct-pl-lora_unload",
+    "Phind/Phind-CodeLlama-34B-v2",
+    "BreadAi/MusePy-1-2",
+    "cerebras/Cerebras-GPT-590M",
+    "microsoft/CodeGPT-small-py",
+    "victor123/WizardLM-13B-1.0",
+    "OptimalScale/robin-65b-v2-delta",
+    "voidful/changpt-bart",
+    "FabbriSimo01/GPT_Large_Quantized",
+    "MayaPH/FinOPT-Lincoln",
+    "KoboldAI/fairseq-dense-125M",
+    "SebastianSchramm/Cerebras-GPT-111M-instruction",
+    "TheTravellingEngineer/bloom-560m-RLHF",
+    "breadlicker45/dough-instruct-base-001",
+    "WizardLM/WizardLM-30B-V1.0",
+    "WizardLM/WizardLM-30B-V1.0",
+    "WizardLM/WizardLM-30B-V1.0",
+    "TaylorAI/Flash-Llama-30M-20001",
+    "porkorbeef/Llama-2-13b-12_153950",
+    "huggingtweets/bladeecity-jerma985",
+    "KnutJaegersberg/megatron-GPT-2-345m-EvolInstruct",
+    "bhenrym14/airoboros-33b-gpt4-1.4.1-lxctx-PI-16384-fp16",
+    "microsoft/DialoGPT-small",
+    "Corianas/590m",
+    "facebook/xglm-564M",
+    "EleutherAI/gpt-neo-125m",
+    "EleutherAI/pythia-160m-deduped",
+    "klosax/pythia-160m-deduped-step92k-193bt",
+    "MBZUAI/lamini-neo-125m",
+    "bigcode/tiny_starcoder_py",
+    "concedo/OPT-19M-ChatSalad",
+    "anton-l/gpt-j-tiny-random",
+    "grantprice/Cerebras-GPT-590M-finetuned-DND",
+    "deepnight-research/zsc-text",
+    "WangZeJun/bloom-820m-chat",
+    "cerebras/Cerebras-GPT-256M",
+    "ai-forever/rugpt3large_based_on_gpt2",
+    "alibidaran/medical_transcription_generator",
+    "Deci/DeciCoder-1b",
+    "microsoft/DialoGPT-medium",
+    "ogimgio/gpt-neo-125m-neurallinguisticpioneers",
+    "open-llm-leaderboard/bloom-560m-4bit-alpaca-auto-eval-adapter-applied",
+    "BreadAi/gpt-YA-1-1_160M",
+    "microsoft/DialoGPT-large",
+    "facebook/opt-125m",
+    "huggingtweets/jerma985",
+    "Locutusque/gpt2-conversational-or-qa",
+    "concedo/Pythia-70M-ChatSalad",
+    "roneneldan/TinyStories-1M",
+    "BreadAi/DiscordPy",
+    "bigcode/gpt_bigcode-santacoder",
+    "Tincando/fiction_story_generator",
+    "klosax/pythia-70m-deduped-step44k-92bt",
+    "Quake24/easyTermsSummerizer",
+    "BreadAi/gpt-YA-1-1_70M",
+    "EleutherAI/pythia-160m",
+    "euclaise/gpt-neox-122m-minipile-digits",
+    "MBZUAI/lamini-cerebras-590m",
+    "nicholasKluge/Aira-124M",
+    "MayaPH/FinOPT-Washington",
+    "cyberagent/open-calm-large",
+    "BreadAi/StoryPy",
+    "EleutherAI/pythia-70m",
+    "BreadAi/gpt-Youtube",
+    "roneneldan/TinyStories-33M",
+    "EleutherAI/pythia-70m-deduped",
+    "lgaalves/gpt2_guanaco-dolly-platypus",
+    "Corianas/Quokka_590m",
+    "lgaalves/gpt2_platypus-dolly-guanaco",
+    "cyberagent/open-calm-7b",
+    "RWKV/rwkv-4-169m-pile",
+    "gpt2",
+    "roneneldan/TinyStories-28M",
+    "lgaalves/gpt2_open-platypus",
+    "gpt2",
+    "SaylorTwift/gpt2_test",
+    "roneneldan/TinyStories-3M",
+    "nthngdy/pythia-owt2-70m-50k",
+    "Corianas/256_5epoch",
+    "roneneldan/TinyStories-8M",
+    "lgaalves/gpt2-dolly",
+    "nthngdy/pythia-owt2-70m-100k",
+    "aisquared/dlite-v2-124m",
+    "mncai/SGPT-1.3B-insurance-epoch10",
+    "huggingtweets/gladosystem",
+    "abhiramtirumala/DialoGPT-sarcastic-medium",
+    "MBZUAI/lamini-cerebras-256m",
+    "cerebras/Cerebras-GPT-111M",
+    "uberkie/metharme-1.3b-finetuned",
+    "MBZUAI/lamini-cerebras-111m",
+    "psyche/kogpt",
+    "Corianas/Quokka_256m",
+    "vicgalle/gpt2-alpaca-gpt4",
+    "aisquared/dlite-v1-124m",
+    "Mikivis/xuanxuan",
+    "MBZUAI/LaMini-GPT-124M",
+    "vicgalle/gpt2-alpaca",
+    "huashiyiqike/testmodel",
+    "Corianas/111m",
+    "baseline",
+]

src/tools/plots.py

@@ -0,0 +1,154 @@
+import pandas as pd
+import numpy as np
+import plotly.express as px
+from plotly.graph_objs import Figure
+
+from src.leaderboard.filter_models import FLAGGED_MODELS
+from src.display.utils import human_baseline_row as HUMAN_BASELINE, AutoEvalColumn, Tasks, Task, BENCHMARK_COLS
+from src.leaderboard.read_evals import EvalResult
+
+
+
+def create_scores_df(raw_data: list[EvalResult]) -> 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 = pd.DataFrame(raw_data)
+    #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["full_model"]
+            if current_model in FLAGGED_MODELS:
+                continue
+
+            current_date = row["date"]
+            if task.benchmark == "Average":
+                current_score = np.mean(list(row["results"].values()))
+            else:
+                current_score = row["results"][task.benchmark]
+
+            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")

update_dynamic.py

@@ -0,0 +1,4 @@
+from src.scripts.update_all_request_files import update_dynamic_files
+
+if __name__ == "__main__":
+    update_dynamic_files()