corrected leaderboard code

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 .

README.md

@@ -1,13 +1,36 @@
 ---
-title: Test Leaderboard
-emoji: 🐢
-colorFrom: pink
-colorTo: red
+title: Demo Leaderboard
+emoji: 🥇
+colorFrom: green
+colorTo: indigo
 sdk: gradio
-sdk_version: 4.15.0
+sdk_version: 4.4.0
 app_file: app.py
-pinned: false
+pinned: true
 license: apache-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+Most of the variables to change for a default leaderboard are in env (replace the path for your leaderboard) and src/display/about.
+
+Results files should have the following format:
+```
+{
+    "config": {
+        "model_dtype": "torch.float16", # or torch.bfloat16 or 8bit or 4bit
+        "model_name": "path of the model on the hub: org/model",
+        "model_sha": "revision on the hub",
+    },
+    "results": {
+        "task_name": {
+            "metric_name": score,
+        },
+        "task_name2": {
+            "metric_name": score,
+        }
+    }
+}
+```
+
+Request files are created automatically by this tool.

app.py

@@ -1,9 +1,47 @@
 import gradio as gr
 import pandas as pd
-
 from apscheduler.schedulers.background import BackgroundScheduler
+from huggingface_hub import snapshot_download
+
+# import os
+
+# # Define the folders to delete
+# folders_to_delete = ['eval-results', 'eval-queue']
+
+# import shutil
+
+# # Delete the folders and their contents
+# deleted_folders = []
+# nonexistent_folders = []
+
+# for folder in folders_to_delete:
+#     if os.path.exists(folder) and os.path.isdir(folder):
+#         shutil.rmtree(folder)  # This removes the directory and its contents
+#         deleted_folders.append(folder)
+#     else:
+#         nonexistent_folders.append(folder)
+
+
+
+# import subprocess
+# import signal
+
+# # Find and kill processes running on port 7878
+# try:
+#     # Find process using port 7878
+#     output = subprocess.check_output(["lsof", "-ti", "tcp:7878"]).decode().strip()
+#     if output:
+#         # Split the output in case there are multiple PIDs
+#         pids = output.split('\n')
+#         for pid in pids:
+#             # Kill each process
+#             os.kill(int(pid), signal.SIGKILL)
+#         result = "Processes running on port 7878 have been killed."
+#     else:
+#         result = "No processes are running on port 7878."
+# except Exception as e:
+#     result = f"An error occurred: {str(e)}"
 
-from src.display.css_html_js import custom_css
 
 from src.display.about import (
     CITATION_BUTTON_LABEL,
@@ -11,11 +49,9 @@ from src.display.about import (
     EVALUATION_QUEUE_TEXT,
     INTRODUCTION_TEXT,
     LLM_BENCHMARKS_TEXT,
-    LLM_BENCHMARKS_DETAILS,
-    FAQ_TEXT,
     TITLE,
 )
-
+from src.display.css_html_js import custom_css
 from src.display.utils import (
     BENCHMARK_COLS,
     COLS,
@@ -29,41 +65,56 @@ from src.display.utils import (
     WeightType,
     Precision
 )
-
+from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, TOKEN, QUEUE_REPO, REPO_ID, RESULTS_REPO
 from src.populate import get_evaluation_queue_df, get_leaderboard_df
-
-from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, H4_TOKEN, IS_PUBLIC, QUEUE_REPO, REPO_ID, RESULTS_REPO
 from src.submission.submit import add_new_eval
 
-from src.display.utils import Tasks
-
-from huggingface_hub import snapshot_download
-
-## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## -------##
 
 def restart_space():
-    API.restart_space(repo_id=REPO_ID, token=H4_TOKEN)
+    API.restart_space(repo_id=REPO_ID, token=TOKEN)
+
+try:
+    print(EVAL_REQUESTS_PATH)
+    snapshot_download(
+        repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30
+    )
+except Exception:
+    restart_space()
+try:
+    print(EVAL_RESULTS_PATH)
+    snapshot_download(
+        repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30
+    )
+except Exception:
+    restart_space()
+
+
+raw_data, original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS)
+leaderboard_df = original_df.copy()
+
+(
+    finished_eval_queue_df,
+    running_eval_queue_df,
+    pending_eval_queue_df,
+) = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
 
-def ui_snapshot_download(repo_id, local_dir, repo_type, tqdm_class, etag_timeout):
-    try:
-        print(f"local_dir for snapshot download = {local_dir}")
-        snapshot_download(repo_id=repo_id, local_dir=local_dir, repo_type=repo_type, tqdm_class=tqdm_class, etag_timeout=etag_timeout)
-    except Exception:
-        print(f"ui_snapshot_download failed. restarting space...")
-        restart_space()
 
 # Searching and filtering
-def update_table(hidden_df: pd.DataFrame, columns: list, type_query: list, precision_query: list, size_query: list, query: str):
-    print(f"hidden_df = {hidden_df}")
-    show_deleted = True
+def update_table(
+    hidden_df: pd.DataFrame,
+    columns: list,
+    type_query: list,
+    precision_query: str,
+    size_query: list,
+    show_deleted: bool,
+    query: str,
+):
     filtered_df = filter_models(hidden_df, type_query, size_query, precision_query, show_deleted)
-
-    print(f"filtered_df = {filtered_df}")
     filtered_df = filter_queries(query, filtered_df)
     df = select_columns(filtered_df, columns)
-    print(f"df = {df}")
     return df
 
+
 def search_table(df: pd.DataFrame, query: str) -> pd.DataFrame:
     return df[(df[AutoEvalColumn.dummy.name].str.contains(query, case=False))]
 
@@ -79,7 +130,8 @@ def select_columns(df: pd.DataFrame, columns: list) -> pd.DataFrame:
     ]
     return filtered_df
 
-def filter_queries(query: str, filtered_df: pd.DataFrame):
+
+def filter_queries(query: str, filtered_df: pd.DataFrame) -> pd.DataFrame:
     final_df = []
     if query != "":
         queries = [q.strip() for q in query.split(";")]
@@ -98,22 +150,18 @@ def filter_queries(query: str, filtered_df: pd.DataFrame):
     return filtered_df
 
 
-def filter_models(df: pd.DataFrame, type_query: list, size_query: list, precision_query: list, show_deleted: bool) -> pd.DataFrame:
-
-
-    print("aa this is an example", df)
-    print(f"filter_models()'s df: {df}\n")
+def filter_models(
+    df: pd.DataFrame, type_query: list, size_query: list, precision_query: list, show_deleted: bool
+) -> pd.DataFrame:
     # Show all models
-    if show_deleted:
-        filtered_df = df
-    else:  # Show only still on the hub models
-        filtered_df = df[df[AutoEvalColumn.still_on_hub.name] is True]
+    filtered_df = df
+    # if show_deleted:
+    #     filtered_df = df
+    # else:  # Show only still on the hub models
+    #     filtered_df = df[df[AutoEvalColumn.still_on_hub.name] == True]
 
     type_emoji = [t[0] for t in type_query]
-    print("aa this is an example", df, AutoEvalColumn.model_type_symbol.name, "thhhthht")
-    print("type", type_emoji)
     filtered_df = filtered_df.loc[df[AutoEvalColumn.model_type_symbol.name].isin(type_emoji)]
-    print("bb", filtered_df)
     filtered_df = filtered_df.loc[df[AutoEvalColumn.precision.name].isin(precision_query + ["None"])]
 
     numeric_interval = pd.IntervalIndex(sorted([NUMERIC_INTERVALS[s] for s in size_query]))
@@ -124,34 +172,21 @@ def filter_models(df: pd.DataFrame, type_query: list, size_query: list, precisio
     return filtered_df
 
 
-## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- ## ------- 
-
-ui_snapshot_download(repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30)
-ui_snapshot_download(repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30)
-
-print(f"COLS = {COLS}")
-
-
-raw_data, original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS) # k the problem is that the results are only saved in _bk dirs. 
-leaderboard_df = original_df.copy()
-print(f"leaderboard_df = {leaderboard_df}")
-
-
-################################################################################################################################
 demo = gr.Blocks(css=custom_css)
 with demo:
     gr.HTML(TITLE)
     gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
 
     with gr.Tabs(elem_classes="tab-buttons") as tabs:
-
-        # toggle break 1: this tab just RENDERS existing result files on remote repo. 
-        with gr.TabItem("Benchmarks", elem_id="llm-benchmark-tab-table", id=0):
-        
+        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=" 🔍 Model search (separate multiple queries with `;`)", show_label=False, elem_id="search-bar",)
+                        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=[
@@ -168,8 +203,12 @@ with demo:
                             elem_id="column-select",
                             interactive=True,
                         )
-
+                    with gr.Row():
+                        deleted_models_visibility = gr.Checkbox(
+                            value=True, label="Show gated/private/deleted models", interactive=True
+                        )
                 with gr.Column(min_width=320):
+                    #with gr.Box(elem_id="box-filter"):
                     filter_columns_type = gr.CheckboxGroup(
                         label="Model types",
                         choices=[t.to_str() for t in ModelType],
@@ -192,41 +231,41 @@ with demo:
                         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]
-            #     ] if leaderboard_df.empty is False else leaderboard_df,
-            #     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%", "20%"]
-            # )
             leaderboard_table = gr.components.Dataframe(
-                # value=leaderboard_df,
                 value=leaderboard_df[
                     [c.name for c in fields(AutoEvalColumn) if c.never_hidden]
                     + shown_columns.value
                     + [AutoEvalColumn.dummy.name]
-                ] if leaderboard_df.empty is False else leaderboard_df,
+                ],
                 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%", "20%"]
+                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] if original_df.empty is False else original_df,
+                value=original_df[COLS],
                 headers=COLS,
                 datatype=TYPES,
-                visible=False
+                visible=False,
             )
-            for selector in [shown_columns, filter_columns_type, filter_columns_precision, filter_columns_size]:
+            search_bar.submit(
+                update_table,
+                [
+                    hidden_leaderboard_table_for_search,
+                    shown_columns,
+                    filter_columns_type,
+                    filter_columns_precision,
+                    filter_columns_size,
+                    deleted_models_visibility,
+                    search_bar,
+                ],
+                leaderboard_table,
+            )
+            for selector in [shown_columns, filter_columns_type, filter_columns_precision, filter_columns_size, deleted_models_visibility]:
                 selector.change(
                     update_table,
                     [
@@ -235,62 +274,63 @@ with demo:
                         filter_columns_type,
                         filter_columns_precision,
                         filter_columns_size,
+                        deleted_models_visibility,
                         search_bar,
                     ],
                     leaderboard_table,
                     queue=True,
                 )
 
-        # toggle break 2: Submission -> runs add_new_eval() (actual evaluation is done on backend when backend-cli.py is run.)
+        with gr.TabItem("📝 About", elem_id="llm-benchmark-tab-table", id=2):
+            gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
+
         with gr.TabItem("🚀 Submit here! ", elem_id="llm-benchmark-tab-table", id=3):
