Initial commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.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
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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

.gitignore

@@ -0,0 +1,15 @@
+auto_evals/
+venv/
+__pycache__/
+.env
+.ipynb_checkpoints
+*ipynb
+.vscode/
+
+gpt_4_evals/
+human_evals/
+eval-queue/
+eval-results/
+auto_evals/
+
+src/assets/model_counts.html

.pre-commit-config.yaml

@@ -0,0 +1,53 @@
+# 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

@@ -0,0 +1,13 @@
+.PHONY: style format
+
+
+style:
+	python -m black --line-length 119 .
+	python -m isort .
+	ruff check --fix .
+
+
+quality:
+	python -m black --check --line-length 119 .
+	python -m isort --check-only .
+	ruff check .

README.md

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

README_github.md

@@ -0,0 +1,154 @@
+# Kyrgyz LLM Evaluation Dataset
+
+Welcome to the **KyrgyzLLM-Bench - kyrgyz LLM Evaluation Dataset**, your one-stop solution for evaluating Large Language Models (LLMs) in Kyrgyz. This toolkit helps you measure model performance across diverse domains and question types specific to the Kyrgyz language, so your models can be more accurate, robust, and helpful for Kyrgyz-speaking users. Whether you're a researcher, developer, or practitioner—this dataset is tailored to help your Kyrgyz-capable LLM thrive.
+
+[![Paper](https://img.shields.io/badge/IEEE%20Xplore-Paper-blue)](https://ieeexplore.ieee.org/document/11206960)  
+[![Model](https://img.shields.io/badge/HuggingFace-Hub-yellow)](https://huggingface.co/TTimur)
+
+
+![Kyrgyz LLM Evaluation in Tech Landscape](Kyrgyz%20LLM%20Evaluation%20in%20Tech%20Landscape.png "Kyrgyz LLM Evaluation")
+
+
+Quick facts:
+- Language Support: Kyrgyz (ky)
+- Audience: Researchers, developers, and the Kyrgyz NLP community
+- A native kyrgyz language datasets:
+• MMLU
+• Reading comprehension
+
+- Translated Benchmarks
+• Commonsense reasoning & understanding: HellaSwag and WinoGrande
+• Reading comprehension: BoolQ
+• Mathematics: GSM8K
+• Robustness & factuality: TruthfulQA 
+- Tooling: First-class support with Lighteval (see `lighteval/` scripts) and LM_harness (see `lm_harness/` scripts)
+
+## 🔍 What's Inside?
+
+KyrgyzLLM-Bench is a comprehensive suite purpose-built to evaluate LLMs’ deep understanding and reasoning in **Kyrgyz**. It combines natively authored benchmarks with carefully translated and post-edited international tasks to provide broad and culturally grounded coverage.
+
+- **Language**: Kyrgyz (ky)
+- **Components**:
+  - KyrgyzMMLU (native, multiple-choice, 7,977 questions)
+  - KyrgyzRC (native, reading comprehension, 400 questions)
+  - Translated benchmarks: HellaSwag, WinoGrande, BoolQ, GSM8K, TruthfulQA (manually post-edited)
+
+### 🧠 Diverse and Deep Evaluation Domains
+
+KyrgyzLLM-Bench spans foundational sciences, humanities, and applied domains relevant to the Kyrgyz national curriculum and public knowledge.
+
+#### KyrgyzMMLU (native, multiple-choice)
+- Total: 7,977 questions written by curriculum experts
+- Subjects and counts:
+  - Math: 1,169
+  - Physics: 1,228
+  - Geography: 640
+  - Biology: 1,550
+  - Kyrgyz Language: 360
+  - Kyrgyz Literature: 1,169
+  - Kyrgyz History: 440
+  - Medicine: 216
+  - Chemistry: 1,205
+
+#### KyrgyzRC (native, reading comprehension)
+- Total: 400 multiple-choice questions (4 options, 1 correct)
+- Sources: Kyrgyz Wikipedia, national news, literature, and school-style math word problems
+- Skills evaluated: factual understanding, inference, vocabulary-in-context, multi-sentence reasoning
+
+#### Translated Benchmarks (with manual post-editing)
+- Commonsense reasoning: HellaSwag, WinoGrande
+- Reading comprehension: BoolQ
+- Mathematics: GSM8K
+- Robustness/factuality: TruthfulQA
+
+Translation pipeline: dual-model machine translation (Claude 4 Sonnet, Gemini 2.5 Flash), ensemble comparison, expert post-editing, and quality checks (incl. back-translation sampling).
+
+## ⚡ Turbocharge Your Evaluations with Lighteval 🚀
+If you want to evaluate models with Lighteval, please see `README_lighteval.md` — all installation steps, supported Kyrgyz tasks, example commands (HF and local), and leaderboard task files are documented there.
+
+- Guide: [README_lighteval.md](./README_lighteval.md)
+
+## 📊 Results
+
+Below are the benchmark results for **Kyrgyz** in both zero-shot and few-shot settings.  
+Higher scores indicate better performance (accuracy for most tasks, QEM for GSM8K).
+
+---
+
+### 🏔️ Kyrgyz Zero-Shot Evaluation Results
+
+| Model                 | KyrgyzMMLU | KyrgyzRC | WinoGrande | BoolQ | HellaSwag | GSM8K | TruthfulQA | **Average** |
+| :-------------------- | :--------: | :------: | :--------: | :---: | :-------: | :---: | :--------: | :---------: |
+| **Qwen**              |            |          |            |       |           |       |            |             |
+| Qwen2.5-0.5B-Instruct |    27.4    |   53.2   |    51.5    |  37.9 |    14.6   |  0.7  |    33.5    |     31.3    |
+| Qwen2.5-1.5B-Instruct |    27.9    |   60.5   |    50.1    |  38.6 |    22.9   |  0.7  |    32.5    |     33.3    |
+| Qwen2.5-3B-Instruct   |    28.6    |   66.0   |    50.5    |  59.4 |    22.0   |  0.7  |    34.2    |     37.3    |
+| Qwen2.5-7B-Instruct   |    31.5    |   70.0   |    48.7    |  56.3 |    10.0   |  1.1  |    34.1    |     36.0    |
+| Qwen3-0.6B            |    26.0    |   61.8   |    49.8    |  38.0 |    11.1   |  0.7  |    29.9    |     31.0    |
+| Qwen3-1.7B            |    27.9    |   61.8   |    48.9    |  40.4 |    24.6   |  0.7  |    29.6    |     33.4    |
+| Qwen3-4B              |    30.3    |   68.2   |    49.0    |  38.3 |    24.5   |  0.7  |    32.9    |     34.8    |
+| Qwen3-8B              |    32.1    |   71.8   |    51.0    |  39.2 |    24.6   |  0.7  |    34.7    |     36.3    |
+| **Gemma**             |            |          |            |       |           |       |            |             |
+| gemma-3-1b-it         |    26.7    |   58.2   |    50.0    |  37.9 |    24.4   |  0.7  |    34.0    |     33.1    |
+| gemma-3-270m          |    27.5    |   56.8   |    48.3    |  37.9 |    17.4   |  0.7  |    34.7    |     31.9    |
+| gemma-3-4b-it         |    30.3    |   70.2   |    50.6    |  58.3 |    24.6   |  0.7  |    34.7    |   **38.5**  |
+| **Meta-Llama**        |            |          |            |       |           |       |            |             |
+| Llama-3.1-8B-Instruct |    31.0    |   75.2   |    50.6    |  50.3 |    26.6   |  0.7  |    33.7    |     38.3    |
+| Llama-3.2-1B-Instruct |    26.3    |   58.2   |    49.4    |  38.3 |    0.2    |  0.7  |    30.1    |     29.0    |
+| Llama-3.2-3B-Instruct |    27.8    |   64.2   |    49.1    |  43.1 |    24.5   |  0.7  |    31.5    |     34.4    |
+
+
+*Zero-shot evaluation results on Kyrgyz benchmarks (%). The metric is accuracy, except for GSM8K which uses QEM. Higher is better.*
+
+---
+
+### 🏔️ Kyrgyz Few-Shot Evaluation Results
+
+| Model                 | KyrgyzMMLU | KyrgyzRC | WinoGrande | BoolQ | HellaSwag | GSM8K | TruthfulQA | **Average** |
+| :-------------------- | :--------: | :------: | :--------: | :---: | :-------: | :---: | :--------: | :---------: |
+| **Qwen**              |            |          |            |       |           |       |            |             |
+| Qwen2.5-0.5B-Instruct |    25.4    |   54.0   |    49.7    |  61.0 |    25.9   |  2.2  |    33.4    |     35.9    |
+| Qwen2.5-1.5B-Instruct |    28.7    |   67.5   |    50.1    |  58.0 |    26.5   |  6.1  |    32.9    |     38.5    |
+| Qwen2.5-3B-Instruct   |    34.0    |   73.2   |    51.3    |  57.4 |    23.7   |  9.5  |    34.4    |     40.5    |
+| Qwen2.5-7B-Instruct   |    38.5    |   74.8   |    50.4    |  64.6 |    17.8   |  32.1 |    36.2    |     44.9    |
+| Qwen3-0.6B            |    26.8    |   59.5   |    50.1    |  60.1 |    26.4   |  4.3  |    30.0    |     36.8    |
+| Qwen3-1.7B            |    30.8    |   71.2   |    48.6    |  62.0 |    25.2   |  18.5 |    30.3    |     41.0    |
+| Qwen3-4B              |    38.5    |   77.2   |    48.1    |  74.0 |    24.7   |  51.5 |    32.5    |     49.4    |
+| Qwen3-8B              |    44.5    |   81.8   |    50.6    |  76.9 |    26.4   |  60.0 |    35.8    |   **53.7**  |
+| **Gemma**             |            |          |            |       |           |       |            |             |
+| gemma-3-1b-it         |    26.5    |   38.0   |    48.9    |  62.8 |    23.5   |  3.2  |    31.3    |     33.5    |
+| gemma-3-270m          |    27.0    |   53.2   |    48.7    |  61.5 |    27.6   |  1.4  |    36.6    |     36.6    |
+| gemma-3-4b-it         |    29.5    |   25.0   |    49.6    |  62.1 |    24.6   |  0.0  |    50.0    |     34.5    |
+| **Meta-Llama**        |            |          |            |       |           |       |            |             |
+| Llama-3.1-8B-Instruct |    38.1    |   80.5   |    51.6    |  75.5 |    21.9   |  37.0 |    34.4    |     48.5    |
+| Llama-3.2-1B-Instruct |    26.1    |   45.8   |    49.7    |  62.0 |    25.8   |  2.7  |    30.3    |     34.7    |
+| Llama-3.2-3B-Instruct |    29.4    |   64.8   |    48.9    |  62.3 |    25.3   |  12.9 |    32.9    |     39.6    |
+
+
+*Few-shot evaluation results on Kyrgyz benchmarks (%). All tasks are 5-shot, except for HellaSwag (10-shot). The metric is accuracy, except for GSM8K which uses QEM. Higher is better.*
+
+
+## 💡 Contributions Welcome!
+
+Have ideas, bug fixes, or want to add a custom task? We'd love for you to be part of the journey! Contributions help grow and enhance the capabilities of the **KyrgyzLLM-Bench**.
+
+## 📜 Citation
+
+Thanks for using **KyrgyzLLM-Bench** — where language learning models meet Serbian precision and creativity! Let's build smarter models together. 🚀�
+
+If you find this dataset useful in your research, please cite it as follows:
+
+```bibtex
+@article{KyrgyzLLM-Bench,
+  title={Bridging the Gap in Less-Resourced Languages: Building a Benchmark for Kyrgyz Language Models},
+  author={Timur Turatali, Aida Turdubaeva, Islam Zhenishbekov, Zhoomart Suranbaev, Anton Alekseev, Rustem Izmailov},
+  year={2025},
+  url={https://huggingface.co/datasets/TTimur/kyrgyzMMLU, 
+  https://huggingface.co/datasets/TTimur/kyrgyzRC, 
+  https://huggingface.co/datasets/TTimur/winogrande_kg, 
+  https://huggingface.co/datasets/TTimur/boolq_kg, 
+  https://huggingface.co/datasets/TTimur/truthfulqa_kg, 
+  https://huggingface.co/datasets/TTimur/gsm8k_kg, 
+  https://huggingface.co/datasets/TTimur/hellaswag_kg}
+}
+```

app.py

@@ -0,0 +1,348 @@
+import gradio as gr
+import pandas as pd
+from apscheduler.schedulers.background import BackgroundScheduler
+from huggingface_hub import snapshot_download
+import os
+os.environ['CURL_CA_BUNDLE'] = ''
+
+from src.display.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, TOKEN, QUEUE_REPO, REPO_ID, RESULTS_REPO
+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, token=TOKEN)
+
+try:
+    print(EVAL_REQUESTS_PATH)
+    snapshot_download(
+        repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30
+    )
+except Exception:
+    restart_space()
+try:
+    print(EVAL_RESULTS_PATH)
+    snapshot_download(
+        repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30
+    )
+except Exception:
+    restart_space()
+
+
+raw_data, original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS)
+leaderboard_df = original_df.copy()
+
+(
+    finished_eval_queue_df,
+    running_eval_queue_df,
+    pending_eval_queue_df,
+) = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
+
+
+# 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)
+    return df
+
+
+def search_table(df: pd.DataFrame, query: str) -> pd.DataFrame:
+    return df[(df[AutoEvalColumn.dummy.name].str.contains(query, case=False))]
+
+
+def select_columns(df: pd.DataFrame, columns: list) -> pd.DataFrame:
+    always_here_cols = [
+        AutoEvalColumn.model_type_symbol.name,
+        AutoEvalColumn.model.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] + [AutoEvalColumn.dummy.name]
+    ]
+    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
+
+
+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]
+
+    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]
+
+    return filtered_df
+
+
+demo = gr.Blocks(css=custom_css)
+with demo:
+    gr.HTML(TITLE)
+    gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
+
+    with gr.Tabs(elem_classes="tab-buttons") as tabs:
+        with gr.TabItem("🏅 LLM Benchmark", elem_id="llm-benchmark-tab-table", id=0):
+            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 and not c.dummy
+                            ],
+                            value=[
+                                c.name
+                                for c in fields(AutoEvalColumn)
+                                if c.displayed_by_default and not c.hidden and not c.never_hidden
+                            ],
+                            label="Select columns 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",
+                    )
+
+            leaderboard_table = gr.components.Dataframe(
+                value=leaderboard_df[
+                    [c.name for c in fields(AutoEvalColumn) if c.never_hidden]
+                    + shown_columns.value
+                    + [AutoEvalColumn.dummy.name]
+                ],
+                headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
+                datatype=TYPES,
+                elem_id="leaderboard-table",
+                interactive=False,
+                visible=True,
+                column_widths=["2%", "33%"] 
+            )
+
+            # Dummy leaderboard for handling the case when the user uses backspace key
+            hidden_leaderboard_table_for_search = gr.components.Dataframe(
+                value=original_df[COLS],
+                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,
+                    search_bar,
+                ],
+                leaderboard_table,
+            )
+            for selector in [shown_columns, filter_columns_type, filter_columns_precision, filter_columns_size, deleted_models_visibility]:
+                selector.change(
+                    update_table,
+                    [
+                        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 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()

kyrgyz_results/results_Qwen__Qwen2.5-0.5B-Instruct_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen2.5-0.5B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.254
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.54
+    },
+    "WinoGrande": {
+      "metric_name": 0.49700000000000005
+    },
+    "BoolQ": {
+      "metric_name": 0.61
+    },
+    "HellaSwag": {
+      "metric_name": 0.259
+    },
+    "GSM8K": {
+      "metric_name": 0.022000000000000002
+    },
+    "TruthfulQA": {
+      "metric_name": 0.33399999999999996
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen2.5-0.5B-Instruct_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen2.5-0.5B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.27399999999999997
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.532
+    },
+    "WinoGrande": {
+      "metric_name": 0.515
+    },
+    "BoolQ": {
+      "metric_name": 0.379
+    },
+    "HellaSwag": {
+      "metric_name": 0.146
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.335
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen2.5-1.5B-Instruct_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen2.5-1.5B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.287
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.675
+    },
+    "WinoGrande": {
+      "metric_name": 0.501
+    },
+    "BoolQ": {
+      "metric_name": 0.58
+    },
+    "HellaSwag": {
+      "metric_name": 0.265
+    },
+    "GSM8K": {
+      "metric_name": 0.061
+    },
+    "TruthfulQA": {
+      "metric_name": 0.32899999999999996
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen2.5-1.5B-Instruct_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen2.5-1.5B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.27899999999999997
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.605
+    },
+    "WinoGrande": {
+      "metric_name": 0.501
+    },
+    "BoolQ": {
+      "metric_name": 0.386
+    },
+    "HellaSwag": {
+      "metric_name": 0.22899999999999998
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.325
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen2.5-3B-Instruct_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen2.5-3B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.34
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.732
+    },
+    "WinoGrande": {
+      "metric_name": 0.513
+    },
+    "BoolQ": {
+      "metric_name": 0.574
+    },
+    "HellaSwag": {
+      "metric_name": 0.237
+    },
+    "GSM8K": {
+      "metric_name": 0.095
+    },
+    "TruthfulQA": {
+      "metric_name": 0.344
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen2.5-3B-Instruct_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen2.5-3B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.28600000000000003
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.66
+    },
+    "WinoGrande": {
+      "metric_name": 0.505
+    },
+    "BoolQ": {
+      "metric_name": 0.594
+    },
+    "HellaSwag": {
+      "metric_name": 0.22
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.342
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen2.5-7B-Instruct_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen2.5-7B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.385
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.748
+    },
+    "WinoGrande": {
+      "metric_name": 0.504
+    },
+    "BoolQ": {
+      "metric_name": 0.6459999999999999
+    },
+    "HellaSwag": {
+      "metric_name": 0.17800000000000002
+    },
+    "GSM8K": {
+      "metric_name": 0.321
+    },
+    "TruthfulQA": {
+      "metric_name": 0.36200000000000004
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen2.5-7B-Instruct_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen2.5-7B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.315
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.7
+    },
+    "WinoGrande": {
+      "metric_name": 0.48700000000000004
+    },
+    "BoolQ": {
+      "metric_name": 0.563
+    },
+    "HellaSwag": {
+      "metric_name": 0.1
+    },
+    "GSM8K": {
+      "metric_name": 0.011000000000000001
+    },
+    "TruthfulQA": {
+      "metric_name": 0.341
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen3-0.6B_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen3-0.6B",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.268
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.595
+    },
+    "WinoGrande": {
+      "metric_name": 0.501
+    },
+    "BoolQ": {
+      "metric_name": 0.601
+    },
+    "HellaSwag": {
+      "metric_name": 0.264
+    },
+    "GSM8K": {
+      "metric_name": 0.043
+    },
+    "TruthfulQA": {
+      "metric_name": 0.3
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen3-0.6B_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen3-0.6B",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.26
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.618
+    },
+    "WinoGrande": {
+      "metric_name": 0.498
+    },
+    "BoolQ": {
+      "metric_name": 0.38
+    },
+    "HellaSwag": {
+      "metric_name": 0.111
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.299
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen3-1.7B_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen3-1.7B",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.308
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.7120000000000001
+    },
+    "WinoGrande": {
+      "metric_name": 0.486
+    },
+    "BoolQ": {
+      "metric_name": 0.62
+    },
+    "HellaSwag": {
+      "metric_name": 0.252
+    },
+    "GSM8K": {
+      "metric_name": 0.185
+    },
+    "TruthfulQA": {
+      "metric_name": 0.303
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen3-1.7B_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen3-1.7B",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.27899999999999997
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.618
+    },
+    "WinoGrande": {
+      "metric_name": 0.489
+    },
+    "BoolQ": {
+      "metric_name": 0.40399999999999997
+    },
+    "HellaSwag": {
+      "metric_name": 0.24600000000000002
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.29600000000000004
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen3-4B_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen3-4B",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.385
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.772
+    },
+    "WinoGrande": {
+      "metric_name": 0.48100000000000004
+    },
+    "BoolQ": {
+      "metric_name": 0.74
+    },
+    "HellaSwag": {
+      "metric_name": 0.247
+    },
+    "GSM8K": {
+      "metric_name": 0.515
+    },
+    "TruthfulQA": {
+      "metric_name": 0.325
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen3-4B_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen3-4B",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.303
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.682
+    },
+    "WinoGrande": {
+      "metric_name": 0.49
+    },
+    "BoolQ": {
+      "metric_name": 0.38299999999999995
+    },
+    "HellaSwag": {
+      "metric_name": 0.245
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.32899999999999996
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen3-8B_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen3-8B",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.445
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.818
+    },
+    "WinoGrande": {
+      "metric_name": 0.506
+    },
+    "BoolQ": {
+      "metric_name": 0.769
+    },
+    "HellaSwag": {
+      "metric_name": 0.264
+    },
+    "GSM8K": {
+      "metric_name": 0.6
+    },
+    "TruthfulQA": {
+      "metric_name": 0.358
+    }
+  }
+}

