Upload 4 files

app.py

@@ -1,204 +1,68 @@
 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.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()
+from gradio_leaderboard import Leaderboard, SelectColumns, ColumnFilter
+from pathlib import Path
+
+from utils import LLM_BENCHMARKS_ABOUT_TEXT, LLM_BENCHMARKS_SUBMIT_TEXT, custom_css, jsonl_to_dataframe, add_average_column_to_df, apply_markdown_format_for_columns, submit, PART_LOGO, sort_dataframe_by_column
+
+
+
+abs_path = Path(__file__).parent
+
+# Any pandas-compatible data
+leaderboard_df = jsonl_to_dataframe(str(abs_path / "leaderboard_data.jsonl"))
 
+average_column_name = "Average Accuracy"
 
-LEADERBOARD_DF = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS)
+all_columns = ["Model", average_column_name, "Precision", "#Params (B)", "MMLU", "GSM8K", "TruthfulQA", "Winogrande", "ARC Easy", "Hellaswag", "Belebele"]
+columns_to_average = ["MMLU", "GSM8K", "TruthfulQA", "Winogrande", "ARC Easy", "Hellaswag", "Belebele"]
 
-(
-    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)],
+leaderboard_df = add_average_column_to_df(leaderboard_df, columns_to_average, index=3, average_column_name=average_column_name)
+leaderboard_df = apply_markdown_format_for_columns(df=leaderboard_df, model_column_name="Model")
+leaderboard_df = sort_dataframe_by_column(leaderboard_df, column_name=average_column_name)
+
+columns_data_type = ["markdown" for i in range(len(leaderboard_df.columns))]
+# "str", "number", "bool", "date", "markdown"
+# columns_data_type[0] = "markdown"
+
+NUM_MODELS=len(leaderboard_df)
+
+with gr.Blocks(css=custom_css) as demo:
+    gr.Markdown("""
+    # Open Lithuanian LLM Leaderboard
+    """)
+
+    gr.Markdown(f"""
+    - **Total Models**: {NUM_MODELS}
+    """)
+
+    with gr.Tab("🎖️ Lithuanian Leaderboard"):
+        Leaderboard(
+        value=leaderboard_df,
+        datatype=columns_data_type,
         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:",
+            default_selection=all_columns,
+            cant_deselect=["Model"],
+            label="Select Columns to Show",
         ),
-        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,
+        search_columns=["model_name_for_query"],
+        hide_columns=["model_name_for_query",],
+        filter_columns=["Precision", "#Params (B)"],
     )
+    with gr.TabItem("📝 About"):
+        gr.Markdown(LLM_BENCHMARKS_ABOUT_TEXT)
+
+    with gr.Tab("✉️ Submit"):
+        gr.Markdown(LLM_BENCHMARKS_SUBMIT_TEXT)
+        model_name = gr.Textbox(label="Model name")
+        model_id = gr.Textbox(label="username/space e.g neurotechnology/Lt-Llama-2-7b-hf")
+        contact_email = gr.Textbox(label="Contact E-Mail")
+        submit_btn = gr.Button("Submit")
+
+        submit_btn.click(submit, inputs=[model_name, model_id, contact_email], outputs=[])
 
+        gr.Markdown("""
+        Please find more information about Neurotechnology on [www.neurotechnology.com](https://www.neurotechnology.com/natural-language-processing.html)""")
 
-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.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)")
-
-            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.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()
+if __name__ == "__main__":
+    demo.launch()

envs.py

@@ -0,0 +1,25 @@
+import os
+
+from huggingface_hub import HfApi
+
+# Info to change for your repository
+# ----------------------------------
+TOKEN = os.environ.get("HF_TOKEN") # A read/write token for your org
+
+OWNER = "neurotechnology" # Change to your org - don't forget to create a results and request dataset, with the correct format!
+# ----------------------------------
+
+REPO_ID = f"{OWNER}/open-lithuanian-llm-leaderboard"
+QUEUE_REPO = f"{OWNER}/leaderboard-requests"
+RESULTS_REPO = f"{OWNER}/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)

leaderboard_data.jsonl