-            # with gr.Column():
-            #     with gr.Row():
-            #         gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")
-
-                # with gr.Column():
-                    # with gr.Accordion(
-                    #     f"✅ Finished Evaluations ({len(finished_eval_queue_df)})",
-                    #     open=False,
-                    # ):
-                    #     with gr.Row():
-                    #         finished_eval_table = gr.components.Dataframe(
-                    #             value=finished_eval_queue_df,
-                    #             headers=EVAL_COLS,
-                    #             datatype=EVAL_TYPES,
-                    #             row_count=5
-                    #         )
-                    # with gr.Accordion(
-                    #     f"🔄 Running Evaluation Queue ({len(running_eval_queue_df)})",
-                    #     open=False,
-                    # ):
-                    #     with gr.Row():
-                    #         running_eval_table = gr.components.Dataframe(
-                    #             value=running_eval_queue_df,
-                    #             headers=EVAL_COLS,
-                    #             datatype=EVAL_TYPES,
-                    #             row_count=5
-                    #         )
-
-                    # with gr.Accordion(
-                    #     f"⏳ Pending Evaluation Queue ({len(pending_eval_queue_df)})",
-                    #     open=False,
-                    # ):
-                    #     with gr.Row():
-                    #         pending_eval_table = gr.components.Dataframe(
-                    #             value=pending_eval_queue_df,
-                    #             headers=EVAL_COLS,
-                    #             datatype=EVAL_TYPES,
-                    #             row_count=5
-                    #         )
+            with gr.Column():
+                with gr.Row():
+                    gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")
+
+                with gr.Column():
+                    with gr.Accordion(
+                        f"✅ Finished Evaluations ({len(finished_eval_queue_df)})",
+                        open=False,
+                    ):
+                        with gr.Row():
+                            finished_eval_table = gr.components.Dataframe(
+                                value=finished_eval_queue_df,
+                                headers=EVAL_COLS,
+                                datatype=EVAL_TYPES,
+                                row_count=5,
+                            )
+                    with gr.Accordion(
+                        f"🔄 Running Evaluation Queue ({len(running_eval_queue_df)})",
+                        open=False,
+                    ):
+                        with gr.Row():
+                            running_eval_table = gr.components.Dataframe(
+                                value=running_eval_queue_df,
+                                headers=EVAL_COLS,
+                                datatype=EVAL_TYPES,
+                                row_count=5,
+                            )
+
+                    with gr.Accordion(
+                        f"⏳ Pending Evaluation Queue ({len(pending_eval_queue_df)})",
+                        open=False,
+                    ):
+                        with gr.Row():
+                            pending_eval_table = gr.components.Dataframe(
+                                value=pending_eval_queue_df,
+                                headers=EVAL_COLS,
+                                datatype=EVAL_TYPES,
+                                row_count=5,
+                            )
             with gr.Row():
                 gr.Markdown("# ✉️✨ Submit your model here!", elem_classes="markdown-text")
 
             with gr.Row():
                 with gr.Column():
                     model_name_textbox = gr.Textbox(label="Model name")
-                    # You can use the revision parameter to point to the specific commit hash when downloading.
                     revision_name_textbox = gr.Textbox(label="Revision commit", placeholder="main")
-                    private = gr.Checkbox(False, label="Private", visible=not IS_PUBLIC)
                     model_type = gr.Dropdown(
                         choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
                         label="Model type",
@@ -304,7 +344,7 @@ with demo:
                         choices=[i.value.name for i in Precision if i != Precision.Unknown],
                         label="Precision",
                         multiselect=False,
-                        value="float32",
+                        value="float16",
                         interactive=True,
                     )
                     weight_type = gr.Dropdown(
@@ -314,51 +354,40 @@ with demo:
                         value="Original",
                         interactive=True,
                     )
-
-
-                    requested_tasks = gr.CheckboxGroup(
-                        choices=[ (i.value.col_name, i.value) for i in Tasks], 
-
-                        label="Select tasks",
-                        elem_id="task-select",
-                        interactive=True,
-                    )
-
-
                     base_model_name_textbox = gr.Textbox(label="Base model (for delta or adapter weights)")
 
             submit_button = gr.Button("Submit Eval")
             submission_result = gr.Markdown()
-
-            # we need to add task specification argument here as well. 
             submit_button.click(
                 add_new_eval,
                 [
                     model_name_textbox,
-
-                    requested_tasks, # is this a list of str or class Task? i think it's Task. 
-
                     base_model_name_textbox,
                     revision_name_textbox,
                     precision,
-                    private,
                     weight_type,
                     model_type,
                 ],
-                submission_result)
-
-
-
-# demo.launch()
+                submission_result,
+            )
 
-####
+    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=6 * 60 * 60)
-
+scheduler.add_job(restart_space, "interval", seconds=1800)
 scheduler.start()
-# demo.queue(default_concurrency_limit=40).launch()
+demo.queue(default_concurrency_limit=40).launch()
+
 
-# demo.launch(show_api=False, enable_queue=False)
-demo.launch() # TypeError: Blocks.launch() got an unexpected keyword argument 'enable_queue'
+# scheduler = BackgroundScheduler()
+# scheduler.add_job(restart_space, "interval", seconds=6 * 60 * 60)
+# scheduler.start()
+# demo.queue().launch()

app_empty.py

@@ -1,7 +0,0 @@
-import gradio as gr
-
-def greet(name):
-    return "Hello " + name + "!!"
-
-# iface = gr.Interface(fn=greet, inputs="text", outputs="text")
-# iface.launch()

backend-cli.py

@@ -1,187 +0,0 @@
-#!/usr/bin/env python
-
-import os
-import json
-
-import random
-from datetime import datetime
-
-from src.backend.run_eval_suite import run_evaluation
-from src.backend.manage_requests import check_completed_evals, get_eval_requests, set_eval_request
-from src.backend.sort_queue import sort_models_by_priority
-
-
-from src.backend.envs import EVAL_REQUESTS_PATH_BACKEND, EVAL_RESULTS_PATH_BACKEND, DEVICE, LIMIT, Tasks, Task, num_fewshots
-
-from src.backend.manage_requests import EvalRequest
-from src.leaderboard.read_evals import EvalResult
-
-from src.envs import QUEUE_REPO, RESULTS_REPO, API
-from src.utils import my_snapshot_download
-
-import time
-
-import logging
-import pprint
-import argparse
-
-
-# def get_subdirectories(path):
-#     subdirectories = []
-#     # Get all entries in the directory
-#     entries = os.listdir(path)
-#     for entry in entries:
-#         # Check if the entry is a directory
-#         if os.path.isdir(os.path.join(path, entry)):
-#             subdirectories.append(entry)
-#     return subdirectories
-
-# parser = argparse.ArgumentParser(description="Get subdirectory names")
-# parser.add_argument("include_path", help="Path to the directory", nargs='?', default=None)
-# args = parser.parse_args()
-    
-# # = get_subdirectories(args.include_path)
-
-
-
-
-def my_set_eval_request(api, eval_request, set_to_status, hf_repo, local_dir):
-    for i in range(10):
-        try:
-            set_eval_request(api=api, eval_request=eval_request, set_to_status=set_to_status, hf_repo=hf_repo, local_dir=local_dir)
-            return
-        except Exception:
-            time.sleep(60)
-    return
-
-
-logging.getLogger("openai").setLevel(logging.WARNING)
-
-logging.basicConfig(level=logging.ERROR)
-pp = pprint.PrettyPrinter(width=80)
-
-PENDING_STATUS = "PENDING"
-RUNNING_STATUS = "RUNNING"
-FINISHED_STATUS = "FINISHED"
-FAILED_STATUS = "FAILED"
-
-TASKS_HARNESS = [task.value for task in Tasks]
-
-# starts by downloading results and requests. makes sense since we want to be able to use different backend servers!
-my_snapshot_download(repo_id=RESULTS_REPO, revision="main", local_dir=EVAL_RESULTS_PATH_BACKEND, repo_type="dataset", max_workers=60)
-my_snapshot_download(repo_id=QUEUE_REPO, revision="main", local_dir=EVAL_REQUESTS_PATH_BACKEND, repo_type="dataset", max_workers=60)
-
-
-def sanity_checks():
-    print(f'Device: {DEVICE}')
-
-    # pull the eval dataset from the hub and parse any eval requests
-    # check completed evals and set them to finished
-    my_snapshot_download(repo_id=QUEUE_REPO, revision="main", local_dir=EVAL_REQUESTS_PATH_BACKEND, repo_type="dataset", max_workers=60)
-    check_completed_evals(api=API, checked_status=RUNNING_STATUS, completed_status=FINISHED_STATUS,
-                          failed_status=FAILED_STATUS, hf_repo=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH_BACKEND,
-                          hf_repo_results=RESULTS_REPO, local_dir_results=EVAL_RESULTS_PATH_BACKEND)
-    return
-
-
-def request_to_result_name(request: EvalRequest) -> str:
-    
-    org_and_model = request.model.split("/", 1)
-    if len(org_and_model) == 1:
-        model = org_and_model[0]
-        res = f"{model}_{request.precision}"
-    else:
-        org = org_and_model[0]
-        model = org_and_model[1]
-        res = f"{org}_{model}_{request.precision}"
-    return res
-
-# doesn't make distinctions for tasks since the original code runs eval on ALL tasks. 
-def process_evaluation(task_name: str, eval_request: EvalRequest) -> dict:
-    # batch_size = 1
-    batch_size = "auto"
-
-    # might not have to get the benchmark. 
-    print(f"task_name parameter in process_evaluation() = {task_name}") #, task_names=[task.benchmark] = {[task.benchmark]}")
-
-    num_fewshot = num_fewshots[task_name]
-
-    results = run_evaluation(eval_request=eval_request, task_names=task_name, num_fewshot=num_fewshot,
-                             batch_size=batch_size, device=DEVICE, use_cache=None, limit=LIMIT)
-
-    print('RESULTS', results)
-
-    dumped = json.dumps(results, indent=2, default=lambda o: '<not serializable>')
-    print(dumped)
-
-    output_path = os.path.join(EVAL_RESULTS_PATH_BACKEND, *eval_request.model.split("/"), f"results_{task_name}_{datetime.now()}.json")
-    os.makedirs(os.path.dirname(output_path), exist_ok=True)
-    with open(output_path, "w") as f:
-        f.write(dumped)
-
-    my_snapshot_download(repo_id=RESULTS_REPO, revision="main", local_dir=EVAL_RESULTS_PATH_BACKEND, repo_type="dataset", max_workers=60)
-    API.upload_file(path_or_fileobj=output_path, path_in_repo=f"{eval_request.model}/results_{task_name}_{datetime.now()}.json",
-                    repo_id=RESULTS_REPO, repo_type="dataset")
-    return results
-
-
-# the rendering is done with files in local repo. 
-def process_pending_requests() -> bool:
-    sanity_checks()
-
-    current_pending_status = [PENDING_STATUS]
-
-    # Get all eval request that are PENDING, if you want to run other evals, change this parameter
-    # GETTING REQUESTS FROM THE HUB NOT LOCAL DIR. 
-    eval_requests = get_eval_requests(job_status=current_pending_status, hf_repo=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH_BACKEND)
-    # Sort the evals by priority (first submitted first run)
-    eval_requests = sort_models_by_priority(api=API, models=eval_requests)
-
-    random.shuffle(eval_requests)
-
-    # this says zero 
-    print(f"Found {len(eval_requests)} {','.join(current_pending_status)} eval requests")
-
-    if len(eval_requests) == 0:
-        return False
-
-    eval_request = eval_requests[0] 
-    pp.pprint(eval_request)
-
-    my_snapshot_download(repo_id=QUEUE_REPO, revision="main", local_dir=EVAL_REQUESTS_PATH_BACKEND, repo_type="dataset", max_workers=60)
-    my_set_eval_request(api=API, eval_request=eval_request, set_to_status=RUNNING_STATUS, hf_repo=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH_BACKEND)
-
-    # task_lst = TASKS_HARNESS.copy()
-    task_lst = eval_request.get_user_requested_task_names()
-    random.shuffle(task_lst)
-    print(f"task_lst in process_pending_requests(): {task_lst}")
-
-    for task_name in task_lst: 
-        
-        results = process_evaluation(task_name, eval_request)
-
-    my_snapshot_download(repo_id=QUEUE_REPO, revision="main", local_dir=EVAL_REQUESTS_PATH_BACKEND, repo_type="dataset", max_workers=60)
-    my_set_eval_request(api=API, eval_request=eval_request, set_to_status=FINISHED_STATUS, hf_repo=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH_BACKEND)
-
-    return True
-
-
-if __name__ == "__main__":
-    # wait = True
-
-    # import socket
-    # if socket.gethostname() in {'hamburg'} or os.path.isdir("/home/pminervi"):
-    #     wait = False
-
-    # if wait:
-    #     time.sleep(60 * random.randint(2, 5))
-    #     pass
-
-    # res = False
-    res = process_pending_requests()
-
-    # if res is False:
-    #     res = process_finished_requests(100)
-
-    # if res is False:
-    #     res = process_finished_requests(0)