kyrgyz_results/results_Qwen__Qwen3-8B_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "Qwen/Qwen3-8B",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.321
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.718
+    },
+    "WinoGrande": {
+      "metric_name": 0.51
+    },
+    "BoolQ": {
+      "metric_name": 0.392
+    },
+    "HellaSwag": {
+      "metric_name": 0.24600000000000002
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.34700000000000003
+    }
+  }
+}

kyrgyz_results/results_google__gemma-3-1b-it_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "google/gemma-3-1b-it",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.265
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.38
+    },
+    "WinoGrande": {
+      "metric_name": 0.489
+    },
+    "BoolQ": {
+      "metric_name": 0.628
+    },
+    "HellaSwag": {
+      "metric_name": 0.235
+    },
+    "GSM8K": {
+      "metric_name": 0.032
+    },
+    "TruthfulQA": {
+      "metric_name": 0.313
+    }
+  }
+}

kyrgyz_results/results_google__gemma-3-1b-it_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "google/gemma-3-1b-it",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.267
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.5820000000000001
+    },
+    "WinoGrande": {
+      "metric_name": 0.5
+    },
+    "BoolQ": {
+      "metric_name": 0.379
+    },
+    "HellaSwag": {
+      "metric_name": 0.244
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.34
+    }
+  }
+}