@@ -0,0 +1,11 @@
+{"Model":"meta-llama/Llama-3.2-1B", "Precision": "bfloat16", "#Params (B)": 1.24, "MMLU": 25.85, "GSM8K": 1.82, "ARC Easy": 29.08, "Winogrande": 49.80, "TruthfulQA": 38.75, "Hellaswag": 28.53, "Belebele": 27.33, "Hub License": "llama3.2", "Model sha": "main", "model_name_for_query": "meta-llama/Llama-3.2-1B"}
+{"Model":"neurotechnology/Lt-Llama-2-7b-hf ", "Precision": "bfloat16", "#Params (B)": 6.9, "MMLU": 26.01, "GSM8K": 0.0, "ARC Easy": 43.18, "Winogrande": 53.67, "TruthfulQA": 41.38, "Hellaswag": 33.17, "Belebele": 27.23, "Hub License": "llama2", "Model sha": "main", "model_name_for_query": "neurotechnology/Lt-Llama-2-7b-hf"}
+{"Model":"neurotechnology/Lt-Llama-2-13b-hf ", "Precision": "bfloat16", "#Params (B)": 12.7, "MMLU": 26.44, "GSM8K": 0.45, "ARC Easy": 54.5, "Winogrande": 61.72, "TruthfulQA": 35.23, "Hellaswag": 40.61, "Belebele": 27.67, "Hub License": "llama2", "Model sha": "main", "model_name_for_query": "neurotechnology/Lt-Llama-2-13b-hf"}
+{"Model":"meta-llama/Llama-3.2-3B", "Precision": "bfloat16", "#Params (B)": 3.21, "MMLU": 36.41, "GSM8K": 13.04, "ARC Easy": 39.39, "Winogrande": 51.85, "TruthfulQA": 38.87, "Hellaswag": 31.51, "Belebele": 46.22, "Hub License": "llama3.2", "Model sha": "main", "model_name_for_query": "meta-llama/Llama-3.2-3B"}
+{"Model":"google/gemma-2-2b", "Precision": "bfloat16", "#Params (B)": 2.61, "MMLU": 35.84, "GSM8K": 3.64, "ARC Easy": 45.45, "Winogrande": 51.85, "TruthfulQA": 54.78, "Hellaswag": 34.80, "Belebele": 52.44, "Hub License": "gemma", "Model sha": "main", "model_name_for_query": "google/gemma-2-2b"}
+{"Model":"meta-llama/Llama-3.1-8B", "Precision": "bfloat16", "#Params (B)": 8.03, "MMLU": 44.86, "GSM8K": 30.17, "ARC Easy": 48.65, "Winogrande": 54.22, "TruthfulQA": 37.61, "Hellaswag": 35.19, "Belebele": 67.56, "Hub License": "llama3.1", "Model sha": "main", "model_name_for_query": "meta-llama/Llama-3.1-8B"}
+{"Model":"utter-project/EuroLLM-9B", "Precision": "bfloat16", "#Params (B)": 9.15, "MMLU": 51.95, "GSM8K": 31.16, "ARC Easy": 71.55, "Winogrande": 64.17, "TruthfulQA": 42.13, "Hellaswag": 46.32, "Belebele": 69.44, "Hub License": "eurollm", "Model sha": "main", "model_name_for_query": "utter-project/EuroLLM-9B"}
+{"Model":"google/gemma-2-9b", "Precision": "bfloat16", "#Params (B)": 9.24, "MMLU": 60.09, "GSM8K": 25.78, "ARC Easy": 68.31, "Winogrande": 65.15, "TruthfulQA": 39.69, "Hellaswag": 45.32, "Belebele": 86.78, "Hub License": "gemma", "Model sha": "main", "model_name_for_query": "google/gemma-2-9b"}
+{"Model":"meta-llama/Llama-3.1-70B", "Precision": "bfloat16", "#Params (B)": 70, "MMLU": 67.50, "GSM8K": 72.40, "ARC Easy": 70.92, "Winogrande": 64.01, "TruthfulQA": 43.59, "Hellaswag": 46.39, "Belebele": 90.02, "Hub License": "llama3.1", "Model sha": "main", "model_name_for_query": "meta-llama/Llama-3.1-70B"}
+{"Model":"google/gemma-2-27b", "Precision": "bfloat16", "#Params (B)": 27.2, "MMLU": 64.82, "GSM8K": 68.69, "ARC Easy": 77.40, "Winogrande": 66.77, "TruthfulQA": 42.06, "Hellaswag": 50.82, "Belebele": 89.22, "Hub License": "gemma", "Model sha": "main", "model_name_for_query": "google/gemma-2-27b"}
+{"Model":"meta-llama/Llama-3.3-70B", "Precision": "bfloat16", "#Params (B)": 70, "MMLU": 71.46, "GSM8K": 80.97, "ARC Easy": 70.66, "Winogrande": 59.83, "TruthfulQA": 45.61, "Hellaswag": 46.05, "Belebele": 89.33, "Hub License": "llama3.3", "Model sha": "main", "model_name_for_query": "meta-llama/Llama-3.3-70B"}

