Merge branch 'main' of https://huggingface.co./spaces/HuggingFaceH4/open_llm_leaderboard

app.py

@@ -1,6 +1,5 @@
 import json
 import os
-import re
 from datetime import datetime, timezone
 
 import gradio as gr
@@ -17,9 +16,17 @@ from src.assets.text_content import (
     LLM_BENCHMARKS_TEXT,
     TITLE,
 )
-from src.display_models.get_model_metadata import DO_NOT_SUBMIT_MODELS, ModelType
-from src.display_models.modelcard_filter import check_model_card
-from src.display_models.utils import (
+from src.plots.plot_results import (
+    create_metric_plot_obj,
+    create_scores_df,
+    create_plot_df,
+    join_model_info_with_results,
+    HUMAN_BASELINES,
+)
+from src.get_model_info.apply_metadata_to_df import DO_NOT_SUBMIT_MODELS, ModelType
+from src.get_model_info.get_metadata_from_hub import get_model_size
+from src.filters import check_model_card
+from src.get_model_info.utils import (
     AutoEvalColumn,
     EvalQueueColumn,
     fields,
@@ -27,8 +34,9 @@ from src.display_models.utils import (
     styled_message,
     styled_warning,
 )
-from src.load_from_hub import get_all_requested_models, get_evaluation_queue_df, get_leaderboard_df, is_model_on_hub
-from src.rate_limiting import user_submission_permission
+from src.manage_collections import update_collections
+from src.load_from_hub import get_all_requested_models, get_evaluation_queue_df, get_leaderboard_df
+from src.filters import is_model_on_hub, user_submission_permission
 
 pd.set_option("display.precision", 1)
 
@@ -88,9 +96,11 @@ snapshot_download(repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="
 requested_models, users_to_submission_dates = get_all_requested_models(EVAL_REQUESTS_PATH)
 
 original_df = get_leaderboard_df(EVAL_RESULTS_PATH, COLS, BENCHMARK_COLS)
+update_collections(original_df.copy())
 leaderboard_df = original_df.copy()
 
 models = original_df["model_name_for_query"].tolist()  # needed for model backlinks in their to the leaderboard
+plot_df = create_plot_df(create_scores_df(join_model_info_with_results(original_df)))
 to_be_dumped = f"models = {repr(models)}\n"
 
 (
@@ -117,14 +127,8 @@ def add_new_eval(
         return styled_error("Please select a model type.")
 
     # Is the user rate limited?
-    num_models_submitted_in_period = user_submission_permission(model, users_to_submission_dates, RATE_LIMIT_PERIOD)
-    if num_models_submitted_in_period > RATE_LIMIT_QUOTA:
-        error_msg = f"Organisation or user `{model.split('/')[0]}`"
-        error_msg += f"already has {num_models_submitted_in_period} model requests submitted to the leaderboard "
-        error_msg += f"in the last {RATE_LIMIT_PERIOD} days.\n"
-        error_msg += (
-            "Please wait a couple of days before resubmitting, so that everybody can enjoy using the leaderboard 🤗"
-        )
+    user_can_submit, error_msg = user_submission_permission(model, 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?
@@ -145,28 +149,19 @@ def add_new_eval(
         if not model_on_hub:
             return styled_error(f'Model "{model}" {error}')
 
-    model_info = api.model_info(repo_id=model, revision=revision)
-
-    size_pattern = size_pattern = re.compile(r"(\d\.)?\d+(b|m)")
     try:
-        model_size = round(model_info.safetensors["total"] / 1e9, 3)
-    except AttributeError:
-        try:
-            size_match = re.search(size_pattern, model.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 65
-
-    size_factor = 8 if (precision == "GPTQ" or "GPTQ" in model) else 1
-    model_size = size_factor * model_size
+        model_info = api.model_info(repo_id=model, revision=revision)
+    except Exception:
+        return styled_error("Could not get your model information. Please fill it up properly.")
 
+    model_size = get_model_size(model_info=model_info , precision= precision)
+
+    # Were the model card and license filled?
     try:
         license = model_info.cardData["license"]
     except Exception:
-        license = "?"
+        return styled_error("Please select a license for your model")
 
-    # Were the model card and license filled?
     modelcard_OK, error_msg = check_model_card(model)
     if not modelcard_OK:
         return styled_error(error_msg)
@@ -269,13 +264,13 @@ def select_columns(df: pd.DataFrame, columns: list) -> pd.DataFrame:
 
 NUMERIC_INTERVALS = {
     "?": pd.Interval(-1, 0, closed="right"),
-    "0~1.5": pd.Interval(0, 1.5, closed="right"),
-    "1.5~3": pd.Interval(1.5, 3, closed="right"),
-    "3~7": pd.Interval(3, 7, closed="right"),
-    "7~13": pd.Interval(7, 13, closed="right"),
-    "13~35": pd.Interval(13, 35, closed="right"),
-    "35~60": pd.Interval(35, 60, closed="right"),
-    "60+": pd.Interval(60, 10000, closed="right"),
+    "~1.5": pd.Interval(0, 2, closed="right"),
+    "~3": pd.Interval(2, 4, closed="right"),
+    "~7": pd.Interval(4, 9, closed="right"),
+    "~13": pd.Interval(9, 20, closed="right"),
+    "~35": pd.Interval(20, 45, closed="right"),
+    "~60": pd.Interval(45, 70, closed="right"),
+    "70+": pd.Interval(70, 10000, closed="right"),
 }
 
 
@@ -513,6 +508,25 @@ with demo:
                 leaderboard_table,
                 queue=True,
             )
+
+        with gr.TabItem("📈 Metrics evolution through time", elem_id="llm-benchmark-tab-table", id=4):
+            with gr.Row():
+                with gr.Column():
+                    chart = create_metric_plot_obj(
+                        plot_df,
+                        ["Average ⬆️"],
+                        HUMAN_BASELINES,
+                        title="Average of Top Scores and Human Baseline Over Time",
+                    )
+                    gr.Plot(value=chart, interactive=False, width=500, height=500)
+                with gr.Column():
+                    chart = create_metric_plot_obj(
+                        plot_df,
+                        ["ARC", "HellaSwag", "MMLU", "TruthfulQA"],
+                        HUMAN_BASELINES,
+                        title="Top Scores and Human Baseline Over Time",
+                    )
+                    gr.Plot(value=chart, interactive=False, width=500, height=500)
         with gr.TabItem("📝 About", elem_id="llm-benchmark-tab-table", id=2):
             gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
 

requirements.txt

@@ -19,13 +19,13 @@ ffmpy==0.3.0
 filelock==3.11.0
 fonttools==4.39.3
 frozenlist==1.3.3
-fsspec==2023.4.0
+fsspec==2023.5.0
 gradio==3.43.2
 gradio-client==0.5.0
 h11==0.14.0
 httpcore==0.17.0
 httpx==0.24.0
-huggingface-hub==0.16.4
+huggingface-hub==0.18.0
 idna==3.4
 Jinja2==3.1.2
 jsonschema==4.17.3
@@ -60,7 +60,7 @@ sniffio==1.3.0
 starlette==0.26.1
 toolz==0.12.0
 tqdm==4.65.0
-transformers==4.34.0
+transformers
 typing_extensions==4.5.0
 tzdata==2023.3
 tzlocal==4.3

src/assets/hardcoded_evals.py

@@ -1,4 +1,4 @@
-from src.display_models.utils import AutoEvalColumn, model_hyperlink
+from src.get_model_info.utils import AutoEvalColumn, model_hyperlink
 
 gpt4_values = {
     AutoEvalColumn.model.name: model_hyperlink("https://arxiv.org/abs/2303.08774", "gpt4"),

src/assets/text_content.py

@@ -1,4 +1,4 @@
-from src.display_models.model_metadata_type import ModelType
+from src.get_model_info.hardocded_metadata.types import ModelType
 
 TITLE = """<h1 align="center" id="space-title">🤗 Open LLM Leaderboard</h1>"""
 
@@ -14,13 +14,14 @@ LLM_BENCHMARKS_TEXT = f"""
 With the plethora of large language models (LLMs) and chatbots being released week upon week, often with grandiose claims of their performance, it can be hard to filter out the genuine progress that is being made by the open-source community and which model is the current state of the art.
 
 ## Icons
-{ModelType.PT.to_str(" : ")} model
-{ModelType.FT.to_str(" : ")} model
-{ModelType.IFT.to_str(" : ")} model
-{ModelType.RL.to_str(" : ")} model
+{ModelType.PT.to_str(" : ")} model: new, base models, trained on a given corpora
+{ModelType.FT.to_str(" : ")} model: pretrained models finetuned on more data
+Specific fine-tune subcategories (more adapted to chat):
+{ModelType.IFT.to_str(" : ")} model: instruction fine-tunes, which are model fine-tuned specifically on datasets of task instruction 
+{ModelType.RL.to_str(" : ")} model: reinforcement fine-tunes, which usually change the model loss a bit with an added policy. 
 If there is no icon, we have not uploaded the information on the model yet, feel free to open an issue with the model information!
 
-🏴‍☠️ indicates that this model has been flagged by the community, and should probably be ignored! Clicking the icon will redirect you to the discussion about the model.
+"Flagged" indicates that this model has been flagged by the community, and should probably be ignored! Clicking the link will redirect you to the discussion about the model.
 (For ex, the model was trained on the evaluation data, and is therefore cheating on the leaderboard.)
 
 ## How it works

src/{display_models/modelcard_filter.py → filters.py}

@@ -1,5 +1,8 @@
 import huggingface_hub
 from huggingface_hub import ModelCard
+from transformers import AutoConfig
+
+from datetime import datetime, timedelta, timezone
 
 
 # ht to @Wauplin, thank you for the snippet!
@@ -24,3 +27,40 @@ def check_model_card(repo_id: str) -> tuple[bool, str]:
         return False, "Please add a description to your model card, it is too short."
 
     return True, ""
+
+
+def is_model_on_hub(model_name: str, revision: str) -> bool:
+    try:
+        AutoConfig.from_pretrained(model_name, revision=revision, trust_remote_code=False)
+        return True, None
+
+    except ValueError:
+        return (
+            False,
+            "needs to be launched with `trust_remote_code=True`. For safety reason, we do not allow these models to be automatically submitted to the leaderboard.",
+        )
+
+    except Exception:
+        return False, "was not found on hub!"
+
+
+def user_submission_permission(submission_name, users_to_submission_dates, rate_limit_period, rate_limit_quota):
+    org_or_user, _ = submission_name.split("/")
+    if org_or_user not in users_to_submission_dates:
+        return True, ""
+    submission_dates = sorted(users_to_submission_dates[org_or_user])
+
+    time_limit = (datetime.now(timezone.utc) - timedelta(days=rate_limit_period)).strftime("%Y-%m-%dT%H:%M:%SZ")
+    submissions_after_timelimit = [d for d in submission_dates if d > time_limit]
+
+    num_models_submitted_in_period = len(submissions_after_timelimit)
+    if num_models_submitted_in_period > rate_limit_quota:
+        error_msg = f"Organisation or user `{org_or_user}`"
+        error_msg += f"already has {num_models_submitted_in_period} model requests submitted to the leaderboard "
+        error_msg += f"in the last {rate_limit_period} days.\n"
+        error_msg += (
+            "Please wait a couple of days before resubmitting, so that everybody can enjoy using the leaderboard 🤗"
+        )
+        return False, error_msg
+    return True, ""
+

src/{display_models/get_model_metadata.py → get_model_info/apply_metadata_to_df.py}

@@ -6,9 +6,9 @@ from typing import List
 from huggingface_hub import HfApi
 from tqdm import tqdm
 
-from src.display_models.model_metadata_flags import DO_NOT_SUBMIT_MODELS, FLAGGED_MODELS
-from src.display_models.model_metadata_type import MODEL_TYPE_METADATA, ModelType, model_type_from_str
-from src.display_models.utils import AutoEvalColumn, model_hyperlink
+from src.get_model_info.hardocded_metadata.flags import DO_NOT_SUBMIT_MODELS, FLAGGED_MODELS
+from src.get_model_info.hardocded_metadata.types import MODEL_TYPE_METADATA, ModelType, model_type_from_str
+from src.get_model_info.utils import AutoEvalColumn, model_hyperlink
 
 api = HfApi(token=os.environ.get("H4_TOKEN", None))
 
@@ -45,10 +45,7 @@ def get_model_metadata(leaderboard_data: List[dict]):
             model_data[AutoEvalColumn.license.name] = request.get("license", "?")
             model_data[AutoEvalColumn.likes.name] = request.get("likes", 0)
             model_data[AutoEvalColumn.params.name] = request.get("params", 0)
-        except Exception as e:
-            print(f"Could not find request file for {model_data['model_name_for_query']}: {e}")
-            print(f"{request_file=}")
-            print(f"{request_files=}")
+        except Exception:
             if model_data["model_name_for_query"] in MODEL_TYPE_METADATA:
                 model_data[AutoEvalColumn.model_type.name] = MODEL_TYPE_METADATA[
                     model_data["model_name_for_query"]

src/get_model_info/get_metadata_from_hub.py

@@ -0,0 +1,19 @@
+import re
+from huggingface_hub.hf_api import ModelInfo
+
+
+def get_model_size(model_info: ModelInfo, 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:
+        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

src/load_from_hub.py

@@ -3,12 +3,11 @@ import os
 from collections import defaultdict
 
 import pandas as pd
-from transformers import AutoConfig
 
 from src.assets.hardcoded_evals import baseline, gpt4_values, gpt35_values
-from src.display_models.get_model_metadata import apply_metadata
-from src.display_models.read_results import get_eval_results_dicts, make_clickable_model
-from src.display_models.utils import AutoEvalColumn, EvalQueueColumn, has_no_nan_values
+from src.get_model_info.apply_metadata_to_df import apply_metadata
+from src.plots.read_results import get_eval_results_dicts, make_clickable_model
+from src.get_model_info.utils import AutoEvalColumn, EvalQueueColumn, has_no_nan_values
 
 IS_PUBLIC = bool(os.environ.get("IS_PUBLIC", True))
 
@@ -90,17 +89,3 @@ def get_evaluation_queue_df(save_path: str, cols: list) -> list[pd.DataFrame]:
     df_finished = pd.DataFrame.from_records(finished_list, columns=cols)
     return df_finished[cols], df_running[cols], df_pending[cols]
 
-
-def is_model_on_hub(model_name: str, revision: str) -> bool:
-    try:
-        AutoConfig.from_pretrained(model_name, revision=revision, trust_remote_code=False)
-        return True, None
-
-    except ValueError:
-        return (
-            False,
-            "needs to be launched with `trust_remote_code=True`. For safety reason, we do not allow these models to be automatically submitted to the leaderboard.",
-        )
-
-    except Exception:
-        return False, "was not found on hub!"

src/manage_collections.py

@@ -0,0 +1,75 @@
+import os
+import pandas as pd
+from pandas import DataFrame
+from huggingface_hub import get_collection, add_collection_item, update_collection_item, delete_collection_item
+from huggingface_hub.utils._errors import HfHubHTTPError
+
+from src.get_model_info.hardocded_metadata.types import ModelType
+from src.get_model_info.utils import AutoEvalColumn
+
+H4_TOKEN = os.environ.get("H4_TOKEN", None)
+
+path_to_collection = "open-llm-leaderboard/llm-leaderboard-best-models-652d6c7965a4619fb5c27a03"
+intervals = {
+    "1B": pd.Interval(0, 1.5, closed="right"),
+    "3B": pd.Interval(2.5, 3.5, closed="neither"),
+    "7B": pd.Interval(6, 8, closed="neither"),
+    "13B": pd.Interval(10, 14, closed="neither"),
+    "30B":pd.Interval(25, 35, closed="neither"), 
+    "65B": pd.Interval(60, 70, closed="neither"),
+}
+
+def update_collections(df: DataFrame):
+    """This function updates the Open LLM Leaderboard model collection with the latest best models for 
+    each size category and type.
+    """
+    collection = get_collection(collection_slug=path_to_collection, token=H4_TOKEN)
+    params_column = pd.to_numeric(df[AutoEvalColumn.params.name], errors="coerce")
+
+    cur_best_models = []
+
+    ix = 0
+    for type in ModelType:
+        if type.value.name == "": continue
+        for size in intervals:
+            # We filter the df to gather the relevant models
+            type_emoji = [t[0] for t in type.value.symbol]
+            filtered_df = df[df[AutoEvalColumn.model_type_symbol.name].isin(type_emoji)]
+
+            numeric_interval = pd.IntervalIndex([intervals[size]])
+            mask = params_column.apply(lambda x: any(numeric_interval.contains(x)))
+            filtered_df = filtered_df.loc[mask]
+
+            best_models = list(filtered_df.sort_values(AutoEvalColumn.average.name, ascending=False)[AutoEvalColumn.dummy.name])
+            print(type.value.symbol, size, best_models[:10])
+
+            # We add them one by one to the leaderboard
+            for model in best_models:
+                ix += 1
+                cur_len_collection = len(collection.items)
+                try:
+                    collection = add_collection_item(
+                        path_to_collection, 
+                        item_id=model, 
+                        item_type="model", 
+                        exists_ok=True,
+                        note=f"Best {type.to_str(' ')} model of around {size} on the leaderboard today!", 
+                        token=H4_TOKEN
+                    )
+                    if len(collection.items) > cur_len_collection: # we added an item - we make sure its position is correct
+                        item_object_id = collection.items[-1].item_object_id 
+                        update_collection_item(collection_slug=path_to_collection, item_object_id=item_object_id, position=ix)
+                        cur_len_collection = len(collection.items)
+                    cur_best_models.append(model)
+                    break
+                except HfHubHTTPError:
+                    continue
+
+    collection = get_collection(path_to_collection, token=H4_TOKEN)
+    for item in collection.items:
+        if item.item_id not in cur_best_models:
+            try:
+                delete_collection_item(collection_slug=path_to_collection, item_object_id=item.item_object_id, token=H4_TOKEN)
+            except HfHubHTTPError:
+                continue
+

src/plots/plot_results.py

@@ -0,0 +1,223 @@
+import pandas as pd
+import plotly.express as px
+from plotly.graph_objs import Figure
+import pickle
+from datetime import datetime, timezone
+from typing import List, Dict, Tuple, Any
+from src.get_model_info.hardocded_metadata.flags import FLAGGED_MODELS
+
+# Average ⬆️ human baseline is 0.897 (source: averaging human baselines below)
+# ARC human baseline is 0.80 (source: https://lab42.global/arc/)
+# HellaSwag human baseline is 0.95 (source: https://deepgram.com/learn/hellaswag-llm-benchmark-guide)
+# MMLU human baseline is 0.898 (source: https://openreview.net/forum?id=d7KBjmI3GmQ)
+# TruthfulQA human baseline is 0.94(source: https://arxiv.org/pdf/2109.07958.pdf)
+# Define the human baselines
+HUMAN_BASELINES = {
+    "Average ⬆️": 0.897 * 100,
+    "ARC": 0.80 * 100,
+    "HellaSwag": 0.95 * 100,
+    "MMLU": 0.898 * 100,
+    "TruthfulQA": 0.94 * 100,
+}
+
+
+def to_datetime(model_info: Tuple[str, Any]) -> datetime:
+    """
+    Converts the lastModified attribute of the object to datetime.
+
+    :param model_info: A tuple containing the name and object.
+                       The object must have a lastModified attribute
+                       with a string representing the date and time.
+    :return: A datetime object converted from the lastModified attribute of the input object.
+    """
+    name, obj = model_info
+    return datetime.strptime(obj.lastModified, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=timezone.utc)
+
+
+def join_model_info_with_results(results_df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Integrates model information with the results DataFrame by matching 'Model sha'.
+    :param results_df: A DataFrame containing results information including 'Model sha' column.
+    :return: A DataFrame with updated 'Results Date' columns, which are synchronized with model information.
+    """
+    # copy dataframe to avoid modifying the original
+    df = results_df.copy(deep=True)
+
+    # Filter out FLAGGED_MODELS to ensure graph is not skewed by mistakes
+    df = df[~df["model_name_for_query"].isin(FLAGGED_MODELS.keys())].reset_index(drop=True)
+
+    # load cache from disk
+    try:
+        with open("model_info_cache.pkl", "rb") as f:
+            model_info_cache = pickle.load(f)
+    except (EOFError, FileNotFoundError):
+        model_info_cache = {}
+
+    # Sort date strings using datetime objects as keys
+    sorted_dates = sorted(list(model_info_cache.items()), key=to_datetime, reverse=True)
+    df["Results Date"] = datetime.now().replace(tzinfo=timezone.utc)
+
+    # Define the date format string
+    date_format = "%Y-%m-%dT%H:%M:%S.%fZ"
+
+    # Iterate over sorted_dates and update the dataframe
+    for name, obj in sorted_dates:
+        # Convert the lastModified string to a datetime object
+        last_modified_datetime = datetime.strptime(obj.lastModified, date_format).replace(tzinfo=timezone.utc)
+
+        # Update the "Results Date" column where "Model sha" equals obj.sha
+        df.loc[df["Model sha"] == obj.sha, "Results Date"] = last_modified_datetime
+    return df
+
+
+def create_scores_df(results_df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Generates a DataFrame containing the maximum scores until each result date.
+
+    :param results_df: A DataFrame containing result information including metric scores and result dates.
+    :return: A new DataFrame containing the maximum scores until each result date for every metric.
+    """
+    # Step 1: Ensure 'Results Date' is in datetime format and sort the DataFrame by it
+    results_df["Results Date"] = pd.to_datetime(results_df["Results Date"])
+    results_df.sort_values(by="Results Date", inplace=True)
+
+    # Step 2: Initialize the scores dictionary
+    scores = {
+        "Average ⬆️": [],
+        "ARC": [],
+        "HellaSwag": [],
+        "MMLU": [],
+        "TruthfulQA": [],
+        "Result Date": [],
+        "Model Name": [],
+    }
+
+    # Step 3: Iterate over the rows of the DataFrame and update the scores dictionary
+    for i, row in results_df.iterrows():
+        date = row["Results Date"]
+        for column in scores.keys():
+            if column == "Result Date":
+                if not scores[column] or scores[column][-1] <= date:
+                    scores[column].append(date)
+                continue
+            if column == "Model Name":
+                scores[column].append(row["model_name_for_query"])
+                continue
+            current_max = scores[column][-1] if scores[column] else float("-inf")
+            scores[column].append(max(current_max, row[column]))
+
+    # Step 4: Convert the dictionary to a DataFrame
+    return pd.DataFrame(scores)
+
+
+def create_plot_df(scores_df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Transforms the scores DataFrame into a new format suitable for plotting.
+
+    :param scores_df: A DataFrame containing metric scores and result dates.
+    :return: A new DataFrame reshaped for plotting purposes.
+    """
+    # Sample columns
+    cols = ["Average ⬆️", "ARC", "HellaSwag", "MMLU", "TruthfulQA"]
+
+    # Initialize the list to store DataFrames
+    dfs = []
+
+    # Iterate over the cols and create a new DataFrame for each column
+    for col in cols:
+        d = scores_df[[col, "Model Name", "Result Date"]].copy().reset_index(drop=True)
+        d["Metric Name"] = col
+        d.rename(columns={col: "Metric Value"}, inplace=True)
+        dfs.append(d)
+
+    # Concatenate all the created DataFrames
+    concat_df = pd.concat(dfs, ignore_index=True)
+
+    # Sort values by 'Result Date'
+    concat_df.sort_values(by="Result Date", inplace=True)
+    concat_df.reset_index(drop=True, inplace=True)
+
+    # Drop duplicates based on 'Metric Name' and 'Metric Value' and keep the first (earliest) occurrence
+    concat_df.drop_duplicates(subset=["Metric Name", "Metric Value"], keep="first", inplace=True)
+
+    concat_df.reset_index(drop=True, inplace=True)
+    return concat_df
+
+
+def create_metric_plot_obj(
+    df: pd.DataFrame, metrics: List[str], human_baselines: Dict[str, float], title: str
+) -> Figure:
+    """
+    Create a Plotly figure object with lines representing different metrics
+    and horizontal dotted lines representing human baselines.
+
+    :param df: The DataFrame containing the metric values, names, and dates.
+    :param metrics: A list of strings representing the names of the metrics
+                    to be included in the plot.
+    :param human_baselines: A dictionary where keys are metric names
+                            and values are human baseline values for the metrics.
+    :param title: A string representing the title of the plot.
+    :return: A Plotly figure object with lines representing metrics and
+             horizontal dotted lines representing human baselines.
+    """
+
+    # Filter the DataFrame based on the specified metrics
+    df = df[df["Metric Name"].isin(metrics)]
+
+    # Filter the human baselines based on the specified metrics
+    filtered_human_baselines = {k: v for k, v in human_baselines.items() if k in metrics}
+
+    # Create a line figure using plotly express with specified markers and custom data
+    fig = px.line(
+        df,
+        x="Result Date",
+        y="Metric Value",
+        color="Metric Name",
+        markers=True,
+        custom_data=["Metric Name", "Metric Value", "Model Name"],
+        title=title,
+    )
+
+    # Update hovertemplate for better hover interaction experience
+    fig.update_traces(
+        hovertemplate="<br>".join(
+            [
+                "Model Name: %{customdata[2]}",
+                "Metric Name: %{customdata[0]}",
+                "Date: %{x}",
+                "Metric Value: %{y}",
+            ]
+        )
+    )
+
+    # Update the range of the y-axis
+    fig.update_layout(yaxis_range=[0, 100])
+
+    # Create a dictionary to hold the color mapping for each metric
+    metric_color_mapping = {}
+
+    # Map each metric name to its color in the figure
+    for trace in fig.data:
+        metric_color_mapping[trace.name] = trace.line.color
+
+    # Iterate over filtered human baselines and add horizontal lines to the figure
+    for metric, value in filtered_human_baselines.items():
+        color = metric_color_mapping.get(metric, "blue")  # Retrieve color from mapping; default to blue if not found
+        location = "top left" if metric == "HellaSwag" else "bottom left"  # Set annotation position
+        # Add horizontal line with matched color and positioned annotation
+        fig.add_hline(
+            y=value,
+            line_dash="dot",
+            annotation_text=f"{metric} human baseline",
+            annotation_position=location,
+            annotation_font_size=10,
+            annotation_font_color=color,
+            line_color=color,
+        )
+
+    return fig
+
+
+# Example Usage:
+# human_baselines dictionary is defined.
+# chart = create_metric_plot_obj(scores_df, ["ARC", "HellaSwag", "MMLU", "TruthfulQA"], human_baselines, "Graph Title")

src/{display_models → plots}/read_results.py

@@ -6,7 +6,7 @@ from typing import Dict, List, Tuple
 import dateutil
 import numpy as np
 
-from src.display_models.utils import AutoEvalColumn, make_clickable_model
+from src.get_model_info.utils import AutoEvalColumn, make_clickable_model
 
 METRICS = ["acc_norm", "acc_norm", "acc", "mc2"]
 BENCHMARKS = ["arc:challenge", "hellaswag", "hendrycksTest", "truthfulqa:mc"]
@@ -31,7 +31,7 @@ class EvalResult:
     date: str = ""
 
     def to_dict(self):
-        from src.load_from_hub import is_model_on_hub
+        from src.filters import is_model_on_hub
 
         if self.org is not None:
             base_model = f"{self.org}/{self.model}"

src/rate_limiting.py

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