update initial lb results

app.py

@@ -1,193 +1,335 @@
 import gradio as gr
-from gradio_leaderboard import Leaderboard, ColumnFilter, SelectColumns
 import pandas as pd
-from apscheduler.schedulers.background import BackgroundScheduler
-from huggingface_hub import snapshot_download
-
-from src.about import (
-    CITATION_BUTTON_LABEL,
-    CITATION_BUTTON_TEXT,
-    EVALUATION_QUEUE_TEXT,
-    INTRODUCTION_TEXT,
-    LLM_BENCHMARKS_TEXT,
-    TITLE,
-)
+
+from src.about import CITATION_BUTTON_LABEL, CITATION_BUTTON_TEXT, INTRODUCTION_TEXT, LLM_BENCHMARKS_TEXT, SUBMIT_TEXT, TITLE
 from src.display.css_html_js import custom_css
-from src.display.utils import (
-    BENCHMARK_COLS,
-    COLS,
-    EVAL_COLS,
-    EVAL_TYPES,
-    AutoEvalColumn,
-    ModelType,
-    fields,
-    WeightType,
-    Precision
-)
-from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN
-from src.populate import get_evaluation_queue_df, get_leaderboard_df
-from src.submission.submit import add_new_eval
-
-
-def restart_space():
-    API.restart_space(repo_id=REPO_ID)
-
-### Space initialisation
-try:
-    print(EVAL_REQUESTS_PATH)
-    snapshot_download(
-        repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
-    )
-except Exception:
-    restart_space()
-try:
-    print(EVAL_RESULTS_PATH)
-    snapshot_download(
-        repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
-    )
-except Exception:
-    restart_space()
-
-
-LEADERBOARD_DF = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS)
-
-(
-    finished_eval_queue_df,
-    running_eval_queue_df,
-    pending_eval_queue_df,
-) = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
-
-def init_leaderboard(dataframe):
-    if dataframe is None or dataframe.empty:
-        raise ValueError("Leaderboard DataFrame is empty or None.")
-    return Leaderboard(
-        value=dataframe,
-        datatype=[c.type for c in fields(AutoEvalColumn)],
-        select_columns=SelectColumns(
-            default_selection=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default],
-            cant_deselect=[c.name for c in fields(AutoEvalColumn) if c.never_hidden],
-            label="Select Columns to Display:",
-        ),
-        search_columns=[AutoEvalColumn.model.name, AutoEvalColumn.license.name],
-        hide_columns=[c.name for c in fields(AutoEvalColumn) if c.hidden],
-        filter_columns=[
-            ColumnFilter(AutoEvalColumn.model_type.name, type="checkboxgroup", label="Model types"),
-            ColumnFilter(AutoEvalColumn.precision.name, type="checkboxgroup", label="Precision"),
-            ColumnFilter(
-                AutoEvalColumn.params.name,
-                type="slider",
-                min=0.01,
-                max=150,
-                label="Select the number of parameters (B)",
-            ),
-            ColumnFilter(
-                AutoEvalColumn.still_on_hub.name, type="boolean", label="Deleted/incomplete", default=True
-            ),
-        ],
-        bool_checkboxgroup_label="Hide models",
-        interactive=False,
+from src.display.utils import COLS, TYPES, AutoEvalColumn, fields
+from src.envs import CRM_RESULTS_PATH
+from src.populate import get_leaderboard_df_crm
+
+original_df = get_leaderboard_df_crm(CRM_RESULTS_PATH, COLS)
+
+leaderboard_df = original_df.copy()
+# leaderboard_df = leaderboard_df.style.format({"accuracy_metric_average": "{0:.2f}"})
+
+
+# Searching and filtering
+def update_table(
+    hidden_df: pd.DataFrame,
+    columns: list,
+    framework_query: list
+    # llm_query: list,
+    # llm_provider_query: list,
+    # accuracy_method_query: str,
+    # accuracy_threshold_query: str,
+    # use_case_area_query: list,
+    # use_case_query: list,
+    # use_case_type_query: list,
+    # metric_area_query: list,
+):
+    filtered_df = filter_framework_func(hidden_df, framework_query)
+    # filtered_df = filter_llm_func(hidden_df, llm_query)
+    
+    # filtered_df = filter_llm_provider_func(filtered_df, llm_provider_query)
+    # filtered_df = filter_accuracy_method_func(filtered_df, accuracy_method_query)
+    # filtered_df["Accuracy Threshold"] = filter_accuracy_threshold_func(filtered_df, accuracy_threshold_query)
+    # filtered_df = filtered_df[filtered_df["Accuracy Threshold"]]
+    # filtered_df["Use Case Area"] = filtered_df["Use Case Name"].apply(lambda x: x.split(": ")[0])
+    # filtered_df = filter_use_case_area_func(filtered_df, use_case_area_query)
+    # filtered_df = filter_use_case_func(filtered_df, use_case_query)
+    # filtered_df = filter_use_case_type_func(filtered_df, use_case_type_query)
+    # Filtering by metric area
+    # metric_area_maps = {
+    #     "Cost": ["Cost Band"],
+    #     "Accuracy": ["Accuracy", "Instruction Following", "Conciseness", "Completeness", "Factuality"],
+    #     "Speed (Latency)": ["Response Time (Sec)", "Mean Output Tokens"],
+    #     "Trust & Safety": ["Trust & Safety", "Safety", "Privacy", "Truthfulness", "CRM Fairness"],
+    # }
+    # all_metric_cols = []
+    # for area in metric_area_maps:
+    #     all_metric_cols = all_metric_cols + metric_area_maps[area]
+
+    # columns_to_keep = list(set(columns).difference(set(all_metric_cols)))
+    # for area in metric_area_query:
+    #     columns_to_keep = columns_to_keep + metric_area_maps[area]
+    # columns = list(set(columns).intersection(set(columns_to_keep)))
+    
+    df = select_columns(filtered_df, columns)
+    
+    
+
+    return df.style.map(highlight_cost_band_low, props="background-color: #b3d5a4")
+
+
+# def highlight_cols(x):
+#     df = x.copy()
+#     df.loc[:, :] = "color: black"
+#     df.loc[, ["Accuracy"]] = "background-color: #b3d5a4"
+#     return df
+
+
+def highlight_cost_band_low(s, props=""):
+
+    return props if s == "Low" else None
+
+
+def init_leaderboard_df(
+    leaderboard_df: pd.DataFrame,
+    columns: list,
+    llm_query: list,
+    # llm_provider_query: list,
+    # accuracy_method_query: str,
+    # accuracy_threshold_query: str,
+    # use_case_area_query: list,
+    # use_case_query: list,
+    # use_case_type_query: list,
+    # metric_area_query: list,
+):
+
+    # Applying the style function
+    # return df.style.apply(highlight_cols, axis=None)
+    return update_table(
+        leaderboard_df,
+        columns,
+        llm_query,
+        # llm_provider_query,
+        # accuracy_method_query,
+        # accuracy_threshold_query,
+        # use_case_area_query,
+        # use_case_query,
+        # use_case_type_query,
+        # metric_area_query,
     )
 
 