kyrgyz_results/results_google__gemma-3-270m_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "google/gemma-3-270m",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.27
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.532
+    },
+    "WinoGrande": {
+      "metric_name": 0.48700000000000004
+    },
+    "BoolQ": {
+      "metric_name": 0.615
+    },
+    "HellaSwag": {
+      "metric_name": 0.276
+    },
+    "GSM8K": {
+      "metric_name": 0.013999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.366
+    }
+  }
+}

kyrgyz_results/results_google__gemma-3-270m_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "google/gemma-3-270m",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.275
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.568
+    },
+    "WinoGrande": {
+      "metric_name": 0.483
+    },
+    "BoolQ": {
+      "metric_name": 0.379
+    },
+    "HellaSwag": {
+      "metric_name": 0.174
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.34700000000000003
+    }
+  }
+}

kyrgyz_results/results_google__gemma-3-4b-it_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "google/gemma-3-4b-it",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.295
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.25
+    },
+    "WinoGrande": {
+      "metric_name": 0.496
+    },
+    "BoolQ": {
+      "metric_name": 0.621
+    },
+    "HellaSwag": {
+      "metric_name": 0.24600000000000002
+    },
+    "GSM8K": {
+      "metric_name": 0.0
+    },
+    "TruthfulQA": {
+      "metric_name": 0.5
+    }
+  }
+}