manage_repos.ipynb

@@ -1,226 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "https://huggingface.co/datasets/chaeeunlee/test_requests\n",
-    "\n",
-    "https://huggingface.co/datasets/chaeeunlee/test_results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CACHE_PATH = /Users/chaeeunlee/Documents/VSC_workspaces/huggingface_home_cache\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/chaeeunlee/anaconda3/envs/lb/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'\\n( path_in_repo: str\\nrepo_id: str\\ntoken: typing.Optional[str] = None\\nrepo_type: typing.Optional[str] = Nonerevision: typing.Optional[str] = Nonecommit_message: typing.Optional[str] = Nonecommit_description: typing.Optional[str] = Nonecreate_pr: typing.Optional[bool] = Noneparent_commit: typing.Optional[str] = None )\\n'"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from src.envs import H4_TOKEN, API, QUEUE_REPO, RESULTS_REPO, REPO_ID\n",
-    "\n",
-    "from huggingface_hub import HfApi\n",
-    "\n",
-    "'''\n",
-    "( path_in_repo: str\n",
-    "repo_id: str\n",
-    "token: typing.Optional[str] = None\n",
-    "repo_type: typing.Optional[str] = Nonerevision: typing.Optional[str] = Nonecommit_message: typing.Optional[str] = Nonecommit_description: typing.Optional[str] = Nonecreate_pr: typing.Optional[bool] = Noneparent_commit: typing.Optional[str] = None )\n",
-    "'''\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "res = API.delete_folder(path_in_repo='hub/', repo_id=REPO_ID, repo_type='space')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "EntryNotFoundError",
-     "evalue": "404 Client Error. (Request ID: Root=1-65c43c73-7771219478c3ca215705378d;6308513c-7fb2-4810-afa4-9ea734f21820)\n\nEntry Not Found for url: https://huggingface.co/api/datasets/chaeeunlee/test_results/commit/main.",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mHTTPError\u001b[0m                                 Traceback (most recent call last)",
-      "File \u001b[0;32m~/anaconda3/envs/lb/lib/python3.10/site-packages/huggingface_hub/utils/_errors.py:286\u001b[0m, in \u001b[0;36mhf_raise_for_status\u001b[0;34m(response, endpoint_name)\u001b[0m\n\u001b[1;32m    285\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 286\u001b[0m     \u001b[43mresponse\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    287\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m HTTPError \u001b[38;5;28;01mas\u001b[39;00m e:\n",
-      "File \u001b[0;32m~/anaconda3/envs/lb/lib/python3.10/site-packages/requests/models.py:1021\u001b[0m, in \u001b[0;36mResponse.raise_for_status\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1020\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m http_error_msg:\n\u001b[0;32m-> 1021\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m HTTPError(http_error_msg, response\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m)\n",
-      "\u001b[0;31mHTTPError\u001b[0m: 404 Client Error: Not Found for url: https://huggingface.co/api/datasets/chaeeunlee/test_results/commit/main",
-      "\nThe above exception was the direct cause of the following exception:\n",
-      "\u001b[0;31mEntryNotFoundError\u001b[0m                        Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[14], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mAPI\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdelete_folder\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath_in_repo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mEleutherAI/\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrepo_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mRESULTS_REPO\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrepo_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdataset\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/anaconda3/envs/lb/lib/python3.10/site-packages/huggingface_hub/utils/_validators.py:118\u001b[0m, in \u001b[0;36mvalidate_hf_hub_args.<locals>._inner_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    115\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m check_use_auth_token:\n\u001b[1;32m    116\u001b[0m     kwargs \u001b[38;5;241m=\u001b[39m smoothly_deprecate_use_auth_token(fn_name\u001b[38;5;241m=\u001b[39mfn\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m, has_token\u001b[38;5;241m=\u001b[39mhas_token, kwargs\u001b[38;5;241m=\u001b[39mkwargs)\n\u001b[0;32m--> 118\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/anaconda3/envs/lb/lib/python3.10/site-packages/huggingface_hub/hf_api.py:4767\u001b[0m, in \u001b[0;36mHfApi.delete_folder\u001b[0;34m(self, path_in_repo, repo_id, token, repo_type, revision, commit_message, commit_description, create_pr, parent_commit)\u001b[0m\n\u001b[1;32m   4716\u001b[0m \u001b[38;5;129m@validate_hf_hub_args\u001b[39m\n\u001b[1;32m   4717\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdelete_folder\u001b[39m(\n\u001b[1;32m   4718\u001b[0m     \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   4728\u001b[0m     parent_commit: Optional[\u001b[38;5;28mstr\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m   4729\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m CommitInfo:\n\u001b[1;32m   4730\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m   4731\u001b[0m \u001b[38;5;124;03m    Deletes a folder in the given repo.\u001b[39;00m\n\u001b[1;32m   4732\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   4765\u001b[0m \u001b[38;5;124;03m            especially useful if the repo is updated / committed to concurrently.\u001b[39;00m\n\u001b[1;32m   4766\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m-> 4767\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_commit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   4768\u001b[0m \u001b[43m        \u001b[49m\u001b[43mrepo_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrepo_id\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   4769\u001b[0m \u001b[43m        \u001b[49m\u001b[43mrepo_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrepo_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   4770\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtoken\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtoken\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   4771\u001b[0m \u001b[43m        \u001b[49m\u001b[43moperations\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mCommitOperationDelete\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath_in_repo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpath_in_repo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_folder\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   4772\u001b[0m \u001b[43m        \u001b[49m\u001b[43mrevision\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrevision\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   4773\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcommit_message\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m   4774\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcommit_message\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mcommit_message\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mDelete folder \u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mpath_in_repo\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m with huggingface_hub\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[1;32m   4775\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   4776\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcommit_description\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcommit_description\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   4777\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcreate_pr\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcreate_pr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   4778\u001b[0m \u001b[43m        \u001b[49m\u001b[43mparent_commit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparent_commit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   4779\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/anaconda3/envs/lb/lib/python3.10/site-packages/huggingface_hub/utils/_validators.py:118\u001b[0m, in \u001b[0;36mvalidate_hf_hub_args.<locals>._inner_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    115\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m check_use_auth_token:\n\u001b[1;32m    116\u001b[0m     kwargs \u001b[38;5;241m=\u001b[39m smoothly_deprecate_use_auth_token(fn_name\u001b[38;5;241m=\u001b[39mfn\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m, has_token\u001b[38;5;241m=\u001b[39mhas_token, kwargs\u001b[38;5;241m=\u001b[39mkwargs)\n\u001b[0;32m--> 118\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/anaconda3/envs/lb/lib/python3.10/site-packages/huggingface_hub/hf_api.py:1208\u001b[0m, in \u001b[0;36mfuture_compatible.<locals>._inner\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1205\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrun_as_future(fn, \u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m   1207\u001b[0m \u001b[38;5;66;03m# Otherwise, call the function normally\u001b[39;00m\n\u001b[0;32m-> 1208\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/anaconda3/envs/lb/lib/python3.10/site-packages/huggingface_hub/hf_api.py:3600\u001b[0m, in \u001b[0;36mHfApi.create_commit\u001b[0;34m(self, repo_id, operations, commit_message, commit_description, token, repo_type, revision, create_pr, num_threads, parent_commit, run_as_future)\u001b[0m\n\u001b[1;32m   3598\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   3599\u001b[0m     commit_resp \u001b[38;5;241m=\u001b[39m get_session()\u001b[38;5;241m.\u001b[39mpost(url\u001b[38;5;241m=\u001b[39mcommit_url, headers\u001b[38;5;241m=\u001b[39mheaders, data\u001b[38;5;241m=\u001b[39mdata, params\u001b[38;5;241m=\u001b[39mparams)\n\u001b[0;32m-> 3600\u001b[0m     \u001b[43mhf_raise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcommit_resp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mendpoint_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcommit\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m   3601\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m RepositoryNotFoundError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m   3602\u001b[0m     e\u001b[38;5;241m.\u001b[39mappend_to_message(_CREATE_COMMIT_NO_REPO_ERROR_MESSAGE)\n",
-      "File \u001b[0;32m~/anaconda3/envs/lb/lib/python3.10/site-packages/huggingface_hub/utils/_errors.py:296\u001b[0m, in \u001b[0;36mhf_raise_for_status\u001b[0;34m(response, endpoint_name)\u001b[0m\n\u001b[1;32m    294\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m error_code \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEntryNotFound\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    295\u001b[0m     message \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresponse\u001b[38;5;241m.\u001b[39mstatus_code\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m Client Error.\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEntry Not Found for url: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresponse\u001b[38;5;241m.\u001b[39murl\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 296\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m EntryNotFoundError(message, response) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m    298\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m error_code \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mGatedRepo\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    299\u001b[0m     message \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m    300\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresponse\u001b[38;5;241m.\u001b[39mstatus_code\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m Client Error.\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCannot access gated repo for url \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresponse\u001b[38;5;241m.\u001b[39murl\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    301\u001b[0m     )\n",
-      "\u001b[0;31mEntryNotFoundError\u001b[0m: 404 Client Error. (Request ID: Root=1-65c43c73-7771219478c3ca215705378d;6308513c-7fb2-4810-afa4-9ea734f21820)\n\nEntry Not Found for url: https://huggingface.co/api/datasets/chaeeunlee/test_results/commit/main."
-     ]
-    }
-   ],
-   "source": [
-    "res = API.delete_folder(path_in_repo='EleutherAI/', repo_id=RESULTS_REPO, repo_type='dataset')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "res = API.delete_folder(path_in_repo='EleutherAI/pythia-70m_biolama_umls_eval_request_False_float32_Original.json', repo_id=QUEUE_REPO, repo_type='dataset')\n",
-    "# res = API.delete_folder(path_in_repo='mistralai/', repo_id=QUEUE_REPO, repo_type='dataset')\n",
-    "\n",
-    "# res = API.delete_file(path_in_repo=\"EleutherAI/pythia-70m_pubmedqa_eval_request_False_float32_Original.json\", repo_id=QUEUE_REPO, repo_type='dataset')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# import os\n",
-    "\n",
-    "# for root, _, files in os.walk(results_path):\n",
-    "#     # We should only have json files in model results\n",
-    "#     if len(files) == 0 or any([not f.endswith(\".json\") for f in files]):\n",
-    "#         continue\n",
-    "\n",
-    "#     # Sort the files by date\n",
-    "#     try:\n",
-    "#         files.sort(key=lambda x: x.removesuffix(\".json\").removeprefix(\"results_\")[:-7])\n",
-    "#     except dateutil.parser._parser.ParserError:\n",
-    "#         files = [files[-1]]\n",
-    "\n",
-    "\n",
-    "#     print(f\"files = {files}\")\n",
-    "\n",
-    "#     for file in files:\n",
-    "#         model_result_filepaths.append(os.path.join(root, file))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "DatasetInfo(id='chaeeunlee/test_requests', author='chaeeunlee', sha='c7f4d0c0b1207cc773dcd0b1df49cd6a883e02be', created_at=datetime.datetime(2024, 1, 31, 11, 19, 22, tzinfo=datetime.timezone.utc), last_modified=datetime.datetime(2024, 1, 31, 19, 55, 30, tzinfo=datetime.timezone.utc), private=False, gated=False, disabled=False, downloads=0, likes=0, paperswithcode_id=None, tags=['license:mit', 'region:us'], card_data={'annotations_creators': None, 'language_creators': None, 'language': None, 'license': 'mit', 'multilinguality': None, 'size_categories': None, 'source_datasets': None, 'task_categories': None, 'task_ids': None, 'paperswithcode_id': None, 'pretty_name': None, 'config_names': None, 'train_eval_index': None}, siblings=[RepoSibling(rfilename='.gitattributes', size=None, blob_id=None, lfs=None), RepoSibling(rfilename='EleutherAI/pythia-160m_eval_request_False_float32_Original.json', size=None, blob_id=None, lfs=None), RepoSibling(rfilename='README.md', size=None, blob_id=None, lfs=None)])\n"
-     ]
-    }
-   ],
-   "source": [
-    "info = API.dataset_info(repo_id=QUEUE_REPO)\n",
-    "print(info)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from huggingface_hub import HfApi\n",
-    "\n",
-    "def print_repo_directory_structure(api, repo_id, is_dataset=True):\n",
-    "    \"\"\"\n",
-    "    Print the directory structure of a Hugging Face repository.\n",
-    "\n",
-    "    Parameters:\n",
-    "    - repo_id (str): Repository ID in the format \"username/reponame\".\n",
-    "    \"\"\"\n",
-    "    # api = HfApi()\n",
-    "    if is_dataset:\n",
-    "        repo_files = api.list_repo_files(repo_id=repo_id, repo_type='dataset')\n",
-    "    else:\n",
-    "        repo_files = api.list_repo_files(repo_id=repo_id)\n",
-    "\n",
-    "\n",
-    "    print(f\"Directory structure of {repo_id}:\")\n",
-    "    print()\n",
-    "    for file_path in repo_files:\n",
-    "        print(file_path)\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Directory structure of chaeeunlee/test_requests:\n",
-      "\n",
-      ".gitattributes\n",
-      "README.md\n"
-     ]
-    }
-   ],
-   "source": [
-    "repo_id = QUEUE_REPO  # Replace with the target repository ID\n",
-    "print_repo_directory_structure(API, repo_id)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "lb",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

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

@@ -1,31 +1,15 @@
-torch
-colorama
-APScheduler
-black
-click
-datasets
-gradio
-gradio_client
-huggingface-hub
-matplotlib
-numpy
-pandas
-plotly
-python-dateutil
-requests
-semantic-version
-tqdm
-transformers>=4.36.0,<4.37.0
-tokenizers>=0.15.0
-lm_eval @ git+https://github.com/EleutherAI/lm-evaluation-harness.git
-accelerate
-sentencepiece
-langdetect
-sacrebleu
-cchardet
-rouge_score
-bert-score
-evaluate
-spacy
-selfcheckgpt
-immutabledict
+APScheduler==3.10.1
+black==23.11.0
+click==8.1.3
+datasets==2.14.5
+gradio==4.4.0
+gradio_client==0.7.0
+huggingface-hub>=0.18.0
+matplotlib==3.7.1
+numpy==1.24.2
+pandas==2.0.0
+python-dateutil==2.8.2
+requests==2.28.2
+tqdm==4.65.0
+transformers==4.35.2
+tokenizers>=0.15.0

scripts/create_request_file.py

@@ -0,0 +1,107 @@
+import json
+import os
+import pprint
+import re
+from datetime import datetime, timezone
+
+import click
+from colorama import Fore
+from huggingface_hub import HfApi, snapshot_download
+
+EVAL_REQUESTS_PATH = "eval-queue"
+QUEUE_REPO = "open-llm-leaderboard/requests"
+
+precisions = ("float16", "bfloat16", "8bit (LLM.int8)", "4bit (QLoRA / FP4)", "GPTQ")
+model_types = ("pretrained", "fine-tuned", "RL-tuned", "instruction-tuned")
+weight_types = ("Original", "Delta", "Adapter")
+
+
+def get_model_size(model_info, precision: str):
+    size_pattern = size_pattern = re.compile(r"(\d\.)?\d+(b|m)")
+    try:
+        model_size = round(model_info.safetensors["total"] / 1e9, 3)
+    except (AttributeError, TypeError):
+        try:
+            size_match = re.search(size_pattern, model_info.modelId.lower())
+            model_size = size_match.group(0)
+            model_size = round(float(model_size[:-1]) if model_size[-1] == "b" else float(model_size[:-1]) / 1e3, 3)
+        except AttributeError:
+            return 0  # Unknown model sizes are indicated as 0, see NUMERIC_INTERVALS in app.py
+
+    size_factor = 8 if (precision == "GPTQ" or "gptq" in model_info.modelId.lower()) else 1
+    model_size = size_factor * model_size
+    return model_size
+
+
+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/backend/envs.py

@@ -1,54 +0,0 @@
-import os
-
-import torch
-
-from dataclasses import dataclass
-from enum import Enum
-
-from src.envs import CACHE_PATH
-
-
-@dataclass
-class Task:
-    benchmark: str
-    # metric: str # yeah i don't think we need this. 
-    col_name: str
-    num_fewshot: int
-
-
-class Tasks(Enum):
-    
-    task0 = Task("medmcqa", "MedMCQA", 0) 
-    task1   = Task("medqa_4options", "MedQA", 0)
-
-    task2   = Task("anatomy (mmlu)", "MMLU Anatomy", 0) 
-    task3        = Task("clinical_knowledge (mmlu)", "MMLU Clinical Knowledge", 0) 
-    task4        = Task("college_biology (mmlu)", "MMLU College Biology", 0) 
-    task5        = Task("college_medicine (mmlu)", "MMLU College Medicine", 0) 
-    task6        = Task("medical_genetics (mmlu)", "MMLU Medical Genetics", 0) 
-    task7        = Task("professional_medicine (mmlu)", "MMLU Professional Medicine", 0) 
-    task8       = Task("pubmedqa", "PubMedQA", 0)
-    
-
-
-num_fewshots = {
-    "medmcqa": 0,
-    "medqa_4options": 0,
-    "anatomy (mmlu)":0,
-    "clinical_knowledge (mmlu)": 0, 
-    "college_biology (mmlu)":0,
-    "college_medicine (mmlu)":0,
-    "medical_genetics (mmlu)":0,
-    "professional_medicine (mmlu)":0,
-    "pubmedqa":0,
-}
-
-
-# NUM_FEWSHOT = 64  # Change with your few shot
-
-EVAL_REQUESTS_PATH_BACKEND = os.path.join(CACHE_PATH, "eval-queue-bk")
-EVAL_RESULTS_PATH_BACKEND = os.path.join(CACHE_PATH, "eval-results-bk")
-
-DEVICE = "cuda" if torch.cuda.is_available() else 'mps'
-
-LIMIT = None  # Testing; needs to be None

src/backend/manage_requests.py

@@ -1,140 +0,0 @@
-import glob
-import json
-from dataclasses import dataclass
-from typing import Optional, List
-
-from huggingface_hub import HfApi, snapshot_download
-
-from src.utils import my_snapshot_download
-
-from lm_eval import tasks, evaluator, utils
-
-from src.display.utils import Task
-
-
-@dataclass
-class EvalRequest:
-    model: str
-
-    ## added 
-    requested_tasks: List[Task] # dict?
-
-
-    private: bool
-    status: str
-    json_filepath: str
-    weight_type: str = "Original"
-    model_type: str = ""  # pretrained, finetuned, with RL
-    precision: str = ""  # float16, bfloat16
-    base_model: Optional[str] = None # for adapter models
-    revision: str = "main" # commit
-    submitted_time: Optional[str] = "2022-05-18T11:40:22.519222"  # random date just so that we can still order requests by date
-    model_type: Optional[str] = None
-    likes: Optional[int] = 0
-    params: Optional[int] = None
-    license: Optional[str] = ""
-
-    ## added by chaeeun
-    def get_user_requested_task_names(self) -> List[str]:
-        user_requested_tasks = self.requested_tasks
-        # print(f" {user_requested_tasks}")
-
-        task_names = [task['benchmark'] for task in user_requested_tasks]
-
-        return task_names
-
-    
-    def get_model_args(self) -> str:
-
-        ## added
-        if "gpt" in self.model:
-            model_args = f"model={self.model},revision={self.revision},parallelize=True"
-        else:
-            model_args = f"pretrained={self.model},revision={self.revision},parallelize=True"
-
-        if self.precision in ["float16", "float32", "bfloat16"]:
-            model_args += f",dtype={self.precision}"
-        # Quantized models need some added config, the install of bits and bytes, etc
-        #elif self.precision == "8bit":
-        #    model_args += ",load_in_8bit=True"
-        #elif self.precision == "4bit":
-        #    model_args += ",load_in_4bit=True"
-        #elif self.precision == "GPTQ":
-            # A GPTQ model does not need dtype to be specified,
-            # it will be inferred from the config
-            pass
-        else:
-            raise Exception(f"Unknown precision {self.precision}.")
-        
-        return model_args
-
-# set as in on remote repo!
-def set_eval_request(api: HfApi, eval_request: EvalRequest, set_to_status: str, hf_repo: str, local_dir: str):
-    """Updates a given eval request with its new status on the hub (running, completed, failed, ...)"""
-    json_filepath = eval_request.json_filepath
-
-    with open(json_filepath) as fp:
-        data = json.load(fp)
-
-    data["status"] = set_to_status
-
-    with open(json_filepath, "w") as f:
-        f.write(json.dumps(data))
-
-    api.upload_file(path_or_fileobj=json_filepath, path_in_repo=json_filepath.replace(local_dir, ""),
-                    repo_id=hf_repo, repo_type="dataset")
-
-# getting status from the remote repo as well. 
-def get_eval_requests(job_status: list, local_dir: str, hf_repo: str) -> list[EvalRequest]:
-    """Get all pending evaluation requests and return a list in which private
-    models appearing first, followed by public models sorted by the number of
-    likes.
-
-    Returns:
-        `list[EvalRequest]`: a list of model info dicts.
-    """
-    my_snapshot_download(repo_id=hf_repo, revision="main", local_dir=local_dir, repo_type="dataset", max_workers=60)
-    json_files = glob.glob(f"{local_dir}/**/*.json", recursive=True)
-
-    eval_requests = []
-    for json_filepath in json_files:
-        with open(json_filepath) as fp:
-            data = json.load(fp)
-        if data["status"] in job_status:
-            # import pdb
-            # breakpoint()
-            data["json_filepath"] = json_filepath
-
-            if 'job_id' in data:
-                del data['job_id']
-
-            print(f"data in get_eval_requests(): {data}")
-
-            eval_request = EvalRequest(**data)
-            eval_requests.append(eval_request)
-
-    print(f"eval_requests right before returning: {eval_requests}")
-    return eval_requests
-
-# not entirely sure what this one does. 
-def check_completed_evals(api: HfApi, hf_repo: str, local_dir: str, checked_status: str, completed_status: str,
-                          failed_status: str, hf_repo_results: str, local_dir_results: str):
-    """Checks if the currently running evals are completed, if yes, update their status on the hub."""
-    my_snapshot_download(repo_id=hf_repo_results, revision="main", local_dir=local_dir_results, repo_type="dataset", max_workers=60)
-
-    running_evals = get_eval_requests([checked_status], hf_repo=hf_repo, local_dir=local_dir)
-
-    for eval_request in running_evals:
-        model = eval_request.model
-        print("====================================")
-        print(f"Checking {model}")
-
-        output_path = model
-        output_file = f"{local_dir_results}/{output_path}/results*.json"
-        output_file_exists = len(glob.glob(output_file)) > 0
-
-        if output_file_exists:
-            print(f"EXISTS output file exists for {model} setting it to {completed_status}")
-            set_eval_request(api, eval_request, completed_status, hf_repo, local_dir)
-
-

src/backend/run_eval_suite.py

@@ -1,75 +0,0 @@
-from lm_eval import tasks, evaluator, utils
-from lm_eval.tasks import initialize_tasks, TaskManager
-
-try: 
-    from lm_eval.tasks import include_task_folder
-except:
-    from lm_eval.tasks import include_path
-
-from src.backend.manage_requests import EvalRequest
-
-# from src.backend.tasks.xsum.task import XSum
-# from src.backend.tasks.xsum.task_v2 import XSumv2
-
-# from src.backend.tasks.cnndm.task import CNNDM
-# from src.backend.tasks.cnndm.task_v2 import CNNDMv2
-
-# from src.backend.tasks.selfcheckgpt.task import SelfCheckGpt
-
-
-
-def run_evaluation(eval_request: EvalRequest, task_names, num_fewshot, batch_size, device, use_cache=None, limit=None, max_nb_samples=100) -> dict:
-    if limit:
-        print("WARNING: --limit SHOULD ONLY BE USED FOR TESTING. REAL METRICS SHOULD NOT BE COMPUTED USING LIMIT.")
-
-
-    # try: 
-    #     include_task_folder("src/backend/tasks/")
-    # except:
-    #     include_path("src/backend/tasks")
-
-    # initialize_tasks('INFO')
-    # https://github.com/EleutherAI/lm-evaluation-harness/blob/main/docs/interface.md#external-library-usage
-    # indexes all tasks from the `lm_eval/tasks` subdirectory.
-    # Alternatively, you can set `TaskManager(include_path="path/to/my/custom/task/configs")`
-    # to include a set of tasks in a separate directory.
-    task_manager = TaskManager(include_path="src/backend/probing_tasks")
-
-    if "gpt" in eval_request.model:
-        model = "openai-chat-completions"
-    else:
-        model = "hf-auto"
-
-    print(f"Considered Tasks (after overriding): {task_names}")
-
-    print(f"model_args: {eval_request.get_model_args()}")
-
-    results = evaluator.simple_evaluate(model=model,  # "hf-causal-experimental",  # "hf-causal" how can i make this work for 
-                                        model_args=eval_request.get_model_args(),
-                                        task_manager=task_manager,
-                                        tasks=task_names,
-                                        num_fewshot=num_fewshot,
-                                        batch_size=batch_size,
-                                        max_batch_size=8,
-                                        device=device,
-                                        use_cache=use_cache,
-                                        limit=limit,
-
-                                        # task_manager=task_manager,
-                                        # include_path="/Users/chaeeunlee/Documents/VSC_workspaces/biomed_probing_leaderboard/src/backend/tasks",
-                                        write_out=True)
-
-    results["config"]["model_dtype"] = eval_request.precision
-    results["config"]["model_name"] = eval_request.model
-    results["config"]["model_sha"] = eval_request.revision
-
-    if max_nb_samples is not None:
-        if 'samples' in results:
-            samples = results['samples']
-            for task_name in samples.keys():
-                if len(samples[task_name]) > max_nb_samples:
-                    results['samples'][task_name] = results['samples'][task_name][:max_nb_samples]
-
-    # print(evaluator.make_table(results))
-
-    return results

src/backend/sort_queue.py

@@ -1,28 +0,0 @@
-from dataclasses import dataclass
-from huggingface_hub import HfApi
-from src.backend.manage_requests import EvalRequest
-
-
-@dataclass
-class ModelMetadata:
-    likes: int = 0
-    size: int = 15
-
-
-def sort_models_by_priority(api: HfApi, models: list[EvalRequest]) -> list[EvalRequest]:
-    private_models = [model for model in models if model.private]
-    public_models = [model for model in models if not model.private]
-
-    return sort_by_submit_date(private_models) + sort_by_submit_date(public_models)
-
-
-def sort_by_submit_date(eval_requests: list[EvalRequest]) -> list[EvalRequest]:
-    return sorted(eval_requests, key=lambda x: x.submitted_time, reverse=False)
-
-
-def sort_by_size(eval_requests: list[EvalRequest]) -> list[EvalRequest]:
-    return sorted(eval_requests, key=lambda x: x.params, reverse=False)
-
-
-def sort_by_likes(eval_requests: list[EvalRequest]) -> list[EvalRequest]:
-    return sorted(eval_requests, key=lambda x: x.likes, reverse=False)

src/display/about.py

@@ -1,13 +1,46 @@
-from src.display.utils import ModelType
+from dataclasses import dataclass
+from enum import Enum
+# from src.display.utils import ModelType
+
+
+@dataclass
+class Task:
+    benchmark: str
+    metric: str
+    col_name: str
+
+
+# Init: to update with your specific keys
+class Tasks(Enum):
+    # task_key in the json file, metric_key in the json file, name to display in the leaderboard 
+    task0        = Task("medmcqa", "acc,none", "MedMCQA") 
+    task1        = Task("medqa_4options", "acc,none", "MedQA")
+    task2        = Task("mmlu_anatomy", "acc,none", "MMLU Anatomy") 
+    task3        = Task("mmlu_clinical_knowledge", "acc,none", "MMLU Clinical Knowledge") 
+    task4        = Task("mmlu_college_biology", "acc,none", "MMLU College Biology") 
+    task5        = Task("mmlu_college_medicine", "acc,none", "MMLU College Medicine") 
+    task6        = Task("mmlu_medical_genetics", "acc,none", "MMLU Medical Genetics") 
+    task7        = Task("mmlu_professional_medicine", "acc,none", "MMLU Professional Medicine") 
+    task8        = Task("pubmedqa", "acc,none", "PubMedQA")
+
+    
+# "medmcqa", "acc,none", "MedMCQA"
+
+# Your leaderboard name
+# <h1 align="center" style="color: #1a237e;"> Open Medical-LLM Leaderboard</h1>
+TITLE = """
+
+
+<div style="text-align: center; margin-bottom: 20px;">
+    <img src="https://raw.githubusercontent.com/monk1337/MultiMedQA/main/assets/logs.png" alt="Descriptive Alt Text" style="display: block; margin: auto; height: 160px;">
+</div>
+
+<h1 align="center" style="color: #1a237e; font-size: 40px;">Open <span style="color: #990001;">Medical-LLM</span> Leaderboard</h1>
 
-# <div style="text-align: center;">
-#     <img src="https://raw.githubusercontent.com/monk1337/MultiMedQA/main/assets/logs.png" alt="Descriptive Alt Text" style="display: block; margin: auto; height: 160px;">
-# </div>
 
-TITLE = """
-<h1 align="center" style="color: #1a237e;"> Open Medical-LLM Leaderboard</h1>
 """
 
+# What does your leaderboard evaluate?
 INTRODUCTION_TEXT = """
 🩺 The Open Medical LLM Leaderboard aims to track, rank and evaluate the performance of large language models (LLMs) on medical question answering tasks. It evaluates LLMs across a diverse array of medical datasets, including MedQA (USMLE), PubMedQA, MedMCQA, and subsets of MMLU related to medicine and biology. The leaderboard offers a comprehensive assessment of each model's medical knowledge and question answering capabilities.
 
@@ -20,11 +53,25 @@ The backend of the Open Medical LLM Leaderboard uses the Eleuther AI Language Mo
 
 LLM_BENCHMARKS_TEXT = f"""
 
-Context
+<h2 style="color: #2c3e50;"> Why Leaderboard? </h2>
+
 Evaluating the medical knowledge and clinical reasoning capabilities of LLMs is crucial as they are increasingly being applied to healthcare and biomedical applications. The Open Medical LLM Leaderboard provides a platform to assess the latest LLMs on their performance on a variety of medical question answering tasks. This can help identify the strengths and gaps in medical understanding of current models.
 
-How it works
+<h2 style="color: #2c3e50;">How it works</h2>
+
 📈 We evaluate the models on 9 medical Q&A datasets 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 language models on different tasks.
+
+<h2 style="color: #2c3e50;">About Open Life Science AI</h2>
+An Open Life Science Project to Benchmark and Track AI Progress, Share Models and Datasets in the Life Science Field.
+<a href="https://openlifescience.ai/" target="_blank"> More info </a>
+
+
+<h2 style="color: #2c3e50;">Datasets</h2>
+
+<div style="font-family: Arial, sans-serif; line-height: 1.6; color: #333;"> <ul style="list-style-type: none; padding: 0;"> <li style="margin-bottom: 20px;"> <h3 style="color: #2c3e50; margin-bottom: 5px;"><a href="https://arxiv.org/abs/2009.13081" target="_blank" style="color: #3498db;">MedQA (USMLE)</a></h3> <p>1273 real-world questions from the US Medical License Exams (USMLE) to test general medical knowledge</p> </li> <li style="margin-bottom: 20px;"> <h3 style="color: #2c3e50; margin-bottom: 5px;"><a href="https://arxiv.org/abs/1909.06146" target="_blank" style="color: #3498db;">PubMedQA</a></h3> <p>500 questions constructed from PubMed article titles along with the abstracts as context to test understanding of biomedical research</p> </li> <li style="margin-bottom: 20px;"> <h3 style="color: #2c3e50; margin-bottom: 5px;"><a href="https://proceedings.mlr.press/v174/pal22a.html" target="_blank" style="color: #3498db;">MedMCQA</a></h3> <p>4183 questions from Indian medical entrance exams (AIIMS & NEET PG) spanning 2.4k healthcare topics</p> </li> <li style="margin-bottom: 20px;"> <h3 style="color: #2c3e50; margin-bottom: 5px;"><a href="https://arxiv.org/abs/2009.03300" target="_blank" style="color: #3498db;">MMLU-Clinical knowledge</a></h3> <p>265 multiple choice questions on clinical knowledge</p> </li> <li style="margin-bottom: 20px;"> <h3 style="color: #2c3e50; margin-bottom: 5px;"><a href="https://arxiv.org/abs/2009.03300" target="_blank" style="color: #3498db;">MMLU-Medical genetics</a></h3> <p>100 MCQs on medical genetics</p> </li> <li style="margin-bottom: 20px;"> <h3 style="color: #2c3e50; margin-bottom: 5px;"><a href="https://arxiv.org/abs/2009.03300" target="_blank" style="color: #3498db;">MMLU-Anatomy</a></h3> <p>135 anatomy MCQs</p> </li> <li style="margin-bottom: 20px;"> <h3 style="color: #2c3e50; margin-bottom: 5px;"><a href="https://arxiv.org/abs/2009.03300" target="_blank" style="color: #3498db;">MMLU-Professional medicine</a></h3> <p>272 MCQs on professional medicine</p> </li> <li style="margin-bottom: 20px;"> <h3 style="color: #2c3e50; margin-bottom: 5px;"><a href="https://arxiv.org/abs/2009.03300" target="_blank" style="color: #3498db;">MMLU-College biology</a></h3> <p>144 MCQs on college-level biology</p> </li> <li> <h3 style="color: #2c3e50; margin-bottom: 5px;"><a href="https://arxiv.org/abs/2009.03300" target="_blank" style="color: #3498db;">MMLU-College medicine</a></h3> <p>173 college medicine MCQs</p> </li> </ul> </div>
+
+<div style="font-family: Arial, sans-serif; line-height: 1.6; color: #333;"> <h2 style="color: #2c3e50;">Evaluation Metric</h2> <p>Metric Accuracy (ACC) is used as the main evaluation metric across all datasets.</p> <h2 style="color: #2c3e50;">Details and Logs</h2> <p>Detailed results are available in the results directory:</p> <a href="https://huggingface.co/datasets/openlifescienceai/results" target="_blank" style="color: #3498db;">https://huggingface.co/datasets/openlifescienceai/results</a> <p>Input/outputs for each model can be found in the details page accessible by clicking the 📄 emoji next to the model name.</p> <h2 style="color: #2c3e50;">Reproducibility</h2> <p>To reproduce the results, you can run this evaluation script:</p> <pre style="background-color: #f0f0f0; padding: 10px; border-radius: 5px;">python eval_medical_llm.py</pre> <p>To evaluate a specific dataset on a model, use the EleutherAI LLM Evaluation Harness:</p> <pre style="background-color: #f0f0f0; padding: 10px; border-radius: 5px;">python main.py --model=hf-auto --model_args="pretrained=&lt;model&gt;,revision=&lt;revision&gt;,parallelize=True" --tasks=&lt;dataset&gt; --num_fewshot=&lt;n_shots&gt; --batch_size=1 --output_path=&lt;output_dir&gt;</pre> <p>Note some datasets may require additional setup, refer to the Evaluation Harness documentation.</p> <p>Adjust batch size based on your GPU memory if not using parallelism. Minor variations in results are expected with different batch sizes due to padding.</p> <h2 style="color: #2c3e50;">Icons</h2> <ul style="list-style-type: none; padding: 0;"> <li>🟢 Pre-trained model</li> <li>🔶 Fine-tuned model</li> <li>? Unknown model type</li> <li>⭕ Instruction-tuned</li> <li>🟦 RL-tuned</li> </ul> <p>Missing icons indicate the model info is not yet added, feel free to open an issue to include it!</p> </div>
+
 """
 
 LLM_BENCHMARKS_DETAILS = f"""
@@ -55,9 +102,11 @@ python main.py --model=hf-auto --model_args="pretrained=<model>,revision=<revisi
 Note some datasets may require additional setup, refer to the Evaluation Harness documentation. Adjust batch size based on your GPU memory if not using parallelism. Minor variations in results are expected with different batch sizes due to padding.
 
 Icons
-{ModelType.PT.to_str(" : ")} Pre-trained model
-{ModelType.FT.to_str(" : ")} Fine-tuned model
-{ModelType.Unknown.to_str(" : ")} Unknown model type
+🟢 Pre-trained model
+🔶 Fine-tuned model
+? Unknown model type
+⭕ instruction-tuned
+🟦 RL-tuned
 Missing icons indicate the model info is not yet added, feel free to open an issue to include it!
 """
 
@@ -113,4 +162,15 @@ year = {2024},
 publisher = {Hugging Face},
 howpublished = "\url{https://huggingface.co/spaces/openlifescienceai/open_medical_llm_leaderboard}"
 }