+def filter_accuracy_method_func(df: pd.DataFrame, accuracy_method_query: str) -> pd.DataFrame:
+    return df[df["Accuracy Method"] == accuracy_method_query]
+
+
+def filter_accuracy_threshold_func(df: pd.DataFrame, accuracy_threshold_query: str) -> pd.DataFrame:
+    accuracy_cols = ["Instruction Following", "Conciseness", "Completeness", "Accuracy"]
+    return (df.loc[:, accuracy_cols] >= float(accuracy_threshold_query)).all(axis=1)
+
+
+def filter_use_case_area_func(df: pd.DataFrame, use_case_area_query: list) -> pd.DataFrame:
+    return df[
+        df["Use Case Area"].apply(
+            lambda x: len(set([_.strip() for _ in x.split("&")]).intersection(use_case_area_query))
+        )
+        > 0
+    ]
+
+
+def filter_use_case_func(df: pd.DataFrame, use_case_query: list) -> pd.DataFrame:
+    return df[df["Use Case Name"].isin(use_case_query)]
+
+
+def filter_use_case_type_func(df: pd.DataFrame, use_case_type_query: list) -> pd.DataFrame:
+    return df[df["Use Case Type"].isin(use_case_type_query)]
+
+
+def filter_llm_func(df: pd.DataFrame, llm_query: list) -> pd.DataFrame:
+    return df[df["Model"].isin(llm_query)]
+
+def filter_framework_func(df: pd.DataFrame, framework_query: list) -> pd.DataFrame:
+    return df[df["Agentic Framework"].isin(framework_query)]
+
+def filter_llm_provider_func(df: pd.DataFrame, llm_provider_query: list) -> pd.DataFrame:
+    return df[df["LLM Provider"].isin(llm_provider_query)]
+
+
+def select_columns(df: pd.DataFrame, columns: list) -> pd.DataFrame:
+    # always_here_cols = [
+    #     AutoEvalColumn.model.name,
+    # ]
+    # model_provider_col = [AutoEvalColumn.model_provider.name] if AutoEvalColumn.model_provider.name in columns else []
+    # We use COLS to maintain sortingx
+    
+    filtered_df = df[
+        (
+            [AutoEvalColumn.model.name]
+            # + model_provider_col
+            + [AutoEvalColumn.agentic_framework.name]
+            + [c for c in COLS if c in df.columns and c in columns ]
+            + [AutoEvalColumn.overall.name]
+        )
+    ]
+    
+    return filtered_df
+
+
 demo = gr.Blocks(css=custom_css)
 with demo:
     gr.HTML(TITLE)
     gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
 
     with gr.Tabs(elem_classes="tab-buttons") as tabs:
-        with gr.TabItem("🏅 LLM Benchmark", elem_id="llm-benchmark-tab-table", id=0):
-            leaderboard = init_leaderboard(LEADERBOARD_DF)
-
-        with gr.TabItem("📝 About", elem_id="llm-benchmark-tab-table", id=2):
-            gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
-
-        with gr.TabItem("🚀 Submit here! ", elem_id="llm-benchmark-tab-table", id=3):
-            with gr.Column():
-                with gr.Row():
-                    gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")
-
-                with gr.Column():
-                    with gr.Accordion(
-                        f"✅ Finished Evaluations ({len(finished_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            finished_eval_table = gr.components.Dataframe(
-                                value=finished_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                            )
-                    with gr.Accordion(
-                        f"🔄 Running Evaluation Queue ({len(running_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            running_eval_table = gr.components.Dataframe(
-                                value=running_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                            )
-
-                    with gr.Accordion(
-                        f"⏳ Pending Evaluation Queue ({len(pending_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            pending_eval_table = gr.components.Dataframe(
-                                value=pending_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                            )
-            with gr.Row():
-                gr.Markdown("# ✉️✨ Submit your model here!", elem_classes="markdown-text")
-
+        with gr.TabItem("🏅 CRMArena Benchmark", elem_id="llm-benchmark-tab-table", id=0):
+            
             with gr.Row():
                 with gr.Column():