kyrgyz_results/results_google__gemma-3-4b-it_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "google/gemma-3-4b-it",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.303
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.7020000000000001
+    },
+    "WinoGrande": {
+      "metric_name": 0.506
+    },
+    "BoolQ": {
+      "metric_name": 0.583
+    },
+    "HellaSwag": {
+      "metric_name": 0.24600000000000002
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.34700000000000003
+    }
+  }
+}

kyrgyz_results/results_meta-llama__Llama-3.1-8B-Instruct_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "meta-llama/Llama-3.1-8B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.381
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.805
+    },
+    "WinoGrande": {
+      "metric_name": 0.516
+    },
+    "BoolQ": {
+      "metric_name": 0.755
+    },
+    "HellaSwag": {
+      "metric_name": 0.21899999999999997
+    },
+    "GSM8K": {
+      "metric_name": 0.37
+    },
+    "TruthfulQA": {
+      "metric_name": 0.344
+    }
+  }
+}

kyrgyz_results/results_meta-llama__Llama-3.1-8B-Instruct_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "meta-llama/Llama-3.1-8B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.31
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.752
+    },
+    "WinoGrande": {
+      "metric_name": 0.506
+    },
+    "BoolQ": {
+      "metric_name": 0.503
+    },
+    "HellaSwag": {
+      "metric_name": 0.266
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.337
+    }
+  }
+}

kyrgyz_results/results_meta-llama__Llama-3.2-1B-Instruct_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "meta-llama/Llama-3.2-1B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.261
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.45799999999999996
+    },
+    "WinoGrande": {
+      "metric_name": 0.49700000000000005
+    },
+    "BoolQ": {
+      "metric_name": 0.62
+    },
+    "HellaSwag": {
+      "metric_name": 0.258
+    },
+    "GSM8K": {
+      "metric_name": 0.027000000000000003
+    },
+    "TruthfulQA": {
+      "metric_name": 0.303
+    }
+  }
+}

kyrgyz_results/results_meta-llama__Llama-3.2-1B-Instruct_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "meta-llama/Llama-3.2-1B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.263
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.5820000000000001
+    },
+    "WinoGrande": {
+      "metric_name": 0.494
+    },
+    "BoolQ": {
+      "metric_name": 0.38299999999999995
+    },
+    "HellaSwag": {
+      "metric_name": 0.002
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.301
+    }
+  }
+}

kyrgyz_results/results_meta-llama__Llama-3.2-3B-Instruct_few_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "meta-llama/Llama-3.2-3B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.294
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.648
+    },
+    "WinoGrande": {
+      "metric_name": 0.489
+    },
+    "BoolQ": {
+      "metric_name": 0.623
+    },
+    "HellaSwag": {
+      "metric_name": 0.253
+    },
+    "GSM8K": {
+      "metric_name": 0.129
+    },
+    "TruthfulQA": {
+      "metric_name": 0.32899999999999996
+    }
+  }
+}

kyrgyz_results/results_meta-llama__Llama-3.2-3B-Instruct_zero_shot.json

@@ -0,0 +1,30 @@
+{
+  "config": {
+    "model_name": "meta-llama/Llama-3.2-3B-Instruct",
+    "model_dtype": "float16",
+    "model_sha": "main"
+  },
+  "results": {
+    "KyrgyzMMLU": {
+      "metric_name": 0.278
+    },
+    "KyrgyzRC": {
+      "metric_name": 0.642
+    },
+    "WinoGrande": {
+      "metric_name": 0.491
+    },
+    "BoolQ": {
+      "metric_name": 0.431
+    },
+    "HellaSwag": {
+      "metric_name": 0.245
+    },
+    "GSM8K": {
+      "metric_name": 0.006999999999999999
+    },
+    "TruthfulQA": {
+      "metric_name": 0.315
+    }
+  }
+}

pyproject.toml