-"""
+
+
+
+@misc{singhal2023expertlevel,
+      title={Towards Expert-Level Medical Question Answering with Large Language Models}, 
+      author={Karan Singhal et al.},
+      year={2023},
+      eprint={2305.09617},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+"""

src/display/css_html_js.py

@@ -1,9 +1,5 @@
 custom_css = """
 
-.gradio-container {
-  max-width: 100%!important;
-}
-
 .markdown-text {
     font-size: 16px !important;
 }

src/display/formatting.py

@@ -7,18 +7,12 @@ 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("/", "__")
-    # details_link = f"https://huggingface.co/datasets/open-llm-leaderboard/details_{details_model_name}"
-
-    # return model_hyperlink(link, model_name) + "  " + model_hyperlink(details_link, "📑")
     return model_hyperlink(link, model_name)
 
 

src/display/utils.py

@@ -3,30 +3,12 @@ from enum import Enum
 
 import pandas as pd
 
+from src.display.about import Tasks
 
 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):
-    medmcqa = Task("medmcqa", "acc", "MedMCQA")
-    medqa = Task("medqa_4options", "acc", "MedQA")
-
-    mmlu_anatomy = Task("anatomy (mmlu)", "acc", "MMLU Anatomy")
-    mmlu_ck = Task("clinical_knowledge (mmlu)", "acc", "MMLU Clinical Knowledge")
-    mmlu_cb = Task("college_biology (mmlu)", "acc", "MMLU College Biology")
-    mmlu_cm = Task("college_medicine (mmlu)", "acc", "MMLU College Medicine")
-    mmlu_mg = Task("medical_genetics (mmlu)", "acc", "MMLU Medical Genetics")
-    mmlu_pm = Task("professional_medicine (mmlu)", "acc", "MMLU Professional Medicine")
-    pubmedqa = Task("pubmedqa", "acc", "PubMedQA")
-    
 # These classes are for user facing column names,
 # to avoid having to change them all around the code
 # when a modif is needed
@@ -38,16 +20,16 @@ class ColumnContent:
     hidden: bool = False
     never_hidden: bool = False
     dummy: bool = False
-    is_task: bool = False
 
+## Leaderboard columns
 auto_eval_column_dict = []
 # Init
 auto_eval_column_dict.append(["model_type_symbol", ColumnContent, ColumnContent("T", "str", True, never_hidden=True)])
 auto_eval_column_dict.append(["model", ColumnContent, ColumnContent("Model", "markdown", True, never_hidden=True)])
 #Scores
-auto_eval_column_dict.append(["average", ColumnContent, ColumnContent("Avg", "number", True)])
+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, is_task=True)]) # hidden was true by default
+    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)])
@@ -64,7 +46,7 @@ auto_eval_column_dict.append(["dummy", ColumnContent, ColumnContent("model_name_
 # We use make dataclass to dynamically fill the scores from Tasks
 AutoEvalColumn = make_dataclass("AutoEvalColumn", auto_eval_column_dict, frozen=True)
 
-
+## For the queue columns in the submission tab
 @dataclass(frozen=True)
 class EvalQueueColumn:  # Queue column
     model = ColumnContent("model", "markdown", True)
@@ -74,11 +56,12 @@ class EvalQueueColumn:  # Queue column
     weight_type = ColumnContent("weight_type", "str", "Original")
     status = ColumnContent("status", "str", True)
 
-
+## All the model information that we might need
 @dataclass
 class ModelDetails:
     name: str
-    symbol: str = ""  # emoji, only for the model type
+    display_name: str = ""
+    symbol: str = "" # emoji
 
 
 class ModelType(Enum):
@@ -103,18 +86,12 @@ class ModelType(Enum):
             return ModelType.IFT
         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")
     qt_8bit = ModelDetails("8bit")
@@ -122,10 +99,7 @@ class Precision(Enum):
     qt_GPTQ = ModelDetails("GPTQ")
     Unknown = ModelDetails("?")
 
-    @staticmethod
-    def from_str(precision: str):
-        if precision in ["torch.float32", "float32"]:
-            return Precision.float32
+    def from_str(precision):
         if precision in ["torch.float16", "float16"]:
             return Precision.float16
         if precision in ["torch.bfloat16", "bfloat16"]:
@@ -137,7 +111,6 @@ class Precision(Enum):
         if precision in ["GPTQ", "None"]:
             return Precision.qt_GPTQ
         return Precision.Unknown
-        
 
 # Column selection
 COLS = [c.name for c in fields(AutoEvalColumn) if not c.hidden]

src/envs.py

@@ -2,38 +2,19 @@ import os
 
 from huggingface_hub import HfApi
 
+# clone / pull the lmeh eval data
+TOKEN = os.environ.get("TOKEN", None)
 
-H4_TOKEN = os.environ.get("HF_SECRET", None) 
+OWNER = "openlifescienceai"
+REPO_ID = f"{OWNER}/open_medical_llm_leaderboard"
+QUEUE_REPO = f"{OWNER}/requests"
+RESULTS_REPO = f"{OWNER}/results"
 
-# REPO_ID = "pminervini/hallucinations-leaderboard"
-REPO_ID = "openlifescienceai/open_medical_llm_leaderboard" 
-
-QUEUE_REPO = "openlifescienceai/test_requests"
-RESULTS_REPO = "openlifescienceai/test_results"
-
-# have not created these repos yet
-PRIVATE_QUEUE_REPO = "openlifescienceai/test_private-requests"
-PRIVATE_RESULTS_REPO = "openlifescienceai/test_private-results"
-
-IS_PUBLIC = bool(os.environ.get("IS_PUBLIC", True))
-
-# CACHE_PATH = "/Users/chaeeunlee/Documents/VSC_workspaces/test_leaderboard" # 
-CACHE_PATH = os.getenv("HF_HOME", ".") 
-
-print(f"CACHE_PATH = {CACHE_PATH}")
+CACHE_PATH=os.getenv("HF_HOME", ".")
+# print("CACHE_PATH", CACHE_PATH)
 
+# Local caches
 EVAL_REQUESTS_PATH = os.path.join(CACHE_PATH, "eval-queue")
 EVAL_RESULTS_PATH = os.path.join(CACHE_PATH, "eval-results")
 
-EVAL_REQUESTS_PATH_PRIVATE = "eval-queue-private"
-EVAL_RESULTS_PATH_PRIVATE = "eval-results-private"
-
-# PATH_TO_COLLECTION = "hallucinations-leaderboard/llm-leaderboard-best-models-652d6c7965a4619fb5c27a03" # ??
-
-# Rate limit variables
-RATE_LIMIT_PERIOD = 7
-RATE_LIMIT_QUOTA = 5
-HAS_HIGHER_RATE_LIMIT = ["TheBloke"]
-
-API = HfApi(token=H4_TOKEN)
-# API = HfApi()
+API = HfApi(token=TOKEN)

src/leaderboard/filter_models.py

@@ -1,50 +0,0 @@
-from src.display.formatting import model_hyperlink
-from src.display.utils import AutoEvalColumn
-
-# Models which have been flagged by users as being problematic for a reason or another
-# (Model name to forum discussion link)
-FLAGGED_MODELS = {
-    "Voicelab/trurl-2-13b": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/202",
-    "deepnight-research/llama-2-70B-inst": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/207",
-    "Aspik101/trurl-2-13b-pl-instruct_unload": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/213",
-    "Fredithefish/ReasonixPajama-3B-HF": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/236",
-    "TigerResearch/tigerbot-7b-sft-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/237",
-    "gaodrew/gaodrew-gorgonzola-13b": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/215",
-    "AIDC-ai-business/Marcoroni-70B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/287",
-    "AIDC-ai-business/Marcoroni-13B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/287",
-    "AIDC-ai-business/Marcoroni-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/287",
-}
-
-# Models which have been requested by orgs to not be submitted on the leaderboard
-DO_NOT_SUBMIT_MODELS = [
-    "Voicelab/trurl-2-13b",  # trained on MMLU
-]
-
-
-def flag_models(leaderboard_data: list[dict]):
-    for model_data in leaderboard_data:
-        if model_data["model_name_for_query"] in FLAGGED_MODELS:
-            issue_num = FLAGGED_MODELS[model_data["model_name_for_query"]].split("/")[-1]
-            issue_link = model_hyperlink(
-                FLAGGED_MODELS[model_data["model_name_for_query"]],
-                f"See discussion #{issue_num}",
-            )
-            model_data[
-                AutoEvalColumn.model.name
-            ] = f"{model_data[AutoEvalColumn.model.name]} has been flagged! {issue_link}"
-
-
-def remove_forbidden_models(leaderboard_data: list[dict]):
-    indices_to_remove = []
-    for ix, model in enumerate(leaderboard_data):
-        if model["model_name_for_query"] in DO_NOT_SUBMIT_MODELS:
-            indices_to_remove.append(ix)
-
-    for ix in reversed(indices_to_remove):
-        leaderboard_data.pop(ix)
-    return leaderboard_data
-
-
-def filter_models(leaderboard_data: list[dict]):
-    leaderboard_data = remove_forbidden_models(leaderboard_data)
-    flag_models(leaderboard_data)

src/leaderboard/read_evals.py

@@ -1,5 +1,6 @@
 import glob
 import json
+import math
 import os
 from dataclasses import dataclass
 
@@ -13,7 +14,6 @@ from src.submission.check_validity import is_model_on_hub
 
 @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 
@@ -23,21 +23,20 @@ class EvalResult:
     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
+    architecture: str = "Unknown" 
     license: str = "?"
     likes: int = 0
     num_params: int = 0
     date: str = "" # submission date of request file
     still_on_hub: bool = False
 
-    @staticmethod
-    def init_from_json_file(json_filepath, is_backend: bool = False):
+    @classmethod
+    def init_from_json_file(self, json_filepath):
         """Inits the result from the specific model result file"""
         with open(json_filepath) as fp:
             data = json.load(fp)
 
-        # We manage the legacy config format
-        config = data.get("config", data.get("config_general", None))
+        config = data.get("config")
 
         # Precision
         precision = Precision.from_str(config.get("model_dtype"))
@@ -56,7 +55,9 @@ class EvalResult:
             result_key = f"{org}_{model}_{precision.value.name}"
         full_model = "/".join(org_and_model)
 
-        still_on_hub, error, model_config = is_model_on_hub(full_model, config.get("model_sha", "main"), trust_remote_code=True, test_tokenizer=False)
+        still_on_hub, _, model_config = is_model_on_hub(
+            full_model, config.get("model_sha", "main"), trust_remote_code=True, test_tokenizer=False
+        )
         architecture = "?"
         if model_config is not None:
             architectures = getattr(model_config, "architectures", None)
@@ -65,47 +66,28 @@ class EvalResult:
 
         # Extract results available in this file (some results are split in several files)
         results = {}
-
-        task_iterator = Tasks
-        if is_backend is True:
-            from src.backend.envs import Tasks as BackendTasks
-            task_iterator = BackendTasks
-
-        for task in task_iterator:
+        for task in Tasks:
             task = task.value
 
-            def post_process_results(results: dict) -> dict:
-                # {'nq_open': {'em': 0.018005540166204988, 'em_stderr': 0.0022134216580395583}}
-                res_copy = results.copy()
-
-                for task_name in res_copy.keys():
-                    entry_copy = results[task_name].copy()
-
-                    for k, v in entry_copy.items():
-                        if "exact_match" in k:
-                            results[task_name][k.replace("exact_match", "em")] = v
-
-                    entry_copy = results[task_name].copy()
-
-                    for k, v in entry_copy.items():
-                        if "," in k:
-                            tokens = k.split(",")
-                            results[task_name][tokens[0]] = v
-
-                return results
-
-            accs = np.array([v.get(task.metric, None) for k, v in post_process_results(data["results"]).items() if task.benchmark in k])
-
+            # We average all scores of a given metric (not all metrics are present in all files)
+            accs = np.array([v.get(task.metric, None) for k, v in data["results"].items() if task.benchmark == k])
             if accs.size == 0 or any([acc is None for acc in accs]):
                 continue
 
             mean_acc = np.mean(accs) * 100.0
-            mean_acc = round(mean_acc, 2)
             results[task.benchmark] = mean_acc
 
-        return EvalResult(eval_name=result_key, full_model=full_model, org=org, model=model, results=results,
-                          precision=precision, revision=config.get("model_sha", ""), still_on_hub=still_on_hub,
-                          architecture=architecture)
+        return self(
+            eval_name=result_key,
+            full_model=full_model,
+            org=org,
+            model=model,
+            results=results,
+            precision=precision,  
+            revision= config.get("model_sha", ""),
+            still_on_hub=still_on_hub,
+            architecture=architecture
+        )
 
     def update_with_request_file(self, requests_path):
         """Finds the relevant request file for the current model and updates info with it"""
@@ -120,19 +102,12 @@ class EvalResult:
             self.likes = request.get("likes", 0)
             self.num_params = request.get("params", 0)
             self.date = request.get("submitted_time", "")
-        except Exception as e:
-            print(f"Could not find request file for {self.org}/{self.model} -- path: {requests_path} -- {e}")
-
-    def is_complete(self) -> bool:
-        for task in Tasks:
-            if task.value.benchmark not in self.results:
-                return False
-        return True
+        except Exception:
+            print(f"Could not find request file for {self.org}/{self.model}")
 
     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)
-        average = round(average, 2)
         data_dict = {
             "eval_name": self.eval_name,  # not a column, just a save name,
             AutoEvalColumn.precision.name: self.precision.value.name,
@@ -151,48 +126,42 @@ class EvalResult:
         }
 
         for task in Tasks:
-            if task.value.benchmark in self.results:  # XXX
-                data_dict[task.value.col_name] = self.results[task.value.benchmark]
+            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 and RUNNING"""
+    """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)
 
+    print("yahaa", request_files)
+
     # Select correct request file (precision)
     request_file = ""
     request_files = sorted(request_files, reverse=True)
-    # print('XXX', request_files)
     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", "RUNNING"] and
-                req_content["precision"] == precision.split(".")[-1]
+                req_content["status"] in ["FINISHED"]
+                and req_content["precision"] == precision.split(".")[-1]
             ):
                 request_file = tmp_request_file
     return request_file
 
 
-def get_raw_eval_results(results_path: str, requests_path: str, is_backend: bool = False) -> list[EvalResult]:
+def get_raw_eval_results(results_path: str, requests_path: str) -> list[EvalResult]:
     """From the path of the results folder root, extract all needed info for results"""
     model_result_filepaths = []
 
-    print(f"results_path: {results_path}")
-
-    walked_list = list(os.walk(results_path))
-    print(f"len(walked_list): {len(walked_list)}") # 1
-
     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]):
-            print("negative condition met")
             continue
 
         # Sort the files by date
@@ -201,16 +170,13 @@ def get_raw_eval_results(results_path: str, requests_path: str, is_backend: bool
         except dateutil.parser._parser.ParserError:
             files = [files[-1]]
 
-
-        print(f"files = {files}")
-
         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, is_backend=is_backend)
+        eval_result = EvalResult.init_from_json_file(model_result_filepath)
         eval_result.update_with_request_file(requests_path)
 
         # Store results of same eval together
@@ -222,7 +188,10 @@ def get_raw_eval_results(results_path: str, requests_path: str, is_backend: bool
 
     results = []
     for v in eval_results.values():
-        results.append(v)
+        try:
+            v.to_dict() # we test if the dict version is complete
+            results.append(v)
+        except KeyError:  # not all eval values present
+            continue
 
-    print(f"results = {results}")
     return results

src/populate.py

@@ -5,56 +5,23 @@ import pandas as pd
 
 from src.display.formatting import has_no_nan_values, make_clickable_model
 from src.display.utils import AutoEvalColumn, EvalQueueColumn
-from src.leaderboard.filter_models import filter_models
-from src.leaderboard.read_evals import get_raw_eval_results, EvalResult
+from src.leaderboard.read_evals import get_raw_eval_results
 
-'''
-This function, get_leaderboard_df, is designed to read and process evaluation results from a specified results path and requests path, 
-ultimately producing a leaderboard in the form of a pandas DataFrame. The process involves several steps, including filtering, sorting, 
-and cleaning the data based on specific criteria. Let's break down the function step by step:
-
-'''
-
-## TO-DO: if raw_data is [], return dummy df with correct columns so that the UI shows the right columns
-def get_leaderboard_df(results_path: str, requests_path: str, cols: list, benchmark_cols: list) -> tuple[list[EvalResult], pd.DataFrame]:
-
-    print(f"results_path = {results_path}")
 
+def get_leaderboard_df(results_path: str, requests_path: str, cols: list, benchmark_cols: list) -> pd.DataFrame:
     raw_data = get_raw_eval_results(results_path, requests_path)
-
-    all_data_json = [v.to_dict() for v in raw_data] # if v.is_complete()]
-    # all_data_json.append(baseline_row)
-    filter_models(all_data_json)
-
-    print(f"all_data_json  = {all_data_json}")
+    all_data_json = [v.to_dict() for v in raw_data]
 
     df = pd.DataFrame.from_records(all_data_json)
+    df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
+    df = df[cols].round(decimals=2)
 
-    task_attributes = []
-
-    # Iterate over all attributes of AutoEvalColumn class
-    for attr_name in dir(AutoEvalColumn):
-        # Retrieve the attribute object
-        attr = getattr(AutoEvalColumn, attr_name)
-        # Check if the attribute has 'is_task' attribute and it is True
-        if hasattr(attr, 'is_task') and getattr(attr, 'is_task'):
-            task_attributes.append(attr)
-
-    # Now task_attributes contains all attributes where is_task=True
-    # print(task_attributes)
-    task_col_names_all = [str(item.name) for item in task_attributes]
-
-    # import pdb; pdb.set_trace()
-
-    # Add empty columns with specified names
-    for col_name in task_col_names_all:
-        if col_name not in df.columns:
-            df[col_name] = None
-            
+    # filter out if any of the benchmarks have not been produced
+    df = df[has_no_nan_values(df, benchmark_cols)]
     return raw_data, df
 
 
-def get_evaluation_queue_df(save_path: str, cols: list) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+def get_evaluation_queue_df(save_path: str, cols: list) -> list[pd.DataFrame]:
     entries = [entry for entry in os.listdir(save_path) if not entry.startswith(".")]
     all_evals = []
 

src/submission/check_validity.py

@@ -7,17 +7,11 @@ from datetime import datetime, timedelta, timezone
 import huggingface_hub
 from huggingface_hub import ModelCard
 from huggingface_hub.hf_api import ModelInfo
-# from transformers import AutoConfig
-from transformers import AutoConfig, AutoTokenizer
+from transformers import AutoConfig
 from transformers.models.auto.tokenization_auto import tokenizer_class_from_name, get_tokenizer_config
 
-from src.envs import HAS_HIGHER_RATE_LIMIT
-
-
-# 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
+    """Checks if the model card and license exist and have been filled"""
     try:
         card = ModelCard.load(repo_id)
     except huggingface_hub.utils.EntryNotFoundError:
@@ -38,58 +32,28 @@ def check_model_card(repo_id: str) -> tuple[bool, str]:
     return True, ""
 
 
-# def is_model_on_hub(model_name: str, revision: str, token: str = None, trust_remote_code=False, test_tokenizer=False) -> tuple[bool, str]:
-#     try:
-#         config = AutoConfig.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token)
-#         if test_tokenizer:
-#             tokenizer_config = get_tokenizer_config(model_name)
-
-#             if tokenizer_config is not None:
-#                 tokenizer_class_candidate = tokenizer_config.get("tokenizer_class", None)
-#             else:
-#                 tokenizer_class_candidate = config.tokenizer_class
-
-#             tokenizer_class = None
-#             if tokenizer_class_candidate is not None:
-#                 tokenizer_class = tokenizer_class_from_name(tokenizer_class_candidate)
-
-#             if tokenizer_class is None:
-#                 return (
-#                     False,
-#                     f"uses {tokenizer_class_candidate}, which is not in a transformers release, therefore not supported at the moment.", # pythia-160m throws this error. seems unnecessary. 
-#                     None
-#                 )
-#         return True, None, config
-
-#     except ValueError:
-#         return (
-#             False,
-#             "needs to be launched with `trust_remote_code=True`. For safety reason, we do not allow these models to be automatically submitted to the leaderboard.",
-#             None
-#         )
-
-#     except Exception as e:
-#         print('XXX', e)
-#         return False, "was not found on hub!", None
-
-# replaced with https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/blob/main/src/submission/check_validity.py
-def is_model_on_hub(model_name: str, revision: str, token: str = None, trust_remote_code=False, test_tokenizer=False) -> tuple[bool, str, AutoConfig]:
+def is_model_on_hub(model_name: str, revision: str, token: str = None, trust_remote_code=False, test_tokenizer=False) -> tuple[bool, str]:
+    """Makes sure the model is on the hub, and uses a valid configuration (in the latest transformers version)"""
     try:
-        config = AutoConfig.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token) #, force_download=True)
+        config = AutoConfig.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token)
         if test_tokenizer:
-            try:
-                tk = AutoTokenizer.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token)
-            except ValueError as e:
+            tokenizer_config = get_tokenizer_config(model_name) 
+            if tokenizer_config is not None:
+                tokenizer_class_candidate = tokenizer_config.get("tokenizer_class", None)
+            else:
+                tokenizer_class_candidate = config.tokenizer_class 
+
+
+            tokenizer_class = tokenizer_class_from_name(tokenizer_class_candidate)
+            if tokenizer_class is None:
                 return (
                     False,
-                    f"uses a tokenizer which is not in a transformers release: {e}",
+                    f"uses {tokenizer_class_candidate}, which is not in a transformers release, therefore not supported at the moment.",
                     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:
+    except ValueError:
         return (
             False,
             "needs to be launched with `trust_remote_code=True`. For safety reason, we do not allow these models to be automatically submitted to the leaderboard.",
@@ -99,77 +63,25 @@ def is_model_on_hub(model_name: str, revision: str, token: str = None, trust_rem
     except Exception as e:
         return False, "was not found on hub!", None
 
+
 def get_model_size(model_info: ModelInfo, precision: str):
-    size_pattern = size_pattern = re.compile(r"(\d\.)?\d+(b|m)")
+    """Gets the model size from the configuration, or the model name if the configuration does not contain the information."""
     try:
         model_size = round(model_info.safetensors["total"] / 1e9, 3)
-    except (AttributeError, TypeError ):
-        try:
-            size_match = re.search(size_pattern, model_info.modelId.lower())
-            model_size = size_match.group(0)
-            model_size = round(float(model_size[:-1]) if model_size[-1] == "b" else float(model_size[:-1]) / 1e3, 3)
-        except AttributeError:
-            return 0  # Unknown model sizes are indicated as 0, see NUMERIC_INTERVALS in app.py
+    except (AttributeError, TypeError):
+        return 0  # Unknown model sizes are indicated as 0, see NUMERIC_INTERVALS in app.py
 
     size_factor = 8 if (precision == "GPTQ" or "gptq" in model_info.modelId.lower()) else 1
     model_size = size_factor * model_size
     return model_size
 
 def get_model_arch(model_info: ModelInfo):
+    """Gets the model architecture from the configuration"""
     return model_info.config.get("architectures", "Unknown")
 
-def 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 org_or_user in HAS_HIGHER_RATE_LIMIT:
-        rate_limit_quota = 2 * rate_limit_quota
-
-    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, ""
-
-
-# # already_submitted_models(EVAL_REQUESTS_PATH) os.path.join(CACHE_PATH, "eval-queue")
-# # REQUESTED_MODELS, USERS_TO_SUBMISSION_DATES = already_submitted_models(EVAL_REQUESTS_PATH)
-# # debug: current code doesn't allow submission of the same model for a different task. 
-# 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"]) # why is this useful?
-
-#     return set(file_names), users_to_submission_dates
-
 def already_submitted_models(requested_models_dir: str) -> set[str]:
     depth = 1
-    file_names = [] # more like identifiers
+    file_names = []
     users_to_submission_dates = defaultdict(list)
 
     for root, _, files in os.walk(requested_models_dir):
@@ -180,15 +92,12 @@ def already_submitted_models(requested_models_dir: str) -> set[str]:
                     continue
                 with open(os.path.join(root, file), "r") as f:
                     info = json.load(f)
-                    requested_tasks = [task_dic['benchmark'] for task_dic in info["requested_tasks"]]
-                    for requested_task in requested_tasks:
-
-                        file_names.append(f"{info['model']}_{requested_task}_{info['revision']}_{info['precision']}")
+                    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"]) # why is this useful?
+                    # Select organisation
+                    if info["model"].count("/") == 0 or "submitted_time" not in info:
+                        continue
+                    organisation, _ = info["model"].split("/")
+                    users_to_submission_dates[organisation].append(info["submitted_time"])
 
     return set(file_names), users_to_submission_dates

src/submission/submit.py

@@ -3,32 +3,22 @@ import os
 from datetime import datetime, timezone
 
 from src.display.formatting import styled_error, styled_message, styled_warning
-from src.envs import API, EVAL_REQUESTS_PATH, H4_TOKEN, QUEUE_REPO, RATE_LIMIT_PERIOD, RATE_LIMIT_QUOTA
-from src.leaderboard.filter_models import DO_NOT_SUBMIT_MODELS
+from src.envs import API, EVAL_REQUESTS_PATH, TOKEN, QUEUE_REPO
 from src.submission.check_validity import (
     already_submitted_models,
     check_model_card,
     get_model_size,
     is_model_on_hub,
-    user_submission_permission,
 )
 
-## it just uploads request file. where does the evaluation actually happen?
-
 REQUESTED_MODELS = None
 USERS_TO_SUBMISSION_DATES = None
 
-
 def add_new_eval(
     model: str,
-
-    requested_tasks: list, # write better type hints. this is list of class Task. 
-
-
     base_model: str,
     revision: str,
     precision: str,
-    private: bool,
     weight_type: str,
     model_type: str,
 ):
@@ -36,7 +26,6 @@ def add_new_eval(
     global USERS_TO_SUBMISSION_DATES
     if not REQUESTED_MODELS:
         REQUESTED_MODELS, USERS_TO_SUBMISSION_DATES = already_submitted_models(EVAL_REQUESTS_PATH)
-        # REQUESTED_MODELS is set(file_names), where file_names.append(f"{info['model']}_{info['revision']}_{info['precision']}")
 
     user_name = ""
     model_path = model
@@ -50,25 +39,13 @@ def add_new_eval(
     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)
+        base_model_on_hub, error, _ = is_model_on_hub(model_name=base_model, revision=revision, token=TOKEN, test_tokenizer=True)
         if not base_model_on_hub:
             return styled_error(f'Base model "{base_model}" {error}')
 
@@ -98,54 +75,10 @@ def add_new_eval(
     # Seems good, creating the eval
     print("Adding new eval")
 
-    print()
-    print(f"requested_tasks: {requested_tasks}")
-    print(f"type(requested_tasks): {type(requested_tasks)}")
-    print()
-    # requested_tasks: [{'benchmark': 'hellaswag', 'metric': 'acc_norm', 'col_name': 'HellaSwag'}, {'benchmark': 'pubmedqa', 'metric': 'acc', 'col_name': 'PubMedQA'}]
-    # type(requested_tasks): <class 'list'>
-
-    requested_task_names = [task_dic['benchmark'] for task_dic in requested_tasks]
-
-    print()
-    print(f"requested_task_names: {requested_task_names}")
-    print(f"type(requested_task_names): {type(requested_task_names)}")
-    print()
-
-    already_submitted_tasks = []
-
-    for requested_task_name in requested_task_names:
-
-        if f"{model}_{requested_task_name}_{revision}_{precision}" in REQUESTED_MODELS:
-            # return styled_warning("This model has been already submitted.")
-            already_submitted_tasks.append(requested_task_name)
-
-    task_names_for_eval = set(requested_task_names) - set(already_submitted_tasks)
-    task_names_for_eval = list(task_names_for_eval)
-
-    return_msg = "Your request has been submitted to the evaluation queue! Please wait for up to an hour for the model to show in the PENDING list."
-    if len(already_submitted_tasks) > 0:
-
-        return_msg = f"This model has been already submitted for task(s) {already_submitted_tasks}. Evaluation will proceed for tasks {task_names_for_eval}. Please wait for up to an hour for the model to show in the PENDING list."
-
-        if len(task_names_for_eval)==0:
-            return styled_warning(f"This model has been already submitted for task(s) {already_submitted_tasks}.")
-    
-    tasks_for_eval = [dct for dct in requested_tasks if dct['benchmark'] in task_names_for_eval]
-
-    print()
-    print(f"tasks_for_eval: {tasks_for_eval}")
-    # print(f"type(requested_task_names): {type(requested_task_names)}")
-    print()
-    
     eval_entry = {
         "model": model,
-
-        "requested_tasks": tasks_for_eval, # this is a list of tasks. would eval file be written correctly for each tasks? YES. run_evaluation() takes list of tasks. might have to specify 
-
         "base_model": base_model,
         "revision": revision,
-        "private": private,
         "precision": precision,
         "weight_type": weight_type,
         "status": "PENDING",
@@ -155,25 +88,20 @@ def add_new_eval(
         "params": model_size,
         "license": license,
     }
-    
-
-    ####---- ####---- ####---- ####---- ####---- ####---- ####---- ####---- ####---- ####---- ####---- ####---- ####---- ####----
-
 
+    # 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}" # local path
+    OUT_DIR = f"{EVAL_REQUESTS_PATH}/{user_name}"
     os.makedirs(OUT_DIR, exist_ok=True)
-    out_path = f"{OUT_DIR}/{model_path}_{'_'.join([f'{task}' for task in task_names_for_eval])}_eval_request_{private}_{precision}_{weight_type}.json"
-
-    print(f"out_path = {out_path}")
+    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)) # local path used! for saving request file. 
+        f.write(json.dumps(eval_entry))
 
-    print("Uploading eval file (QUEUE_REPO)")
-    print()
-    print(f"path_or_fileobj={out_path}, path_in_repo={out_path.split('eval-queue/')[1]}, repo_id={QUEUE_REPO}, repo_type=dataset,")
+    print("Uploading eval file")
     API.upload_file(
         path_or_fileobj=out_path,
         path_in_repo=out_path.split("eval-queue/")[1],
@@ -182,10 +110,9 @@ def add_new_eval(
         commit_message=f"Add {model} to eval queue",
     )
 
-    print(f"is os.remove(out_path) the problem?")
     # Remove the local file
     os.remove(out_path)
 
     return styled_message(
-        return_msg
+        "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/utils.py

@@ -1,29 +0,0 @@
-import pandas as pd
-from huggingface_hub import snapshot_download
-
-
-def my_snapshot_download(repo_id, revision, local_dir, repo_type, max_workers):
-    for i in range(10):
-        try:
-            snapshot_download(repo_id=repo_id, revision=revision, local_dir=local_dir, repo_type=repo_type, max_workers=max_workers)
-            return
-        except Exception:
-            import time
-            time.sleep(60)
-    return
-
-
-def get_dataset_url(row):
-    dataset_name = row['Benchmark']
-    dataset_url = row['Dataset Link']
-    benchmark = f'<a target="_blank" href="{dataset_url}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{dataset_name}</a>'
-    return benchmark
-
-def get_dataset_summary_table(file_path):
-    df = pd.read_csv(file_path)
-
-    df['Benchmark'] = df.apply(lambda x: get_dataset_url(x), axis=1)
-
-    df = df[['Category', 'Benchmark', 'Data Split', 'Data Size', 'Language']]
-
-    return df