-                    model_name_textbox = gr.Textbox(label="Model name")
-                    revision_name_textbox = gr.Textbox(label="Revision commit", placeholder="main")
-                    model_type = gr.Dropdown(
-                        choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
-                        label="Model type",
-                        multiselect=False,
-                        value=None,
+                    filter_agentic_framework = gr.CheckboxGroup(
+                        choices=list(original_df["Agentic Framework"].unique()),
+                        value=list(original_df["Agentic Framework"].unique()),
+                        label="Agentic Framework",
+                        info="",
                         interactive=True,
                     )
+                    
+            with gr.Row():
+                shown_columns = gr.CheckboxGroup(
+                    choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden],
+                    value=[
+                        c.name
+                        for c in fields(AutoEvalColumn)
+                        if c.displayed_by_default and not c.hidden and not c.never_hidden
+                    ],
+                    label="Select tasks to show",
+                    elem_id="column-select",
+                    interactive=True,
+                )
+            
+                # with gr.Column():
+                #     filter_llm = gr.CheckboxGroup(
+                #         choices=list(original_df["Model"].unique()),
+                #         value=list(original_df["Model"].unique()),
+                #         label="Model",
+                #         info="",
+                #         interactive=True,
+                #     )
+                # with gr.Column():
+                #     with gr.Row():
+                #         filter_llm_provider = gr.CheckboxGroup(
+                #             choices=list(original_df["LLM Provider"].unique()),
+                #             value=list(original_df["LLM Provider"].unique()),
+                #             label="LLM Provider",
+                #             info="",
+                #             interactive=True,
+                #         )
+                #     with gr.Row():
+                #         filter_metric_area = gr.CheckboxGroup(
+                #             choices=["Accuracy", "Speed (Latency)", "Trust & Safety", "Cost"],
+                #             value=["Accuracy", "Speed (Latency)", "Trust & Safety", "Cost"],
+                #             label="Metric Area",
+                #             info="",
+                #             interactive=True,
+                #         )
+            # with gr.Row():
+            #     filter_use_case = gr.CheckboxGroup(
+            #         choices=list(original_df["Use Case Name"].unique()),
+            #         value=list(original_df["Use Case Name"].unique()),
+            #         label="Use Case",
+            #         info="",
+            #         # multiselect=True,
+            #         interactive=True,
+            #     )
+            # with gr.Row():
+            #     with gr.Column():
+            #         filter_use_case_area = gr.CheckboxGroup(
+            #             choices=["Service", "Sales"],
+            #             value=["Service", "Sales"],
+            #             label="Use Case Area",
+            #             info="",
+            #             interactive=True,
+            #         )
+            #     with gr.Column():
+            #         filter_use_case_type = gr.CheckboxGroup(
+            #             choices=["Summary", "Generation"],
+            #             value=["Summary", "Generation"],
+            #             label="Use Case Type",
+            #             info="",
+            #             interactive=True,
+            #         )
+                # with gr.Column():
+                #     filter_use_case = gr.Dropdown(
+                #         choices=list(original_df["Use Case Name"].unique()),
+                #         value=list(original_df["Use Case Name"].unique()),
+                #         label="Use Case",
+                #         info="",
+                #         multiselect=True,
+                #         interactive=True,
+                #     )
+                # with gr.Column():
+                #     filter_accuracy_method = gr.Radio(
+                #         choices=["Manual", "Auto"],
+                #         value="Manual",
+                #         label="Accuracy Method",
+                #         info="",
+                #         interactive=True,
+                #     )
+                # with gr.Column():
+                #     filter_accuracy_threshold = gr.Number(
+                #         value="0",
+                #         label="Accuracy Threshold",
+                #         info="Range: 0.0 to 4.0",
+                #         interactive=True,
+                #     )
 