@@ -0,0 +1,13 @@
+[tool.ruff]
+# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
+select = ["E", "F"]
+ignore = ["E501"] # line too long (black is taking care of this)
+line-length = 119
+fixable = ["A", "B", "C", "D", "E", "F", "G", "I", "N", "Q", "S", "T", "W", "ANN", "ARG", "BLE", "COM", "DJ", "DTZ", "EM", "ERA", "EXE", "FBT", "ICN", "INP", "ISC", "NPY", "PD", "PGH", "PIE", "PL", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "SIM", "SLF", "TCH", "TID", "TRY", "UP", "YTT"]
+
+[tool.isort]
+profile = "black"
+line_length = 119
+
+[tool.black]
+line-length = 119

requirements.txt

@@ -0,0 +1,15 @@
+APScheduler==3.10.1
+black==23.11.0
+click==8.1.3
+datasets==2.14.5
+gradio==4.43.0
+gradio-client==1.3.0
+huggingface-hub>=0.18.0
+matplotlib==3.7.1
+numpy==1.24.2
+pandas==2.0.0
+python-dateutil==2.8.2
+requests
+tqdm==4.65.0
+transformers==4.35.2
+tokenizers>=0.15.0

scripts/create_request_file.py

@@ -0,0 +1,107 @@
+import json
+import os
+import pprint
+import re
+from datetime import datetime, timezone
+
+import click
+from colorama import Fore
+from huggingface_hub import HfApi, snapshot_download
+
+EVAL_REQUESTS_PATH = "eval-queue"
+QUEUE_REPO = "open-llm-leaderboard/requests"
+
+precisions = ("float16", "bfloat16", "8bit (LLM.int8)", "4bit (QLoRA / FP4)", "GPTQ")
+model_types = ("pretrained", "fine-tuned", "RL-tuned", "instruction-tuned")
+weight_types = ("Original", "Delta", "Adapter")
+
+
+def get_model_size(model_info, precision: str):
+    size_pattern = size_pattern = re.compile(r"(\d\.)?\d+(b|m)")
+    try:
+        model_size = round(model_info.safetensors["total"] / 1e9, 3)
+    except (AttributeError, TypeError):
+        try:
+            size_match = re.search(size_pattern, model_info.modelId.lower())
+            model_size = size_match.group(0)
+            model_size = round(float(model_size[:-1]) if model_size[-1] == "b" else float(model_size[:-1]) / 1e3, 3)
+        except AttributeError:
+            return 0  # Unknown model sizes are indicated as 0, see NUMERIC_INTERVALS in app.py
+
+    size_factor = 8 if (precision == "GPTQ" or "gptq" in model_info.modelId.lower()) else 1
+    model_size = size_factor * model_size
+    return model_size
+
+
+def main():
+    api = HfApi()
+    current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    snapshot_download(repo_id=QUEUE_REPO, revision="main", local_dir=EVAL_REQUESTS_PATH, repo_type="dataset")
+
+    model_name = click.prompt("Enter model name")
+    revision = click.prompt("Enter revision", default="main")
+    precision = click.prompt("Enter precision", default="float16", type=click.Choice(precisions))
+    model_type = click.prompt("Enter model type", type=click.Choice(model_types))
+    weight_type = click.prompt("Enter weight type", default="Original", type=click.Choice(weight_types))
+    base_model = click.prompt("Enter base model", default="")
+    status = click.prompt("Enter status", default="FINISHED")
+
+    try:
+        model_info = api.model_info(repo_id=model_name, revision=revision)
+    except Exception as e:
+        print(f"{Fore.RED}Could not find model info for {model_name} on the Hub\n{e}{Fore.RESET}")
+        return 1
+
+    model_size = get_model_size(model_info=model_info, precision=precision)
+
+    try:
+        license = model_info.cardData["license"]
+    except Exception:
+        license = "?"
+
+    eval_entry = {
+        "model": model_name,
+        "base_model": base_model,
+        "revision": revision,
+        "private": False,
+        "precision": precision,
+        "weight_type": weight_type,
+        "status": status,
+        "submitted_time": current_time,
+        "model_type": model_type,
+        "likes": model_info.likes,
+        "params": model_size,
+        "license": license,
+    }
+
+    user_name = ""
+    model_path = model_name
+    if "/" in model_name:
+        user_name = model_name.split("/")[0]
+        model_path = model_name.split("/")[1]
+
+    pprint.pprint(eval_entry)
+
+    if click.confirm("Do you want to continue? This request file will be pushed to the hub"):
+        click.echo("continuing...")
+
+        out_dir = f"{EVAL_REQUESTS_PATH}/{user_name}"
+        os.makedirs(out_dir, exist_ok=True)
+        out_path = f"{out_dir}/{model_path}_eval_request_{False}_{precision}_{weight_type}.json"
+
+        with open(out_path, "w") as f:
+            f.write(json.dumps(eval_entry))
+
+        api.upload_file(
+            path_or_fileobj=out_path,
+            path_in_repo=out_path.split(f"{EVAL_REQUESTS_PATH}/")[1],
+            repo_id=QUEUE_REPO,
+            repo_type="dataset",
+            commit_message=f"Add {model_name} to eval queue",
+        )
+    else:
+        click.echo("aborting...")
+
+
+if __name__ == "__main__":
+    main()

scripts/generate_kyrgyz_results_json.py