utils.py

@@ -0,0 +1,268 @@
+import json
+import os
+from datetime import datetime
+
+import gradio as gr
+import pandas as pd
+
+from envs import API, EVAL_REQUESTS_PATH, TOKEN, QUEUE_REPO
+
+custom_css = """
+@import url('https://fonts.googleapis.com/css2?family=Vazirmatn&display=swap');
+body, .gradio-container, .gr-button, .gr-input, .gr-slider, .gr-dropdown, .gr-markdown {
+    font-family: 'Vazirmatn', sans-serif !important;
+}
+.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;
+    text-align: center;
+}
+#leaderboard-table,
+#leaderboard-table th,
+#leaderboard-table td {
+    text-align: center;
+    vertical-align: middle;
+    border-collapse: collapse;
+}
+#leaderboard-table td:first-child,
+#leaderboard-table th:first-child {
+    text-align: left;
+    max-width: 500px;
+}
+table > thead {
+    white-space: normal;
+}
+table > thead th,
+table > tbody td {
+    text-align: center;
+    vertical-align: middle;
+}
+table > tbody td:first-child {
+    text-align: left;
+    max-width: 500px;
+}
+#leaderboard-table-lite {
+    margin-top: 15px;
+}
+#search-bar-table-box > div:first-child {
+    background: none;
+    border: none;
+}
+#search-bar {
+    padding: 0px;
+}
+.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;
+}
+"""
+
+LLM_BENCHMARKS_ABOUT_TEXT = f"""## Open Lithuanian LLM Leaderboard (v1.0.1)
+> The Open Lithuanian LLM Evaluation Leaderboard, developed by **Part DP AI** in collaboration with **Vilnius University NLP Lab**, provides a comprehensive benchmarking system specifically designed for Lithuanian LLMs. This leaderboard, based on the open-source [LM Evaluation Harness](https://github.com/EleutherAI/lm-evaluation-harness), offers a unique platform for evaluating the performance of large language models (LLMs) on tasks that demand linguistic proficiency and technical skill in Lithuanian.
+> **Note:** This leaderboard is continuously updating its data and models, reflecting the latest developments in Lithuanian LLMs. It is currently in version 1.0.0, serving as the initial benchmark for Lithuanian LLM evaluation, with plans for future enhancements.
+## 1. Key Features
+> 1. **Open Evaluation Access**  
+>    The leaderboard allows open participation, meaning that developers and researchers working with open-source models can submit evaluation requests for their models. This accessibility encourages the development and testing of Lithuanian LLMs within the broader AI ecosystem.
+> 
+> 2. **Task Diversity**  
+>    Six specialized tasks have been curated for this leaderboard, each tailored to challenge different aspects of a model’s capabilities. These tasks include:
+>    - **MMLU**
+>    - **GSM8K**
+>    - **TruthfulQA**
+>    - **ARC Easy**
+>    - **Winogrande**
+>    - **Hellaswag**
+>    - **Belebele**
+> 
+>    Each dataset is available in Lithuanian, providing a robust testing ground for models in a non-English setting. The datasets collectively contain over **40k samples** across various categories such as **Common Knowledge**, **Reasoning**, **Summarization**, **Math**, and **Specialized Examinations**, offering comprehensive coverage of diverse linguistic and technical challenges.
+> 
+> 3. **Open-Source Dataset Sample**  
+>    A sample of the evaluation dataset is hosted on [Hugging Face Datasets](https://huggingface.co/datasets/PartAI/llm-leaderboard-datasets-sample), offering the AI community a glimpse of the benchmark content and format. This sample allows developers to pre-assess their models against representative data before a full leaderboard evaluation.
+> 
+> 4. **Collaborative Development**  
+>
+>    This leaderboard is developed by [**Neurotechnology**](https://huggingface.co/neurotechnology) and authored by [**Artūras Nakvosas**](https://huggingface.co/artena), leveraging cutting-edge industrial expertise to create a high-quality, open benchmarking tool. The project underscores a commitment to advancing Lithuanian LLMs through innovative solutions and fostering the growth of the local AI ecosystem.
+> 
+> 5. **Comprehensive Evaluation Pipeline**  
+>    By integrating a standardized evaluation pipeline, models are assessed across a variety of data types, including text, mathematical formulas, and numerical data. This multi-faceted approach enhances the evaluation’s reliability and allows for precise, nuanced assessment of model performance across multiple dimensions.
+## 2. Background and Goals
+> Recent months have seen a notable increase in the development of Lithuanian LLMs by research centers and AI companies in Lithuania. However, the lack of reliable, standardized benchmarks for Lithuanian LLMs has made it challenging to evaluate model quality comprehensively. Global benchmarks typically do not support Lithuanian, resulting in skewed or unreliable results for Lithuanian LLMs.
+> 
+> This leaderboard addresses this gap by providing a locally-focused, transparent system that enables consistent, fair comparisons of Lithuanian LLMs. It is expected to be a valuable tool for Lithuanian-speaking businesses and developers, allowing them to select models best suited to their needs. Researchers and model developers also benefit from the competitive environment, with opportunities to showcase and improve their models based on benchmark rankings.
+## 3. Data Privacy and Integrity
+> To maintain evaluation integrity and prevent overfitting or data leakage, only part of the benchmark dataset is openly available. This limited access approach upholds model evaluation reliability, ensuring that results are genuinely representative of each model’s capabilities across unseen data.
+> 
+> The leaderboard represents a significant milestone in Lithuanian LLMs and is positioned to become the leading standard for LLM evaluation in the Lithuanian-speaking world.
+"""
+
+
+LLM_BENCHMARKS_SUBMIT_TEXT = """### Submitting a Model for Evaluation
+
+> To submit your open-source model for evaluation, follow these steps:
+> 
+> 1. **Ensure your model is on Hugging Face**: Your model must be publicly available on [Hugging Face](https://huggingface.co/).
+> 
+> 2. **Submit Request**: Send a request with your model's Hugging Face identifier via the provided submission form or email.
+> 
+> 3. **Manual Queue**: Please note that the evaluation process is currently handled manually. Submissions will be queued and processed in the order received.
+> 
+> 4. **Results**: Once the evaluation is complete, your model’s results will be updated on the leaderboard and shared with you.
+> 
+> We appreciate your patience and contributions to the Lithuanian LLM ecosystem!
+"""
+
+
+PART_LOGO = """
+<img src="https://avatars.githubusercontent.com/u/39557177?v=4" style="width:30%;display:block;margin-left:auto;margin-right:auto"> 
+<h1 style="font-size: 28px; margin-bottom: 2px;">Part DP AI</h1>
+"""
+
+
+def load_jsonl(input_file):
+    data = []
+    with open(input_file, 'r') as f:
+        for line in f:
+            data.append(json.loads(line))
+    return data
+
+
+def jsonl_to_dataframe(input_file):
+    data = load_jsonl(input_file)
+    return pd.DataFrame(data)
+
+
+def sort_dataframe_by_column(df, column_name):
+    if column_name not in df.columns:
+        raise ValueError(f"Column '{column_name}' does not exist in the DataFrame.")
+    return df.sort_values(by=column_name, ascending=False).reset_index(drop=True)
+
+
+def add_average_column_to_df(df,columns_to_average, index=3, average_column_name="Average Accuracy"):
+    average_column = df[columns_to_average].mean(axis=1)
+    df.insert(index, average_column_name, average_column)
+    return df
+
+
+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 center_align_markdown(text):
+    return f'<div align="center">{text}</div>'
+
+
+def apply_markdown_format_for_columns(df, model_column_name):
+    columns = list(df.columns)
+    df[model_column_name] = df[model_column_name].apply(make_clickable_model)
+    # for column in columns:
+    #     if column != model_column_name:
+    #         df[column] = df[column].apply(center_align_markdown)
+    return df
+
+
+def submit(model_name, model_id, contact_email):
+    if model_name == "" or model_id == "" or contact_email == "":
+        gr.Info("Please fill all the fields")
+        return
+
+
+    try:
+        user_name = ""
+        if "/" in model_id:
+            user_name = model_id.split("/")[0]
+            model_path = model_id.split("/")[1]
+
+        eval_entry = {
+            "model_name": model_name,
+            "model_id": model_id,
+            "contact_email": contact_email,
+        }
+
+        # Get the current timestamp to add to the filename
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+        OUT_DIR = f"{EVAL_REQUESTS_PATH}/{user_name}"
+        os.makedirs(OUT_DIR, exist_ok=True)
+
+        # Add the timestamp to the filename
+        out_path = f"{OUT_DIR}/{user_name}_{model_path}_{timestamp}.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_name} to eval queue",
+        )
+
+        gr.Info("Successfully submitted", duration=10)
+        # Remove the local file
+        os.remove(out_path)
+    except Exception as e:
+        gr.Error(f"Error submitting the model: {e}")