-                with gr.Column():
-                    precision = gr.Dropdown(
-                        choices=[i.value.name for i in Precision if i != Precision.Unknown],
-                        label="Precision",
-                        multiselect=False,
-                        value="float16",
-                        interactive=True,
-                    )
-                    weight_type = gr.Dropdown(
-                        choices=[i.value.name for i in WeightType],
-                        label="Weights type",
-                        multiselect=False,
-                        value="Original",
-                        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()
-            submit_button.click(
-                add_new_eval,
-                [
-                    model_name_textbox,
-                    base_model_name_textbox,
-                    revision_name_textbox,
-                    precision,
-                    weight_type,
-                    model_type,
-                ],
-                submission_result,
+            leaderboard_table = gr.components.Dataframe(
+                # value=leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
+                value=init_leaderboard_df(
+                    leaderboard_df,
+                    shown_columns.value,
+                    filter_agentic_framework.value
+                    # filter_llm.value,
+                    # filter_llm_provider.value,
+                    # filter_accuracy_method.value,
+                    # filter_accuracy_threshold.value,
+                    # filter_use_case_area.value,
+                    # filter_use_case.value,
+                    # filter_use_case_type.value,
+                    # filter_metric_area.value,
+                ),
+                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,
             )
 
+            # Dummy leaderboard for handling the case when the user uses backspace key
+            hidden_leaderboard_table_for_search = gr.components.Dataframe(
+                value=original_df[COLS],
+                headers=COLS,
+                datatype=TYPES,
+                visible=False,
+            )
+            for selector in [
+                shown_columns,
+                filter_agentic_framework
+                # filter_llm,
+                # filter_llm_provider,
+                # filter_accuracy_method,
+                # filter_accuracy_threshold,
+                # filter_use_case_area,
+                # filter_use_case,
+                # filter_use_case_type,
+                # filter_metric_area,
+            ]:
+                selector.change(
+                    update_table,
+                    [
+                        hidden_leaderboard_table_for_search,
+                        shown_columns,
+                        filter_agentic_framework,
+                        # filter_llm,
+                        # filter_llm_provider,
+                        # filter_accuracy_method,
+                        # filter_accuracy_threshold,
+                        # filter_use_case_area,
+                        # filter_use_case,
+                        # filter_use_case_type,
+                        # filter_metric_area,
+                    ],
+                    leaderboard_table,
+                    queue=True,
+                )
+        with gr.TabItem("📝 About", elem_id="llm-benchmark-tab-table", id=3):
+            gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
+            
+        with gr.TabItem("🚀 Submit", elem_id="llm-benchmark-tab-table", id=4):
+            gr.Markdown(SUBMIT_TEXT, elem_classes="markdown-text")
+
     with gr.Row():
         with gr.Accordion("📙 Citation", open=False):
             citation_button = gr.Textbox(
@@ -198,7 +340,7 @@ with demo:
                 show_copy_button=True,
             )
 
-scheduler = BackgroundScheduler()
-scheduler.add_job(restart_space, "interval", seconds=1800)
-scheduler.start()
-demo.queue(default_concurrency_limit=40).launch()
+# scheduler = BackgroundScheduler()
+# scheduler.add_job(restart_space, "interval", seconds=1800)
+# scheduler.start()
+demo.queue(default_concurrency_limit=40).launch()

crmarena_results/all_results.csv

@@ -0,0 +1,19 @@
+,Model,Agentic Framework,NCR,HTU,TCU,NED,PVI,KQA,TII,MTA,BRI,Overall ⬆️
+0,gpt-4o,Act,43.1,10.0,17.7,30.8,28.5,29.3,68.5,29.2,7.7,29.4
+1,gpt-4o-mini,Act,0.8,38.5,23.8,9.2,0.0,43.1,26.9,3.8,3.8,16.7
+2,claude-3.5-sonnet,Act,78.5,24.6,15.4,51.5,28.5,44.7,45.4,20.8,26.9,37.4
+3,claude-3-sonnet,Act,9.2,26.9,24.6,30.8,23.8,16.6,16.2,1.5,0.0,16.6
+4,llama3.1-405b,Act,46.2,17.7,17.7,13.9,30.0,47.0,15.4,5.4,6.9,22.2
+5,llama3.1-70b,Act,28.5,20.0,24.6,6.2,30.0,47.9,8.5,0.0,1.5,18.6
+6,gpt-4o,ReAct,70.0,39.2,22.3,30.8,35.4,50.2,64.6,20.9,10.8,38.2
+7,gpt-4o-mini,ReAct,40.8,36.9,25.4,31.5,24.6,52.8,30.0,6.2,6.2,28.3
+8,claude-3.5-sonnet,ReAct,62.9,20.0,11.5,52.3,30.0,45.0,43.9,20.8,21.5,34.3
+9,claude-3-sonnet,ReAct,7.7,24.6,26.9,29.2,28.5,16.0,22.3,0.8,0.0,17.3
+10,llama3.1-405b,ReAct,81.5,22.3,15.4,33.9,34.6,55.3,34.6,13.9,13.1,33.8
+11,llama3.1-70b,ReAct,48.5,20.0,13.9,33.1,37.7,48.7,23.9,13.9,10.8,27.8
+12,gpt-4o,Function Calling,60.0,47.7,81.5,46.2,39.2,30.4,97.7,27.7,59.2,54.4
+13,gpt-4o-mini,Function Calling,0.8,10.8,10.8,17.7,13.8,39.7,60.0,0.0,21.5,19.5
+14,claude-3.5-sonnet,Function Calling,4.6,33.1,82.3,52.3,30.0,40.5,69.2,26.9,36.9,41.8
+15,claude-3-sonnet,Function Calling,0.8,1.5,30.0,25.4,41.5,23.2,12.3,1.5,0.0,15.1
+16,llama3.1-405b,Function Calling,16.2,31.5,64.6,50.0,26.9,47.6,95.4,86.9,42.3,51.3
+17,llama3.1-70b,Function Calling,1.5,23.1,44.6,53.8,37.4,42.4,93.8,43.8,29.2,41.1

src/about.py

@@ -1,72 +1,40 @@
-from dataclasses import dataclass
-from enum import Enum
-
-@dataclass
-class Task:
-    benchmark: str
-    metric: str
-    col_name: str
-
-
-# Select your tasks here
-# ---------------------------------------------------
-class Tasks(Enum):
-    # task_key in the json file, metric_key in the json file, name to display in the leaderboard 
-    task0 = Task("anli_r1", "acc", "ANLI")
-    task1 = Task("logiqa", "acc_norm", "LogiQA")
-
-NUM_FEWSHOT = 0 # Change with your few shot
-# ---------------------------------------------------
-
-
-
 # Your leaderboard name
-TITLE = """<h1 align="center" id="space-title">Demo leaderboard</h1>"""
+TITLE = """<h1 align="center" id="space-title">CRMArena Leaderboard</h1>
+CRMArena is a novel benchmark designed to assess LLM agents on realistic customer service tasks within professional environments. By working with CRM experts, CRMArena offers nine challenging tasks across three personas—service agent, analyst, and manager—populated within a simulated organization using 16 interrelated industrial objects. This benchmark invites the community to improve AI agent capabilities in function-calling and work task understanding, demonstrating tangible business value in a realistic Salesforce Org.
+"""
 
 # What does your leaderboard evaluate?
 INTRODUCTION_TEXT = """
-Intro text
-"""
-
-# Which evaluations are you running? how can people reproduce what you have?
-LLM_BENCHMARKS_TEXT = f"""
-## How it works
-
-## Reproducibility
-To reproduce our results, here is the commands you can run:
 
 """
 
-EVALUATION_QUEUE_TEXT = """
-## Some good practices before submitting a model
-
-### 1) Make sure you can load your model and tokenizer using AutoClasses:
-```python
-from transformers import AutoConfig, AutoModel, AutoTokenizer
-config = AutoConfig.from_pretrained("your model name", revision=revision)
-model = AutoModel.from_pretrained("your model name", revision=revision)
-tokenizer = AutoTokenizer.from_pretrained("your model name", revision=revision)
-```
-If this step fails, follow the error messages to debug your model before submitting it. It's likely your model has been improperly uploaded.
-
-Note: make sure your model is public!
-Note: if your model needs `use_remote_code=True`, we do not support this option yet but we are working on adding it, stay posted!
-
-### 2) Convert your model weights to [safetensors](https://huggingface.co/docs/safetensors/index)
-It's a new format for storing weights which is safer and faster to load and use. It will also allow us to add the number of parameters of your model to the `Extended Viewer`!
-
-### 3) Make sure your model has an open license!
-This is a leaderboard for Open LLMs, and we'd love for as many people as possible to know they can use your model 🤗
-
-### 4) Fill up your model card
-When we add extra information about models to the leaderboard, it will be automatically taken from the model card
+LLM_BENCHMARKS_TEXT = """
+### Overview
+Customer Relationship Management (CRM) systems are vital for modern enterprises, providing a foundation for managing customer interactions and data. Integrating AI agents into CRM systems can automate routine processes and enhance personalized service. However, deploying and evaluating these agents is challenging due to the lack of realistic benchmarks that reflect the complexity of real-world CRM tasks. To address this issue, we introduce CRMArena, a novel benchmark designed to evaluate AI agents on realistic tasks grounded in professional work environments. We worked with CRM experts to design nine customer service tasks distributed across three personas: service agent, analyst, and manager. We synthesize a large-scale simulated organization, populating 16 commonly-used industrial objects (e.g., account, order, knowledge article, case) with high interconnectivity, and upload it into a real Salesforce CRM organization. UI and API access to the CRM is provided to systems that attempt to complete the tasks in CRMArena. Experimental results reveal that state-of-the-art LLM agents succeed in less than 40% of the tasks with ReAct prompting and less than 55% even when provided manually-crafted function-calling tools. Our findings highlight the need for enhanced agent capabilities in function-calling and rule-following to be deployed in real-world work environments. CRMArena is an open challenge to the community: systems that can reliably complete tasks showcase direct business value in a popular work environment.
+### Task Definitions
+
+| Task                               | Description                                                                                                                                                                                                                   |
+|------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **New Case Routing (NCR)**         | Assign the best human agent to an incoming case based on case subject and description to optimize performance metrics. Involves matching cases to agents using case histories, skills, and availability.                      |
+| **Handle Time Understanding (HTU)**| Identify the agent with the shortest/longest average handle time based on case history data, evaluating the LLM agent's ability to analyze performance data accurately.                                                      |
+| **Transfer Count Understanding (TCU)** | Determine which human agent transferred cases the least/most over a given period, assessing the LLM agent's capacity to analyze transfer performance accurately.                                                             |
+| **Name Entity Disambiguation (NED)** | Disambiguate named entities related to customer transactions, focusing on product names. Identify specific orders corresponding to product names within a given timeframe.                                                 |
+| **Policy Violation Identification (PVI)** | Determine if company policies have been breached in a case involving customer-agent interaction by comparing case details against policy rules in knowledge articles.                                                          |
+| **Knowledge Question Answering (KQA)** | Answer specific questions based on knowledge articles, demonstrating the LLM agent's ability to retrieve accurate and relevant information from a CRM knowledge repository.                                                     |
+| **Top Issue Identification (TII)** | Identify the most reported issue for a particular product based on case history, assessing the ability to analyze issue reports for trend analysis.                                                                           |
+| **Monthly Trend Analysis (MTA)**   | Determine which months have the highest number of cases for a given product and timeframe, demonstrating the LLM agent's ability to recognize trends and patterns over time.                                                |
+| **Best Region Identification (BRI)** | Identify the regions where cases are closed the fastest by analyzing case closure times across various regions to indicate top-performing regions.                                                                             |
+"""
 
-## In case of model failure
-If your model is displayed in the `FAILED` category, its execution stopped.
-Make sure you have followed the above steps first.
-If everything is done, check you can launch the EleutherAIHarness on your model locally, using the above command without modifications (you can add `--limit` to limit the number of examples per task).
+SUBMIT_TEXT= """
+To submit your results to CRMArena leaderboard, please send your outputs to us at kh.huang@salesforce.com.
 """
 
-CITATION_BUTTON_LABEL = "Copy the following snippet to cite these results"
+CITATION_BUTTON_LABEL = "If you find our work helpful, please consider citing our paper!"
 CITATION_BUTTON_TEXT = r"""
+@misc{huang-2024-crmarena,
+  title={CRMArena: Understanding the Capacity of LLM Agents to Perform Professional CRM Tasks in Realistic Environments},
+  author={Huang, Kung-Hsiang and Prabhakar, Akshara and Dhawan, Sidharth and Mao, Yixin and Wang, Huan and Savarese, Silvio and Xiong, Caiming and Laban, Philippe and Wu, Chien-Sheng},
+  year = {2024},
+}
 """

src/display/css_html_js.py

@@ -33,7 +33,7 @@ custom_css = """
     background: none;
     border: none;
 }
- 
+
 #search-bar {
     padding: 0px;
 }