@@ -0,0 +1,117 @@
+import json
+import os
+from typing import Dict, List
+
+
+# Maps display names in README to real Hub model IDs for better visibility (still_on_hub=True)
+MODEL_ID_MAP = {
+    # Qwen
+    "Qwen2.5-0.5B-Instruct": "Qwen/Qwen2.5-0.5B-Instruct",
+    "Qwen2.5-1.5B-Instruct": "Qwen/Qwen2.5-1.5B-Instruct",
+    "Qwen2.5-3B-Instruct": "Qwen/Qwen2.5-3B-Instruct",
+    "Qwen2.5-7B-Instruct": "Qwen/Qwen2.5-7B-Instruct",
+    "Qwen3-0.6B": "Qwen/Qwen3-0.6B",
+    "Qwen3-1.7B": "Qwen/Qwen3-1.7B",
+    "Qwen3-4B": "Qwen/Qwen3-4B",
+    "Qwen3-8B": "Qwen/Qwen3-8B",
+    # Gemma
+    "gemma-3-270m": "google/gemma-3-270m",
+    "gemma-3-1b-it": "google/gemma-3-1b-it",
+    "gemma-3-4b-it": "google/gemma-3-4b-it",
+    # Llama
+    "Llama-3.1-8B-Instruct": "meta-llama/Llama-3.1-8B-Instruct",
+    "Llama-3.2-1B-Instruct": "meta-llama/Llama-3.2-1B-Instruct",
+    "Llama-3.2-3B-Instruct": "meta-llama/Llama-3.2-3B-Instruct",
+}
+
+
+TASK_KEYS = [
+    "KyrgyzMMLU",
+    "KyrgyzRC",
+    "WinoGrande",
+    "BoolQ",
+    "HellaSwag",
+    "GSM8K",
+    "TruthfulQA",
+]
+
+
+# Percent values from README tables (Zero-shot)
+ZERO_SHOT: Dict[str, Dict[str, float]] = {
+    # Qwen
+    "Qwen2.5-0.5B-Instruct": {"KyrgyzMMLU": 27.4, "KyrgyzRC": 53.2, "WinoGrande": 51.5, "BoolQ": 37.9, "HellaSwag": 14.6, "GSM8K": 0.7, "TruthfulQA": 33.5},
+    "Qwen2.5-1.5B-Instruct": {"KyrgyzMMLU": 27.9, "KyrgyzRC": 60.5, "WinoGrande": 50.1, "BoolQ": 38.6, "HellaSwag": 22.9, "GSM8K": 0.7, "TruthfulQA": 32.5},
+    "Qwen2.5-3B-Instruct": {"KyrgyzMMLU": 28.6, "KyrgyzRC": 66.0, "WinoGrande": 50.5, "BoolQ": 59.4, "HellaSwag": 22.0, "GSM8K": 0.7, "TruthfulQA": 34.2},
+    "Qwen2.5-7B-Instruct": {"KyrgyzMMLU": 31.5, "KyrgyzRC": 70.0, "WinoGrande": 48.7, "BoolQ": 56.3, "HellaSwag": 10.0, "GSM8K": 1.1, "TruthfulQA": 34.1},
+    "Qwen3-0.6B": {"KyrgyzMMLU": 26.0, "KyrgyzRC": 61.8, "WinoGrande": 49.8, "BoolQ": 38.0, "HellaSwag": 11.1, "GSM8K": 0.7, "TruthfulQA": 29.9},
+    "Qwen3-1.7B": {"KyrgyzMMLU": 27.9, "KyrgyzRC": 61.8, "WinoGrande": 48.9, "BoolQ": 40.4, "HellaSwag": 24.6, "GSM8K": 0.7, "TruthfulQA": 29.6},
+    "Qwen3-4B": {"KyrgyzMMLU": 30.3, "KyrgyzRC": 68.2, "WinoGrande": 49.0, "BoolQ": 38.3, "HellaSwag": 24.5, "GSM8K": 0.7, "TruthfulQA": 32.9},
+    "Qwen3-8B": {"KyrgyzMMLU": 32.1, "KyrgyzRC": 71.8, "WinoGrande": 51.0, "BoolQ": 39.2, "HellaSwag": 24.6, "GSM8K": 0.7, "TruthfulQA": 34.7},
+    # Gemma
+    "gemma-3-1b-it": {"KyrgyzMMLU": 26.7, "KyrgyzRC": 58.2, "WinoGrande": 50.0, "BoolQ": 37.9, "HellaSwag": 24.4, "GSM8K": 0.7, "TruthfulQA": 34.0},
+    "gemma-3-270m": {"KyrgyzMMLU": 27.5, "KyrgyzRC": 56.8, "WinoGrande": 48.3, "BoolQ": 37.9, "HellaSwag": 17.4, "GSM8K": 0.7, "TruthfulQA": 34.7},
+    "gemma-3-4b-it": {"KyrgyzMMLU": 30.3, "KyrgyzRC": 70.2, "WinoGrande": 50.6, "BoolQ": 58.3, "HellaSwag": 24.6, "GSM8K": 0.7, "TruthfulQA": 34.7},
+    # Llama
+    "Llama-3.1-8B-Instruct": {"KyrgyzMMLU": 31.0, "KyrgyzRC": 75.2, "WinoGrande": 50.6, "BoolQ": 50.3, "HellaSwag": 26.6, "GSM8K": 0.7, "TruthfulQA": 33.7},
+    "Llama-3.2-1B-Instruct": {"KyrgyzMMLU": 26.3, "KyrgyzRC": 58.2, "WinoGrande": 49.4, "BoolQ": 38.3, "HellaSwag": 0.2, "GSM8K": 0.7, "TruthfulQA": 30.1},
+    "Llama-3.2-3B-Instruct": {"KyrgyzMMLU": 27.8, "KyrgyzRC": 64.2, "WinoGrande": 49.1, "BoolQ": 43.1, "HellaSwag": 24.5, "GSM8K": 0.7, "TruthfulQA": 31.5},
+}
+
+
+# Percent values from README tables (Few-shot)
+FEW_SHOT: Dict[str, Dict[str, float]] = {
+    # Qwen
+    "Qwen2.5-0.5B-Instruct": {"KyrgyzMMLU": 25.4, "KyrgyzRC": 54.0, "WinoGrande": 49.7, "BoolQ": 61.0, "HellaSwag": 25.9, "GSM8K": 2.2, "TruthfulQA": 33.4},
+    "Qwen2.5-1.5B-Instruct": {"KyrgyzMMLU": 28.7, "KyrgyzRC": 67.5, "WinoGrande": 50.1, "BoolQ": 58.0, "HellaSwag": 26.5, "GSM8K": 6.1, "TruthfulQA": 32.9},
+    "Qwen2.5-3B-Instruct": {"KyrgyzMMLU": 34.0, "KyrgyzRC": 73.2, "WinoGrande": 51.3, "BoolQ": 57.4, "HellaSwag": 23.7, "GSM8K": 9.5, "TruthfulQA": 34.4},
+    "Qwen2.5-7B-Instruct": {"KyrgyzMMLU": 38.5, "KyrgyzRC": 74.8, "WinoGrande": 50.4, "BoolQ": 64.6, "HellaSwag": 17.8, "GSM8K": 32.1, "TruthfulQA": 36.2},
+    "Qwen3-0.6B": {"KyrgyzMMLU": 26.8, "KyrgyzRC": 59.5, "WinoGrande": 50.1, "BoolQ": 60.1, "HellaSwag": 26.4, "GSM8K": 4.3, "TruthfulQA": 30.0},
+    "Qwen3-1.7B": {"KyrgyzMMLU": 30.8, "KyrgyzRC": 71.2, "WinoGrande": 48.6, "BoolQ": 62.0, "HellaSwag": 25.2, "GSM8K": 18.5, "TruthfulQA": 30.3},
+    "Qwen3-4B": {"KyrgyzMMLU": 38.5, "KyrgyzRC": 77.2, "WinoGrande": 48.1, "BoolQ": 74.0, "HellaSwag": 24.7, "GSM8K": 51.5, "TruthfulQA": 32.5},
+    "Qwen3-8B": {"KyrgyzMMLU": 44.5, "KyrgyzRC": 81.8, "WinoGrande": 50.6, "BoolQ": 76.9, "HellaSwag": 26.4, "GSM8K": 60.0, "TruthfulQA": 35.8},
+    # Gemma
+    "gemma-3-1b-it": {"KyrgyzMMLU": 26.5, "KyrgyzRC": 38.0, "WinoGrande": 48.9, "BoolQ": 62.8, "HellaSwag": 23.5, "GSM8K": 3.2, "TruthfulQA": 31.3},
+    "gemma-3-270m": {"KyrgyzMMLU": 27.0, "KyrgyzRC": 53.2, "WinoGrande": 48.7, "BoolQ": 61.5, "HellaSwag": 27.6, "GSM8K": 1.4, "TruthfulQA": 36.6},
+    "gemma-3-4b-it": {"KyrgyzMMLU": 29.5, "KyrgyzRC": 25.0, "WinoGrande": 49.6, "BoolQ": 62.1, "HellaSwag": 24.6, "GSM8K": 0.0, "TruthfulQA": 50.0},
+    # Llama
+    "Llama-3.1-8B-Instruct": {"KyrgyzMMLU": 38.1, "KyrgyzRC": 80.5, "WinoGrande": 51.6, "BoolQ": 75.5, "HellaSwag": 21.9, "GSM8K": 37.0, "TruthfulQA": 34.4},
+    "Llama-3.2-1B-Instruct": {"KyrgyzMMLU": 26.1, "KyrgyzRC": 45.8, "WinoGrande": 49.7, "BoolQ": 62.0, "HellaSwag": 25.8, "GSM8K": 2.7, "TruthfulQA": 30.3},
+    "Llama-3.2-3B-Instruct": {"KyrgyzMMLU": 29.4, "KyrgyzRC": 64.8, "WinoGrande": 48.9, "BoolQ": 62.3, "HellaSwag": 25.3, "GSM8K": 12.9, "TruthfulQA": 32.9},
+}
+
+
+def to_result_json(model_id: str, metrics: Dict[str, float]) -> Dict:
+    return {
+        "config": {
+            "model_name": model_id,
+            "model_dtype": "float16",
+            "model_sha": "main",
+        },
+        "results": {k: {"metric_name": (v / 100.0) if v is not None else None} for k, v in metrics.items()},
+    }
+
+
+def write_results(out_dir: str, table: Dict[str, Dict[str, float]], tag: str):
+    os.makedirs(out_dir, exist_ok=True)
+    for display_name, metrics in table.items():
+        model_id = MODEL_ID_MAP.get(display_name, f"TTimur/{display_name}")
+        payload = to_result_json(model_id, metrics)
+        # Filename convention similar to other spaces; any name ending with .json is fine
+        safe_model = model_id.replace("/", "__")
+        out_path = os.path.join(out_dir, f"results_{safe_model}_{tag}.json")
+        with open(out_path, "w") as f:
+            json.dump(payload, f, ensure_ascii=False, indent=2)
+        print(f"Wrote {out_path}")
+
+
+def main():
+    out_dir = os.environ.get("OUT_DIR", "./kyrgyz_results")
+    write_results(out_dir, ZERO_SHOT, "zero_shot")
+    write_results(out_dir, FEW_SHOT, "few_shot")
+    print("Done. Upload generated JSONs to your dataset repo (e.g., TTimur/results_kg_v0.1)")
+
+
+if __name__ == "__main__":
+    main()
+
+

