Initial Commit

.gitattributes

@@ -25,6 +25,7 @@
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
 *.wasm filter=lfs diff=lfs merge=lfs -text
@@ -32,4 +33,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-scale-hf-logo.png filter=lfs diff=lfs merge=lfs -text

.pre-commit-config.yaml

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

Makefile

@@ -1,13 +0,0 @@
-.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,45 +1,13 @@
 ---
 title: IL-TUR Leaderboard
-emoji: 🥇
-colorFrom: green
-colorTo: indigo
+emoji: 📊
+colorFrom: yellow
+colorTo: green
 sdk: gradio
-sdk_version: 4.4.0
+sdk_version: 4.8.0
 app_file: app.py
-pinned: true
+pinned: false
 license: apache-2.0
 ---
 
-# Start the configuration
-
-Most of the variables to change for a default leaderboard are in `src/env.py` (replace the path for your leaderboard) and `src/about.py` (for tasks).
-
-Results files should have the following format and be stored as json files:
-```json
-{
-    "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.
-
-If you encounter problem on the space, don't hesitate to restart it to remove the create eval-queue, eval-queue-bk, eval-results and eval-results-bk created folder.
-
-# Code logic for more complex edits
-
-You'll find 
-- the main table' columns names and properties in `src/display/utils.py`
-- the logic to read all results and request files, then convert them in dataframe lines, in `src/leaderboard/read_evals.py`, and `src/populate.py`
-- teh logic to allow or filter submissions in `src/submission/submit.py` and `src/submission/check_validity.py`
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,394 +1,224 @@
-import subprocess
 import gradio as gr
 import pandas as pd
+import os
 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.display.css_html_js import custom_css
-from src.display.utils import (
-    BENCHMARK_COLS,
-    COLS,
-    EVAL_COLS,
-    EVAL_TYPES,
-    NUMERIC_INTERVALS,
-    TYPES,
-    AutoEvalColumn,
-    ModelType,
-    fields,
-    WeightType,
-    Precision,
-)
-from src.envs import API, EVAL_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
+from huggingface_hub import HfApi
+from uploads import add_new_eval
+
+CITATION_BUTTON_LABEL = "Copy the following snippet to cite these results"
+CITATION_BUTTON_TEXT = r"""@inproceedings{iltur-2024,
+    title = "IL-TUR: Benchmark for Indian Legal Text Understanding and Reasoning",
+    author = "Joshi, Abhinav  and Paul, Shaunak Sharma, Akshat  and Goyal, Pawan  and   Ghosh, Saptarshi and Modi, Ashutosh",
+    booktitle = "Proceedings of the 62st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
+    month = aug,
+    year = "2024",
+    address = "Bangkok, Thailand",
+    publisher = "Association for Computational Linguistics",
+}
+}"""
+
+api = HfApi()
+TOKEN = os.environ.get("TOKEN", None)
+LEADERBOARD_PATH = f"Exploration-lab/IL-TUR-Leaderboard"
 
 
 def restart_space():
-    # breakpoint()
-    # API.restart_space(repo_id=REPO_ID)
-    return
-
-
-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()
-
-
-raw_data, original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS)
-
-leaderboard_df = original_df.copy()
-# breakpoint()
-
-(
-    finished_eval_queue_df,
-    running_eval_queue_df,
-    pending_eval_queue_df,
-) = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
-
-
-# Searching and filtering
-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)
-    filtered_df = filter_queries(query, filtered_df)
-    df = select_columns(filtered_df, columns)
+    api.restart_space(repo_id=LEADERBOARD_PATH, token=TOKEN)
+
+
+# Function to load data from a given CSV file
+def baseline_load_data(tasks):
+    # version = version.replace("%", "p")
+    file_path = f"submissions/baseline/baseline.csv"  # Replace with your file paths
+    df = pd.read_csv(file_path)
+
+    # we only want specific columns and in a specific order
+
+    column_names = [
+        "Method",
+        "Submitted By",
+        "L-NER",
+        "RR",
+        "CJPE",
+        "BAIL",
+        "LSI",
+        "PCR",
+        "SUMM",
+        "Average",
+    ]
+    if tasks is None:
+        breakpoint()
+    # based on the tasks, remove the columns that are not needed
+    if "L-NER" not in tasks:
+        column_names.remove("L-NER")
+    if "RR" not in tasks:
+        column_names.remove("RR")
+    if "CJPE" not in tasks:
+        column_names.remove("CJPE")
+    if "BAIL" not in tasks:
+        column_names.remove("BAIL")
+    if "LSI" not in tasks:
+        column_names.remove("LSI")
+    if "PCR" not in tasks:
+        column_names.remove("PCR")
+    if "SUMM" not in tasks:
+        column_names.remove("SUMM")
+
+    df = df[column_names]
+    df = df.sort_values(by="Average", ascending=False)
+    df = df.drop_duplicates(subset=["Method"], keep="first")
+
     return df
 
 
-def search_table(df: pd.DataFrame, query: str) -> pd.DataFrame:
-    return df[(df[AutoEvalColumn.model.name].str.contains(query, case=False))]
+def load_data(tasks):
+    baseline_df = baseline_load_data(tasks)
 
+    return baseline_df
 
-def select_columns(df: pd.DataFrame, columns: list) -> pd.DataFrame:
-    # breakpoint()
-    always_here_cols = [
-        # AutoEvalColumn.model_type_symbol.name,
-        # AutoEvalColumn.model_name.name,
-        "eval_name"
-    ]
-    print(
-        "---------------",
-        AutoEvalColumn.model_name.name,
-    )
-    # We use COLS to maintain sorting
-    filtered_df = df[always_here_cols + [c for c in COLS if c in df.columns and c in columns]]
-    # filtered_df = df[[c for c in COLS if c in df.columns and c in columns]]
-    # breakpoint()
-    return filtered_df
-
-
-def filter_queries(query: str, filtered_df: pd.DataFrame) -> pd.DataFrame:
-    final_df = []
-    if query != "":
-        queries = [q.strip() for q in query.split(";")]
-        for _q in queries:
-            _q = _q.strip()
-            if _q != "":
-                temp_filtered_df = search_table(filtered_df, _q)
-                if len(temp_filtered_df) > 0:
-                    final_df.append(temp_filtered_df)
-        if len(final_df) > 0:
-            filtered_df = pd.concat(final_df)
-            filtered_df = filtered_df.drop_duplicates(
-                subset=[AutoEvalColumn.model.name, AutoEvalColumn.precision.name, AutoEvalColumn.revision.name]
-            )
 
-    return filtered_df
+# Function for searching in the leaderboard
+def search_leaderboard(df, query):
+    if query == "":
+        return df
+    else:
+        return df[df["Method"].str.contains(query)]
 
 
-def filter_models(
-    df: pd.DataFrame, type_query: list, size_query: list, precision_query: list, show_deleted: bool
-) -> pd.DataFrame:
-    # Show all models
-    if show_deleted:
-        filtered_df = df
-    else:  # Show only still on the hub models
-        filtered_df = df[df[AutoEvalColumn.still_on_hub.name] == True]
+# Function to change the version of the leaderboard
+def change_version(tasks):
+    new_df = load_data(tasks)
+    return new_df
 
-    type_emoji = [t[0] for t in type_query]
-    filtered_df = filtered_df.loc[df[AutoEvalColumn.model_type_symbol.name].isin(type_emoji)]
-    filtered_df = filtered_df.loc[df[AutoEvalColumn.precision.name].isin(precision_query + ["None"])]
 
-    numeric_interval = pd.IntervalIndex(sorted([NUMERIC_INTERVALS[s] for s in size_query]))
-    params_column = pd.to_numeric(df[AutoEvalColumn.params.name], errors="coerce")
-    mask = params_column.apply(lambda x: any(numeric_interval.contains(x)))
-    filtered_df = filtered_df.loc[mask]
+# Initialize Gradio app
+demo = gr.Blocks()
 
-    return filtered_df
+with demo:
+    gr.Markdown(
+        """
+    ## 🥇 IL-TUR Leaderboard
+    Legal systems worldwide are inundated with exponential growth in cases and documents. There is an imminent need to develop NLP and ML techniques for automatically processing and understanding legal documents to streamline the legal system. However, evaluating and comparing various NLP models designed specifically for the legal domain is challenging. This paper addresses this challenge by proposing IL-TUR: Benchmark for Indian Legal Text Understanding and Reasoning. IL-TUR  contains monolingual (English, Hindi) and multi-lingual (9 Indian languages) domain-specific tasks that address different aspects of the legal system from the point of view of understanding and reasoning over Indian legal documents. We present baseline models (including LLM-based) for each task, outlining the gap between models and the ground truth. We will release a public leaderboard where the research community can upload and compare legal text understanding systems on various metrics, thus fostering research in the legal domain.
+    Read more at [https://exploration-lab.github.io/IL-TUR/](https://exploration-lab.github.io/IL-TUR/).
+    """
+    )
 
+    with gr.Row():
+        with gr.Accordion("📙 Citation", open=False):
+            citation_button = gr.Textbox(
+                value=CITATION_BUTTON_TEXT,
+                label=CITATION_BUTTON_LABEL,
+                elem_id="citation-button",
+                show_copy_button=True,
+            )  # .style(show_copy_button=True)
 
-demo = gr.Blocks(css=custom_css)
-with demo:
-    gr.HTML(TITLE)
-    gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
+    with gr.Tabs():
+        with gr.TabItem("Leaderboard"):
 
-    with gr.Tabs(elem_classes="tab-buttons") as tabs:
-        with gr.TabItem("🏅 IL-TUR Benchmark", elem_id="llm-benchmark-tab-table", id=0):
             with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        search_bar = gr.Textbox(
-                            placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
-                            show_label=False,
-                            elem_id="search-bar",
-                        )
-                    with gr.Row():
-                        shown_columns = gr.CheckboxGroup(
-                            choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden],
-                            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.Row():
-                    #     deleted_models_visibility = gr.Checkbox(
-                    #         value=False, 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],
-                #         value=[t.to_str() for t in ModelType],
-                #         interactive=True,
-                #         elem_id="filter-columns-type",
-                #     )
-                #     filter_columns_precision = gr.CheckboxGroup(
-                #         label="Precision",
-                #         choices=[i.value.name for i in Precision],
-                #         value=[i.value.name for i in Precision],
-                #         interactive=True,
-                #         elem_id="filter-columns-precision",
-                #     )
-                #     filter_columns_size = gr.CheckboxGroup(
-                #         label="Model sizes (in billions of parameters)",
-                #         choices=list(NUMERIC_INTERVALS.keys()),
-                #         value=list(NUMERIC_INTERVALS.keys()),
-                #         interactive=True,
-                #         elem_id="filter-columns-size",
-                #     )
+                tasks_checkbox = gr.CheckboxGroup(
+                    label="Select Tasks",
+                    choices=["L-NER", "RR", "CJPE", "BAIL", "LSI", "PCR", "SUMM"],
+                    value=["L-NER", "RR", "CJPE", "BAIL", "LSI", "PCR", "SUMM"],
+                )
+
+            with gr.Row():
+                search_bar = gr.Textbox(
+                    placeholder="Search for methods...",
+                    show_label=False,
+                )
 
             leaderboard_table = gr.components.Dataframe(
-                value=leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
-                headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                datatype=TYPES,
-                elem_id="leaderboard-table",
-                interactive=False,
+                value=load_data(
+                    # "baseline",
+                    ["L-NER", "RR", "CJPE", "BAIL", "LSI", "PCR", "SUMM"],
+                ),
+                interactive=True,
                 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,
-            )
-            search_bar.submit(
-                update_table,
-                [
-                    hidden_leaderboard_table_for_search,
-                    shown_columns,
-                    # filter_columns_type,
-                    # filter_columns_precision,
-                    # filter_columns_size,
-                    # deleted_models_visibility,
+            # version_dropdown.change(
+            #     change_version,
+            #     inputs=[model_dropdown, version_dropdown, tasks_checkbox],
+            #     outputs=leaderboard_table,
+            # )
+
+            # model_dropdown.change(
+            #     change_version,
+            #     inputs=[model_dropdown, version_dropdown, tasks_checkbox],
+            #     outputs=leaderboard_table,
+            # )
+
+            search_bar.change(
+                search_leaderboard,
+                inputs=[
+                    leaderboard_table,
                     search_bar,
+                    # tasks_checkbox
                 ],
-                leaderboard_table,
+                outputs=leaderboard_table,
             )
-            for selector in [
-                shown_columns,
-                # filter_columns_type,
-                # filter_columns_precision,
-                # filter_columns_size,
-                # deleted_models_visibility,
-            ]:
-                selector.change(
-                    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,
-                    queue=True,
-                )
 
-        # with gr.TabItem("📝 About", elem_id="llm-benchmark-tab-table", id=2):
-        #     gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
-
-        # with gr.TabItem("🚀 Submit here! ", elem_id="llm-benchmark-tab-table", id=3):
-        #     with gr.Column():
-        #         with gr.Row():
-        #             gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")
-
-        #         with gr.Column():
-        #             with gr.Accordion(
-        #                 f"✅ Finished Evaluations ({len(finished_eval_queue_df)})",
-        #                 open=False,
-        #             ):
-        #                 with gr.Row():
-        #                     finished_eval_table = gr.components.Dataframe(
-        #                         value=finished_eval_queue_df,
-        #                         headers=EVAL_COLS,
-        #                         datatype=EVAL_TYPES,
-        #                         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 Results here!", elem_classes="markdown-text")
-
-        # with gr.Row():
-        #     with gr.Column():
-        #         model_name_textbox = gr.Textbox(label="Model name")
-        #         revision_name_textbox = gr.Textbox(label="Revision commit", placeholder="main")
-        #         model_type = gr.Dropdown(
-        #             choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
-        #             label="Model type",
-        #             multiselect=False,
-        #             value=None,
-        #             interactive=True,
-        #         )
-
-        #     with gr.Column():
-        #         precision = gr.Dropdown(
-        #             choices=[i.value.name for i in Precision if i != Precision.Unknown],
-        #             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)")
-
-        with gr.Accordion("Submit a prediction files for evaluation"):
-            with gr.Row():
-                with gr.Column():
-                    method_name_textbox = gr.Textbox(label="Method name")
-                    # llama, phi
-                    # model_family_radio = gr.Radio(["llama", "phi"], value="llama", label="Model family")
-                    # forget_rate_radio = gr.Radio(["1%", "5%", "10%"], value="10%", label="Forget rate")
-                    url_textbox = gr.Textbox(label="Url to model information")
-                with gr.Column():
-                    organisation = gr.Textbox(label="Organisation")
-                    mail = gr.Textbox(label="Contact email")
-                    file_output = gr.File()
-
-            submit_button = gr.Button("Submit Eval")
-            submission_result = gr.Markdown()
-            submit_button.click(
-                add_new_eval,
-                [
-                    method_name_textbox,
-                    # model_family_radio,
-                    # forget_rate_radio,
-                    url_textbox,
-                    file_output,
-                    organisation,
-                    mail,
-                ],
-                submission_result,
+            tasks_checkbox.change(
+                change_version,
+                inputs=[tasks_checkbox],
+                outputs=leaderboard_table,
             )
 
-            # 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,
-            # )
+    with gr.Accordion("Submit a new model for evaluation"):
+        with gr.Row():
+            with gr.Column():
+                method_name_textbox = gr.Textbox(label="Method name")
+                url_textbox = gr.Textbox(label="Url to model information")
+            with gr.Column():
+                organisation = gr.Textbox(label="Organisation")
+                mail = gr.Textbox(label="Contact email")
+                file_output = gr.File()
+
+        submit_button = gr.Button("Submit Eval")
+        submission_result = gr.Markdown()
+        submit_button.click(
+            add_new_eval,
+            [
+                method_name_textbox,
+                url_textbox,
+                file_output,
+                organisation,
+                mail,
+            ],
+            submission_result,
+        )
+
+    gr.Markdown(
+        """
+    ## Quick Links
+
+    - [**Website**](https://exploration-lab.github.io/IL-TUR): The landing page for IL-TUR
+    - [**arXiv Paper**](https://arxiv.org/abs/2307.05260): Detailed information about the IL-TUR dataset and its significance in unlearning tasks.
+    - [**GitHub Repository**](https://github.com/exploration-lab/IL-TUR): Access the source code, fine-tuning scripts, and additional resources for the IL-TUR dataset.
+    - [**Dataset on Hugging Face**](https://huggingface.co/datasets/Exploration-Lab/IL-TUR): Direct link to download the IL-TUR dataset.
+    - [**Leaderboard on Hugging Face Spaces**](https://huggingface.co/spaces/Exploration-Lab/IL-TUR_leaderboard): Current rankings and submissions for the IL-TUR dataset challenges.
+    
+    ## Loading the Dataset
+    
+    To load the dataset, use the following code:
+    
+    ```python
+    from datasets import load_dataset
+    dataset = load_dataset("Exploration-Lab/IL-TUR","<task_name>")
+    ```
+
+
+    """
+    )
 
-    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=1800)
+# scheduler.start()
+# demo.queue(default_concurrency_limit=40).launch()
 
+# demo.launch()
 scheduler = BackgroundScheduler()
-scheduler.add_job(restart_space, "interval", seconds=1800)
+scheduler.add_job(restart_space, "interval", seconds=3600)
 scheduler.start()
-demo.queue(default_concurrency_limit=40).launch()
+demo.launch(debug=True)

pyproject.toml

@@ -1,13 +0,0 @@
-[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,18 +1,7 @@
-APScheduler==3.10.1
-black==23.11.0
-click==8.1.3
+seaborn
+scipy
 datasets==2.14.5
-gradio==4.4.0
-gradio_client==0.7.0
-huggingface-hub>=0.18.0
-matplotlib==3.7.1
+gradio==4.3.0
+huggingface-hub==0.18.0
 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
-git+https://github.com/EleutherAI/lm-evaluation-harness.git@b281b0921b636bc36ad05c0b0b0763bd6dd43463#egg=lm-eval
-accelerate==0.24.1
-sentencepiece
+APScheduler==3.10.1

src/about.py

@@ -1,56 +0,0 @@
-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", "Legal Named Entity Recognition (L-NER)")
-    task1 = Task("logiqa", "acc_norm", "Rhetorical Role Prediction (RR)")
-    task2 = Task("logiqa", "acc_norm", "Court Judgment Prediction and Explanation (CJPE)")
-    task3 = Task("logiqa", "acc_norm", "Bail Prediction (BAIL)")
-    task4 = Task("logiqa", "acc_norm", "Legal Statute Identification (LSI)")
-    task5 = Task("logiqa", "acc_norm", "Prior Case Retrieval (PCR)")
-    task6 = Task("logiqa", "acc_norm", "Summarization (SUMM)")
-
-
-# ---------------------------------------------------
-
-
-NUM_FEWSHOT = 0  # Change with your few shot
-# ---------------------------------------------------
-
-
-# Your leaderboard name
-TITLE = """<h1 align="center" id="space-title">IL-TUR Leaderboard</h1>"""
-
-# What does your leaderboard evaluate?
-INTRODUCTION_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 = """
-We encourage submissions for the IL-TUR leaderboard. The leaderboard is open to all researchers and practitioners.
-
-Every task has its own leaderboard, and researchers can submit their results for any task. We also encourage submissions for multiple tasks.
-"""
-
-CITATION_BUTTON_LABEL = "Copy the following snippet to cite these results"
-CITATION_BUTTON_TEXT = r"""
-"""

src/display/css_html_js.py

@@ -1,105 +0,0 @@
-custom_css = """
-
-.markdown-text {
-    font-size: 16px !important;
-}
-
-#models-to-add-text {
-    font-size: 18px !important;
-}
-
-#citation-button span {
-    font-size: 16px !important;
-}
-
-#citation-button textarea {
-    font-size: 16px !important;
-}
-
-#citation-button > label > button {
-    margin: 6px;
-    transform: scale(1.3);
-}
-
-#leaderboard-table {
-    margin-top: 15px
-}
-
-#leaderboard-table-lite {
-    margin-top: 15px
-}
-
-#search-bar-table-box > div:first-child {
-    background: none;
-    border: none;
-}
- 
-#search-bar {
-    padding: 0px;
-}
-
-/* Limit the width of the first AutoEvalColumn so that names don't expand too much */
-table td:first-child,
-table th:first-child {
-    max-width: 400px;
-    overflow: auto;
-    white-space: nowrap;
-}
-
-.tab-buttons button {
-    font-size: 20px;
-}
-
-#scale-logo {
-    border-style: none !important;
-    box-shadow: none;
-    display: block;
-    margin-left: auto;
-    margin-right: auto;
-    max-width: 600px;
-}
-
-#scale-logo .download {
-    display: none;
-}
-#filter_type{
-    border: 0;
-    padding-left: 0;
-    padding-top: 0;
-}
-#filter_type label {
-    display: flex;
-}
-#filter_type label > span{
-    margin-top: var(--spacing-lg);
-    margin-right: 0.5em;
-}
-#filter_type label > .wrap{
-    width: 103px;
-}
-#filter_type label > .wrap .wrap-inner{  
-    padding: 2px;
-}
-#filter_type label > .wrap .wrap-inner input{
-    width: 1px
-}
-#filter-columns-type{
-    border:0;
-    padding:0.5;
-}
-#filter-columns-size{
-    border:0;
-    padding:0.5;
-}
-#box-filter > .form{
-    border: 0
-}
-"""
-
-get_window_url_params = """
-    function(url_params) {
-        const params = new URLSearchParams(window.location.search);
-        url_params = Object.fromEntries(params);
-        return url_params;
-    }
-    """

src/display/formatting.py

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

src/display/utils.py

@@ -1,144 +0,0 @@
-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:] != "__"]
-
-
-# These classes are for user facing column names,
-# to avoid having to change them all around the code
-# when a modif is needed
-@dataclass
-class ColumnContent:
-    name: str
-    type: str
-    displayed_by_default: bool
-    hidden: bool = False
-    never_hidden: bool = False
-
-
-## 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(["team", ColumnContent, ColumnContent("Team", "markdown", True, never_hidden=True)])
-# auto_eval_column_dict.append(["team_name", ColumnContent, ColumnContent("team_name", "str", True)])
-# Scores
-auto_eval_column_dict.append(["eval_name", ColumnContent, ColumnContent("eval_name", "str", 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)])
-# # 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")
-    float32 = ModelDetails("float32")
-    # qt_8bit = ModelDetails("8bit")
-    # qt_4bit = ModelDetails("4bit")
-    # qt_GPTQ = ModelDetails("GPTQ")
-    Unknown = ModelDetails("?")
-
-    def from_str(precision):
-        if precision in ["torch.float16", "float16"]:
-            return Precision.float16
-        if precision in ["torch.bfloat16", "bfloat16"]:
-            return Precision.bfloat16
-        if precision in ["float32"]:
-            return Precision.float32
-        # if precision in ["8bit"]:
-        #    return Precision.qt_8bit
-        # if precision in ["4bit"]:
-        #    return Precision.qt_4bit
-        # if precision in ["GPTQ", "None"]:
-        #    return Precision.qt_GPTQ
-        return Precision.Unknown
-
-
-# Column selection
-COLS = [c.name for c in fields(AutoEvalColumn) 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]
-
-EVAL_COLS = [c.name for c in fields(EvalQueueColumn)]
-EVAL_TYPES = [c.type for c in fields(EvalQueueColumn)]
-
-BENCHMARK_COLS = [t.value.col_name for t in Tasks]
-
-NUMERIC_INTERVALS = {
-    "?": pd.Interval(-1, 0, closed="right"),
-    "~1.5": pd.Interval(0, 2, closed="right"),
-    "~3": pd.Interval(2, 4, closed="right"),
-    "~7": pd.Interval(4, 9, closed="right"),
-    "~13": pd.Interval(9, 20, closed="right"),
-    "~35": pd.Interval(20, 45, closed="right"),
-    "~60": pd.Interval(45, 70, closed="right"),
-    "70+": pd.Interval(70, 10000, closed="right"),
-}

src/envs.py

@@ -1,25 +0,0 @@
-import os
-
-from huggingface_hub import HfApi
-
-# Info to change for your repository
-# ----------------------------------
-TOKEN = os.environ.get("TOKEN") # A read/write token for your org
-
-OWNER = "Exploration-Lab" # Change to your org - don't forget to create a results and request dataset, with the correct format!
-# ----------------------------------
-
-REPO_ID = f"{OWNER}/IL-TUR-Leaderboard"
-QUEUE_REPO = f"{OWNER}/IL-TUR-Leaderboard-requests"
-RESULTS_REPO = f"{OWNER}/IL-TUR-Leaderboard-results"
-
-# If you setup a cache later, just change 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")
-EVAL_REQUESTS_PATH_BACKEND = os.path.join(CACHE_PATH, "eval-queue-bk")
-EVAL_RESULTS_PATH_BACKEND = os.path.join(CACHE_PATH, "eval-results-bk")
-
-API = HfApi(token=TOKEN)

src/leaderboard/read_evals.py

@@ -1,216 +0,0 @@
-import glob
-import json
-import math
-import os
-from dataclasses import dataclass
-
-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
-
-
-@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
-    model: str
-    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"
-    license: str = "?"
-    likes: int = 0
-    num_params: int = 0
-    date: str = ""  # submission date of request file
-    still_on_hub: 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)
-
-        config = data.get("config")
-
-        # Precision
-        precision = Precision.from_str(config.get("model_dtype"))
-
-        # Get model and org
-        org_and_model = config.get("model_name", config.get("model_args", None))
-        org_and_model = org_and_model.split("/", 1)
-
-        if len(org_and_model) == 1:
-            org = None
-            model = org_and_model[0]
-            result_key = f"{model}_{precision.value.name}"
-        else:
-            org = org_and_model[0]
-            model = org_and_model[1]
-            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
-        )
-        architecture = "?"
-        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 = {}
-        for task in Tasks:
-            task = task.value
-
-            # 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
-            results[task.benchmark] = mean_acc
-
-        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"""
-        request_file = get_request_file_for_model(requests_path, self.full_model, self.precision.value.name)
-
-        try:
-            with open(request_file, "r") as f:
-                request = json.load(f)
-            self.model_type = ModelType.from_str(request.get("model_type", ""))
-            self.weight_type = WeightType[request.get("weight_type", "Original")]
-            self.license = request.get("license", "?")
-            self.likes = request.get("likes", 0)
-            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}"
-            )
-
-    def to_dict(self):
-        """Converts the Eval Result to a dict compatible with our dataframe display"""
-
-        average = sum([v for v in self.results.values() if v is not None]) / len(Tasks)
-
-        data_dict = {
-            "eval_name": self.eval_name,  # not a column, just a save name,
-            # AutoEvalColumn.precision.name: self.precision.value.name,
-            # AutoEvalColumn.team_name.name: self.team_name.value.name,
-            # AutoEvalColumn.weight_type.name: self.weight_type.value.name,
-            # AutoEvalColumn.architecture.name: self.architecture,
-            # AutoEvalColumn.model.name: make_clickable_model(self.full_model),
-            # AutoEvalColumn.revision.name: self.revision,
-            AutoEvalColumn.average.name: average,
-            # AutoEvalColumn.license.name: self.license,
-            # AutoEvalColumn.likes.name: self.likes,
-            # AutoEvalColumn.params.name: self.num_params,
-            # AutoEvalColumn.still_on_hub.name: self.still_on_hub,
-        }
-
-        for task in Tasks:
-            data_dict[task.value.col_name] = self.results[task.value.benchmark]
-
-        # data_dict = {
-        #     "eval_name": self.eval_name,  # not a column, just a save name,
-        #     # AutoEvalColumn.precision.name: self.precision.value.name,
-        #     AutoEvalColumn.model_type.name: self.model_type.value.name,
-        #     AutoEvalColumn.model_type_symbol.name: self.model_type.value.symbol,
-        #     # AutoEvalColumn.weight_type.name: self.weight_type.value.name,
-        #     # AutoEvalColumn.architecture.name: self.architecture,
-        #     # AutoEvalColumn.model.name: make_clickable_model(self.full_model),
-        #     # AutoEvalColumn.revision.name: self.revision,
-        #     AutoEvalColumn.average.name: average,
-        #     # AutoEvalColumn.license.name: self.license,
-        #     # AutoEvalColumn.likes.name: self.likes,
-        #     # AutoEvalColumn.params.name: self.num_params,
-        #     # AutoEvalColumn.still_on_hub.name: self.still_on_hub,
-        # }
-
-        return data_dict
-
-
-def get_request_file_for_model(requests_path, model_name, precision):
-    """Selects the correct request file for a given model. Only keeps runs tagged as FINISHED"""
-    request_files = os.path.join(
-        requests_path,
-        f"{model_name}_eval_request_*.json",
-    )
-    request_files = glob.glob(request_files)
-
-    # Select correct request file (precision)
-    request_file = ""
-    request_files = sorted(request_files, reverse=True)
-    for tmp_request_file in request_files:
-        with open(tmp_request_file, "r") as f:
-            req_content = json.load(f)
-            if (
-                req_content["status"]
-                in ["FINISHED"]
-                # and req_content["precision"] == precision.split(".")[-1]
-            ):
-                request_file = tmp_request_file
-    return request_file
-
-
-def get_raw_eval_results(results_path: str, requests_path: str) -> list[EvalResult]:
-    """From the path of the results folder root, extract all needed info for results"""
-    model_result_filepaths = []
-
-    for root, _, files in os.walk(results_path):
-        # We should only have json files in model results
-        if len(files) == 0 or any([not f.endswith(".json") for f in files]):
-            continue
-
-        # Sort the files by date
-        try:
-            files.sort(key=lambda x: x.removesuffix(".json").removeprefix("results_")[:-7])
-        except dateutil.parser._parser.ParserError:
-            files = [files[-1]]
-
-        for file in files:
-            model_result_filepaths.append(os.path.join(root, file))
-
-    eval_results = {}
-    for model_result_filepath in model_result_filepaths:
-        # Creation of result
-        eval_result = EvalResult.init_from_json_file(model_result_filepath)
-        eval_result.update_with_request_file(requests_path)
-
-        # Store results of same eval together
-        eval_name = eval_result.eval_name
-        if eval_name in eval_results.keys():
-            eval_results[eval_name].results.update({k: v for k, v in eval_result.results.items() if v is not None})
-        else:
-            eval_results[eval_name] = eval_result
-
-    results = []
-    for v in eval_results.values():
-        try:
-            v.to_dict()  # we test if the dict version is complete
-            results.append(v)
-        except KeyError:  # not all eval values present
-            continue
-
-    return results

src/populate.py

@@ -1,60 +0,0 @@
-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
-
-
-def get_leaderboard_df(results_path: str, requests_path: str, cols: list, benchmark_cols: list) -> 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)
-    # breakpoint()
-    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)]
-    # breakpoint()
-    return raw_data, 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 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]

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,205 +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
-
-OUT_DIR = f"{EVAL_REQUESTS_PATH}"
-RESULTS_PATH = f"{OUT_DIR}/evaluation.json"
-
-# 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."
-#     )
-
-
-def format_error(msg):
-    return f"<p style='color: red; font-size: 20px; text-align: center;'>{msg}</p>"
-
-
-def format_warning(msg):
-    return f"<p style='color: orange; font-size: 20px; text-align: center;'>{msg}</p>"
-
-
-def format_log(msg):
-    return f"<p style='color: green; font-size: 20px; text-align: center;'>{msg}</p>"
-
-
-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 input_verification(model, model_family, forget_rate, url, path_to_file, organisation, mail):
-    for input in [model, model_family, forget_rate, url, organisation]:
-        if input == "":
-            return format_warning("Please fill all the fields.")
-
-    # Very basic email parsing
-    _, parsed_mail = parseaddr(mail)
-    if not "@" in parsed_mail:
-        return format_warning("Please provide a valid email adress.")
-
-    if path_to_file is None:
-        return format_warning("Please attach a file.")
-
-    return parsed_mail
-
-
-def add_new_eval(
-    model: str,
-    model_family: str,
-    forget_rate: str,
-    url: str,
-    path_to_file: str,
-    organisation: str,
-    mail: str,
-):
-
-    parsed_mail = input_verification(model, model_family, forget_rate, url, path_to_file, organisation, mail)
-
-    # load the file
-    df = pd.read_csv(path_to_file)
-
-    # modify the df to include metadata
-    df["model"] = model
-    df["model_family"] = model_family
-    df["forget_rate"] = forget_rate
-    df["url"] = url
-    df["organisation"] = organisation
-    df["mail"] = parsed_mail
-    df["timestamp"] = datetime.datetime.now()
-
-    # upload to spaces using the hf api at
-
-    path_in_repo = f"versions/{model_family}-{forget_rate.replace('%', 'p')}"
-    file_name = f"{model}-{organisation}-{datetime.datetime.now().strftime('%Y-%m-%d')}.csv"
-
-    # upload the df to spaces
-    import io
-
-    buffer = io.BytesIO()
-    df.to_csv(buffer, index=False)  # Write the DataFrame to a buffer in CSV format
-    buffer.seek(0)  # Rewind the buffer to the beginning
-
-    API.upload_file(
-        repo_id=RESULTS_PATH,
-        path_in_repo=f"{path_in_repo}/{file_name}",
-        path_or_fileobj=buffer,
-        token=TOKEN,
-        repo_type="space",
-    )
-
-    return format_log(
-        f"Model {model} submitted by {organisation} successfully. \nPlease refresh the leaderboard, and wait a bit to see the score displayed"
-    )

submissions/baseline/baseline.csv

@@ -0,0 +1,3 @@
+,index,Method,Submitted By,L-NER,RR,CJPE,BAIL,LSI,PCR,SUMM,Average
+,0,baseline,baseline,0,0,0,0,0,0,0,0
+,0,baseline2,baseline2,0,0,0,0,0,0,0,0

submissions/modify.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Loop through each CSV file in the current directory
+for csv_file in *.csv; do
+    # Check if the file is a regular file
+    if [ -f "$csv_file" ]; then
+        echo "Processing $csv_file..."
+
+        # Temporary file
+        temp_file=$(mktemp)
+
+        # Check if the file has a header
+        if head -1 "$csv_file" | grep -q "Submitted By"; then
+            echo "The 'Submitted By' column already exists in $csv_file."
+            continue
+        fi
+
+        # Add 'Submitted By' column header and 'Baseline' entry for each row
+        awk -v OFS="," 'NR==1 {print $0, "Submitted By"} NR>1 {print $0, "Baseline"}' "$csv_file" > "$temp_file"
+
+        # Move the temporary file to original file
+        mv "$temp_file" "$csv_file"
+
+        echo "Column 'Submitted By' added successfully with 'Baseline' entry in each row for $csv_file."
+    fi
+done
+
+echo "All CSV files processed."

uploads.py

@@ -0,0 +1,94 @@
+from email.utils import parseaddr
+from huggingface_hub import HfApi
+import os
+import datetime
+import pandas as pd
+
+
+RESULTS_PATH = "Exploration-Lab/IL-TUR-Leaderboard-results"
+api = HfApi()
+TOKEN = os.environ.get("TOKEN", None)
+YEAR_VERSION = "2024"
+
+
+def format_error(msg):
+    return f"<p style='color: red; font-size: 20px; text-align: center;'>{msg}</p>"
+
+
+def format_warning(msg):
+    return f"<p style='color: orange; font-size: 20px; text-align: center;'>{msg}</p>"
+
+
+def format_log(msg):
+    return f"<p style='color: green; font-size: 20px; text-align: center;'>{msg}</p>"
+
+
+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 input_verification(method_name, url, path_to_file, organisation, mail):
+    for input in [method_name, url, path_to_file, organisation, mail]:
+        if input == "":
+            return format_warning("Please fill all the fields.")
+
+    # Very basic email parsing
+    _, parsed_mail = parseaddr(mail)
+    if not "@" in parsed_mail:
+        return format_warning("Please provide a valid email adress.")
+
+    if path_to_file is None:
+        return format_warning("Please attach a file.")
+
+    return parsed_mail
+
+
+def add_new_eval(
+    method_name: str,
+    url: str,
+    path_to_file: str,
+    organisation: str,
+    mail: str,
+):
+
+    parsed_mail = input_verification(
+        method_name,
+        url,
+        path_to_file,
+        organisation,
+        mail,
+    )
+
+    # load the file
+    df = pd.read_csv(path_to_file)
+
+    # modify the df to include metadata
+    df["method_name"] = method_name
+    df["url"] = url
+    df["organisation"] = organisation
+    df["mail"] = parsed_mail
+    df["timestamp"] = datetime.datetime.now()
+
+    # upload to spaces using the hf api at
+
+    path_in_repo = f"submissions/{method_name}"
+    file_name = f"{method_name}-{organisation}-{datetime.datetime.now().strftime('%Y-%m-%d')}.csv"
+
+    # upload the df to spaces
+    import io
+
+    buffer = io.BytesIO()
+    df.to_csv(buffer, index=False)  # Write the DataFrame to a buffer in CSV format
+    buffer.seek(0)  # Rewind the buffer to the beginning
+
+    api.upload_file(
+        repo_id=RESULTS_PATH,
+        path_in_repo=f"{path_in_repo}/{file_name}",
+        path_or_fileobj=buffer,
+        token=TOKEN,
+        repo_type="dataset",
+    )
+
+    return format_log(
+        f"Method {method_name} submitted by {organisation} successfully. \nPlease refresh the leaderboard, and wait a bit to see the score displayed"
+    )