@@ -77,7 +77,7 @@ table th:first-child {
 #filter_type label > .wrap{
     width: 103px;
 }
-#filter_type label > .wrap .wrap-inner{  
+#filter_type label > .wrap .wrap-inner{
     padding: 2px;
 }
 #filter_type label > .wrap .wrap-inner input{

src/display/utils.py

@@ -1,9 +1,7 @@
 from dataclasses import dataclass, make_dataclass
-from enum import Enum
 
 import pandas as pd
 
-from src.about import Tasks
 
 def fields(raw_class):
     return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
@@ -20,91 +18,94 @@ class ColumnContent:
     hidden: bool = False
     never_hidden: bool = False
 
+
 ## Leaderboard columns
+
+
 auto_eval_column_dict = []
+
+# 'Model', 'NCR', 'HTU', 'TCU', 'NED', 'PVI', 'KQA', 'TII', 'MTA', 'BRI', 'Overall', 'Agentic Framework']
 # Init
-auto_eval_column_dict.append(["model_type_symbol", ColumnContent, ColumnContent("T", "str", True, never_hidden=True)])
-auto_eval_column_dict.append(["model", ColumnContent, ColumnContent("Model", "markdown", True, never_hidden=True)])
-#Scores
-auto_eval_column_dict.append(["average", ColumnContent, ColumnContent("Average ⬆️", "number", True)])
-for task in Tasks:
-    auto_eval_column_dict.append([task.name, ColumnContent, ColumnContent(task.value.col_name, "number", True)])
-# Model information
-auto_eval_column_dict.append(["model_type", ColumnContent, ColumnContent("Type", "str", False)])
-auto_eval_column_dict.append(["architecture", ColumnContent, ColumnContent("Architecture", "str", False)])
-auto_eval_column_dict.append(["weight_type", ColumnContent, ColumnContent("Weight type", "str", False, True)])
-auto_eval_column_dict.append(["precision", ColumnContent, ColumnContent("Precision", "str", False)])
-auto_eval_column_dict.append(["license", ColumnContent, ColumnContent("Hub License", "str", False)])
-auto_eval_column_dict.append(["params", ColumnContent, ColumnContent("#Params (B)", "number", False)])
-auto_eval_column_dict.append(["likes", ColumnContent, ColumnContent("Hub ❤️", "number", False)])
-auto_eval_column_dict.append(["still_on_hub", ColumnContent, ColumnContent("Available on the hub", "bool", False)])
-auto_eval_column_dict.append(["revision", ColumnContent, ColumnContent("Model sha", "str", False, False)])
-
-# We use make dataclass to dynamically fill the scores from Tasks
-AutoEvalColumn = make_dataclass("AutoEvalColumn", auto_eval_column_dict, frozen=True)
-
-## For the queue columns in the submission tab
-@dataclass(frozen=True)
-class EvalQueueColumn:  # Queue column
-    model = ColumnContent("model", "markdown", True)
-    revision = ColumnContent("revision", "str", True)
-    private = ColumnContent("private", "bool", True)
-    precision = ColumnContent("precision", "str", True)
-    weight_type = ColumnContent("weight_type", "str", "Original")
-    status = ColumnContent("status", "str", True)
-
-## All the model information that we might need
-@dataclass
-class ModelDetails:
-    name: str
-    display_name: str = ""
-    symbol: str = "" # emoji
-
-
-class ModelType(Enum):
-    PT = ModelDetails(name="pretrained", symbol="🟢")
-    FT = ModelDetails(name="fine-tuned", symbol="🔶")
-    IFT = ModelDetails(name="instruction-tuned", symbol="⭕")
-    RL = ModelDetails(name="RL-tuned", symbol="🟦")
-    Unknown = ModelDetails(name="", symbol="?")
-
-    def to_str(self, separator=" "):
-        return f"{self.value.symbol}{separator}{self.value.name}"
-
-    @staticmethod
-    def from_str(type):
-        if "fine-tuned" in type or "🔶" in type:
-            return ModelType.FT
-        if "pretrained" in type or "🟢" in type:
-            return ModelType.PT
-        if "RL-tuned" in type or "🟦" in type:
-            return ModelType.RL
-        if "instruction-tuned" in type or "⭕" in type:
-            return ModelType.IFT
-        return ModelType.Unknown
-
-class WeightType(Enum):
-    Adapter = ModelDetails("Adapter")
-    Original = ModelDetails("Original")
-    Delta = ModelDetails("Delta")
-
-class Precision(Enum):
-    float16 = ModelDetails("float16")
-    bfloat16 = ModelDetails("bfloat16")
-    Unknown = ModelDetails("?")
-
-    def from_str(precision):
-        if precision in ["torch.float16", "float16"]:
-            return Precision.float16
-        if precision in ["torch.bfloat16", "bfloat16"]:
-            return Precision.bfloat16
-        return Precision.Unknown
+auto_eval_column_dict.append(
+    ["model", ColumnContent, ColumnContent("Model", "markdown", True, never_hidden=True)]
+)
 