src/display/about.py

@@ -0,0 +1,103 @@
+from dataclasses import dataclass
+from enum import Enum
+
+@dataclass
+class Task:
+    benchmark: str
+    metric: str
+    col_name: str
+
+
+# Init: to update with your specific keys
+class Tasks(Enum):
+    # task_key in the json file, metric_key in the json file, name to display in the leaderboard 
+    task0 = Task("KyrgyzMMLU", "metric_name", "KyrgyzMMLU")
+    task1 = Task("KyrgyzRC", "metric_name", "KyrgyzRC")
+    task2 = Task("WinoGrande", "metric_name", "WinoGrande")
+    task3 = Task("BoolQ", "metric_name", "BoolQ")
+    task4 = Task("HellaSwag", "metric_name", "HellaSwag")
+    task5 = Task("GSM8K", "metric_name", "GSM8K")
+    task6 = Task("TruthfulQA", "metric_name", "TruthfulQA")
+    
+
+# Your leaderboard name
+TITLE = """<h1 align="center" id="space-title"> OpenLLM Kyrgyz Leaderboard v0.1</h1>"""
+
+# What does your leaderboard evaluate?
+INTRODUCTION_TEXT = """
+Welcome to the Kyrgyz LLM Leaderboard — a dedicated platform for evaluating Large Language Models on Kyrgyz benchmarks. This space highlights models that perform well in Kyrgyz and helps advance research and tooling for low-resource languages.
+
+Benchmarks include native Kyrgyz tasks (KyrgyzMMLU, KyrgyzRC) and carefully translated sets (WinoGrande, BoolQ, HellaSwag, GSM8K, TruthfulQA). Scores are comparable across models and settings.
+
+🚀 Submit Your Model 🚀
+
+Have a Kyrgyz-capable model? Submit it for evaluation (currently manual) and help build a stronger Kyrgyz NLP ecosystem. See the About tab for details.
+"""
+
+# Which evaluations are you running? how can people reproduce what you have?
+LLM_BENCHMARKS_TEXT = f"""
+## How it works
+
+## Reproducibility
+
+This leaderboard aggregates results from Kyrgyz benchmarks. Datasets are hosted on the Hugging Face Hub under `TTimur`:
+- KyrgyzMMLU: `TTimur/kyrgyzMMLU`
+- KyrgyzRC: `TTimur/kyrgyzRC`
+- WinoGrande (KY): `TTimur/winogrande_kg`
+- BoolQ (KY): `TTimur/boolq_kg`
+- HellaSwag (KY): `TTimur/hellaswag_kg`
+- GSM8K (KY): `TTimur/gsm8k_kg`
+- TruthfulQA (KY): `TTimur/truthfulqa_kg`
+
+You can evaluate using your preferred evaluation harness (e.g., Lighteval or EleutherAI's lm-evaluation-harness) with Kyrgyz tasks enabled and then upload the resulting JSON to the results dataset for this Space.
+
+Notes:
+- Metrics reported are accuracy (or QEM for GSM8K), aligned with the dataset conventions.
+- Ensure you use consistent few-shot settings when comparing models.
+"""
+
+EVALUATION_QUEUE_TEXT = """
+## Some good practices before submitting a model
+
+### 1) Make sure you can load your model and tokenizer using AutoClasses:
+```python
+from transformers import AutoConfig, AutoModel, AutoTokenizer
+config = AutoConfig.from_pretrained("your model name", revision=revision)
+model = AutoModel.from_pretrained("your model name", revision=revision)
+tokenizer = AutoTokenizer.from_pretrained("your model name", revision=revision)
+```
+If this step fails, follow the error messages to debug your model before submitting it. It's likely your model has been improperly uploaded.
+
+Note: make sure your model is public!
+Note: if your model needs `use_remote_code=True`, we do not support this option yet but we are working on adding it, stay posted!
+
+### 2) Convert your model weights to [safetensors](https://huggingface.co/docs/safetensors/index)
+It's a new format for storing weights which is safer and faster to load and use. It will also allow us to add the number of parameters of your model to the `Extended Viewer`!
+
+### 3) Make sure your model has an open license!
+This is a leaderboard for Open LLMs, and we'd love for as many people as possible to know they can use your model 🤗
+
+### 4) Fill up your model card
+When we add extra information about models to the leaderboard, it will be automatically taken from the model card
+
+## In case of model failure
+If your model is displayed in the `FAILED` category, its execution stopped.
+Make sure you have followed the above steps first.
+If everything is done, check you can launch the EleutherAIHarness on your model locally, using the above command without modifications (you can add `--limit` to limit the number of examples per task).
+"""
+
+CITATION_BUTTON_LABEL = "Copy the following snippet to cite these results"
+CITATION_BUTTON_TEXT = r"""
+@article{KyrgyzLLM-Bench,
+  title={Bridging the Gap in Less-Resourced Languages: Building a Benchmark for Kyrgyz Language Models},
+  author={Timur Turatali, Aida Turdubaeva, Islam Zhenishbekov, Zhoomart Suranbaev, Anton Alekseev, Rustem Izmailov},
+  year={2025},
+  url={https://huggingface.co/datasets/TTimur/kyrgyzMMLU, 
+  https://huggingface.co/datasets/TTimur/kyrgyzRC, 
+  https://huggingface.co/datasets/TTimur/winogrande_kg, 
+  https://huggingface.co/datasets/TTimur/boolq_kg, 
+  https://huggingface.co/datasets/TTimur/truthfulqa_kg, 
+  https://huggingface.co/datasets/TTimur/gsm8k_kg, 
+  https://huggingface.co/datasets/TTimur/hellaswag_kg}
+}
+"""