-# Column selection
-COLS = [c.name for c in fields(AutoEvalColumn) if not c.hidden]
+# Agentic Framework
+auto_eval_column_dict.append(
+    ["agentic_framework", ColumnContent, ColumnContent("Agentic Framework", "markdown", True, never_hidden=True)]
+)
+
+# NCR
+auto_eval_column_dict.append(
+    ["ncr", ColumnContent, ColumnContent("NCR", "markdown", True)]
+)
+
+# HTU
+auto_eval_column_dict.append(
+    ["htu", ColumnContent, ColumnContent("HTU", "markdown", True)]
+)
+
+# TCU 
+auto_eval_column_dict.append(
+    ["tcu", ColumnContent, ColumnContent("TCU", "markdown", True)]
+)
 
-EVAL_COLS = [c.name for c in fields(EvalQueueColumn)]
-EVAL_TYPES = [c.type for c in fields(EvalQueueColumn)]
+# NED
+auto_eval_column_dict.append(
+    ["ned", ColumnContent, ColumnContent("NED", "markdown", True)]
+)
 
-BENCHMARK_COLS = [t.value.col_name for t in Tasks]
+# PVI
+auto_eval_column_dict.append(
+    ["pvi", ColumnContent, ColumnContent("PVI", "markdown", True)]
+)
 
+# KQA
+auto_eval_column_dict.append(
+    ["kqa", ColumnContent, ColumnContent("KQA", "markdown", True)]
+)
+
+# TII
+auto_eval_column_dict.append(
+    ["tii", ColumnContent, ColumnContent("TII", "markdown", True)]
+)
+
+# MTA
+auto_eval_column_dict.append(
+    ["mta", ColumnContent, ColumnContent("MTA", "markdown", True)]
+)
+
+# BRI
+auto_eval_column_dict.append(
+    ["bri", ColumnContent, ColumnContent("BRI", "markdown", True)]
+)
+
+# Overall
+auto_eval_column_dict.append(
+    ["overall", ColumnContent, ColumnContent("Overall ⬆️", "markdown", True, never_hidden=True)]
+)
+
+
+
+# Create AutoEvalColumn class
+AutoEvalColumn = make_dataclass("AutoEvalColumn", auto_eval_column_dict)
+
+
+# Column selection
+COLS = [c.name for c in fields(AutoEvalColumn) if not c.hidden]
+TYPES = [c.type for c in fields(AutoEvalColumn) if not c.hidden]
+COLS_LITE = [c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden]
+TYPES_LITE = [c.type for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden]
+
+# BENCHMARK_COLS = [t.value.col_name for t in Tasks]
+
+NUMERIC_INTERVALS = {
+    "?": pd.Interval(-1, 0, closed="right"),
+    "~1.5": pd.Interval(0, 2, closed="right"),
+    "~3": pd.Interval(2, 4, closed="right"),
+    "~7": pd.Interval(4, 9, closed="right"),
+    "~13": pd.Interval(9, 20, closed="right"),
+    "~35": pd.Interval(20, 45, closed="right"),
+    "~60": pd.Interval(45, 70, closed="right"),
+    "70+": pd.Interval(70, 10000, closed="right"),
+}

src/envs.py

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

src/leaderboard/read_evals.py

@@ -1,6 +1,5 @@
 import glob
 import json
-import math
 import os
 from dataclasses import dataclass
 
@@ -8,28 +7,29 @@ import dateutil
 import numpy as np
 
 from src.display.formatting import make_clickable_model
-from src.display.utils import AutoEvalColumn, ModelType, Tasks, Precision, WeightType
-from src.submission.check_validity import is_model_on_hub
+from src.display.utils import AutoEvalColumn, ModelType, Precision, Tasks, WeightType
+
+# from src.submission.check_validity import is_model_on_hub
 
 
 @dataclass
 class EvalResult:
-    """Represents one full evaluation. Built from a combination of the result and request file for a given run.
-    """
-    eval_name: str # org_model_precision (uid)
-    full_model: str # org/model (path on hub)
-    org: str 
+    """Represents one full evaluation. Built from a combination of the result and request file for a given run."""
+
+    eval_name: str  # org_model_precision (uid)
+    full_model: str  # org/model (path on hub)
+    org: str
     model: str
-    revision: str # commit hash, "" if main
+    revision: str  # commit hash, "" if main
     results: dict
     precision: Precision = Precision.Unknown
-    model_type: ModelType = ModelType.Unknown # Pretrained, fine tuned, ...
-    weight_type: WeightType = WeightType.Original # Original or Adapter
-    architecture: str = "Unknown" 
+    model_type: ModelType = ModelType.Unknown  # Pretrained, fine tuned, ...
+    weight_type: WeightType = WeightType.Original  # Original or Adapter
+    architecture: str = "Unknown"
     license: str = "?"
     likes: int = 0
     num_params: int = 0
-    date: str = "" # submission date of request file
+    date: str = ""  # submission date of request file
     still_on_hub: bool = False
 
     @classmethod
@@ -57,14 +57,14 @@ class EvalResult:
             result_key = f"{org}_{model}_{precision.value.name}"
         full_model = "/".join(org_and_model)
 
-        still_on_hub, _, model_config = is_model_on_hub(
-            full_model, config.get("model_sha", "main"), trust_remote_code=True, test_tokenizer=False
-        )
+        # still_on_hub, _, model_config = is_model_on_hub(
+        #     full_model, config.get("model_sha", "main"), trust_remote_code=True, test_tokenizer=False
+        # )
         architecture = "?"