src/display/css_html_js.py

@@ -0,0 +1,111 @@
+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;
+}
+
+/* Hides the final AutoEvalColumn */
+#llm-benchmark-tab-table table td:last-child,
+#llm-benchmark-tab-table table th:last-child {
+    display: none;
+}
+
+/* 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

@@ -0,0 +1,36 @@
+import os
+from datetime import datetime, timezone
+
+from huggingface_hub import HfApi
+from huggingface_hub.hf_api import ModelInfo
+
+
+API = HfApi()
+
+def model_hyperlink(link, model_name):
+    return f'<a target="_blank" href="{link}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{model_name}</a>'
+
+
+def make_clickable_model(model_name):
+    link = f"https://huggingface.co/{model_name}"
+    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

@@ -0,0 +1,135 @@
+from dataclasses import dataclass, make_dataclass
+from enum import Enum
+
+import pandas as pd
+
+from src.display.about import Tasks
+
+def fields(raw_class):
+    return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
+
+
+# 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
+    dummy: bool = False
+
+## Leaderboard columns
+auto_eval_column_dict = []
+# Init
+auto_eval_column_dict.append(["model_type_symbol", ColumnContent, ColumnContent("T", "str", True, never_hidden=True)])
+auto_eval_column_dict.append(["model", ColumnContent, ColumnContent("Model", "markdown", True, never_hidden=True)])
+#Scores
+auto_eval_column_dict.append(["average", ColumnContent, ColumnContent("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)])
+# Dummy column for the search bar (hidden by the custom CSS)
+auto_eval_column_dict.append(["dummy", ColumnContent, ColumnContent("model_name_for_query", "str", False, dummy=True)])
+
+# 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")
+    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 ["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

@@ -0,0 +1,20 @@
+import os
+
+from huggingface_hub import HfApi
+
+# clone / pull the lmeh eval data
+TOKEN = os.environ.get("TOKEN", None)
+
+# Allow overriding via environment; default to Kyrgyz leaderboard repos (v0.1)
+OWNER = os.environ.get("OWNER", "TTimur")
+REPO_ID = os.environ.get("REPO_ID", f"{OWNER}/OpenLLMKyrgyzLeaderboard_v0.1")
+QUEUE_REPO = os.environ.get("QUEUE_REPO", f"{OWNER}/requests_kg_v0.1")
+RESULTS_REPO = os.environ.get("RESULTS_REPO", f"{OWNER}/results_kg_v0.1")
+
+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")
+
+API = HfApi(token=TOKEN)

src/leaderboard/read_evals.py

@@ -0,0 +1,195 @@
+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:
+    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}")
+
+    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.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.dummy.name: 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]
+
+        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

@@ -0,0 +1,56 @@
+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:
+    raw_data = get_raw_eval_results(results_path, requests_path)
+    all_data_json = [v.to_dict() for v in raw_data]
+
+    df = pd.DataFrame.from_records(all_data_json)
+    df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
+    df = df[cols].round(decimals=2)
+
+    # filter out if any of the benchmarks have not been produced
+    df = df[has_no_nan_values(df, benchmark_cols)]
+    return raw_data, df
+
+
+def get_evaluation_queue_df(save_path: str, cols: list) -> list[pd.DataFrame]:
+    entries = [entry for entry in os.listdir(save_path) if not entry.startswith(".")]
+    all_evals = []
+
+    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

@@ -0,0 +1,103 @@
+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 tokenizer_class_from_name, get_tokenizer_config
+
+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]:
+    """Makes sure the model is on the hub, and uses a valid configuration (in the latest transformers version)"""
+    try:
+        config = AutoConfig.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token)
+        if test_tokenizer:
+            tokenizer_config = get_tokenizer_config(model_name) 
+            if tokenizer_config is not None:
+                tokenizer_class_candidate = tokenizer_config.get("tokenizer_class", None)
+            else:
+                tokenizer_class_candidate = config.tokenizer_class 
+
+
+            tokenizer_class = tokenizer_class_from_name(tokenizer_class_candidate)
+            if tokenizer_class is None:
+                return (
+                    False,
+                    f"uses {tokenizer_class_candidate}, which is not in a transformers release, therefore not supported at the moment.",
+                    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]:
+    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

@@ -0,0 +1,113 @@
+import json
+import os
+from datetime import datetime, timezone
+
+from src.display.formatting import styled_error, styled_message, styled_warning
+from src.envs import API, EVAL_REQUESTS_PATH, TOKEN, QUEUE_REPO
+from src.submission.check_validity import (
+    already_submitted_models,
+    check_model_card,
+    get_model_size,
+    is_model_on_hub,
+)
+
+REQUESTED_MODELS = None
+USERS_TO_SUBMISSION_DATES = None
+
+def add_new_eval(
+    model: str,
+    base_model: str,
+    revision: str,
+    precision: str,
+    weight_type: str,
+    model_type: str,
+):
+    global REQUESTED_MODELS
+    global USERS_TO_SUBMISSION_DATES
+    if not REQUESTED_MODELS:
+        REQUESTED_MODELS, USERS_TO_SUBMISSION_DATES = already_submitted_models(EVAL_REQUESTS_PATH)
+
+    user_name = ""
+    model_path = model
+    if "/" in model:
+        user_name = model.split("/")[0]
+        model_path = model.split("/")[1]
+
+    precision = precision.split(" ")[0]
+    current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    if model_type is None or model_type == "":
+        return styled_error("Please select a model type.")
+
+    # Does the model actually exist?
+    if revision == "":
+        revision = "main"
+
+    # Is the model on the hub?
+    if weight_type in ["Delta", "Adapter"]:
+        base_model_on_hub, error, _ = is_model_on_hub(model_name=base_model, revision=revision, token=TOKEN, test_tokenizer=True)
+        if not base_model_on_hub:
+            return styled_error(f'Base model "{base_model}" {error}')
+
+    # 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,
+    }
+
+    # 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."
+    )