-        if model_config is not None:
-            architectures = getattr(model_config, "architectures", None)
-            if architectures:
-                architecture = ";".join(architectures)
+        # if model_config is not None:
+        #     architectures = getattr(model_config, "architectures", None)
+        #     if architectures:
+        #         architecture = ";".join(architectures)
 
         # Extract results available in this file (some results are split in several files)
         results = {}
@@ -85,10 +85,10 @@ class EvalResult:
             org=org,
             model=model,
             results=results,
-            precision=precision,  
-            revision= config.get("model_sha", ""),
-            still_on_hub=still_on_hub,
-            architecture=architecture
+            precision=precision,
+            revision=config.get("model_sha", ""),
+            still_on_hub=False,
+            architecture=architecture,
         )
 
     def update_with_request_file(self, requests_path):
@@ -105,7 +105,9 @@ class EvalResult:
             self.num_params = request.get("params", 0)
             self.date = request.get("submitted_time", "")
         except Exception:
-            print(f"Could not find request file for {self.org}/{self.model} with precision {self.precision.value.name}")
+            print(
+                f"Could not find request file for {self.org}/{self.model} with precision {self.precision.value.name}"
+            )
 
     def to_dict(self):
         """Converts the Eval Result to a dict compatible with our dataframe display"""
@@ -146,10 +148,7 @@ def get_request_file_for_model(requests_path, model_name, precision):
     for tmp_request_file in request_files:
         with open(tmp_request_file, "r") as f:
             req_content = json.load(f)
-            if (
-                req_content["status"] in ["FINISHED"]
-                and req_content["precision"] == precision.split(".")[-1]
-            ):
+            if req_content["status"] in ["FINISHED"] and req_content["precision"] == precision.split(".")[-1]:
                 request_file = tmp_request_file
     return request_file
 
@@ -188,7 +187,7 @@ def get_raw_eval_results(results_path: str, requests_path: str) -> list[EvalResu
     results = []
     for v in eval_results.values():
         try:
-            v.to_dict() # we test if the dict version is complete
+            v.to_dict()  # we test if the dict version is complete
             results.append(v)
         except KeyError:  # not all eval values present
             continue

src/populate.py

@@ -1,58 +1,16 @@
-import json
 import os
 
 import pandas as pd
 
-from src.display.formatting import has_no_nan_values, make_clickable_model
-from src.display.utils import AutoEvalColumn, EvalQueueColumn
-from src.leaderboard.read_evals import get_raw_eval_results
+from src.display.utils import AutoEvalColumn
 
 
-def get_leaderboard_df(results_path: str, requests_path: str, cols: list, benchmark_cols: list) -> pd.DataFrame:
+def get_leaderboard_df_crm(
+    crm_results_path: str, cols: list
+) -> tuple[pd.DataFrame, pd.DataFrame]:
     """Creates a dataframe from all the individual experiment results"""
-    raw_data = get_raw_eval_results(results_path, requests_path)
-    all_data_json = [v.to_dict() for v in raw_data]
-
-    df = pd.DataFrame.from_records(all_data_json)
-    df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
-    df = df[cols].round(decimals=2)
-
-    # filter out if any of the benchmarks have not been produced
-    df = df[has_no_nan_values(df, benchmark_cols)]
-    return df
-
-
-def get_evaluation_queue_df(save_path: str, cols: list) -> list[pd.DataFrame]:
-    """Creates the different dataframes for the evaluation queues requestes"""
-    entries = [entry for entry in os.listdir(save_path) if not entry.startswith(".")]
-    all_evals = []
-
-    for entry in entries:
-        if ".json" in entry:
-            file_path = os.path.join(save_path, entry)
-            with open(file_path) as fp:
-                data = json.load(fp)
-
-            data[EvalQueueColumn.model.name] = make_clickable_model(data["model"])
-            data[EvalQueueColumn.revision.name] = data.get("revision", "main")
-
-            all_evals.append(data)
-        elif ".md" not in entry:
-            # this is a folder
-            sub_entries = [e for e in os.listdir(f"{save_path}/{entry}") if os.path.isfile(e) and not e.startswith(".")]
-            for sub_entry in sub_entries:
-                file_path = os.path.join(save_path, entry, sub_entry)
-                with open(file_path) as fp:
-                    data = json.load(fp)
-
-                data[EvalQueueColumn.model.name] = make_clickable_model(data["model"])
-                data[EvalQueueColumn.revision.name] = data.get("revision", "main")
-                all_evals.append(data)
-
-    pending_list = [e for e in all_evals if e["status"] in ["PENDING", "RERUN"]]
-    running_list = [e for e in all_evals if e["status"] == "RUNNING"]
-    finished_list = [e for e in all_evals if e["status"].startswith("FINISHED") or e["status"] == "PENDING_NEW_EVAL"]
-    df_pending = pd.DataFrame.from_records(pending_list, columns=cols)
-    df_running = pd.DataFrame.from_records(running_list, columns=cols)
-    df_finished = pd.DataFrame.from_records(finished_list, columns=cols)
-    return df_finished[cols], df_running[cols], df_pending[cols]
+    model_performance_df = pd.read_csv(os.path.join(crm_results_path, "all_results.csv"))
+    
+    model_performance_df = model_performance_df[cols].round(decimals=2)
+    model_performance_df = model_performance_df.sort_values("Overall ⬆️", ascending=False)
+    return model_performance_df

src/submission/check_validity.py

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

src/submission/submit.py

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