Initial commit

Initial commit

minor

.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
+*.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

.gitignore

@@ -0,0 +1,13 @@
+auto_evals/
+venv/
+__pycache__/
+.env
+.ipynb_checkpoints
+*ipynb
+.vscode/
+
+eval-queue/
+eval-results/
+eval-queue-bk/
+eval-results-bk/
+logs/

.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 .

NOTICE

@@ -0,0 +1,4 @@
+Certain styling elements of this project are partially adapted from HuggingFace leaderboard code,
+(https://huggingface.co/spaces/galileo-ai/agent-leaderboard),
+licensed under the Apache License, Version 2.0.
+Modifications have been made by Samsung Research.

README.md

@@ -0,0 +1,14 @@
+---
+title: TRUEBench
+emoji: 🔥
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.38.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+hf_oauth: true
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,654 @@
+import gradio as gr
+
+from apscheduler.schedulers.background import BackgroundScheduler
+from huggingface_hub import snapshot_download
+from src.data_utils import get_dataframe_category, get_dataframe_language
+import src.config as configs
+from utils import get_profile_and_organizations, download_with_restart
+from vis_utils import load_leaderboard_data, create_domain_radar_chart, create_len_overall_scatter
+
+from src.about import (
+    CITATION_BUTTON_LABEL,
+    CITATION_BUTTON_TEXT,
+    EVALUATION_QUEUE_TEXT,
+    EVALUATION_QUEUE_TEXT_OPTION1,
+    INTRODUCTION_TEXT,
+    BANNER,
+    TITLE,
+    LINK,
+)
+from src.display.css_html_js import custom_css
+from src.display.utils import (
+    Precision
+)
+from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN
+from src.submission.submit import add_new_eval_option
+
+from ui import create_leaderboard_tab
+
+def restart_space():
+    API.restart_space(repo_id=REPO_ID)
+
+### Space initialisation
+download_with_restart(
+    snapshot_download,
+    repo_id=QUEUE_REPO,
+    local_dir=EVAL_REQUESTS_PATH,
+    repo_type="dataset",
+    token=TOKEN,
+    restart_func=restart_space
+)
+download_with_restart(
+    snapshot_download,
+    repo_id=RESULTS_REPO,
+    local_dir=EVAL_RESULTS_PATH,
+    repo_type="dataset",
+    token=TOKEN,
+    restart_func=restart_space
+)
+
+theme = gr.themes.Default(
+    primary_hue="gray",
+    neutral_hue="gray"
+)
+
+demo = gr.Blocks(css=custom_css, theme=theme)
+with demo:
+    gr.HTML(BANNER + TITLE + LINK)
+    user_state = gr.State()
+    organization_state = gr.State()
+
+    with gr.Tabs(elem_classes="tab-buttons") as main_tabs:
+        with gr.TabItem("TRUEBench", elem_id="llm-benchmark-tab-table", id=2):
+            gr.HTML(INTRODUCTION_TEXT)
+
+            gr.HTML("""
+            <div class="dark-container" style="margin-bottom: 24px;">
+                <div class="section-header">
+                    <h3 style="margin: 0; color: var(--text-primary); font-size: 1.5rem; font-family: 'Geist', sans-serif; font-weight: 700;">
+                        Category Analysis
+                    </h3>
+                </div>
+                <p style="color: var(--text-secondary); margin-bottom: 20px; font-size: 1.1rem; font-family: 'Geist', sans-serif;">TRUEBench consists of 10 categories and 46 sub-categories which highly related to productivity assistants.</p>
+            """)
+            # --- Category Explanation Box (2x5 grid, emoji, desc from about.py) ---
+            from src.about import CATEGORY_DESCRIPTIONS
+            gr.HTML(f"""
+            <style>
+                .category-box-grid {{ 
+                display: flex;
+                flex-direction: column;
+                gap: 18px;
+                margin: 18px 0;
+                }}
+                .category-box-row {{
+                display: flex;
+                gap: 18px;
+                }}
+                .category-box {{
+                background: linear-gradient(135deg, #e3e6f3 60%, #f5f6fa 100%);
+                border-radius: 26px;
+                box-shadow: 0 0 16px #6c63ff44, 0 2px 8px rgba(0,0,0,0.08);
+                color: #222 !important;
+                min-height: 140px;
+                flex: 1 1 0;
+                display: flex;
+                flex-direction: column;
+                align-items: flex-start;
+                padding: 18px 16px 12px 16px;
+                box-shadow: 0 0 16px #6c63ff44, 0 2px 8px rgba(0,0,0,0.08);
+                font-size: 1.08rem;
+                color: #222 !important;
+                transition: box-shadow 0.2s;
+                position: relative;
+                overflow: hidden;
+                opacity: 1;
+                }}
+                .category-title {{
+                font-weight: 700;
+                font-size: 1.18rem;
+                margin-left: 8px;
+                vertical-align: middle;
+                color: #222 !important;
+                }}
+                .category-desc {{
+                margin-top: 12px;
+                font-size: 0.98rem;
+                color: #fff !important;
+                font-weight: 400;
+                min-height: 24px;
+                width: 100%;
+                line-height: 1.5;
+                letter-spacing: 0.01em;
+                }}
+                .category-box:hover {{
+                box-shadow: 0 0 24px #a5a1ff55, 0 4px 16px rgba(0,0,0,0.18);
+                }}
+                .category-title {{
+                font-weight: 700;
+                font-size: 1.18rem;
+                margin-left: 8px;
+                vertical-align: middle;
+                }}
+                .category-desc {{
+                margin-top: 12px;
+                font-size: 0.98rem;
+                color: #222 !important;
+                font-weight: 400;
+                min-height: 24px;
+                width: 100%;
+                line-height: 1.5;
+                letter-spacing: 0.01em;
+                }}
+                @media (prefers-color-scheme: dark) {{
+                  .category-box .category-title {{
+                    color: #f5f6f7 !important;
+                  }}
+                }}
+            </style>
+            <div class='category-box-grid'>
+                <div class='category-box-row'>
+                <div class='category-box'><span class='category-title'>📝 Content Generation</span><div class='category-desc'>{CATEGORY_DESCRIPTIONS["Content Generation"]}</div></div>
+                <div class='category-box'><span class='category-title'>✂️ Editing</span><div class='category-desc'>{CATEGORY_DESCRIPTIONS["Editing"]}</div></div>
+                <div class='category-box'><span class='category-title'>📊 Data Analysis</span><div class='category-desc'>{CATEGORY_DESCRIPTIONS["Data Analysis"]}</div></div>
+                <div class='category-box'><span class='category-title'>🧠 Reasoning</span><div class='category-desc'>{CATEGORY_DESCRIPTIONS["Reasoning"]}</div></div>
+                <div class='category-box'><span class='category-title'>🦄 Hallucination</span><div class='category-desc'>{CATEGORY_DESCRIPTIONS["Hallucination"]}</div></div>
+                </div>
+                <div class='category-box-row'>
+                <div class='category-box'><span class='category-title'>🛡️ Safety</span><div class='category-desc'>{CATEGORY_DESCRIPTIONS["Safety"]}</div></div>
+                <div class='category-box'><span class='category-title'>🔁 Repetition</span><div class='category-desc'>{CATEGORY_DESCRIPTIONS["Repetition"]}</div></div>
+                <div class='category-box'><span class='category-title'>📝 Summarization</span><div class='category-desc'>{CATEGORY_DESCRIPTIONS["Summarization"]}</div></div>
+                <div class='category-box'><span class='category-title'>🌐 Translation</span><div class='category-desc'>{CATEGORY_DESCRIPTIONS["Translation"]}</div></div>
+                <div class='category-box'><span class='category-title'>💬 Multi-Turn</span><div class='category-desc'>{CATEGORY_DESCRIPTIONS["Multi-Turn"]}</div></div>
+                </div>
+            </div>
+            """)
+            df = get_dataframe_category()
+            
+            gr.HTML("""
+            <style>
+            .leaderboard-container {
+                background: #fff;
+            }
+            @media (prefers-color-scheme: dark) {
+                .leaderboard-container {
+                    background: #121212;
+                }
+            }
+            </style>
+            <div class="leaderboard-container">
+            """)
+            leaderboard_tab_cat = create_leaderboard_tab(
+                df,
+                "Category",
+            )
+            gr.HTML("</div>")
+
+            
+            # --- Category Radar Chart Section ---
+            from vis_utils import load_leaderboard_data, create_domain_radar_chart
+            initial_df_cat = load_leaderboard_data()
+            # Top 5 models based on leaderboard (Average Accuracy)
+            if "Overall" in initial_df_cat.columns:
+                top5_models_cat = initial_df_cat.sort_values("Overall", ascending=False)['Model Name'].tolist()[:5]
+            else:
+                top5_models_cat = initial_df_cat['Model Name'].tolist()[:5]
+            gr.HTML('<div class="chart-container" style="display: flex; justify-content: center; align-items: center; width: 100%; max-width: 100%; margin: 0 auto; padding: 0;">')
+            # Radar chart model selector (up to 5)
+            from src.display.formatting import get_display_model_name
+            display_names_cat = initial_df_cat['Model Name'].apply(get_display_model_name).tolist()
+            original_names_cat = initial_df_cat['Model Name'].tolist()
+            display_to_original_cat = dict(zip(display_names_cat, original_names_cat))
+            top5_display_names_cat = [get_display_model_name(m) for m in top5_models_cat]
+            model_selector_cat = gr.Dropdown(
+                choices=display_names_cat,
+                value=top5_display_names_cat,
+                multiselect=True,
+                label="🎯 Select Models for Radar Chart",
+                info="Choose up to 5 models to visualize",
+                elem_classes=["dropdown", "custom-dropdown"],
+                interactive=True,
+                filterable=True,
+                allow_custom_value=False
+            )
+            gr.HTML("""
+            <script>
+            document.querySelector('.custom-dropdown').addEventListener('change', function(e) {
+                if (this.value.length > 5) {
+                    alert('You can select up to 5 models only');
+                    this.value = this.value.slice(0, 5);
+                }
+            });
+            </script>
+            """)
+            radar_chart_cat = gr.Plot(
+                label="",
+                value=create_domain_radar_chart(
+                    initial_df_cat, 
+                    "Average Accuracy", 
+                    top5_models_cat
+                ),
+                elem_classes=["radar-chart", "plot-container"]
+            )
+            gr.HTML('</div>')
+
+            # Update radar chart when model_selector_cat selection changes
+            def update_radar_chart_cat(selected_display_names):
+                # If no selection, fallback to top-5
+                if not selected_display_names or len(selected_display_names) == 0:
+                    df = load_leaderboard_data()
+                    selected_display_names = [get_display_model_name(m) for m in df['Model Name'].tolist()[:5]]
+                selected_models = [display_to_original_cat[name] for name in selected_display_names if name in display_to_original_cat]
+                return create_domain_radar_chart(
+                    load_leaderboard_data(),
+                    "Average Accuracy",
+                    selected_models
+                )
+            model_selector_cat.change(
+                fn=update_radar_chart_cat,
+                inputs=model_selector_cat,
+                outputs=radar_chart_cat
+            )
+            # --- Med. Len. vs Overall Scatter Plot Section ---
+            from vis_utils import create_len_overall_scatter
+            import json
+            with open("src/data/length_data.json", "r") as f:
+                length_data = json.load(f)
+            
+            # --- Create a Gradio State component to hold length_data ---
+            length_data_state = gr.State(value=length_data)
+            gr.HTML("""
+            <div class="dark-container" style="margin-bottom: 24px; margin-top: 24px;">
+                <div class="section-header">
+                    <h3 style="margin: 0; color: var(--text-primary); font-size: 1.5rem; font-family: 'Geist', sans-serif; font-weight: 700;">
+                        Output Length vs. Category Score
+                    </h3>
+                </div>
+                <p style="color: var(--text-secondary); margin-bottom: 20px; font-size: 1.1rem; font-family: 'Geist', sans-serif;">
+                    Explore the relationship between median output length and model performance by category
+                </p>
+            """)
+                                  
+
+            # Category selection buttons (HTML + Gradio Radio for event)
+            category_columns = [col for col in configs.ON_LOAD_COLUMNS_CATEGORY if col not in configs.CATEGORY_EXCLUDED_COLUMNS]
+            # (cat-btn-radio related style block removed, now handled in custom_css)
+            category_selector = gr.Radio(
+                choices=category_columns,
+                value="Overall",
+                label="Select Category for Y-Axis",
+                elem_id="cat-btn-radio",
+                elem_classes=["cat-btn-radio"],
+                interactive=True,
+                show_label=False
+            )
+            x_axis_selector = gr.Radio(
+                choices=["Med. Len.", "Med. Resp. Len."],
+                value="Med. Len.",
+                label="Select X-Axis Data",
+                elem_id="x-axis-btn-radio",
+                elem_classes=["x-axis-btn-radio"],
+                interactive=True,
+                show_label=True
+            )
+            gr.HTML('<div class="chart-container" style="display: flex; justify-content: center; align-items: center;">')
+            scatter_plot_cat = gr.Plot(
+                label="",
+                value=create_len_overall_scatter(
+                    load_leaderboard_data(),
+                    y_col="Overall",
+                    length_data=length_data,
+                    x_axis_data_source=x_axis_selector.value
+                ),
+                elem_classes=["efficiency-chart", "plot-container"]
+            )
+            gr.HTML('</div>')
+            gr.HTML("</div>")
+
+            # Update plot when category or x-axis selection changes
+            def update_scatter_plot_cat(selected_category, selected_x_source, current_length_data_state):
+                return create_len_overall_scatter(
+                    load_leaderboard_data(),
+                    y_col=selected_category,
+                    length_data=current_length_data_state,
+                    x_axis_data_source=selected_x_source
+                )
+            category_selector.change(
+                fn=update_scatter_plot_cat,
+                inputs=[category_selector, x_axis_selector, length_data_state],
+                outputs=scatter_plot_cat
+            )
+            x_axis_selector.change(
+                fn=update_scatter_plot_cat,
+                inputs=[category_selector, x_axis_selector, length_data_state],
+                outputs=scatter_plot_cat
+            )
+
+            # When leaderboard selectors change, synchronize model_selector_cat and radar_chart_cat to top-5
+            def update_model_selector_and_radar_chart_cat_from_leaderboard(types, model_types, thinks, df, sort_col):
+                _, _, top5_models = leaderboard_tab_cat["unified_filter"](types, model_types, thinks, df, sort_col)
+                
+                top5_display_names = [get_display_model_name(m) for m in top5_models[:5]]
+                return gr.update(value=top5_display_names), create_domain_radar_chart(
+                    load_leaderboard_data(),
+                    "Average Accuracy",
+                    top5_models[:5]
+                )
+
+            leaderboard_selectors_cat = [
+                leaderboard_tab_cat["type_selector"],
+                leaderboard_tab_cat["model_type_selector"],
+                leaderboard_tab_cat["think_selector"],
+                leaderboard_tab_cat["df_state"],
+                leaderboard_tab_cat["sort_col_dropdown"]
+            ]
+            for selector in leaderboard_selectors_cat:
+                selector.change(
+                    fn=update_model_selector_and_radar_chart_cat_from_leaderboard,
+                    inputs=leaderboard_selectors_cat,
+                    outputs=[model_selector_cat, radar_chart_cat]
+                )
+
+
+                
+            gr.HTML("""
+            <div class="dark-container" style="margin-bottom: 24px;">
+                <div class="section-header">
+                    <h3 style="margin: 0; color: var(--text-primary); font-size: 1.5rem; font-family: 'Geist', sans-serif; font-weight: 700;">
+                        Language Analysis
+                    </h3>
+                </div>
+                <p style="color: var(--text-secondary); margin-bottom: 20px; font-size: 1.1rem; font-family: 'Geist', sans-serif;">As a multilingual benchmark, TRUEBench supports a total of 12 user input languages: Korean (KO), English (EN), Japanese (JA), Chinese (ZH), Polish (PL), German (DE), Portuguese (PT), Spanish (ES), French (FR), Italian (IT), Russian (RU), and Vietnamese (VI).</p>
+            """)
+            df = get_dataframe_language()
+            
+            leaderboard_tab_lang = create_leaderboard_tab(
+                df,
+                "Language",
+            )
+
+            # --- Language Radar Chart Section ---
+            
+            from vis_utils import load_leaderboard_language_data, create_language_radar_chart
+            initial_df_lang = load_leaderboard_language_data()
+
+            # Top 5 models based on leaderboard (Overall)
+            if "Overall" in initial_df_lang.columns:
+                top5_models_lang = initial_df_lang.sort_values("Overall", ascending=False)['Model Name'].tolist()[:5]
+            else:
+                top5_models_lang = initial_df_lang['Model Name'].tolist()[:5]
+
+            gr.HTML('<div class="chart-container" style="display: flex; justify-content: center; align-items: center;">')
+            # Add model selector
+            display_names_lang = initial_df_lang['Model Name'].apply(get_display_model_name).tolist()
+            original_names_lang = initial_df_lang['Model Name'].tolist()
+            display_to_original_lang = dict(zip(display_names_lang, original_names_lang))
+            top5_display_names_lang = [get_display_model_name(m) for m in top5_models_lang]
+            model_selector_lang = gr.Dropdown(
+                choices=display_names_lang,
+                value=top5_display_names_lang,
+                multiselect=True,
+                label="🎯 Select Models for Radar Chart",
+                info="Choose up to 5 models to visualize",
+                elem_classes=["dropdown", "custom-dropdown"],
+                interactive=True,
+                filterable=True,
+                allow_custom_value=False
+            )
+            gr.HTML("""
+            <script>
+            document.querySelectorAll('.custom-dropdown')[1].addEventListener('change', function(e) {
+                if (this.value.length > 5) {
+                    alert('You can select up to 5 models only');
+                    this.value = this.value.slice(0, 5);
+                }
+            });
+            </script>
+            """)
+            radar_chart_lang = gr.Plot(
+                label="",
+                value=create_language_radar_chart(
+                    initial_df_lang,
+                    "Average Accuracy",
+                    top5_models_lang
+                ),
+                elem_classes=["radar-chart", "plot-container"]
+            )
+            gr.HTML('</div>')
+
+            # Update radar chart when model_selector_lang selection changes
+            def update_radar_chart_lang(selected_display_names):
+                if not selected_display_names or len(selected_display_names) == 0:
+                    df = load_leaderboard_language_data()
+                    selected_display_names = [get_display_model_name(m) for m in df['Model Name'].tolist()[:5]]
+                selected_models = [display_to_original_lang[name] for name in selected_display_names if name in display_to_original_lang]
+                return create_language_radar_chart(
+                    load_leaderboard_language_data(),
+                    "Average Accuracy",
+                    selected_models
+                )
+            model_selector_lang.change(
+                fn=update_radar_chart_lang,
+                inputs=model_selector_lang,
+                outputs=radar_chart_lang
+            )
+
+            # When leaderboard selectors change, automatically synchronize model_selector_lang and radar_chart_lang to top-5
+            def update_model_selector_and_radar_chart_lang_from_leaderboard(types, model_types, thinks, df, sort_col):
+                _, _, top5_models = leaderboard_tab_lang["unified_filter"](types, model_types, thinks, df, sort_col)
+                top5_display_names = [get_display_model_name(m) for m in top5_models[:5]]
+                return gr.update(value=top5_display_names), create_language_radar_chart(
+                    load_leaderboard_language_data(),
+                    "Average Accuracy",
+                    top5_models[:5]
+                )
+
+            leaderboard_selectors_lang = [
+                leaderboard_tab_lang["type_selector"],
+                leaderboard_tab_lang["model_type_selector"],
+                leaderboard_tab_lang["think_selector"],
+                leaderboard_tab_lang["df_state"],
+                leaderboard_tab_lang["sort_col_dropdown"]
+            ]
+
+            for selector in leaderboard_selectors_lang:
+                selector.change(
+                    fn=update_model_selector_and_radar_chart_lang_from_leaderboard,
+                    inputs=leaderboard_selectors_lang,
+                    outputs=[model_selector_lang, radar_chart_lang]
+                )
+
+
+
+        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.Row():
+                    gr.Markdown(EVALUATION_QUEUE_TEXT_OPTION1, elem_classes="markdown-text")
+
+            with gr.Row():
+                gr.Markdown("## ✉️ Submit your model here!", elem_classes="markdown-text")
+            
+            login_button = gr.LoginButton()
+            
+            with gr.Row():
+                with gr.Column():
+                    contact_email = gr.Textbox(label="Contact Email", placeholder="Your email address", interactive=True)
+                    model_name_textbox = gr.Textbox(label="Model Name")
+                    model_type_dropdown = gr.Dropdown(
+                        choices=["Instruct", "Think", "Hybrid"],
+                        label="Model Type (Instruct, Think, or Hybrid)",
+                        multiselect=False,
+                        value="Instruct",
+                        interactive=True,
+                    )
+                    think_type_dropdown = gr.Dropdown(
+                        choices=["On", "Off"],
+                        label="Think Mode (On/Off)",
+                        multiselect=False,
+                        value="Off",
+                        interactive=False,
+                    )
+                    precision = gr.Dropdown(
+                        choices=[i.value.name for i in Precision if i != Precision.Unknown],
+                        label="Precision",
+                        multiselect=False,
+                        value="float16",
+                        interactive=True,
+                    )
+                    # --- Dynamically control think_type based on model_type and connect event ---
+                    def update_think_type(model_type_value):
+                        if model_type_value == "Instruct":
+                            return gr.update(value="Off", interactive=False)
+                        elif model_type_value == "Think":
+                            return gr.update(value="On", interactive=False)
+                        else:  # Hybrid
+                            return gr.update(value="On", interactive=True)
+                    model_type_dropdown.change(
+                        fn=update_think_type,
+                        inputs=model_type_dropdown,
+                        outputs=think_type_dropdown
+                    )
+                    response_prefix_textbox = gr.Textbox(label="Response prefix", placeholder="(e.g., </think>)")
+
+                with gr.Column():
+                    yml_textbox_placeholder = """# vLLM serving parameters 
+# Refence: https://docs.vllm.ai/en/latest/cli/serve.html
+llm_serve_args:
+    max_model_len:
+    tensor_parallel_size:
+    dtype:
+    ...
+# OpenAI-compatible API (chat completion)
+# Reference: https://platform.openai.com/docs/api-reference/chat
+sampling_params:
+    top_p:
+    temperature:
+    presence_penalty:
+    ...
+# vLLM sampling parameters
+# Reference: https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html#chat-api_1
+extra_body:
+    chat_template_kwargs:
+        enable_thinking: 
+        ...
+    top_k:
+    repetition_penalty:
+    ..."""
+                    yml_textbox = gr.Textbox(
+                        label="Configuration (YAML format)",
+                        elem_id="yml-textbox",
+                        lines=7,
+                        value=yml_textbox_placeholder
+                    )
+                    upbox = gr.File(
+                        label="Upload configuration file as .yml or .yaml",
+                        file_types=[".yml", ".yaml"],
+                        type="filepath",
+                        height=150
+                    )
+                    # Add Translate to JSON button below upbox
+                    translate_button = gr.Button(
+                        "Translate to JSON",
+                        elem_id="translate-to-json-btn",
+                        elem_classes=["translate-btn"],
+                        scale=None
+                    )
+                    # Add custom style for the button
+                    gr.HTML(
+                        '''
+                        <style>
+                        #translate-to-json-btn, .translate-btn {
+                            width: 100%;
+                            min-height: 24px;
+                            font-size: 1.1rem;
+                            font-weight: 600;
+                            background: linear-gradient(90deg, #6c63ff 60%, #a5a1ff 100%);
+                            color: #fff;
+                            border: none;
+                            border-radius: 12px;
+                            margin-top: 8px;
+                            margin-bottom: 8px;
+                            box-shadow: 0 2px 8px #6c63ff33;
+                            transition: background 0.2s, box-shadow 0.2s;
+                        }
+                        #translate-to-json-btn:hover, .translate-btn:hover {
+                            background: linear-gradient(90deg, #5a54d6 60%, #7e7bff 100%);
+                            box-shadow: 0 4px 16px #6c63ff55;
+                        }
+                        </style>
+                        '''
+                    )
+                with gr.Column():
+                    requirements_textbox = gr.Textbox(label="(Optional) Requirements", lines=30, elem_id="requirements-textbox")
+
+            output_dict = gr.Code(label="Translated Python Dictionary", language="json")
+            submit_button = gr.Button("Submit Eval")
+            submission_result = gr.Markdown()
+            def parse_and_display_yaml_config(upbox_path, yml_textbox_value):
+                import yaml, json
+                if upbox_path:
+                    try:
+                        with open(upbox_path, "r", encoding="utf-8") as f:
+                            data = yaml.safe_load(f)
+                        if data is None:
+                            return "YAML file is empty."
+                        return json.dumps(data, indent=4, ensure_ascii=False)
+                    except Exception as e:
+                        return f"Error parsing YAML file: {e}"
+                elif yml_textbox_value and yml_textbox_value.strip():
+                    try:
+                        data = yaml.safe_load(yml_textbox_value)
+                        if data is None:
+                            return "YAML textbox is empty or invalid."
+                        return json.dumps(data, indent=4, ensure_ascii=False)
+                    except Exception as e:
+                        return f"Error parsing YAML textbox: {e}"
+                else:
+                    return ""
+
+            event = submit_button.click(get_profile_and_organizations, inputs=[], outputs=[user_state, organization_state])
+            event.then(
+                add_new_eval_option,
+                [
+                    contact_email,
+                    model_name_textbox,
+                    model_type_dropdown,
+                    think_type_dropdown,
+                    precision,
+                    response_prefix_textbox,
+                    requirements_textbox,
+                    user_state,
+                    organization_state,
+                    yml_textbox,
+                    upbox,
+                ],
+                submission_result,
+            ).then(
+                fn=parse_and_display_yaml_config,
+                inputs=[upbox, yml_textbox],
+                outputs=output_dict
+            )
+            translate_button.click(
+                fn=parse_and_display_yaml_config,
+                inputs=[upbox, yml_textbox],
+                outputs=output_dict
+            )
+
+    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()

constants.py

@@ -0,0 +1,20 @@
+# Leaderboard required columns (must always be included)
+LEADERBOARD_REQUIRED_COLUMNS = [
+    "Model Name", "Group", "Overall", "Med. Len.", "Med. Resp. Len.", "Type", "Model Type", "Think", "Rank"
+]
+
+# Columns for number formatting (by category/language)
+NUMERIC_COLS_CATEGORY = [
+    "Overall", "Med. Len.", "Med. Resp. Len.", "Parameter Size (B)",
+    "Content Generation", "Editing", "Data Analysis", "Reasoning",
+    "Hallucination", "Safety", "Repetition", "Summarization", "Translation", "Multi-Turn"
+]
+NUMERIC_INT_COLS_CATEGORY = ["Med. Len.", "Med. Resp. Len.", "Parameter Size (B)"]
+NUMERIC_FLOAT_COLS_CATEGORY = [col for col in NUMERIC_COLS_CATEGORY if col not in NUMERIC_INT_COLS_CATEGORY]
+
+NUMERIC_COLS_LANGUAGE = [
+    "Overall", "Med. Len.", "Med. Resp. Len.", "Parameter Size (B)",
+    "KO", "EN", "JA", "ZH", "PL", "DE", "PT", "ES", "FR", "IT", "RU", "VI"
+]
+NUMERIC_INT_COLS_LANGUAGE = ["Med. Len.", "Med. Resp. Len.", "Parameter Size (B)"]
+NUMERIC_FLOAT_COLS_LANGUAGE = [col for col in NUMERIC_COLS_LANGUAGE if col not in NUMERIC_INT_COLS_LANGUAGE]

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,16 @@
+APScheduler
+black
+datasets
+gradio
+gradio[oauth]
+gradio_leaderboard==0.0.13
+gradio_client
+huggingface-hub>=0.18.0
+matplotlib
+numpy
+pandas
+python-dateutil
+tqdm
+transformers
+tokenizers>=0.15.0
+plotly

src/about.py

@@ -0,0 +1,181 @@
+CATEGORY_DESCRIPTIONS = {
+    "Content Generation": "<p>Evaluates the model's ability to produce diverse written outputs across professional and creative domains. This category measures adaptability to linguistic, stylistic, and formatting constraints, as well as the effectiveness of prompt engineering.</p> <b>🏷️Email 🏷️ReportDrafting</b>",
+    "Editing": "<p>Evaluates refinement capabilities for optimizing given text. It focuses on queries related to rephrasing, revision, and correction, while preserving the rest of the content.</p> <b>🏷️QueryRephrase 🏷️DocumentRevision</b>",
+    "Data Analysis": "<p>Measures proficiency in processing structured and unstructured data. This category includes tasks related to information extraction and data processing.</p> <b>🏷️JSONFormatted 🏷️TableQuery</b>",
+    "Reasoning": "<p>Assesses logical problem-solving in coding, multiple-choice question answering, and mathematical operations. It also includes evaluation of rounding errors made by models in quantitative tasks.</p> <b>🏷️Logical 🏷️Mathematical</b>",
+    "Hallucination": "<p>Detects limitations in generating plausible but inaccurate responses when faced with ambiguous queries, insufficient context, hypothetical scenarios, or challenges in document interpretation.</p> <b>🏷️InsufficientContext 🏷️FalseQueries</b>",
+    "Safety": "<p>Verifies safeguards against harmful/inappropriate content. This category tests filtering of discriminatory, violent, or illegal material while upholding ethical standards.</p> <b>🏷️Illegal 🏷️Prejudice</b>",
+    "Repetition": "<p>Evaluates consistency in producing iterative content variations while maintaining quality and relevance across outputs.</p> <b>🏷️Listing</b>",
+    "Summarization": "<p>Measures ability to distill lengthy content into concise overviews preserving core concepts and eliminating redundancy. This category includes various constraints such as language, format, and output length.</p> <b>🏷️BulletPoints 🏷️N-lineSummary</b>",
+    "Translation": "<p>Tests the ability to accurately translate diverse real-world contexts while adhering to target language and specified constraints. Our benchmark includes linguistic conditions in 12 languages, ensuring comprehensive multilingual evaluation.</p> <b>🏷️Document 🏷️Line-by-line</b>",
+    "Multi-Turn": "<p>Assesses the model's ability to capture user intent in challenging scenarios where the context shifts or understanding of previous context is required.</p> <b>🏷️Consistency 🏷️Non-consistency</b>"
+}
+
+banner_url = "https://cdn-uploads.huggingface.co/production/uploads/6805a7222cbcd604c2e89cab/GIEbCbyNn7PjWBFftEgNm.png"
+BANNER = f'<div style="display: flex; justify-content: flex-start; width: 100%;"> <img src="{banner_url}" alt="Banner" style="width: 100%; height: auto; object-fit: contain;"> </div> '
+
+TITLE = """<html>  
+<body>  
+    <p style="margin: 0; text-align: right">Leaderboards by Samsung Research for LLM evaluation.</p>  
+</body>  
+</html>"""
+
+LINK = """
+<h3 style="text-align: right; margin-top: 0;">    
+    <span>✨</span>    
+    <a href="https://research.samsung.com/" style="text-decoration: none;" rel="nofollow" target="_blank" onmouseover="this.style.textDecoration='underline'" onmouseout="this.style.textDecoration='none'">Samsung Research</a> |    
+    <span>🌕</span>    
+    <a href="https://github.com/samsung" style="text-decoration: none;" rel="nofollow" target="_blank" onmouseover="this.style.textDecoration='underline'" onmouseout="this.style.textDecoration='none'">GitHub</a> |    
+    <span>🌎</span>    
+    <a href="https://x.com/samsungresearch" style="text-decoration: none;" rel="nofollow" target="_blank" onmouseover="this.style.textDecoration='underline'" onmouseout="this.style.textDecoration='none'">X</a> |    
+    <span>🌠</span>    
+    <a href="https://huggingface.co/spaces/SamsungResearch/TRUEBench/discussions" style="text-decoration: none;" rel="nofollow" target="_blank" onmouseover="this.style.textDecoration='underline'" onmouseout="this.style.textDecoration='none'">Discussion</a> |    
+    <span>🔭</span> Updated: 2025-09-16
+</h3>  
+"""
+
+INTRODUCTION_TEXT = """
+<div style="margin-bottom: 20px; text-align: center !important;">
+  <h2 style="padding-bottom: 5px !important; text-align: center !important; font-size: 2.6em !important; font-weight: 900 !important; margin-top: 0.2em !important; margin-bottom: 0.3em !important;">
+    🏆 TRUEBench: A Benchmark for Assessing LLMs as Human Job Productivity Assistants
+  </h2>
+  <p style="font-size: 1.25em !important; line-height: 1.7 !important; margin: 14px 0 !important;">
+    TRUEBench (Trustworthy Real-world Usage Evaluation Benchmark) evaluates LLMs as productivity assistants.  <br>
+    As LLMs become integral to tasks like report drafting and data analysis, existing benchmarks are suboptimal to capture real-world challenges. <br>
+    To address this gap, <strong>Samsung Research</strong> developed TRUEBench as a comprehensive evaluation framework for real-world LLM applications.
+  </p>
+  <p style="font-size: 1.25em !important; line-height: 1.7 !important; margin: 14px 0 !important;">
+    TRUEBench is a benchmark designed to evaluate the instruction-following capabilities of LLMs, determining whether a response receives a Pass (1 point) or Fail (0 points) based on checklists. <br> This aligns with user satisfaction from the perspective of job productivity.
+  </p>
+  <h3 style="font-size: 2em; font-weight: 800; margin-top: 1.2em; margin-bottom: 0.5em; line-height: 1.3; letter-spacing: -0.01em;">
+    Main Features
+  </h3>
+  <div class="intro-feature-row">
+    <div class="intro-feature-box">
+      <div class="intro-feature-icon">📝</div>
+      <div class="intro-feature-title">2,400+ Productivity-Oriented User Inputs</div>
+      <div class="intro-feature-desc">A large-scale collection of complex, real-world user inputs designed to reflect productivity assistant scenarios.</div>
+    </div>
+    <div class="intro-feature-box">
+      <div class="intro-feature-icon">🌎</div>
+      <div class="intro-feature-title">Multilinguality in Real Tasks</div>
+      <div class="intro-feature-desc">Comprehensive 12-language coverage with intra-instance multilingual instructions.</div>
+      <div class="intro-feature-desc" style="font-style: italic; color: #888;">For multilingual aspects, it was created through local research institutes.</div>
+    </div>
+    <div class="intro-feature-box">
+      <div class="intro-feature-icon">🧩</div>
+      <div class="intro-feature-title">Beyond Explicit Constraints</div>
+      <div class="intro-feature-desc">Human-annotated implicit requirements validated by LLMs.</div>
+    </div>
+    <div class="intro-feature-box">
+      <div class="intro-feature-icon">🧭</div>
+      <div class="intro-feature-title">Dynamic Multi-Turn Contexts</div>
+      <div class="intro-feature-desc">Realistic dialogue flows with evolving constraints.</div>
+    </div>
+  </div>
+  <a class="intro-dataset-btn" href="https://huggingface.co/datasets/SamsungResearch/TRUEBench" target="_blank" rel="nofollow">
+    📂 Dataset Sample &rarr;
+  </a>
+</div> """
+
+MAIN_FEATURES_TEXT ="""
+<div style="padding: 10px; border-radius: 8px; margin-bottom: 20px;">  
+  <h2 style="color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 5px;">✨ Main Features</h2>  
+  <ul style="list-style-type: none; padding-left: 0;">  
+    <li style="margin-bottom: 10px; padding-left: 25px; position: relative;">  
+      <span style="position: absolute; left: 0; color: #3498db;">✓</span>  
+      Input prompts across 12 languages
+    </li>  
+    <li style="margin-bottom: 10px; padding-left: 25px; position: relative;">  
+      <span style="position: absolute; left: 0; color: #3498db;">✓</span>  
+      Intra-instance multilingual instructions  
+    </li>  
+    <li style="margin-bottom: 10px; padding-left: 25px; position: relative;">  
+      <span style="position: absolute; left: 0; color: #3498db;">✓</span>  
+      Rigorous evaluation criteria for explicit and implicit constraints  
+    </li>  
+    <li style="margin-bottom: 10px; padding-left: 25px; position: relative;">  
+      <span style="position: absolute; left: 0; color: #3498db;">✓</span>  
+      Complex multi-turn dialogue scenarios  
+    </li>  
+    <li style="margin-bottom: 10px; padding-left: 25px; position: relative;">  
+      <span style="position: absolute; left: 0; color: #3498db;">✓</span>  
+      LLM-validated constraints for reliable evaluation  
+    </li>  
+  </ul>
+  <div style="margin: 20px 0 10px 0;">
+    <a href="https://huggingface.co/datasets/SamsungResearch/TRUEBench" 
+       style="color: #3498db; 
+              text-decoration: underline;
+              font-size: 1.2em;
+              font-weight: bold;" 
+       rel="nofollow" 
+       target="_blank"
+       onmouseover="this.style.textDecoration='none'; this.style.color='#2c3e50'" 
+       onmouseout="this.style.textDecoration='underline'; this.style.color='#3498db'">
+      📂 Dataset Sample →
+    </a>
+  </div>
+</div>  
+"""
+
+LLM_BENCHMARKS_TEXT = f"""
+## How it works
+We utilize LLM Judge with human-crafted criteria to assess AI response.
+"""
+
+EVALUATION_QUEUE_TEXT = '''
+<div style="font-size: 1.25em !important; line-height: 1.7 !important; margin: 14px 0 !important;">
+
+## Submission Policy
+- Submissions are limited to models that are registered on *HuggingFace Models*.
+- Each model affiliation (individual or organization) may submit up to **3** times within **24** hours.
+- The same model can only be submitted once per 24 hours.
+- Duplicate submissions will be determined based on the full model name (i.e., {affiliation}/{model name}). Sampling parameters, dtype, etc. are not considered for duplicate checking.
+- Submissions are only valid if the model's affiliation matches that of the submitter.
+- If the same model is submitted multiple times, only the version with the highest overall score will be reflected on the leaderboard. (Note: A maximum of 3 submissions per model is allowed.)
+
+**[NOTE]** Models with commercial licenses may be excluded from evaluation. We focus on evaluating non-commercial models, such as those under Apache-2.0 or MIT licenses. <br>
+**[NOTE]** We use your user name (via **OAuthProfile**) and your list of registered organizations (via **OAuthToken**) solely to verify submission eligibility. **This information is never stored.**<br><br>
+
+## Evaluation Environments
+- Submitted models are run on our internal servers to generate inference outputs, which are then evaluated using an LLM judge.
+- Models must be runnable on up to **32 H100 GPUs** to be eligible for submission.
+- By default, we perform inference in the vLLM 0.10.1 environment. We recommend testing your model in this environment first. You may include additional requests in the requirements section in a free‑form manner, but please note that such requests could be rejected due to the constraints of inferencing environment.
+- We serve the model based on vLLM and perform inference through the OpenAI-compatible API (chat completion).<br><br>
+
+## Evaluation Rules
+- It might take more than 1 week for submitted models' scores to appear on the leaderboard.
+- The maximum generation length is limited to **64K** tokens.
+- Please provide a valid contact email address in the submission form so we can send notifications related to evaluation.
+
+**[CAUTION]** If inference fails or if inappropriate content is detected, the model might be excluded from evaluation.<br><br>
+
+## Submission Rules
+- For Think models, you must specify the sequence that separates the thinking process and the final response (e.g., &lt;/think&gt;) in the response_prefix field. We will use this prefix to extract the response for evaluation. (NOTE: Models that fail to provide a proper response prefix might be excluded from evaluation.)
+- Referring to the configuration section of the submission form, provide the following in YAML format, either directly or via an uploaded `.yaml` file (if both are provided, the file takes priority):    
+  - **Model serve arguments (llm_serve_args)**: vLLM-based model serving parameters ([Reference](https://docs.vllm.ai/en/latest/cli/serve.html))    
+  - **Sampling parameters (sampling_params)**: Sampling parameters supported by the OpenAI API ([Reference](https://platform.openai.com/docs/api-reference/chat))    
+  - **Extra body including chat template arguments (extra_body)**: `chat_template_kwargs` and sampling parameters supported by vLLM ([Reference](https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html#extra-parameters_1))  
+- Any additional specifications outside the configuration format should be written in the requirements section.
+
+**[NOTE]** If you need to use two or more H100 GPUs, be sure to specify `tensor_parallel_size` within `llm_serve_args`.<br><br>
+</div>
+'''
+
+EVALUATION_QUEUE_TEXT_OPTION1 = """
+<div style="font-size: 1.25em !important; line-height: 1.7 !important; margin: 14px 0 !important;">
+
+## Submission Form
+1. Sign in using the log-in button below.
+2. Fill the information including metadata, requirements, and configuration (fill the textbox or upload .yaml file).
+3. Press "Submit Eval" button to submit.
+"""
+
+EVALUATION_QUEUE_TEXT_OPTION2 = """
+"""
+
+
+CITATION_BUTTON_LABEL = "To be updated"
+CITATION_BUTTON_TEXT = r"""
+"""

src/config.py

@@ -0,0 +1,61 @@
+ON_LOAD_COLUMNS_LANG = [
+    "Model Name",
+    "Group",
+    "Overall",
+    "Med. Len.",
+    "Med. Resp. Len.", 
+    "Parameter Size (B)",
+    "Type",
+    "Model Type",
+    "Think",
+    "KO",
+    "EN",
+    "JA",
+    "ZH",
+    "PL",
+    "DE",
+    "PT",
+    "ES",
+    "FR",
+    "IT",
+    "RU",
+    "VI"
+]
+
+ON_LOAD_COLUMNS_CATEGORY = [
+    "Model Name",
+    "Group",
+    "Overall",
+    "Med. Len.",
+    "Med. Resp. Len.", 
+    "Parameter Size (B)",
+    "Type",
+    "Model Type",
+    "Think",
+    "Content Generation",
+    "Editing",
+    "Data Analysis",
+    "Reasoning",
+    "Hallucination",
+    "Safety",
+    "Repetition",
+    "Summarization",
+    "Translation",
+    "Multi-Turn"
+]
+
+CATEGORY_EXCLUDED_COLUMNS = [
+    "Model Name",
+    "Group",
+    "Med. Len.",
+    "Med. Resp. Len.",
+    "Parameter Size (B)",
+    "Type",
+    "Model Type",
+    "Think"
+]
+
+COLUMN_GROUP_LIST = [
+    "Category",
+    "Language"
+]

src/data/length_data.json

@@ -0,0 +1,1906 @@
+{
+    "Claude 4.1 Opus (20250805) (think)": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "EXAONE 4.0 32B (think)": {
+        "Overall": {
+            "Min": 37,
+            "Max": 142387,
+            "Med": 1274.5,
+            "Med Resp": 503.0
+        },
+        "Content Generation": {
+            "Min": 160,
+            "Max": 131068,
+            "Med": 1178.5,
+            "Med Resp": 559.0
+        },
+        "Editing": {
+            "Min": 37,
+            "Max": 10786,
+            "Med": 1041.0,
+            "Med Resp": 423.5
+        },
+        "Data Analysis": {
+            "Min": 229,
+            "Max": 131072,
+            "Med": 1412.0,
+            "Med Resp": 345.0
+        },
+        "Reasoning": {
+            "Min": 567,
+            "Max": 131076,
+            "Med": 3961.5,
+            "Med Resp": 585.5
+        },
+        "Hallucination": {
+            "Min": 298,
+            "Max": 65533,
+            "Med": 1247.5,
+            "Med Resp": 627.5
+        },
+        "Safety": {
+            "Min": 227,
+            "Max": 5093,
+            "Med": 1145.0,
+            "Med Resp": 589.0
+        },
+        "Repetition": {
+            "Min": 441,
+            "Max": 131072,
+            "Med": 1744.5,
+            "Med Resp": 579.5
+        },
+        "Summarization": {
+            "Min": 149,
+            "Max": 8423,
+            "Med": 693.5,
+            "Med Resp": 311.0
+        },
+        "Translation": {
+            "Min": 227,
+            "Max": 14234,
+            "Med": 915.0,
+            "Med Resp": 411.5
+        },
+        "Multi-Turn": {
+            "Min": 390,
+            "Max": 142387,
+            "Med": 3222.0,
+            "Med Resp": 1488.0
+        }
+    },
+    "DeepSeek V3.1 (think)": {
+        "Overall": {
+            "Min": 80,
+            "Max": 31147,
+            "Med": 710.5,
+            "Med Resp": 356.0
+        },
+        "Content Generation": {
+            "Min": 132,
+            "Max": 5354,
+            "Med": 776.5,
+            "Med Resp": 500.0
+        },
+        "Editing": {
+            "Min": 119,
+            "Max": 2063,
+            "Med": 571.0,
+            "Med Resp": 287.0
+        },
+        "Data Analysis": {
+            "Min": 119,
+            "Max": 13106,
+            "Med": 644.0,
+            "Med Resp": 218.0
+        },
+        "Reasoning": {
+            "Min": 259,
+            "Max": 31147,
+            "Med": 1340.5,
+            "Med Resp": 338.0
+        },
+        "Hallucination": {
+            "Min": 206,
+            "Max": 10356,
+            "Med": 1132.5,
+            "Med Resp": 667.0
+        },
+        "Safety": {
+            "Min": 80,
+            "Max": 3412,
+            "Med": 565.0,
+            "Med Resp": 206.0
+        },
+        "Repetition": {
+            "Min": 290,
+            "Max": 6553,
+            "Med": 826.5,
+            "Med Resp": 450.0
+        },
+        "Summarization": {
+            "Min": 148,
+            "Max": 1533,
+            "Med": 432.0,
+            "Med Resp": 211.5
+        },
+        "Translation": {
+            "Min": 147,
+            "Max": 7448,
+            "Med": 554.5,
+            "Med Resp": 320.0
+        },
+        "Multi-Turn": {
+            "Min": 324,
+            "Max": 7862,
+            "Med": 2558.5,
+            "Med Resp": 1545.0
+        }
+    },
+    "o4-mini": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "Gemini 2.5 Flash": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "Claude 4 Sonnet (20250514) (think)": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "Solar Pro Preview (top_p:0.95, temp: 0.7)": {
+        "Overall": {
+            "Min": 1,
+            "Max": 4060,
+            "Med": 260.0,
+            "Med Resp": 260.0
+        },
+        "Content Generation": {
+            "Min": 15,
+            "Max": 3643,
+            "Med": 426.0,
+            "Med Resp": 426.0
+        },
+        "Editing": {
+            "Min": 14,
+            "Max": 3948,
+            "Med": 218.0,
+            "Med Resp": 218.0
+        },
+        "Data Analysis": {
+            "Min": 2,
+            "Max": 3500,
+            "Med": 89.0,
+            "Med Resp": 89.0
+        },
+        "Reasoning": {
+            "Min": 1,
+            "Max": 3338,
+            "Med": 190.5,
+            "Med Resp": 190.5
+        },
+        "Hallucination": {
+            "Min": 20,
+            "Max": 1093,
+            "Med": 128.5,
+            "Med Resp": 128.5
+        },
+        "Safety": {
+            "Min": 11,
+            "Max": 1507,
+            "Med": 92.0,
+            "Med Resp": 92.0
+        },
+        "Repetition": {
+            "Min": 34,
+            "Max": 4060,
+            "Med": 214.0,
+            "Med Resp": 214.0
+        },
+        "Summarization": {
+            "Min": 43,
+            "Max": 2478,
+            "Med": 218.0,
+            "Med Resp": 218.0
+        },
+        "Translation": {
+            "Min": 20,
+            "Max": 1711,
+            "Med": 360.0,
+            "Med Resp": 360.0
+        },
+        "Multi-Turn": {
+            "Min": 5,
+            "Max": 3353,
+            "Med": 530.0,
+            "Med Resp": 530.0
+        }
+    },
+    "DeepSeek R1 (0528) (top_p: 0.95, temp:0.6)": {
+        "Overall": {
+            "Min": 4,
+            "Max": 16917,
+            "Med": 1177.5,
+            "Med Resp": 554.0
+        },
+        "Content Generation": {
+            "Min": 389,
+            "Max": 7861,
+            "Med": 1261.5,
+            "Med Resp": 694.0
+        },
+        "Editing": {
+            "Min": 4,
+            "Max": 7611,
+            "Med": 1054.5,
+            "Med Resp": 517.5
+        },
+        "Data Analysis": {
+            "Min": 4,
+            "Max": 8191,
+            "Med": 1112.0,
+            "Med Resp": 355.0
+        },
+        "Reasoning": {
+            "Min": 4,
+            "Max": 12257,
+            "Med": 1913.0,
+            "Med Resp": 455.5
+        },
+        "Hallucination": {
+            "Min": 4,
+            "Max": 7390,
+            "Med": 1214.5,
+            "Med Resp": 682.0
+        },
+        "Safety": {
+            "Min": 227,
+            "Max": 6387,
+            "Med": 963.0,
+            "Med Resp": 568.0
+        },
+        "Repetition": {
+            "Min": 4,
+            "Max": 7787,
+            "Med": 1405.5,
+            "Med Resp": 646.5
+        },
+        "Summarization": {
+            "Min": 319,
+            "Max": 2613,
+            "Med": 711.5,
+            "Med Resp": 321.0
+        },
+        "Translation": {
+            "Min": 4,
+            "Max": 7687,
+            "Med": 1021.0,
+            "Med Resp": 561.5
+        },
+        "Multi-Turn": {
+            "Min": 448,
+            "Max": 16917,
+            "Med": 3418.5,
+            "Med Resp": 1874.0
+        }
+    },
+    "A.X 4.0": {
+        "Overall": {
+            "Min": 1,
+            "Max": 65581,
+            "Med": 412.5,
+            "Med Resp": 412.5
+        },
+        "Content Generation": {
+            "Min": 2,
+            "Max": 65581,
+            "Med": 543.0,
+            "Med Resp": 543.0
+        },
+        "Editing": {
+            "Min": 8,
+            "Max": 1791,
+            "Med": 250.0,
+            "Med Resp": 250.0
+        },
+        "Data Analysis": {
+            "Min": 1,
+            "Max": 65537,
+            "Med": 267.0,
+            "Med Resp": 267.0
+        },
+        "Reasoning": {
+            "Min": 2,
+            "Max": 2046,
+            "Med": 498.0,
+            "Med Resp": 498.0
+        },
+        "Hallucination": {
+            "Min": 12,
+            "Max": 2639,
+            "Med": 511.5,
+            "Med Resp": 511.5
+        },
+        "Safety": {
+            "Min": 4,
+            "Max": 2942,
+            "Med": 516.0,
+            "Med Resp": 516.0
+        },
+        "Repetition": {
+            "Min": 84,
+            "Max": 65536,
+            "Med": 341.5,
+            "Med Resp": 341.5
+        },
+        "Summarization": {
+            "Min": 26,
+            "Max": 2369,
+            "Med": 282.0,
+            "Med Resp": 282.0
+        },
+        "Translation": {
+            "Min": 7,
+            "Max": 35068,
+            "Med": 343.0,
+            "Med Resp": 343.0
+        },
+        "Multi-Turn": {
+            "Min": 3,
+            "Max": 9420,
+            "Med": 1455.0,
+            "Med Resp": 1455.0
+        }
+    },
+    "GPT-5 (Reasoning: medium)": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "Kanana 1.5 15.7B A3B Instruct": {
+        "Overall": {
+            "Min": 1,
+            "Max": 34276,
+            "Med": 414.0,
+            "Med Resp": 414.0
+        },
+        "Content Generation": {
+            "Min": 10,
+            "Max": 22194,
+            "Med": 463.5,
+            "Med Resp": 463.5
+        },
+        "Editing": {
+            "Min": 5,
+            "Max": 1311,
+            "Med": 249.5,
+            "Med Resp": 249.5
+        },
+        "Data Analysis": {
+            "Min": 1,
+            "Max": 22211,
+            "Med": 396.0,
+            "Med Resp": 396.0
+        },
+        "Reasoning": {
+            "Min": 1,
+            "Max": 20275,
+            "Med": 581.0,
+            "Med Resp": 581.0
+        },
+        "Hallucination": {
+            "Min": 24,
+            "Max": 21645,
+            "Med": 441.5,
+            "Med Resp": 441.5
+        },
+        "Safety": {
+            "Min": 18,
+            "Max": 1531,
+            "Med": 414.0,
+            "Med Resp": 414.0
+        },
+        "Repetition": {
+            "Min": 76,
+            "Max": 1912,
+            "Med": 299.5,
+            "Med Resp": 299.5
+        },
+        "Summarization": {
+            "Min": 1,
+            "Max": 29578,
+            "Med": 275.5,
+            "Med Resp": 275.5
+        },
+        "Translation": {
+            "Min": 9,
+            "Max": 31839,
+            "Med": 308.5,
+            "Med Resp": 308.5
+        },
+        "Multi-Turn": {
+            "Min": 3,
+            "Max": 34276,
+            "Med": 1167.5,
+            "Med Resp": 1167.5
+        }
+    },
+    "DeepSeek V3 (0324) (top_p: 0.95, temp:1.3)": {
+        "Overall": {
+            "Min": 1,
+            "Max": 5178,
+            "Med": 408.0,
+            "Med Resp": 408.0
+        },
+        "Content Generation": {
+            "Min": 7,
+            "Max": 1974,
+            "Med": 439.5,
+            "Med Resp": 439.5
+        },
+        "Editing": {
+            "Min": 5,
+            "Max": 1192,
+            "Med": 293.0,
+            "Med Resp": 293.0
+        },
+        "Data Analysis": {
+            "Min": 1,
+            "Max": 3155,
+            "Med": 330.0,
+            "Med Resp": 330.0
+        },
+        "Reasoning": {
+            "Min": 63,
+            "Max": 5178,
+            "Med": 519.0,
+            "Med Resp": 519.0
+        },
+        "Hallucination": {
+            "Min": 57,
+            "Max": 1621,
+            "Med": 502.5,
+            "Med Resp": 502.5
+        },
+        "Safety": {
+            "Min": 12,
+            "Max": 1726,
+            "Med": 337.0,
+            "Med Resp": 337.0
+        },
+        "Repetition": {
+            "Min": 98,
+            "Max": 2754,
+            "Med": 406.5,
+            "Med Resp": 406.5
+        },
+        "Summarization": {
+            "Min": 32,
+            "Max": 959,
+            "Med": 251.0,
+            "Med Resp": 251.0
+        },
+        "Translation": {
+            "Min": 60,
+            "Max": 2197,
+            "Med": 351.5,
+            "Med Resp": 351.5
+        },
+        "Multi-Turn": {
+            "Min": 4,
+            "Max": 4959,
+            "Med": 1318.5,
+            "Med Resp": 1318.5
+        }
+    },
+    "GLM-4.5 FP8 (think)": {
+        "Overall": {
+            "Min": 75,
+            "Max": 65432,
+            "Med": 1442.0,
+            "Med Resp": 604.0
+        },
+        "Content Generation": {
+            "Min": 322,
+            "Max": 9320,
+            "Med": 1283.0,
+            "Med Resp": 655.5
+        },
+        "Editing": {
+            "Min": 232,
+            "Max": 10227,
+            "Med": 1163.5,
+            "Med Resp": 571.0
+        },
+        "Data Analysis": {
+            "Min": 318,
+            "Max": 15748,
+            "Med": 1328.0,
+            "Med Resp": 481.0
+        },
+        "Reasoning": {
+            "Min": 558,
+            "Max": 65432,
+            "Med": 3187.5,
+            "Med Resp": 653.0
+        },
+        "Hallucination": {
+            "Min": 75,
+            "Max": 10541,
+            "Med": 1546.5,
+            "Med Resp": 962.5
+        },
+        "Safety": {
+            "Min": 159,
+            "Max": 5552,
+            "Med": 1418.0,
+            "Med Resp": 808.0
+        },
+        "Repetition": {
+            "Min": 284,
+            "Max": 65409,
+            "Med": 1492.0,
+            "Med Resp": 729.5
+        },
+        "Summarization": {
+            "Min": 242,
+            "Max": 3610,
+            "Med": 688.5,
+            "Med Resp": 268.0
+        },
+        "Translation": {
+            "Min": 156,
+            "Max": 10043,
+            "Med": 1448.5,
+            "Med Resp": 414.0
+        },
+        "Multi-Turn": {
+            "Min": 630,
+            "Max": 15831,
+            "Med": 3977.5,
+            "Med Resp": 2277.5
+        }
+    },
+    "Gauss2.3 Hybrid": {
+        "Overall": {
+            "Min": 7,
+            "Max": 134423,
+            "Med": 546.0,
+            "Med Resp": 308.0
+        },
+        "Content Generation": {
+            "Min": 16,
+            "Max": 6706,
+            "Med": 470.0,
+            "Med Resp": 416.5
+        },
+        "Editing": {
+            "Min": 9,
+            "Max": 2943,
+            "Med": 219.0,
+            "Med Resp": 188.5
+        },
+        "Data Analysis": {
+            "Min": 23,
+            "Max": 131072,
+            "Med": 585.0,
+            "Med Resp": 192.0
+        },
+        "Reasoning": {
+            "Min": 329,
+            "Max": 131072,
+            "Med": 2091.0,
+            "Med Resp": 387.0
+        },
+        "Hallucination": {
+            "Min": 20,
+            "Max": 131072,
+            "Med": 972.5,
+            "Med Resp": 387.0
+        },
+        "Safety": {
+            "Min": 20,
+            "Max": 131072,
+            "Med": 603.0,
+            "Med Resp": 270.0
+        },
+        "Repetition": {
+            "Min": 60,
+            "Max": 131085,
+            "Med": 869.5,
+            "Med Resp": 392.0
+        },
+        "Summarization": {
+            "Min": 26,
+            "Max": 2114,
+            "Med": 320.0,
+            "Med Resp": 208.0
+        },
+        "Translation": {
+            "Min": 7,
+            "Max": 71270,
+            "Med": 322.0,
+            "Med Resp": 273.0
+        },
+        "Multi-Turn": {
+            "Min": 7,
+            "Max": 134423,
+            "Med": 2478.5,
+            "Med Resp": 1208.5
+        }
+    },
+    "gpt-oss-120B (Reasoning: medium)": {
+        "Overall": {
+            "Min": 43,
+            "Max": 18693,
+            "Med": 759.5,
+            "Med Resp": 370.5
+        },
+        "Content Generation": {
+            "Min": 126,
+            "Max": 6264,
+            "Med": 897.0,
+            "Med Resp": 613.5
+        },
+        "Editing": {
+            "Min": 61,
+            "Max": 4605,
+            "Med": 475.5,
+            "Med Resp": 248.5
+        },
+        "Data Analysis": {
+            "Min": 49,
+            "Max": 6975,
+            "Med": 596.0,
+            "Med Resp": 213.0
+        },
+        "Reasoning": {
+            "Min": 147,
+            "Max": 10387,
+            "Med": 1170.5,
+            "Med Resp": 635.0
+        },
+        "Hallucination": {
+            "Min": 88,
+            "Max": 5277,
+            "Med": 1317.0,
+            "Med Resp": 1106.5
+        },
+        "Safety": {
+            "Min": 43,
+            "Max": 3651,
+            "Med": 199.0,
+            "Med Resp": 12.0
+        },
+        "Repetition": {
+            "Min": 122,
+            "Max": 6986,
+            "Med": 940.0,
+            "Med Resp": 407.0
+        },
+        "Summarization": {
+            "Min": 83,
+            "Max": 15231,
+            "Med": 378.0,
+            "Med Resp": 246.0
+        },
+        "Translation": {
+            "Min": 107,
+            "Max": 3659,
+            "Med": 737.0,
+            "Med Resp": 299.5
+        },
+        "Multi-Turn": {
+            "Min": 135,
+            "Max": 18693,
+            "Med": 2826.0,
+            "Med Resp": 2150.0
+        }
+    },
+    "Qwen3 32B (think)": {
+        "Overall": {
+            "Min": 164,
+            "Max": 34272,
+            "Med": 1113.0,
+            "Med Resp": 390.0
+        },
+        "Content Generation": {
+            "Min": 164,
+            "Max": 32768,
+            "Med": 1027.5,
+            "Med Resp": 476.0
+        },
+        "Editing": {
+            "Min": 285,
+            "Max": 3646,
+            "Med": 843.0,
+            "Med Resp": 283.0
+        },
+        "Data Analysis": {
+            "Min": 210,
+            "Max": 18774,
+            "Med": 968.0,
+            "Med Resp": 278.0
+        },
+        "Reasoning": {
+            "Min": 477,
+            "Max": 18676,
+            "Med": 1759.0,
+            "Med Resp": 459.0
+        },
+        "Hallucination": {
+            "Min": 170,
+            "Max": 3776,
+            "Med": 1617.0,
+            "Med Resp": 646.0
+        },
+        "Safety": {
+            "Min": 169,
+            "Max": 4053,
+            "Med": 940.0,
+            "Med Resp": 429.0
+        },
+        "Repetition": {
+            "Min": 608,
+            "Max": 32768,
+            "Med": 2316.5,
+            "Med Resp": 537.5
+        },
+        "Summarization": {
+            "Min": 192,
+            "Max": 2255,
+            "Med": 586.0,
+            "Med Resp": 236.5
+        },
+        "Translation": {
+            "Min": 374,
+            "Max": 10683,
+            "Med": 1113.5,
+            "Med Resp": 307.0
+        },
+        "Multi-Turn": {
+            "Min": 493,
+            "Max": 34272,
+            "Med": 3210.0,
+            "Med Resp": 1481.0
+        }
+    },
+    "Qwen3 235B A22B Instruct 2507": {
+        "Overall": {
+            "Min": 1,
+            "Max": 65405,
+            "Med": 433.0,
+            "Med Resp": 433.0
+        },
+        "Content Generation": {
+            "Min": 7,
+            "Max": 4604,
+            "Med": 492.5,
+            "Med Resp": 492.5
+        },
+        "Editing": {
+            "Min": 6,
+            "Max": 2067,
+            "Med": 248.5,
+            "Med Resp": 248.5
+        },
+        "Data Analysis": {
+            "Min": 1,
+            "Max": 5119,
+            "Med": 357.0,
+            "Med Resp": 357.0
+        },
+        "Reasoning": {
+            "Min": 1,
+            "Max": 11933,
+            "Med": 730.5,
+            "Med Resp": 730.5
+        },
+        "Hallucination": {
+            "Min": 38,
+            "Max": 2395,
+            "Med": 630.0,
+            "Med Resp": 630.0
+        },
+        "Safety": {
+            "Min": 12,
+            "Max": 2497,
+            "Med": 352.0,
+            "Med Resp": 352.0
+        },
+        "Repetition": {
+            "Min": 73,
+            "Max": 65405,
+            "Med": 468.5,
+            "Med Resp": 468.5
+        },
+        "Summarization": {
+            "Min": 24,
+            "Max": 1899,
+            "Med": 249.0,
+            "Med Resp": 249.0
+        },
+        "Translation": {
+            "Min": 10,
+            "Max": 64183,
+            "Med": 299.0,
+            "Med Resp": 299.0
+        },
+        "Multi-Turn": {
+            "Min": 3,
+            "Max": 8009,
+            "Med": 1728.5,
+            "Med Resp": 1728.5
+        }
+    },
+    "Claude 4 Opus (20250514) (think)": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "Gemini 2.5 Pro": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "GPT-5 mini (Reasoning: medium)": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "GPT-5 nano (Reasoning: medium)": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "gpt-oss-20B (Reasoning: medium)": {
+        "Overall": {
+            "Min": 32,
+            "Max": 18763,
+            "Med": 953.5,
+            "Med Resp": 326.0
+        },
+        "Content Generation": {
+            "Min": 126,
+            "Max": 6343,
+            "Med": 983.5,
+            "Med Resp": 486.5
+        },
+        "Editing": {
+            "Min": 107,
+            "Max": 7213,
+            "Med": 667.0,
+            "Med Resp": 195.0
+        },
+        "Data Analysis": {
+            "Min": 94,
+            "Max": 14599,
+            "Med": 750.0,
+            "Med Resp": 192.0
+        },
+        "Reasoning": {
+            "Min": 109,
+            "Max": 18763,
+            "Med": 1290.5,
+            "Med Resp": 475.5
+        },
+        "Hallucination": {
+            "Min": 132,
+            "Max": 7937,
+            "Med": 1493.5,
+            "Med Resp": 620.5
+        },
+        "Safety": {
+            "Min": 32,
+            "Max": 6678,
+            "Med": 268.0,
+            "Med Resp": 12.0
+        },
+        "Repetition": {
+            "Min": 258,
+            "Max": 17217,
+            "Med": 1847.0,
+            "Med Resp": 332.5
+        },
+        "Summarization": {
+            "Min": 99,
+            "Max": 4060,
+            "Med": 438.5,
+            "Med Resp": 219.0
+        },
+        "Translation": {
+            "Min": 133,
+            "Max": 10446,
+            "Med": 1028.5,
+            "Med Resp": 290.0
+        },
+        "Multi-Turn": {
+            "Min": 102,
+            "Max": 14863,
+            "Med": 2483.0,
+            "Med Resp": 1514.0
+        }
+    },
+    "o3-pro (Reasoning: medium)": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "Grok-4": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    },
+    "Mi:dm 2.0 Base Instruct": {
+        "Overall": {
+            "Min": 1,
+            "Max": 32764,
+            "Med": 316.0,
+            "Med Resp": 316.0
+        },
+        "Content Generation": {
+            "Min": 7,
+            "Max": 3515,
+            "Med": 400.0,
+            "Med Resp": 400.0
+        },
+        "Editing": {
+            "Min": 10,
+            "Max": 1998,
+            "Med": 191.0,
+            "Med Resp": 191.0
+        },
+        "Data Analysis": {
+            "Min": 1,
+            "Max": 3302,
+            "Med": 260.0,
+            "Med Resp": 260.0
+        },
+        "Reasoning": {
+            "Min": 1,
+            "Max": 32071,
+            "Med": 398.0,
+            "Med Resp": 398.0
+        },
+        "Hallucination": {
+            "Min": 13,
+            "Max": 3061,
+            "Med": 191.5,
+            "Med Resp": 191.5
+        },
+        "Safety": {
+            "Min": 10,
+            "Max": 1110,
+            "Med": 159.0,
+            "Med Resp": 159.0
+        },
+        "Repetition": {
+            "Min": 50,
+            "Max": 2734,
+            "Med": 316.5,
+            "Med Resp": 316.5
+        },
+        "Summarization": {
+            "Min": 35,
+            "Max": 2967,
+            "Med": 261.0,
+            "Med Resp": 261.0
+        },
+        "Translation": {
+            "Min": 7,
+            "Max": 4703,
+            "Med": 289.5,
+            "Med Resp": 289.5
+        },
+        "Multi-Turn": {
+            "Min": 3,
+            "Max": 32764,
+            "Med": 957.0,
+            "Med Resp": 957.0
+        }
+    },
+    "Qwen3 235B A22B Thinking 2507": {
+        "Overall": {
+            "Min": 8,
+            "Max": 19533,
+            "Med": 2404.5,
+            "Med Resp": 423.0
+        },
+        "Content Generation": {
+            "Min": 402,
+            "Max": 13776,
+            "Med": 2337.0,
+            "Med Resp": 577.5
+        },
+        "Editing": {
+            "Min": 482,
+            "Max": 13235,
+            "Med": 1894.5,
+            "Med Resp": 274.5
+        },
+        "Data Analysis": {
+            "Min": 8,
+            "Max": 13217,
+            "Med": 1427.0,
+            "Med Resp": 303.0
+        },
+        "Reasoning": {
+            "Min": 8,
+            "Max": 19533,
+            "Med": 2340.0,
+            "Med Resp": 568.5
+        },
+        "Hallucination": {
+            "Min": 305,
+            "Max": 6670,
+            "Med": 2005.0,
+            "Med Resp": 848.0
+        },
+        "Safety": {
+            "Min": 304,
+            "Max": 8302,
+            "Med": 1708.0,
+            "Med Resp": 619.0
+        },
+        "Repetition": {
+            "Min": 8,
+            "Max": 11012,
+            "Med": 3533.0,
+            "Med Resp": 514.5
+        },
+        "Summarization": {
+            "Min": 373,
+            "Max": 11701,
+            "Med": 1468.5,
+            "Med Resp": 233.5
+        },
+        "Translation": {
+            "Min": 381,
+            "Max": 12124,
+            "Med": 3332.5,
+            "Med Resp": 284.0
+        },
+        "Multi-Turn": {
+            "Min": 721,
+            "Max": 19299,
+            "Med": 5745.0,
+            "Med Resp": 1736.5
+        }
+    },
+    "HyperCLOVAX SEED Think 14B (think)": {
+        "Overall": {
+            "Min": 223,
+            "Max": 131436,
+            "Med": 1444.0,
+            "Med Resp": 382.5
+        },
+        "Content Generation": {
+            "Min": 279,
+            "Max": 72029,
+            "Med": 1222.0,
+            "Med Resp": 476.5
+        },
+        "Editing": {
+            "Min": 304,
+            "Max": 65536,
+            "Med": 1228.5,
+            "Med Resp": 351.0
+        },
+        "Data Analysis": {
+            "Min": 240,
+            "Max": 65536,
+            "Med": 1352.0,
+            "Med Resp": 234.0
+        },
+        "Reasoning": {
+            "Min": 414,
+            "Max": 65536,
+            "Med": 3010.0,
+            "Med Resp": 315.0
+        },
+        "Hallucination": {
+            "Min": 263,
+            "Max": 65536,
+            "Med": 1310.5,
+            "Med Resp": 444.0
+        },
+        "Safety": {
+            "Min": 241,
+            "Max": 65536,
+            "Med": 1100.0,
+            "Med Resp": 412.0
+        },
+        "Repetition": {
+            "Min": 389,
+            "Max": 65536,
+            "Med": 2233.0,
+            "Med Resp": 355.0
+        },
+        "Summarization": {
+            "Min": 223,
+            "Max": 5987,
+            "Med": 833.5,
+            "Med Resp": 285.0
+        },
+        "Translation": {
+            "Min": 457,
+            "Max": 65536,
+            "Med": 1611.0,
+            "Med Resp": 352.0
+        },
+        "Multi-Turn": {
+            "Min": 648,
+            "Max": 131436,
+            "Med": 3234.5,
+            "Med Resp": 1324.5
+        }
+    },
+    "o3": {
+        "Overall": {
+            "Min": -10,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Content Generation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Editing": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Data Analysis": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Reasoning": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Hallucination": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Safety": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Repetition": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Summarization": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Translation": {
+            "Min": -2,
+            "Max": -2,
+            "Med": -2.0,
+            "Med Resp": -1.0
+        },
+        "Multi-Turn": {
+            "Min": -10,
+            "Max": -4,
+            "Med": -6.0,
+            "Med Resp": -3.0
+        }
+    }
+}

src/data/stats.csv

@@ -0,0 +1,48 @@
+"Model Name"	"Link"	"Comment"	"Group"	"Med. Len."	"Med. Resp. Len."	"Parameter Size (B)"	"Type"	"Model Type"	"Think"	"Overall"	"Content Generation"	"Editing"	"Data Analysis"	"Reasoning"	"Hallucination"	"Safety"	"Repetition"	"Summarization"	"Translation"	"Multi-Turn"
+"GPT-5 (Reasoning: medium)"	"https://platform.openai.com/docs/models/gpt-5"	"Reasoning: medium"	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"70.73"	"71.0"	"74.38"	"76.49"	"79.75"	"64.94"	"56.2"	"82.86"	"80.16"	"69.38"	"54.36"
+"o3-pro (Reasoning: medium)"	"https://platform.openai.com/docs/models/o3-pro"	"Reasoning: medium"	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"66.47"	"72.5"	"70.31"	"75.7"	"83.88"	"64.37"	"33.88"	"74.29"	"65.48"	"64.33"	"48.32"
+"Claude 4 Opus (20250514) (think)"	"https://www.anthropic.com/claude/opus"	"version: 20250514"	"Claude"	""	""	""	"Proprietary"	"Hybrid"	"On"	"63.29"	"60.75"	"59.69"	"73.31"	"69.83"	"78.74"	"53.72"	"55.71"	"65.48"	"65.45"	"48.99"
+"Claude 4.1 Opus (20250805) (think)"	"https://www.anthropic.com/claude/opus"	"version: 20250805"	"Claude"	""	""	""	"Proprietary"	"Hybrid"	"On"	"63.24"	"61.25"	"60.0"	"78.49"	"72.73"	"77.01"	"56.2"	"57.14"	"61.9"	"62.64"	"46.98"
+"GPT-5 mini (Reasoning: medium)"	"https://platform.openai.com/docs/models/gpt-5-mini"	"Reasoning: medium"	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"62.56"	"68.0"	"62.5"	"74.9"	"76.86"	"55.17"	"47.93"	"44.29"	"74.6"	"56.18"	"45.3"
+"Claude 4 Sonnet (20250514) (think)"	"https://www.anthropic.com/claude/sonnet"	"version: 20250514"	"Claude"	""	""	""	"Proprietary"	"Hybrid"	"On"	"61.8"	"58.0"	"58.44"	"76.49"	"67.77"	"79.31"	"57.02"	"44.29"	"65.08"	"62.92"	"44.97"
+"o3"	"https://platform.openai.com/docs/models/o3"	""	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"60.91"	"68.75"	"60.0"	"73.31"	"79.34"	"54.02"	"34.71"	"64.29"	"60.71"	"55.06"	"46.98"
+"Gemini 2.5 Pro"	"https://deepmind.google/models/gemini/pro/"	""	"Gemini"	""	""	""	"Proprietary"	"Think"	"On"	"59.34"	"54.0"	"60.94"	"78.88"	"73.14"	"63.22"	"17.36"	"52.86"	"67.86"	"53.93"	"52.68"
+"Grok-4"	"https://x.ai/news/grok-4"	"temperature: 0.6
+top-p: 0.95"	"Grok"	""	""	""	"Proprietary"	"Think"	"On"	"58.74"	"61.0"	"66.25"	"72.51"	"63.22"	"66.09"	"16.53"	"58.57"	"66.27"	"54.21"	"44.3"
+"Gemini 2.5 Flash"	"https://deepmind.google/models/gemini/flash/"	""	"Gemini"	""	""	""	"Proprietary"	"Hybrid"	"On"	"58.62"	"57.25"	"62.19"	"70.52"	"72.31"	"56.9"	"28.93"	"47.14"	"68.65"	"55.06"	"46.98"
+"o4-mini"	"https://platform.openai.com/docs/models/o4-mini"	""	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"57.57"	"67.25"	"61.25"	"71.71"	"75.62"	"45.4"	"39.67"	"44.29"	"59.92"	"47.19"	"41.95"
+"Qwen3 235B A22B Thinking 2507"	"https://huggingface.co/Qwen/Qwen3-235B-A22B-Thinking-2507"	"temperature: 0.6
+top-p: 0.95"	"Qwen"	"2404.5"	"423.0"	"235.0"	"Open"	"Think"	"On"	"55.48"	"57.5"	"53.12"	"73.31"	"75.21"	"55.17"	"25.62"	"35.71"	"55.56"	"56.18"	"40.27"
+"GPT-5 nano (Reasoning: medium)"	"https://platform.openai.com/docs/models/gpt-5-nano"	"Reasoning: medium"	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"55.39"	"63.5"	"47.19"	"68.92"	"75.21"	"55.17"	"52.07"	"34.29"	"63.49"	"40.73"	"42.95"
+"GLM-4.5 FP8 (think)"	"https://huggingface.co/zai-org/GLM-4.5-FP8"	"temperature: 0.6
+top-p: 0.95"	"GLM"	"1442.0"	"604.0"	"355.0"	"Open"	"Hybrid"	"On"	"54.03"	"60.75"	"53.75"	"68.92"	"74.38"	"47.13"	"33.06"	"41.43"	"60.32"	"46.07"	"35.91"
+"Qwen3 235B A22B Instruct 2507"	"https://huggingface.co/Qwen/Qwen3-235B-A22B-Instruct-2507"	"temperature: 0.7
+top-p: 0.8"	"Qwen"	"433.0"	"433.0"	"235.0"	"Open"	"Instruct"	"Off"	"52.94"	"58.0"	"49.69"	"68.13"	"73.97"	"55.17"	"45.45"	"30.0"	"55.95"	"38.48"	"41.61"
+"DeepSeek V3.1 (think)"	"https://huggingface.co/deepseek-ai/DeepSeek-V3.1"	"temperature: 0.6
+top-p: 0.95"	"DeepSeek"	"710.5"	"356.0"	"671.0"	"Open"	"Hybrid"	"On"	"51.45"	"52.0"	"50.0"	"67.33"	"69.83"	"50.0"	"33.88"	"35.71"	"59.52"	"41.85"	"40.27"
+"gpt-oss-120B (Reasoning: medium)"	"https://huggingface.co/openai/gpt-oss-120b"	"Reasoning: medium
+temperature: 1.0
+top-p: 1.0"	"GPT"	"759.5"	"370.5"	"117.0"	"Open"	"Think"	"On"	"49.11"	"58.5"	"48.44"	"68.92"	"69.83"	"41.38"	"39.67"	"25.71"	"50.79"	"35.67"	"32.21"
+"DeepSeek R1 (0528) (top_p: 0.95, temp:0.6)"	"https://huggingface.co/deepseek-ai/DeepSeek-R1-0528"	"version: 0528
+temperature: 0.6
+top-p: 0.95"	"DeepSeek"	"1177.5"	"554.0"	"671.0"	"Open"	"Think"	"On"	"48.79"	"49.75"	"50.0"	"65.34"	"59.09"	"48.85"	"38.02"	"32.86"	"57.94"	"36.52"	"38.93"
+"Gauss2.3 Hybrid"	""	""	"Gauss"	"546.0"	"308.0"	""	"Proprietary"	"Hybrid"	"On"	"46.58"	"52.0"	"46.25"	"59.76"	"66.94"	"41.95"	"34.71"	"25.71"	"53.17"	"34.55"	"33.22"
+"DeepSeek V3 (0324) (top_p: 0.95, temp:1.3)"	"https://huggingface.co/deepseek-ai/DeepSeek-V3-0324"	"version: 0324
+temperature: 1.3
+top-p: 0.95"	"DeepSeek"	"408.0"	"408.0"	"671.0"	"Open"	"Instruct"	"Off"	"45.09"	"46.25"	"45.0"	"58.96"	"60.33"	"41.95"	"21.49"	"30.0"	"55.95"	"38.48"	"33.22"
+"Qwen3 32B (think)"	"https://huggingface.co/Qwen/Qwen3-32B"	"temperature: 0.6
+top-p: 0.95"	"Qwen"	"1113.0"	"390.0"	"32.8"	"Open"	"Hybrid"	"On"	"44.44"	"52.25"	"41.56"	"68.92"	"66.53"	"35.06"	"19.83"	"25.71"	"46.43"	"30.9"	"32.89"
+"A.X 4.0"	"https://huggingface.co/skt/A.X-4.0"	""	"SKT"	"412.5"	"412.5"	"71.9"	"Open"	"Instruct"	"Off"	"41.59"	"56.0"	"43.75"	"43.43"	"42.56"	"40.23"	"15.7"	"24.29"	"53.97"	"33.43"	"32.21"
+"gpt-oss-20B (Reasoning: medium)"	"https://huggingface.co/openai/gpt-oss-20b"	"Reasoning: medium
+temperature: 1.0
+top-p: 1.0"	"GPT"	"953.5"	"326.0"	"21.0"	"Open"	"Think"	"On"	"41.18"	"52.0"	"40.0"	"61.35"	"65.7"	"43.1"	"41.32"	"22.86"	"36.51"	"20.51"	"22.82"
+"EXAONE 4.0 32B (think)"	"https://huggingface.co/LGAI-EXAONE/EXAONE-4.0-32B"	"temperature: 0.6
+top-p: 0.95"	"Exaone"	"1274.5"	"503.0"	"32.0"	"Open"	"Hybrid"	"On"	"33.82"	"34.25"	"29.38"	"56.97"	"57.44"	"24.71"	"27.27"	"17.14"	"38.49"	"18.54"	"25.5"
+"HyperCLOVAX SEED Think 14B (think)"	"https://huggingface.co/naver-hyperclovax/HyperCLOVAX-SEED-Think-14B"	"temperature: 0.5
+top-p: 0.6"	"HCX"	"1444.0"	"382.5"	"14.7"	"Open"	"Hybrid"	"On"	"31.84"	"35.0"	"26.56"	"53.78"	"58.68"	"27.59"	"26.45"	"17.14"	"29.76"	"17.13"	"20.47"
+"Solar Pro Preview (top_p:0.95, temp: 0.7)"	"https://huggingface.co/upstage/solar-pro-preview-instruct"	"temperature: 0.7
+top-p: 0.95"	"Solar"	"260.0"	"260.0"	"22.0"	"Open"	"Instruct"	"Off"	"20.73"	"28.0"	"24.69"	"16.73"	"19.42"	"17.24"	"28.1"	"11.43"	"31.35"	"13.76"	"11.74"
+"Mi:dm 2.0 Base Instruct"	"https://huggingface.co/K-intelligence/Midm-2.0-Base-Instruct"	"temperature: 0.8
+top-p: 0.7"	"kt"	"316.0"	"316.0"	"11.5"	"Open"	"Instruct"	"Off"	"20.25"	"21.75"	"17.5"	"16.73"	"18.6"	"27.59"	"59.5"	"14.29"	"25.4"	"12.64"	"11.41"
+"Kanana 1.5 15.7B A3B Instruct"	"https://huggingface.co/kakaocorp/kanana-1.5-15.7b-a3b-instruct"	"temperature: 1.0
+top-p: 0.95"	"kakao"	"414.0"	"414.0"	"15.7"	"Open"	"Instruct"	"Off"	"11.71"	"14.25"	"10.62"	"13.55"	"11.16"	"22.41"	"22.31"	"4.29"	"11.9"	"6.74"	"5.37"

src/data/stats_lang.csv

@@ -0,0 +1,48 @@
+"Model Name"	"Link"	"Comment"	"Group"	"Med. Len."	"Med. Resp. Len."	"Parameter Size (B)"	"Type"	"Model Type"	"Think"	"Overall"	"KO"	"EN"	"JA"	"ZH"	"PL"	"DE"	"PT"	"ES"	"FR"	"IT"	"RU"	"VI"
+"GPT-5 (Reasoning: medium)"	"https://platform.openai.com/docs/models/gpt-5"	"Reasoning: medium"	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"70.73"	"64.72"	"65.83"	"71.69"	"67.68"	"72.78"	"71.27"	"73.74"	"75.68"	"72.83"	"77.05"	"70.79"	"75.61"
+"o3-pro (Reasoning: medium)"	"https://platform.openai.com/docs/models/o3-pro"	"Reasoning: medium"	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"66.47"	"63.61"	"63.61"	"69.28"	"65.24"	"63.89"	"64.09"	"68.16"	"69.19"	"70.11"	"72.13"	"62.36"	"71.95"
+"Claude 4 Opus (20250514) (think)"	"https://www.anthropic.com/claude/opus"	"version: 20250514"	"Claude"	""	""	""	"Proprietary"	"Hybrid"	"On"	"63.29"	"57.5"	"62.5"	"64.46"	"62.8"	"59.44"	"65.19"	"65.92"	"60.54"	"65.22"	"65.57"	"65.17"	"72.56"
+"Claude 4.1 Opus (20250805) (think)"	"https://www.anthropic.com/claude/opus"	"version: 20250805"	"Claude"	""	""	""	"Proprietary"	"Hybrid"	"On"	"63.24"	"58.33"	"61.39"	"60.84"	"64.02"	"61.67"	"66.85"	"68.16"	"61.08"	"65.76"	"66.67"	"65.73"	"65.24"
+"GPT-5 mini (Reasoning: medium)"	"https://platform.openai.com/docs/models/gpt-5-mini"	"Reasoning: medium"	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"62.56"	"57.5"	"56.39"	"62.65"	"62.2"	"63.89"	"60.22"	"66.48"	"67.03"	"70.11"	"67.76"	"66.29"	"60.98"
+"Claude 4 Sonnet (20250514) (think)"	"https://www.anthropic.com/claude/sonnet"	"version: 20250514"	"Claude"	""	""	""	"Proprietary"	"Hybrid"	"On"	"61.8"	"54.17"	"59.17"	"63.86"	"64.63"	"59.44"	"61.33"	"64.8"	"62.16"	"65.22"	"67.21"	"66.29"	"64.02"
+"o3"	"https://platform.openai.com/docs/models/o3"	""	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"60.91"	"57.5"	"59.17"	"61.45"	"58.54"	"61.11"	"64.09"	"60.89"	"62.16"	"63.59"	"65.03"	"54.49"	"68.29"
+"Gemini 2.5 Pro"	"https://deepmind.google/models/gemini/pro/"	""	"Gemini"	""	""	""	"Proprietary"	"Think"	"On"	"59.34"	"53.61"	"57.78"	"59.04"	"57.93"	"57.22"	"56.91"	"60.89"	"63.24"	"67.93"	"62.3"	"61.24"	"60.98"
+"Grok-4"	"https://x.ai/news/grok-4"	"temperature: 0.6
+top-p: 0.95"	"Grok"	""	""	""	"Proprietary"	"Think"	"On"	"58.74"	"57.78"	"56.67"	"62.65"	"60.37"	"58.33"	"60.22"	"59.78"	"56.22"	"62.5"	"60.66"	"52.25"	"60.98"
+"Gemini 2.5 Flash"	"https://deepmind.google/models/gemini/flash/"	""	"Gemini"	""	""	""	"Proprietary"	"Hybrid"	"On"	"58.62"	"51.11"	"56.39"	"62.05"	"56.71"	"62.78"	"60.77"	"61.45"	"60.0"	"63.04"	"57.92"	"64.04"	"56.71"
+"o4-mini"	"https://platform.openai.com/docs/models/o4-mini"	""	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"57.57"	"54.17"	"55.0"	"62.05"	"59.76"	"52.78"	"58.56"	"63.69"	"55.68"	"57.61"	"60.66"	"56.74"	"60.98"
+"Qwen3 235B A22B Thinking 2507"	"https://huggingface.co/Qwen/Qwen3-235B-A22B-Thinking-2507"	"temperature: 0.6
+top-p: 0.95"	"Qwen"	"2404.5"	"423.0"	"235.0"	"Open"	"Think"	"On"	"55.48"	"49.17"	"53.33"	"56.02"	"58.54"	"50.56"	"62.43"	"60.89"	"52.97"	"56.52"	"60.11"	"53.93"	"60.37"
+"GPT-5 nano (Reasoning: medium)"	"https://platform.openai.com/docs/models/gpt-5-nano"	"Reasoning: medium"	"GPT"	""	""	""	"Proprietary"	"Think"	"On"	"55.39"	"51.94"	"53.89"	"57.23"	"53.66"	"55.56"	"58.01"	"59.78"	"54.59"	"56.52"	"59.02"	"57.3"	"51.83"
+"GLM-4.5 FP8 (think)"	"https://huggingface.co/zai-org/GLM-4.5-FP8"	"temperature: 0.6
+top-p: 0.95"	"GLM"	"1442.0"	"604.0"	"355.0"	"Open"	"Hybrid"	"On"	"54.03"	"46.94"	"54.17"	"60.84"	"58.54"	"48.89"	"55.8"	"54.75"	"48.11"	"57.61"	"57.92"	"57.87"	"54.88"
+"Qwen3 235B A22B Instruct 2507"	"https://huggingface.co/Qwen/Qwen3-235B-A22B-Instruct-2507"	"temperature: 0.7
+top-p: 0.8"	"Qwen"	"433.0"	"433.0"	"235.0"	"Open"	"Instruct"	"Off"	"52.94"	"46.67"	"55.28"	"53.61"	"59.15"	"46.11"	"51.38"	"55.87"	"54.59"	"53.26"	"56.28"	"54.49"	"53.05"
+"DeepSeek V3.1 (think)"	"https://huggingface.co/deepseek-ai/DeepSeek-V3.1"	"temperature: 0.6
+top-p: 0.95"	"DeepSeek"	"710.5"	"356.0"	"671.0"	"Open"	"Hybrid"	"On"	"51.45"	"44.44"	"48.33"	"56.63"	"48.78"	"48.89"	"55.25"	"53.07"	"52.97"	"56.52"	"57.92"	"50.56"	"54.27"
+"gpt-oss-120B (Reasoning: medium)"	"https://huggingface.co/openai/gpt-oss-120b"	"Reasoning: medium
+temperature: 1.0
+top-p: 1.0"	"GPT"	"759.5"	"370.5"	"117.0"	"Open"	"Think"	"On"	"49.11"	"46.67"	"51.39"	"51.81"	"47.56"	"45.0"	"51.38"	"54.75"	"50.27"	"51.63"	"47.54"	"46.07"	"45.12"
+"DeepSeek R1 (0528) (top_p: 0.95, temp:0.6)"	"https://huggingface.co/deepseek-ai/DeepSeek-R1-0528"	"version: 0528
+temperature: 0.6
+top-p: 0.95"	"DeepSeek"	"1177.5"	"554.0"	"671.0"	"Open"	"Think"	"On"	"48.79"	"42.22"	"49.44"	"50.0"	"53.05"	"47.22"	"48.62"	"50.28"	"48.11"	"51.63"	"54.1"	"44.38"	"53.05"
+"Gauss2.3 Hybrid"	""	""	"Gauss"	"546.0"	"308.0"	""	"Proprietary"	"Hybrid"	"On"	"46.58"	"39.72"	"45.56"	"48.8"	"48.17"	"45.0"	"44.2"	"53.63"	"45.41"	"52.17"	"51.91"	"44.94"	"47.56"
+"DeepSeek V3 (0324) (top_p: 0.95, temp:1.3)"	"https://huggingface.co/deepseek-ai/DeepSeek-V3-0324"	"version: 0324
+temperature: 1.3
+top-p: 0.95"	"DeepSeek"	"408.0"	"408.0"	"671.0"	"Open"	"Instruct"	"Off"	"45.09"	"37.5"	"43.61"	"46.99"	"51.22"	"45.56"	"44.75"	"44.69"	"44.32"	"48.91"	"49.18"	"44.94"	"49.39"
+"Qwen3 32B (think)"	"https://huggingface.co/Qwen/Qwen3-32B"	"temperature: 0.6
+top-p: 0.95"	"Qwen"	"1113.0"	"390.0"	"32.8"	"Open"	"Hybrid"	"On"	"44.44"	"38.89"	"41.67"	"48.8"	"50.0"	"38.33"	"46.41"	"44.69"	"44.86"	"44.57"	"50.82"	"46.07"	"47.56"
+"A.X 4.0"	"https://huggingface.co/skt/A.X-4.0"	""	"SKT"	"412.5"	"412.5"	"71.9"	"Open"	"Instruct"	"Off"	"41.59"	"38.89"	"41.11"	"43.98"	"49.39"	"36.11"	"45.86"	"43.58"	"44.32"	"39.67"	"43.17"	"39.89"	"36.59"
+"gpt-oss-20B (Reasoning: medium)"	"https://huggingface.co/openai/gpt-oss-20b"	"Reasoning: medium
+temperature: 1.0
+top-p: 1.0"	"GPT"	"953.5"	"326.0"	"21.0"	"Open"	"Think"	"On"	"41.18"	"36.67"	"42.78"	"45.78"	"45.73"	"37.78"	"35.91"	"41.9"	"39.46"	"51.09"	"40.44"	"38.76"	"41.46"
+"EXAONE 4.0 32B (think)"	"https://huggingface.co/LGAI-EXAONE/EXAONE-4.0-32B"	"temperature: 0.6
+top-p: 0.95"	"Exaone"	"1274.5"	"503.0"	"32.0"	"Open"	"Hybrid"	"On"	"33.82"	"33.61"	"38.33"	"28.92"	"35.98"	"26.11"	"35.91"	"34.08"	"38.92"	"35.33"	"33.88"	"28.09"	"31.71"
+"HyperCLOVAX SEED Think 14B (think)"	"https://huggingface.co/naver-hyperclovax/HyperCLOVAX-SEED-Think-14B"	"temperature: 0.5
+top-p: 0.6"	"HCX"	"1444.0"	"382.5"	"14.7"	"Open"	"Hybrid"	"On"	"31.84"	"32.22"	"37.22"	"31.93"	"38.41"	"27.78"	"32.6"	"30.17"	"29.19"	"32.07"	"33.33"	"25.28"	"26.22"
+"Solar Pro Preview (top_p:0.95, temp: 0.7)"	"https://huggingface.co/upstage/solar-pro-preview-instruct"	"temperature: 0.7
+top-p: 0.95"	"Solar"	"260.0"	"260.0"	"22.0"	"Open"	"Instruct"	"Off"	"20.73"	"9.72"	"22.22"	"21.08"	"24.39"	"9.44"	"18.23"	"24.02"	"29.73"	"29.89"	"33.33"	"22.47"	"12.8"
+"Mi:dm 2.0 Base Instruct"	"https://huggingface.co/K-intelligence/Midm-2.0-Base-Instruct"	"temperature: 0.8
+top-p: 0.7"	"kt"	"316.0"	"316.0"	"11.5"	"Open"	"Instruct"	"Off"	"20.25"	"26.39"	"26.39"	"17.47"	"26.83"	"13.33"	"18.78"	"20.67"	"16.22"	"20.65"	"21.31"	"12.92"	"9.15"
+"Kanana 1.5 15.7B A3B Instruct"	"https://huggingface.co/kakaocorp/kanana-1.5-15.7b-a3b-instruct"	"temperature: 1.0
+top-p: 0.95"	"kakao"	"414.0"	"414.0"	"15.7"	"Open"	"Instruct"	"Off"	"11.71"	"21.11"	"20.28"	"10.84"	"15.24"	"5.56"	"7.73"	"8.94"	"9.19"	"8.15"	"5.46"	"5.06"	"4.88"

src/data_loader.py

@@ -0,0 +1,122 @@
+import pandas as pd
+from pathlib import Path
+from typing import Optional
+
+# Global cache variables
+_category_df_cache: Optional[pd.DataFrame] = None
+_language_df_cache: Optional[pd.DataFrame] = None
+
+def _load_category_csv() -> pd.DataFrame:
+    """Load the category CSV file with proper encoding and delimiter."""
+    abs_path = Path(__file__).parent
+    df = pd.read_csv(str(abs_path / "data/stats.csv"), encoding='utf-8', delimiter="\t")
+    return df.copy()
+
+def _load_language_csv() -> pd.DataFrame:
+    """Load the language CSV file with proper encoding and delimiter."""
+    abs_path = Path(__file__).parent
+    df = pd.read_csv(str(abs_path / "data/stats_lang.csv"), encoding='utf-8', delimiter="\t")
+    return df.copy()
+
+def get_category_dataframe(processed: bool = True) -> pd.DataFrame:
+    """
+    Get the category dataframe.
+    
+    Args:
+        processed: If True, returns processed dataframe (for vis_utils.py compatibility)
+                  If False, returns raw dataframe sorted by Overall (for data_utils.py compatibility)
+    
+    Returns:
+        pd.DataFrame: The category dataframe
+    """
+    global _category_df_cache
+    
+    if _category_df_cache is None:
+        _category_df_cache = _load_category_csv()
+    
+    df = _category_df_cache.copy()
+    
+    if processed:
+        # Apply vis_utils.py processing
+        required_cols = ['Model Name', 'Link', "Group", "Overall", "Med. Len.", "Med. Resp. Len.", "Parameter Size (B)", "Type", "Model Type", "Think", 'Content Generation', 'Editing', 'Data Analysis', 
+                        'Reasoning', 'Hallucination', 'Safety', 'Repetition', 
+                        'Summarization', 'Translation', 'Multi-Turn']
+        
+        for col in required_cols:
+            if col not in df.columns:
+                if col in ["Link", "Group"]:
+                    df[col] = ""
+                else:
+                    df[col] = 0
+
+        from constants import NUMERIC_COLS_CATEGORY, NUMERIC_INT_COLS_CATEGORY
+        for col in NUMERIC_COLS_CATEGORY:
+            if col in df.columns:
+                if col in NUMERIC_INT_COLS_CATEGORY:
+                    df[col] = pd.to_numeric(df[col], errors='coerce').round(0)
+                else:
+                    df[col] = pd.to_numeric(df[col], errors='coerce').round(3)
+            else:
+                df[col] = 0
+
+        if "Think" not in df.columns:
+            df["Think"] = "Off"
+
+        df = df.fillna('')
+        
+    else:
+        # Apply data_utils.py processing
+        df = df.sort_values("Overall", ascending=False)
+
+    return df
+
+def get_language_dataframe(processed: bool = True) -> pd.DataFrame:
+    """
+    Get the language dataframe.
+    
+    Args:
+        processed: If True, returns processed dataframe (for vis_utils.py compatibility)
+                  If False, returns raw dataframe sorted by Overall (for data_utils.py compatibility)
+    
+    Returns:
+        pd.DataFrame: The language dataframe
+    """
+    global _language_df_cache
+    
+    if _language_df_cache is None:
+        _language_df_cache = _load_language_csv()
+    
+    df = _language_df_cache.copy()
+    
+    if processed:
+        # Apply vis_utils.py processing
+        language_cols = ['Model Name', 'Link', "Group", "Overall", "Med. Len.", "Med. Resp. Len.", "Parameter Size (B)", "Type", "Model Type", "Think", 'KO', 'EN', 'JA', 'ZH', 'PL', 'DE', 'PT', 'ES', 'FR', 'IT', 'RU', 'VI']
+        for col in language_cols:
+            if col not in df.columns:
+                if col in ["Link", "Group"]:
+                    df[col] = ""
+                else:
+                    df[col] = 0
+        
+        from constants import NUMERIC_COLS_LANGUAGE, NUMERIC_INT_COLS_LANGUAGE
+        for col in NUMERIC_COLS_LANGUAGE:
+            if col in df.columns:
+                if col in NUMERIC_INT_COLS_LANGUAGE:
+                    df[col] = pd.to_numeric(df[col], errors='coerce').round(0)
+                else:
+                    df[col] = pd.to_numeric(df[col], errors='coerce').round(3)
+            else:
+                df[col] = 0
+        
+        df = df.fillna('')
+    else:
+        # Apply data_utils.py processing
+        df = df.sort_values("Overall", ascending=False)
+    
+    return df
+
+def clear_cache():
+    """Clear the cached dataframes to force reload on next access."""
+    global _category_df_cache, _language_df_cache
+    _category_df_cache = None
+    _language_df_cache = None

src/data_utils.py

@@ -0,0 +1,50 @@
+import pandas as pd
+from pathlib import Path
+
+def get_dataframe_category():
+    from src.data_loader import get_category_dataframe
+    return get_category_dataframe(processed=False)
+
+def get_dataframe_language():
+    from src.data_loader import get_language_dataframe
+    return get_language_dataframe(processed=False)
+
+import json
+
+def get_length_category_df(selected_category):
+    """
+    Loads length_data.json and returns a DataFrame for the selected category.
+    Columns: Model Name, {Category} Min, {Category} Max, {Category} Med,  {Category} Med Resp
+    """
+    abs_path = Path(__file__).parent
+    json_path = abs_path / "data/length_data.json"
+    with open(json_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    rows = []
+    for model_name, stats in data.items():
+        cat = stats.get(selected_category, {})
+        row = {
+            "Model Name": model_name,
+            f"Min Len. ({selected_category})": cat.get("Min", None),
+            f"Max Len. ({selected_category}))": cat.get("Max", None),
+            f"Med. Len. ({selected_category})": cat.get("Med", None),
+            f"Med. Resp. Len. ({selected_category})": cat.get("Med Resp", None),
+        }
+        rows.append(row)
+    df = pd.DataFrame(rows)
+    return df
+
+def get_length_category_list():
+    """
+    Returns the list of available categories in length_data.json (excluding 'Overall').
+    """
+    abs_path = Path(__file__).parent
+    json_path = abs_path / "data/length_data.json"
+    with open(json_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    if not data:
+        return []
+    # Get categories from the first model
+    first_model = next(iter(data.values()))
+    categories = [k for k in first_model.keys() if k != "Overall"]
+    return categories

src/display/css_html_js.py

@@ -0,0 +1,766 @@
+custom_css = """
+/* Info icon for column tooltips */
+.info-icon {
+  color: #b0b0b0;
+  font-size: 15px;
+  margin-left: 4px;
+  vertical-align: middle;
+  font-family: Arial, sans-serif;
+  font-style: normal;
+  font-weight: bold;
+  user-select: none;
+}
+.info-icon:hover {
+  color: #888;
+}
+/* Model Name link hover effect */
+.pretty-leaderboard-table a:hover {
+  text-decoration: underline;
+  color: #1098F7;
+  cursor: pointer;
+}
+
+/* INTRO FEATURE CARDS (for about page) */
+.intro-feature-row {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: 24px;
+  margin: 18px 0 !important;
+}
+.intro-feature-box {
+  background: linear-gradient(135deg, #f8fafc 60%, #e3e6f3 100%);
+  border-radius: 18px;
+  box-shadow: 0 4px 16px rgba(44,62,80,0.08);
+  padding: 32px 28px;
+  width: 380px;
+  min-width: 260px;
+  max-width: 420px;
+  text-align: left;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  transition: box-shadow 0.2s;
+}
+.intro-feature-title {
+  font-weight: 900;
+  font-size: 1.45em;
+  margin-bottom: 12px;
+  color: #23244a;
+}
+.intro-feature-desc {
+  font-size: 1.18em;
+  color: #444;
+  margin-bottom: 7px;
+}
+.intro-feature-icon {
+  font-size: 2.3em;
+  margin-bottom: 16px;
+  color: #1098F7;
+}
+.intro-feature-box:hover {
+  box-shadow: 0 0 24px #a5a1ff55, 0 4px 16px rgba(0,0,0,0.18);
+  transform: translateY(-4px) scale(1.025);
+  transition: box-shadow 0.2s, transform 0.2s;
+  cursor: default;
+}
+@media (prefers-color-scheme: dark) {
+  .intro-feature-box {
+    background: linear-gradient(135deg, #23244a 0%, #2a1859 100%) !important;
+    color: #f5f6f7 !important;
+  }
+  .intro-feature-title, .intro-feature-desc {
+    color: #f5f6f7 !important;
+  }
+}
+
+/* Dataset Sample Button (below feature cards) */
+.intro-dataset-btn {
+  display: inline-block;
+  background: #1098F7;
+  color: #fff !important;
+  border: none;
+  border-radius: 12px;
+  font-weight: 700;
+  font-size: 1.18em;
+  padding: 16px 36px;
+  margin: 32px auto 0 auto;
+  text-align: center;
+  text-decoration: none;
+  box-shadow: 0 2px 8px #1098f733;
+  transition: background 0.18s, color 0.18s, box-shadow 0.18s;
+  cursor: pointer;
+  outline: none;
+}
+.intro-dataset-btn:hover, .intro-dataset-btn:focus {
+  background: #0a6dc2;
+  color: #fff !important;
+  box-shadow: 0 4px 16px #1098f755;
+  text-decoration: none;
+}
+@media (prefers-color-scheme: dark) {
+  .intro-dataset-btn {
+    background: #1a4b7a;
+    color: #fff !important;
+  }
+  .intro-dataset-btn:hover, .intro-dataset-btn:focus {
+    background: #1098F7;
+    color: #fff !important;
+  }
+}
+
+.radar-chart, .plot-container {
+    display: block;
+    margin-left: auto;
+    margin-right: auto;
+    width: fit-content;
+    max-width: 100%;
+}
+
+/* Ensure injected HTML/Markdown blocks are transparent and text is visible in all color schemes */
+.gr-html, .gr-markdown, .gr-html * {
+    background: transparent !important;
+    color: inherit !important;
+}
+.gr-html div, .gr-html body, .gr-markdown div, .gr-markdown body {
+    background: transparent !important;
+    color: inherit !important;
+}
+@media (prefers-color-scheme: dark) {
+    .gr-html, .gr-markdown, .gr-html *, .gr-markdown * {
+        color: #f5f6f7 !important;
+    }
+}
+@media (prefers-color-scheme: light) {
+    .gr-html, .gr-markdown, .gr-html *, .gr-markdown * {
+        color: #23244a !important;
+    }
+}
+
+/* Custom radio styles for category selector */
+.cat-btn-radio label {
+  border-radius: 18px !important;
+  border: 1.5px solid #d1d5db !important;
+  background: #f8fafc !important;
+  color: #222 !important;
+  font-weight: 600 !important;
+  cursor: pointer !important;
+  padding: 8px 20px !important;
+  box-shadow: 0 2px 8px #e5e7eb88 !important;
+  margin: 0 !important;
+  font-size: 1.08rem !important;
+  transition: background 0.2s, color 0.2s, box-shadow 0.2s, border 0.2s !important;
+  display: inline-block !important;
+}
+.cat-btn-radio input[type="radio"] {
+  display: none !important;
+}
+.cat-btn-radio input[type="radio"]:checked + label,
+.cat-btn-radio label.selected {
+  background: #1098F7 !important;
+  color: #fff !important;
+  border: 1.5px solid #1098F7 !important;
+  box-shadow: 0 4px 16px #1098f755, 0 2px 8px #e5e7eb88 !important;
+}
+.cat-btn-radio label:hover {
+  border: 1.5px solid #1098F7 !important;
+  box-shadow: 0 4px 16px #1098f733, 0 2px 8px #e5e7eb88 !important;
+}
+
+/* Gradio tab content: Space-themed background */
+.gr-tabitem {
+    background: linear-gradient(135deg, #e3e6f3 60%, #f5f6fa 100%);
+    background-image:
+      radial-gradient(rgba(255,255,255,0.10) 1.2px, transparent 1.2px),
+      radial-gradient(rgba(255,255,255,0.06) 1px, transparent 1px);
+    background-size: 40px 40px, 80px 80px;
+    background-position: 0 0, 20px 20px;
+}
+@media (prefers-color-scheme: dark) {
+    .gr-tabitem {
+        background: linear-gradient(135deg, #181c3a 0%, #2a1859 100%) !important;
+        background-image:
+          radial-gradient(rgba(255,255,255,0.10) 1.2px, transparent 1.2px),
+          radial-gradient(rgba(255,255,255,0.06) 1px, transparent 1px);
+        background-size: 40px 40px, 80px 80px;
+        background-position: 0 0, 20px 20px;
+    }
+}
+    @media (prefers-color-scheme: light) {
+    .gr-tabitem {
+        background: linear-gradient(135deg, #e3e6f3 60%, #f5f6fa 100%) !important;
+        background-image:
+          radial-gradient(rgba(255,255,255,0.10) 1.2px, transparent 1.2px),
+          radial-gradient(rgba(255,255,255,0.06) 1px, transparent 1px);
+        background-size: 40px 40px, 80px 80px;
+        background-position: 0 0, 20px 20px;
+    }
+    h3 a, h3 a:visited {
+        color: #222 !important;
+    }
+}
+
+/* Sort arrow/button styles */
+.sort-arrow, .sort-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    background: #23244a;
+    color: #ffd700 !important; /* Always yellow */
+    border: 1.5px solid #ffd700; /* Gold border */
+    border-radius: 6px;
+    font-size: 15px;
+    font-weight: 700;
+    margin-left: 6px;
+    margin-right: 2px;
+    padding: 2px 8px 2px 6px;
+    cursor: pointer;
+    transition: background 0.2s, color 0.2s, border 0.2s;
+    min-width: 28px;
+    min-height: 28px;
+    outline: none;
+}
+.sort-arrow.active, .sort-btn.active {
+    color: #ffd700 !important; /* Gold */
+    border-color: #ffd700;
+    background: #1a237e;
+}
+.sort-arrow:hover, .sort-btn:hover {
+    background: #ffd700;
+    color: #23244a !important;
+    border-color: #ffd700;
+}
+.sort-arrow svg, .sort-btn svg {
+    margin-left: 2px;
+    margin-right: 0;
+    width: 1em;
+    height: 1em;
+    vertical-align: middle;
+}
+
+/* Enhanced leaderboard table styles */
+.pretty-leaderboard-table {
+    width: 100%;
+    border-collapse: separate;
+    border-spacing: 0;
+    background: rgba(30, 34, 54, 0.98);
+    /* border-radius: 16px;  테이블 자체에는 radius 제거 */
+    box-shadow: 0 4px 24px 0 rgba(16, 152, 247, 0.10), 0 1.5px 6px 0 rgba(227, 84, 84, 0.08);
+    margin-bottom: 24px;
+}
+.pretty-leaderboard-table thead {
+    border-radius: 16px 16px 0 0;
+    overflow: hidden;
+    background: #23244a;
+}
+
+/* Sticky first and second columns */
+/* Sticky first and second columns - header(th) */
+.pretty-leaderboard-table th:nth-child(1) {
+    position: sticky;
+    left: 0;
+    top: 0;
+    z-index: 5;
+    background: #23244a;
+    min-width: 60px;
+    max-width: 60px;
+    width: 60px;
+}
+.pretty-leaderboard-table th:nth-child(2) {
+    position: sticky;
+    left: 60px;
+    top: 0;
+    z-index: 5;
+    background: #23244a;
+    min-width: 220px;
+    max-width: 400px;
+    width: 220px;
+}
+/* Sticky first and second columns - body(td) with CSS variable for background */
+.pretty-leaderboard-table td:nth-child(1) {
+    position: sticky;
+    left: 0;
+    z-index: 4;
+    background: var(--row-bg) !important;
+    min-width: 60px;
+    max-width: 60px;
+    width: 60px;
+}
+.pretty-leaderboard-table td:nth-child(2) {
+    position: sticky;
+    left: 60px;
+    z-index: 4;
+    background: var(--row-bg) !important;
+    min-width: 220px;
+    max-width: 400px;
+    width: 220px;
+}
+
+/* Set --row-bg variable for each row type */
+.pretty-leaderboard-table tr {
+    --row-bg: #1e2236;
+}
+.pretty-leaderboard-table tr:nth-child(even) {
+    --row-bg: #23253a;
+}
+.pretty-leaderboard-table tr:hover {
+    --row-bg: #2066a0;
+}
+.pretty-leaderboard-table th {
+    z-index: 4;
+}
+.pretty-leaderboard-table th, .pretty-leaderboard-table td {
+    padding: 12px 16px;
+    text-align: left;
+    border-bottom: 1px solid #23244a;
+    font-size: 16px;
+}
+.pretty-leaderboard-table th {
+    background: #23244a;
+    color: #fff;
+    font-weight: 800;
+    letter-spacing: 0.5px;
+    border-bottom: 2px solid #1098F7;
+    text-shadow: 0 1px 8px #0006;
+    transition: background 0.2s, color 0.2s;
+    position: sticky;
+    top: 0;
+    z-index: 2;
+    border-radius: 0 !important;
+}
+.pretty-leaderboard-table th:hover, .pretty-leaderboard-table th:focus {
+    background: #273a8a;
+    color: #fff;
+}
+.pretty-leaderboard-table td {
+    color: #F5F6F7;
+    vertical-align: middle;
+    background: var(--row-bg);
+}
+.pretty-leaderboard-table tr:last-child td {
+    border-bottom: none;
+}
+/* th/td의 border-radius는 모두 제거, 둥근 효과는 thead에만 */
+
+/* Enhanced score bar styles */
+.score-bar {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    width: 100%;
+}
+.score-bar-track {
+    flex-grow: 1;
+    height: 10px;
+    background: rgba(245, 246, 247, 0.12);
+    border-radius: 5px;
+    overflow: hidden;
+    max-width: 220px;
+    box-shadow: 0 1px 4px 0 rgba(16, 152, 247, 0.10);
+}
+.score-bar-fill {
+    height: 100%;
+    background: linear-gradient(90deg, #a259f7 0%, #6d28d9 100%);
+    border-radius: 5px;
+    transition: width 0.3s cubic-bezier(0.4,0,0.2,1);
+}
+.score-bar-value {
+    font-family: 'SF Mono', monospace;
+    font-weight: 600;
+    color: #F5F6F7;
+    min-width: 60px;
+    font-size: 14px;
+}
+
+body {
+    min-height: 100vh;
+}
+/* ���체 배경색은 브라우저 기본값을 따름. gradio-container도 마찬가지로 별도 배경 없음 */
+
+.markdown-text {
+    font-size: 16px !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-container {
+    margin-top: 15px;
+    /* Space-themed background */
+    background: linear-gradient(135deg, #e3e6f3 60%, #f5f6fa 100%);
+    position: relative;
+    background-image:
+      radial-gradient(rgba(255,255,255,0.15) 1.2px, transparent 1.2px),
+      radial-gradient(rgba(255,255,255,0.10) 1px, transparent 1px);
+    background-size: 40px 40px, 80px 80px;
+    background-position: 0 0, 20px 20px;
+}
+@media (prefers-color-scheme: dark) {
+    .leaderboard-table-container {
+        background: linear-gradient(135deg, #1a237e 0%, #311b92 100%) !important;
+        background-image:
+          radial-gradient(rgba(255,255,255,0.15) 1.2px, transparent 1.2px),
+          radial-gradient(rgba(255,255,255,0.10) 1px, transparent 1px);
+        background-size: 40px 40px, 80px 80px;
+        background-position: 0 0, 20px 20px;
+    }
+}
+@media (prefers-color-scheme: light) {
+    .leaderboard-table-container {
+        background: linear-gradient(135deg, #e3e6f3 60%, #f5f6fa 100%) !important;
+        background-image:
+          radial-gradient(rgba(255,255,255,0.15) 1.2px, transparent 1.2px),
+          radial-gradient(rgba(255,255,255,0.10) 1px, transparent 1px);
+        background-size: 40px 40px, 80px 80px;
+        background-position: 0 0, 20px 20px;
+    }
+}
+
+/* Limit the width of the first column so that names don't expand too much */
+.leaderboard-table-container td:nth-child(2),
+.leaderboard-table-container th:nth-child(2) {
+    max-width: 400px;
+    overflow: auto;
+    white-space: nowrap;
+}
+
+.tab-buttons button {
+    font-size: 20px;
+}
+
+
+/* Model type and think badge styles */
+.badge {
+    display: inline-block;
+    border-radius: 12px;
+    padding: 2px 10px;
+    font-size: 0.85em;
+    font-weight: 700;
+    margin-left: 6px;
+    box-shadow: 0 1px 4px rgba(0,0,0,0.10);
+    vertical-align: middle;
+}
+.badge-think-on {
+    background: #A7C7E7;
+    color: #234567;
+    border: 1.5px solid #A7C7E7;
+}
+.badge-think-off {
+    background: #E0E0E0;
+    color: #555;
+    border: 1.5px solid #E0E0E0;
+}
+
+/* Model Type badge styles */
+.badge-modeltype-instruct {
+    background: #B2F2E9;
+    color: #22796A;
+    border: 1.5px solid #B2F2E9;
+}
+.badge-modeltype-think {
+    background: #D6C8F7;
+    color: #5B4B8A;
+    border: 1.5px solid #D6C8F7;
+}
+.badge-modeltype-hybrid {
+    background: #FFE0B2;
+    color: #A67C52;
+    border: 1.5px solid #FFE0B2;
+}
+
+/* Type badge Open/Proprietary styles */
+.badge-type-open {
+    background: #A8E6A3;
+    color: #225522;
+    border: 1.5px solid #A8E6A3;
+}
+.badge-type-proprietary {
+    background: #F7B2B7;
+    color: #7A2F34;
+    border: 1.5px solid #F7B2B7;
+}
+
+
+/* Sort button styles */
+.sort-btn {
+    background: #23244a;
+    color: #F5F6F7;
+    border: 1px solid #1098F7;
+    border-radius: 6px;
+    font-size: 13px;
+    font-weight: 700;
+    margin-left: 4px;
+    margin-right: 2px;
+    padding: 2px 7px;
+    cursor: pointer;
+    transition: background 0.2s, color 0.2s;
+}
+.sort-btn:hover {
+    background: #1098F7;
+    color: #fff;
+}
+
+/* Custom CheckboxGroup and Dropdown styles for table theme */
+.gr-checkbox-group, .gr-checkbox, .gr-checkbox-group label, .gr-checkbox input[type="checkbox"] {
+    background: #23244a !important;
+    color: #F5F6F7 !important;
+    border: 1.5px solid #1098F7 !important;
+    border-radius: 6px !important;
+}
+.gr-checkbox input[type="checkbox"]:checked {
+    background: #1a237e !important;
+    border-color: #ffd700 !important;
+}
+.gr-dropdown, .gr-input, select {
+    background: #23244a !important;
+    color: #F5F6F7 !important;
+    border: 1.5px solid #1098F7 !important;
+    border-radius: 6px !important;
+}
+
+/* Custom style for radar chart model selector's selected tags (only the tag area, not the dropdown list) */
+.custom-dropdown .multiselect__tag {
+  background: #1098F7 !important;
+  color: #fff !important;
+  border: 1.5px solid #1098F7 !important;
+  box-shadow: 0 4px 16px #1098f755, 0 2px 8px #e5e7eb88 !important;
+  border-radius: 18px !important;
+  font-weight: 600 !important;
+  padding: 8px 20px !important;
+  margin: 2px 4px !important;
+  font-size: 1.08rem !important;
+  display: inline-block !important;
+  transition: background 0.2s, color 0.2s, box-shadow 0.2s, border 0.2s !important;
+}
+
+.gr-dropdown:focus, .gr-input:focus, select:focus {
+    border-color: #ffd700 !important;
+    outline: none !important;
+}
+
+    @media (prefers-color-scheme: dark) {
+      .category-box,
+      .space-info-box,
+      .pretty-leaderboard-table,
+      .dark-container {
+        background: linear-gradient(135deg, #23244a 0%, #2a1859 100%) !important;
+        color: #f5f6f7 !important;
+      }
+      .space-info-box, .space-info-box * {
+        color: #f5f6f7 !important;
+      }
+      h3 a, h3 a:visited {
+        color: #f5f6f7 !important;
+      }
+    }
+"""
+
+# requirements_textbox and adaptor_class_textbox scroll/height control
+custom_css += """
+#requirements-textbox textarea {
+  overflow-y: auto !important;
+  resize: vertical;
+  height: 480px;
+  max-height: 480px;
+}
+#yml-textbox textarea {
+  overflow-y: auto !important;
+  resize: vertical;
+  height: 240px;
+  max-height: 240px;
+}
+
+/* No border textbox style for file upload status */
+.no-border-textbox textarea {
+    border: none !important;
+    box-shadow: none !important;
+    background: transparent !important;
+    padding: 0 !important;
+    margin: 0 !important;
+    outline: none !important;
+    resize: none !important;
+    overflow: hidden !important;
+}
+.no-border-textbox .wrap {
+    background: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+    margin: 0 !important;
+    outline: none !important;
+}
+.no-border-textbox .prose {
+    background: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+    margin: 0 !important;
+}
+.no-border-textbox label {
+    display: none !important;
+}
+.no-border-textbox .gr-textbox {
+    border: none !important;
+    box-shadow: none !important;
+    background: transparent !important;
+    padding: 0 !important;
+    margin: 0 !important;
+}
+.no-border-textbox .gr-textbox > div {
+    border: none !important;
+    box-shadow: none !important;
+    background: transparent !important;
+    padding: 0 !important;
+    margin: 0 !important;
+}
+.no-border-textbox .gr-textbox > div > div {
+    border: none !important;
+    box-shadow: none !important;
+    background: transparent !important;
+    padding: 0 !important;
+    margin: 0 !important;
+}
+
+/* Ensure model name tooltips are hoverable */
+.pretty-leaderboard-table td span[title] {
+    pointer-events: auto;
+}
+
+/* Tall file upload container to match lines=25 textbox height */
+.tall-file-upload .file-upload-container {
+    min-height: 283px !important;
+    height: 283px !important;
+}
+.tall-file-upload .gr-file {
+    min-height: 283px !important;
+    height: 283px !important;
+}
+"""
+
+def get_rank_badge(rank: int) -> str:
+    """
+    Returns emoji for 1st, 2nd, 3rd, otherwise just the number.
+    """
+    if rank == 1:
+        return '<span style="font-size:1.5em;" title="1st">🥇</span>'
+    elif rank == 2:
+        return '<span style="font-size:1.5em;" title="2nd">🥈</span>'
+    elif rank == 3:
+        return '<span style="font-size:1.5em;" title="3rd">🥉</span>'
+    else:
+        return f'<span style="font-size:1.2em;color:#a1a1aa;font-weight:500;">{rank}</span>'
+
+def get_score_gauge(score: float) -> str:
+    """
+    Returns HTML for an overall score gauge (progress bar style).
+    Robustly normalizes score to 0~100% regardless of input range (0~1 or 0~100).
+    """
+    # Handle None/NaN
+    try:
+        score = float(score)
+    except (TypeError, ValueError):
+        score = 0.0
+
+    # Normalize: if score is 0~1, treat as normalized and scale to 0~100
+    if score is None or score != score:  # NaN check
+        percent = 0.0
+        display_score = 0.0
+    elif score <= 1.0:
+        percent = score * 100
+        display_score = percent
+    else:
+        percent = score
+        display_score = score
+
+    # For scores above 95, adjust to 98~100% so the bar appears almost full
+    if percent >= 95:
+        percent = 98 + (min(percent, 100) - 95) * 0.4  # 95=98%, 100=100%
+    # Clip to 0~100
+    percent = min(max(percent, 0), 100)
+    display_score = min(max(display_score, 0), 100)
+
+    return f'''
+        <div class="score-bar" style="margin: 0.5em 0;">
+            <div class="score-bar-track">
+                <div class="score-bar-fill" style="width: {percent}%;"></div>
+            </div>
+            <span class="score-bar-value">{display_score:.3f}</span>
+        </div>
+    '''
+
+from src.display.formatting import get_score_stars
+
+def get_leaderboard_table_html(df, key="Category") -> str:
+    """
+    Returns HTML for a pretty leaderboard table using badge and gauge.
+    Displays all columns in df, applying format_leaderboard_cell to each cell as needed.
+    key: "Category" or "Language" (default: "Category")
+    """
+    import pandas as pd
+    from src.display.formatting import get_score_stars, get_type_badge, get_model_type_badge, get_output_badge, format_leaderboard_cell, get_display_model_name
+    # Build table header
+    html = ['<table class="pretty-leaderboard-table">']
+    html.append("<thead><tr>")
+    for col in df.columns:
+        html.append(f"<th>{col}</th>")
+    html.append("</tr></thead>")
+    html.append("<tbody>")
+    for idx, row in df.iterrows():
+        html.append("<tr>")
+        for col in df.columns:
+            cell = row[col]
+            # Special cell handling
+            if col == "Rank":
+                badge = get_rank_badge(cell)
+                html.append(f"<td>{badge}</td>")
+            elif col == "Model Name":
+                # Highlight top 1~3
+                rank = row.get("Rank", None)
+                highlight_style = ""
+                if rank == 1 or rank == "1":
+                    highlight_style = "color: #ffd700; font-weight: bold; text-shadow: 0 0 4px #fff2;"
+                elif rank == 2 or rank == "2":
+                    highlight_style = "color: #b0b0b0; font-weight: bold;"
+                elif rank == 3 or rank == "3":
+                    highlight_style = "color: #cd7f32; font-weight: bold;"
+                else:
+                    highlight_style = "color: #fff; font-weight: 600;"
+                display_name = get_display_model_name(str(cell))
+                link_value = row["Link"] if "Link" in row and pd.notna(row["Link"]) and str(row["Link"]).strip() != "" else None
+                if link_value:
+                    clickable_name = f'<a href="{link_value}" target="_blank" style="color:inherit;">{display_name}</a>'
+                else:
+                    clickable_name = display_name
+                html.append(f'<td><span style="{highlight_style}">{clickable_name}</span></td>')
+            elif col == "Model Type":
+                html.append(f"<td>{get_model_type_badge(row.get('Model Type', ''))}</td>")
+            elif col == "Type":
+                html.append(f"<td>{get_type_badge(row.get('Type', ''))}</td>")
+            elif col == "Think":
+                html.append(f"<td>{get_output_badge(row.get('Think', ''))}</td>")
+            elif col == "Overall":
+                # 별점
+                try:
+                    unique_id = row.get("Model Name", None)
+                    unique_id = unique_id.replace(" ", "_").replace("-", "_").replace("(", "_").replace(")", "_")
+                    cell_html = get_score_stars(float(cell), unique_id=unique_id)
+                except Exception:
+                    cell_html = str(cell)
+                html.append(f"<td>{cell_html}</td>")
+            else:
+                html.append(f"<td>{format_leaderboard_cell(cell, col, key)}</td>")
+        html.append("</tr>")
+    html.append("</tbody></table>")
+    table_html = "\n".join(html)
+    # Wrap in scrollable div for sticky header
+    return f'<div class="leaderboard-table-container" style="max-height:900px;overflow-y:auto;">{table_html}</div>'

src/display/formatting.py

@@ -0,0 +1,305 @@
+import pandas as pd
+from constants import (
+    NUMERIC_COLS_CATEGORY, NUMERIC_INT_COLS_CATEGORY,
+    NUMERIC_COLS_LANGUAGE, NUMERIC_INT_COLS_LANGUAGE
+)
+
+def format_leaderboard_cell(cell, col, key="Category"):
+    """
+    Apply integer/two-decimal formatting to numeric columns.
+    key: "Category" or "Language"
+    """
+    if key == "Language":
+        numeric_cols = NUMERIC_COLS_LANGUAGE
+        int_cols = NUMERIC_INT_COLS_LANGUAGE
+    else:
+        numeric_cols = NUMERIC_COLS_CATEGORY
+        int_cols = NUMERIC_INT_COLS_CATEGORY
+    if pd.isna(cell) or (isinstance(cell, str) and cell.strip() == ""):
+        return ""
+    try:
+        if col in int_cols:
+            return str(int(round(float(cell))))
+        elif col in numeric_cols:
+            return "{:.2f}".format(float(cell))
+        else:
+            return str(cell)
+    except Exception:
+        return ""
+
+
+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)
+
+def get_display_model_name(full_model_name: str) -> str:
+    """
+    Removes text within parentheses from the model name for display purposes.
+    Example: "Model (v1)" -> "Model"
+    """
+    import re
+    return re.sub(r'\s*\(.*?\)', '', full_model_name)
+
+def get_score_stars(score, unique_id=None):
+    """
+    Generate HTML for a 5-star rating visualization.
+
+    Args:
+        score (float or int): Overall score, can be in 0~1 or 0~100 range. 
+            - If 0~1, it will be automatically scaled to 0~100.
+            - If None, NaN, or negative, treated as 0.
+        unique_id (optional): Unique identifier for SVG gradient.
+
+    Returns:
+        str: HTML string with 5-star visualization, filled in proportion to score.
+    """
+    # Robust normalization: 0~1 -> 0~100, None/NaN/negative -> 0
+    max_stars = 5
+    full_stars = int(score // 20)
+    partial = (score % 20) / 20  # 0.0 ~ 0.999
+    stars_html = ""
+    star_size = 18  # px
+
+    # If unique_id is not provided, use "default"
+    uid = str(unique_id) if unique_id is not None else "default"
+
+    def star_svg(fill_ratio, idx):
+        # fill_ratio: 0.0 (empty) ~ 1.0 (full)
+        # White fill, gray background
+        grad_id = f"star-grad-{uid}-{idx}"
+        return f'''
+        <svg width="{star_size}" height="{star_size}" viewBox="0 0 24 24" style="margin-right:0.5px;vertical-align:middle;">
+            <defs>
+                <linearGradient id="{grad_id}" x1="0" x2="1" y1="0" y2="0">
+                    <stop offset="0%" stop-color="#fff"/>
+                    <stop offset="{fill_ratio*100:.1f}%" stop-color="#fff"/>
+                    <stop offset="{fill_ratio*100:.1f}%" stop-color="#666666"/>
+                    <stop offset="100%" stop-color="#666666"/>
+                </linearGradient>
+            </defs>
+            <polygon points="12,2 15,9 22,9.5 17,14.2 18.5,21 12,17.5 5.5,21 7,14.2 2,9.5 9,9"
+                fill="url(#{grad_id})" stroke="#888" stroke-width="1"/>
+        </svg>
+        '''
+
+    # Full stars
+    for i in range(full_stars):
+        stars_html += star_svg(1.0, i)
+    # Partial star (if needed)
+    if full_stars < max_stars:
+        if partial > 0:
+            stars_html += star_svg(partial, full_stars)
+            empty_stars = max_stars - full_stars - 1
+            start_empty = full_stars + 1
+        else:
+            empty_stars = max_stars - full_stars
+            start_empty = full_stars
+    else:
+        empty_stars = 0
+        start_empty = max_stars
+    # Empty stars
+    for i in range(start_empty, start_empty + empty_stars):
+        stars_html += star_svg(0.0, i)
+
+    # Score text
+    score_text = f'<span style="color:#fff;font-size:16px;margin-left:8px;">{score:.2f}</span>'
+
+    return f'''
+    <div style="display:flex;align-items:center;gap:4px;">
+        {stars_html}
+        {score_text}
+    </div>
+    '''
+
+def get_type_badge(type_value):
+    """
+    type_value: e.g. 'Open', 'Proprietary'
+    Returns a badge with class depending on type (Open/Proprietary).
+    """
+    label = str(type_value).capitalize()
+    badge_class = ""
+    if str(type_value).lower() == "open":
+        badge_class = "badge-type-open"
+    elif str(type_value).lower() == "proprietary":
+        badge_class = "badge-type-proprietary"
+    else:
+        badge_class = "badge-type-proprietary"
+   
+    return f'<span class="badge {badge_class}">{label}</span>'
+
+def get_model_type_badge(model_type):
+    """
+    Model Type badge: Style varies depending on Think/Normal
+    """
+    label = str(model_type).capitalize()
+    model_type_str = str(model_type).strip().lower()
+    if model_type_str == "think":
+        badge_class = "badge-modeltype-think"
+    elif model_type_str == "instruct":
+        badge_class = "badge-modeltype-instruct"
+    elif model_type_str == "hybrid":
+        badge_class = "badge-modeltype-hybrid"
+    else:
+        badge_class = "badge-modeltype-instruct"
+    return f'<span class="badge {badge_class}">{label}</span>'
+
+def get_think_badge(think_type):
+    label = str(think_type).capitalize()
+    if str(think_type).lower() == "on":
+        return f'<span class="badge badge-think-on">{label}</span>'
+    elif str(think_type).lower() == "off":
+        return f'<span class="badge badge-think-off">{label}</span>'
+    else:
+        return f'<span class="badge badge-think-off">{label}</span>'
+
+import pandas as pd
+
+def render_leaderboard_html(df, overall_col="Overall", key="Category"):
+    """
+    Render a DataFrame as an HTML table, replacing the overall_col with a star rating visualization.
+    key: "Category" or "Language"
+    """
+
+    # Force column order
+    desired_order = ["Rank", "Model Name", "Link", "Type", "Model Type", "Think", "Overall"]
+    cols = list(df.columns)
+    # Remaining columns
+    rest = [c for c in cols if c not in desired_order]
+    new_cols = []
+    for c in desired_order:
+        if c in cols:
+            new_cols.append(c)
+    new_cols += rest
+    df = df[new_cols]
+
+    # Columns to hide
+    hidden_cols = ["Comment", "Link"]
+
+    # Build table header
+    def get_sort_arrow():
+        # Arrow buttons removed as requested
+        return ""
+
+    # Extract sort state (from State or use default)
+    sort_col = getattr(df, "_sort_col", None) or (df.columns[0] if len(df.columns) > 0 else None)
+    sort_asc = getattr(df, "_sort_asc", None)
+    if sort_asc is None:
+        sort_asc = True
+
+    html = '<table class="pretty-leaderboard-table">\n<thead><tr>'
+    for col in df.columns:
+        if col in hidden_cols:
+            continue
+        # Info icon for Model Name, Med. Len. and Med. Resp. Len.
+        if col == "Model Name":
+            html += (
+                f'<th>{col}'
+                '<span class="info-icon" title="Hovering the mouse displays additional details, and clicking the model name navigates to the corresponding page.">ⓘ</span>'
+                f'{get_sort_arrow()}</th>'
+            )
+        elif col == "Med. Len.":
+            html += (
+                f'<th>{col}'
+                '<span class="info-icon" title="Median token length of think and response for the model.">ⓘ</span>'
+                f'{get_sort_arrow()}</th>'
+            )
+        elif col == "Med. Resp. Len.":
+            html += (
+                f'<th>{col}'
+                '<span class="info-icon" title="Median token length of the model\'s responses (excluding think).">ⓘ</span>'
+                f'{get_sort_arrow()}</th>'
+            )
+        elif col == overall_col:
+            html += f'<th style="min-width: 120px; max-width: 300px; width: 150px;">{col}{get_sort_arrow()}</th>'
+        else:
+            html += f'<th>{col}{get_sort_arrow()}</th>'
+    html += '</tr></thead>\n<tbody>\n'
+
+    # Build table rows
+    for _, row in df.iterrows():
+        html += '<tr>'
+        for col in df.columns:
+            if col in hidden_cols:
+                continue
+            cell = row[col]
+            if col == overall_col:
+                try:
+                    # Use "Model Name" of the row as unique_id
+                    unique_id = row.get("Model Name", None)
+                    unique_id = unique_id.replace(" ", "_").replace("-", "_").replace("(", "_").replace(")", "_")
+                    cell_html = get_score_stars(float(cell), unique_id=unique_id)
+                except Exception:
+                    cell_html = str(cell)
+                html += f'<td style="min-width: 120px; max-width: 300px; width: 150px;">{cell_html}</td>'
+            elif col == "Rank":
+                # For 1st, 2nd, and 3rd place, emphasize with medal emoji and color
+                medal = ""
+                style = "color: #fff; font-weight: 600;"
+                if cell == 1 or cell == "1":
+                    medal = "🥇"
+                    style = "color: #ffd700; font-weight: bold; text-shadow: 0 0 4px #fff2;"
+                elif cell == 2 or cell == "2":
+                    medal = "🥈"
+                    style = "color: #b0b0b0; font-weight: bold;"
+                elif cell == 3 or cell == "3":
+                    medal = "🥉"
+                    style = "color: #cd7f32; font-weight: bold;"
+                html += f'<td><span style="{style}">{medal if medal else cell}</span></td>'
+            elif col in ["Model Name"]:
+                # Only highlight top 1~3, do not apply badge
+                rank = row.get("Rank", None)
+                highlight_style = ""
+                if rank == 1 or rank == "1":
+                    highlight_style = "color: #ffd700; font-weight: bold; text-shadow: 0 0 4px #fff2;"
+                elif rank == 2 or rank == "2":
+                    highlight_style = "color: #b0b0b0; font-weight: bold;"
+                elif rank == 3 or rank == "3":
+                    highlight_style = "color: #cd7f32; font-weight: bold;"
+                else:
+                    highlight_style = "color: #fff; font-weight: 600;"
+                display_name = get_display_model_name(str(cell))
+                
+                # --- Start of new logic for tooltip ---
+                comment_value = ""
+                # Check if 'Comment' column exists and the value is not NaN/empty
+                if "Comment" in row and pd.notna(row["Comment"]) and str(row["Comment"]).strip() != "":
+                    comment_value = str(row["Comment"]).strip()
+                
+                title_attribute = f' title="{comment_value}"' if comment_value else ""
+                # --- End of new logic for tooltip ---
+
+                # Link logic
+                link_value = row["Link"] if "Link" in row and pd.notna(row["Link"]) and str(row["Link"]).strip() != "" else None
+                if link_value:
+                    clickable_name = f'<a href="{link_value}" target="_blank" style="color:inherit;">{display_name}</a>'
+                else:
+                    clickable_name = display_name
+                
+                html += f'<td><span style="{highlight_style}"{title_attribute}>{clickable_name}</span></td>'
+            elif col == "Type":
+                html += f'<td>{get_type_badge(row.get("Type", ""))}</td>'
+            elif col == "Model Type":
+                html += f'<td>{get_model_type_badge(row.get("Model Type", ""))}</td>'
+            elif col == "Think":
+                html += f'<td>{get_think_badge(row.get("Think", ""))}</td>'
+            else:
+                html += f'<td>{format_leaderboard_cell(cell, col, key)}</td>'
+        html += '</tr>\n'
+    html += '</tbody></table>'
+    # Wrap in scrollable div for sticky header
+    return f'<div class="leaderboard-table-container" style="max-height:900px;overflow-y:auto;">{html}</div>'

src/display/utils.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from enum import Enum
+
+def fields(raw_class):
+    return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
+
+## All the model information that we might need
+@dataclass
+class ModelDetails:
+    name: str
+    display_name: str = ""
+    symbol: str = "" # emoji
+
+    
+class Precision(Enum):
+    float16 = ModelDetails("float16")
+    bfloat16 = ModelDetails("bfloat16")
+    fp8 = ModelDetails("fp8")
+    int4 = ModelDetails("int4")
+    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 == "fp8":
+            return Precision.fp8
+        if precision == "int4":
+            return Precision.int4
+        return Precision.Unknown

src/envs.py

@@ -0,0 +1,28 @@
+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 = "SamsungResearch"
+# ----------------------------------
+
+REPO_ID = f"{OWNER}/TRUEBench"
+QUEUE_REPO = f"{OWNER}/SR_Leaderboard_Requests"
+FAILED_QUEUE_REPO = f"{OWNER}/SR_Leaderboard_Failed_Requests"
+RESULTS_REPO = f"{OWNER}/SR_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")
+FAILED_EVAL_REQUESTS_PATH = os.path.join(CACHE_PATH, "failed-eval-queue")
+EVAL_REQUESTS_PATH_BACKEND = os.path.join(CACHE_PATH, "eval-queue-bk")
+EVAL_RESULTS_PATH_BACKEND = os.path.join(CACHE_PATH, "eval-results-bk")
+FAILED_EVAL_REQUESTS_PATH_BACKEND = os.path.join(CACHE_PATH, "failed-eval-queue-bk")
+
+API = HfApi(token=TOKEN)

src/submission/check_validity.py

@@ -0,0 +1,72 @@
+import json
+import os
+import re
+from collections import defaultdict
+from datetime import datetime, timedelta, timezone
+
+import huggingface_hub
+from huggingface_hub import ModelCard
+from huggingface_hub.hf_api import ModelInfo
+from transformers import AutoConfig
+from transformers.models.auto.tokenization_auto import AutoTokenizer
+
+def check_model_card(repo_id: str) -> tuple[bool, str]:
+    """Checks if the model card and license exist and have been filled"""
+    try:
+        card = ModelCard.load(repo_id)
+    except huggingface_hub.utils.EntryNotFoundError:
+        return False, "Please add a model card to your model to explain how you trained/fine-tuned it."
+
+    # Enforce license metadata
+    if card.data.license is None:
+        if not ("license_name" in card.data and "license_link" in card.data):
+            return False, (
+                "License not found. Please add a license to your model card using the `license` metadata or a"
+                " `license_name`/`license_link` pair."
+            )
+
+    # Enforce card content
+    if len(card.text) < 200:
+        return False, "Please add a description to your model card, it is too short."
+
+    return True, ""
+
+def get_model_size(model_info: ModelInfo, precision: str):
+    """Gets the model size from the configuration, or the model name if the configuration does not contain the information."""
+    try:
+        model_size = round(model_info.safetensors["total"] / 1e9, 3)
+    except (AttributeError, TypeError):
+        return 0  # Unknown model sizes are indicated as 0, see NUMERIC_INTERVALS in app.py
+
+    size_factor = 8 if (precision == "GPTQ" or "gptq" in model_info.modelId.lower()) else 1
+    model_size = size_factor * model_size
+    return model_size
+
+def get_model_arch(model_info: ModelInfo):
+    """Gets the model architecture from the configuration"""
+    return model_info.config.get("architectures", "Unknown")
+
+def already_submitted_models(requested_models_dir: str) -> set[str]:
+    """Gather a list of already submitted models to avoid duplicates"""
+    depth = 2
+    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['benchmark']}_{info['model']}")
+
+                    # Select organisation
+                    if info["model"].count("/") == 0 or "submitted_time" not in info:
+                        continue
+                    organisation, _ = info["model"].split("/")
+                    users_to_submission_dates[organisation].extend([{"benchmark": info['benchmark'], "model": info["model"], "submitted_time": info["submitted_time"]}])
+
+    return set(file_names), users_to_submission_dates

src/submission/submit.py

@@ -0,0 +1,279 @@
+import json
+import yaml
+import os
+import re
+from datetime import datetime, timezone, timedelta
+from typing import Optional
+from src.display.formatting import styled_error, styled_message, styled_warning
+from src.envs import API, EVAL_REQUESTS_PATH, FAILED_EVAL_REQUESTS_PATH, TOKEN, FAILED_QUEUE_REPO, QUEUE_REPO, REPO_ID
+from src.submission.check_validity import (
+    already_submitted_models,
+    check_model_card,
+    get_model_size
+)
+import gradio as gr
+from utils import download_with_restart
+from huggingface_hub import snapshot_download
+
+REQUESTED_MODELS = None
+USERS_TO_SUBMISSION_DATES = None
+
+def restart_space():
+    API.restart_space(repo_id=REPO_ID)
+
+def add_new_eval_option(
+    contact_email: str,
+    model: str,
+    model_type: str,
+    think_type: str,
+    precision: str,
+    response_prefix: str,
+    requirements: str,
+    user_state: str,
+    organization_list: list,
+    yml_textbox: str,
+    upbox,
+):
+    
+    ERROR_MESSAGE = None
+
+    # Validate email format
+    email_regex = r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$"
+    if not re.match(email_regex, contact_email):
+        if ERROR_MESSAGE is None:
+            ERROR_MESSAGE = "Please provide a valid email address."
+
+    # Synchronize: Just before submission, copy the latest QUEUE_REPO to EVAL_REQUESTS_PATH
+    download_with_restart(
+        snapshot_download,
+        repo_id=QUEUE_REPO,
+        local_dir=EVAL_REQUESTS_PATH,
+        repo_type="dataset",
+        token=TOKEN,
+        restart_func=restart_space
+    )
+
+    # Synchronize: Just before submission, copy the latest FAILED_QUEUE_REPO to FAILED_EVAL_REQUESTS_PATH
+    download_with_restart(
+        snapshot_download,
+        repo_id=FAILED_QUEUE_REPO,
+        local_dir=FAILED_EVAL_REQUESTS_PATH,
+        repo_type="dataset",
+        token=TOKEN,
+        restart_func=restart_space
+    )
+
+    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]
+    KST = timezone(timedelta(hours=9))
+    current_time = datetime.now(KST).strftime("%Y-%m-%dT%H:%M:%S %z")
+
+    # Remove space in benchmark name
+    benchmark = "TRUEBench"
+
+    # Check submitter qualification
+
+    if user_name != user_state and user_name not in organization_list:
+        if ERROR_MESSAGE is None:
+            ERROR_MESSAGE = "The submitter does not have submission rights for this model."
+        
+    # Does the organization submit more than three times in a day?
+    submission_times = [item['submitted_time'] for item in USERS_TO_SUBMISSION_DATES[user_name] if item['benchmark'] == benchmark]
+    submission_cnt = 0
+    for i in range(len(submission_times)):
+        hours_diff = (datetime.strptime(current_time, "%Y-%m-%dT%H:%M:%S %z") - datetime.strptime(submission_times[i], "%Y-%m-%dT%H:%M:%S %z")).total_seconds() / 3600
+        if hours_diff <= 24:
+            submission_cnt += 1
+    if submission_cnt >= 3:
+        if ERROR_MESSAGE is None:
+            ERROR_MESSAGE = "The organization already submitted three times for this benchmark today."
+
+    # Does the model actually exist?
+    revision = "main"
+
+    # Is the model info correctly filled?
+    model_info = None
+    model_size = "Unknown"
+    try:
+        model_info = API.model_info(repo_id=model, revision=revision)
+        model_size = get_model_size(model_info=model_info, precision=precision)
+    except Exception:
+        if ERROR_MESSAGE is None:
+            ERROR_MESSAGE = "Could not get your model information. Please fill it up properly."
+
+    # Were the model card and license filled?
+    license = "Unknown"
+    if model_info is not None:
+        try:
+            license = model_info.cardData["license"]
+        except Exception:
+            if ERROR_MESSAGE is None:
+                ERROR_MESSAGE = "Please select a license for your model."
+
+        modelcard_OK, error_msg = check_model_card(model)
+        if not modelcard_OK:
+            if ERROR_MESSAGE is None:
+                ERROR_MESSAGE = error_msg
+    
+    # Response prefix check
+    if think_type == "On":
+        if response_prefix == "":
+            if ERROR_MESSAGE is None:
+                ERROR_MESSAGE = "It is required to fill in the response prefix when 'Think' is 'On'."
+    else:
+        response_prefix = ""
+        
+    # Handle YAML config input (file or textbox)
+    config_dict = None
+
+    # Case 1: File uploaded
+    if upbox is not None and getattr(upbox, "name", ""):
+        file_name = upbox.name
+        if not file_name.lower().endswith(".yaml") and not file_name.lower().endswith(".yml"):
+            if ERROR_MESSAGE is None:
+                ERROR_MESSAGE = "Please submit a .yaml or .yml file."
+        try:
+            with open(file_name, 'r', encoding='utf-8') as f:
+                config_dict = yaml.safe_load(f)
+        except yaml.YAMLError:
+            if ERROR_MESSAGE is None:
+                ERROR_MESSAGE = "The file is not a valid YAML format."
+        except Exception as e:
+            if ERROR_MESSAGE is None:
+                ERROR_MESSAGE = f"An error occurred while reading the file. {e}"
+        if config_dict is None:
+            if ERROR_MESSAGE is None:
+                ERROR_MESSAGE = "The YAML file is empty or invalid."
+    else:
+        # Case 2: No file uploaded
+        if not yml_textbox or not yml_textbox.strip():
+            if ERROR_MESSAGE is None:
+                ERROR_MESSAGE = "Please fill in the configuration box or submit a YAML file."
+        try:
+            config_dict = yaml.safe_load(yml_textbox)
+        except yaml.YAMLError:
+            if ERROR_MESSAGE is None:
+                ERROR_MESSAGE = "Please provide a valid configuration."
+        if config_dict is None:
+            if ERROR_MESSAGE is None:
+                ERROR_MESSAGE = "Please provide a valid configuration."
+
+    # Restrict config keys
+    allowed_keys = {"llm_serve_args", "sampling_params", "extra_body"}
+    if not isinstance(config_dict, dict):
+        if ERROR_MESSAGE is None:
+            ERROR_MESSAGE = "The configuration must be a YAML dictionary at the top level."
+    extra_keys = set(config_dict.keys()) - allowed_keys
+    if extra_keys:
+        if ERROR_MESSAGE is None:
+            ERROR_MESSAGE = f"Only the following keys are allowed in the configuration: llm_serve_args, sampling_params, extra_body. Found invalid keys: {', '.join(sorted(extra_keys))}."
+
+    configs = json.dumps(config_dict, indent=4, ensure_ascii=False)
+
+    # Check for duplicate submission
+    submission_times = [item['submitted_time'] for item in USERS_TO_SUBMISSION_DATES[user_name] if item['benchmark'] == benchmark and item['model'] == model]
+    submission_cnt = 0
+    submission_total_cnt = 0
+    for i in range(len(submission_times)):
+        submission_total_cnt += 1
+        hours_diff = (datetime.strptime(current_time, "%Y-%m-%dT%H:%M:%S %z") - datetime.strptime(submission_times[i], "%Y-%m-%dT%H:%M:%S %z")).total_seconds() / 3600
+        if hours_diff <= 24:
+            submission_cnt += 1
+    if submission_cnt >= 1:
+        if ERROR_MESSAGE is None:
+            ERROR_MESSAGE = "This model has been already submitted within 24 hours."
+    if submission_total_cnt >= 3:
+        if ERROR_MESSAGE is None:
+            ERROR_MESSAGE = "This model has been already submitted three times for this benchmark."
+
+    print("Creating eval file")
+    if ERROR_MESSAGE is None:
+        OUT_DIR = f"{EVAL_REQUESTS_PATH}/{user_name}/{benchmark}_{model_path}"
+    else:
+        OUT_DIR = f"{FAILED_EVAL_REQUESTS_PATH}/{user_name}/{benchmark}_{model_path}"
+    os.makedirs(OUT_DIR, exist_ok=True)
+    current_time_replaced = current_time.replace("-", "").replace(":", "").replace("T", "_").split()[0]
+    out_path = f"{OUT_DIR}/{current_time_replaced}.json"
+
+    # Seems good, creating the eval
+    print("Adding new eval")
+
+    if ERROR_MESSAGE is None:
+        eval_entry = {
+            "benchmark": benchmark,
+            "contact_email": contact_email,
+            "model": model,
+            "type": "open",
+            "model_type": model_type,
+            "think_type": think_type,
+            "precision": precision,
+            "response_prefix": response_prefix,
+            "requirements": requirements,
+            "status": "PENDING",
+            "submitted_time": current_time,
+            "likes": getattr(model_info, "likes", -1),
+            "params": model_size,
+            "license": license,
+            "private": False,
+            "configs": configs
+        }
+    else:
+        eval_entry = {
+            "benchmark": benchmark,
+            "contact_email": contact_email,
+            "model": model,
+            "type": "open",
+            "model_type": model_type,
+            "think_type": think_type,
+            "precision": precision,
+            "response_prefix": response_prefix,
+            "requirements": requirements,
+            "status": "Failed",
+            "submitted_time": current_time,
+            "likes": getattr(model_info, "likes", -1),
+            "params": model_size,
+            "license": license,
+            "private": False,
+            "configs": configs,
+            "error_message": ERROR_MESSAGE
+        }
+
+    with open(out_path, "w") as f:
+        f.write(json.dumps(eval_entry))
+
+    print("Uploading eval file")
+    if ERROR_MESSAGE is None:
+        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",
+        )
+    else:
+        API.upload_file(
+            path_or_fileobj=out_path,
+            path_in_repo=out_path.split("failed-eval-queue/")[1],
+            repo_id=FAILED_QUEUE_REPO,
+            repo_type="dataset",
+            commit_message=f"Add {model} to failed eval queue",
+        )
+
+    # Remove the local file
+    os.remove(out_path)
+
+    if ERROR_MESSAGE is None:
+        return styled_message(
+            "Your request has been submitted to the evaluation queue!"
+        )
+    else:
+        return styled_error(
+            ERROR_MESSAGE
+        )

ui.py

@@ -0,0 +1,462 @@
+import gradio as gr
+from src.display.formatting import render_leaderboard_html, get_display_model_name
+from src.data_utils import get_length_category_list, get_length_category_df
+import pandas as pd
+import numpy as np
+
+def render_length_category_html(df, med_len_map=None):
+    """
+    Render the length category table with Model Name colored by Rank (gold/silver/bronze), no Rank column.
+    Model Name cell includes Think, Model Type badges. Overall column is always right after Model Name.
+    Optionally, inserts Med. Len. column after Overall if med_len_map is provided.
+    """
+    if df is None or df.empty:
+        return "<div>No data available.</div>"
+
+    # Compute Rank based on Overall (descending)
+    df = df.copy()
+    # 1. Sort so that empty strings come to the top first
+    df = df.sort_values("Overall", key=lambda x: (x == "").astype(int))
+    # 2. Then sort the actual values in descending order (empty strings are already at the top, so no effect)
+    df = df.sort_values("Overall", ascending=False, kind="mergesort").reset_index(drop=True)
+    df["Rank_Internal"] = df["Overall"].rank(method="min", ascending=False).astype(int)
+
+    # Ensure Think and Model Type columns exist for badge rendering
+    # Rename columns to ensure exact match
+    if "Type" not in df.columns:
+        df["Type"] = "unknown"
+    if "Model Type" not in df.columns:
+        df["Model Type"] = "unknown"
+    if "Think" not in df.columns:
+        df["Think"] = "unknown"
+
+    # Optionally add Med. Len. column
+    if med_len_map is not None:
+        df["Med. Len."] = df["Model Name"].map(med_len_map)
+
+    # Determine display columns: Model Name, Overall, Med. Len., {Category}, (rest, excluding Rank_Internal, Model Type, Think)
+    base_cols = [col for col in df.columns if col not in ["Rank_Internal", "Comment", "Group", "Link"]]
+
+    # Find the dynamic category column (e.g., "Short", "Long", etc.)
+    from src.data_utils import get_length_category_list
+    category_cols = [col for col in get_length_category_list() if col in base_cols]
+    category_col = category_cols[0] if category_cols else None
+
+    # Build display_cols: Model Name, Overall, Med. Len., {Category}, (rest)
+    display_cols = []
+    if "Model Name" in base_cols:
+        display_cols.append("Model Name")
+    if "Overall" in base_cols:
+        display_cols.append("Overall")
+    if "Med. Len." in base_cols:
+        display_cols.append("Med. Len.")
+    if "Med. Resp. Len." in base_cols:
+        display_cols.append("Med. Resp. Len.")
+    if category_col:
+        display_cols.append(category_col)
+    for col in base_cols:
+        if col not in display_cols:
+            display_cols.append(col)
+
+    # Build HTML table
+    html = '<table class="pretty-leaderboard-table">\n<thead><tr>'
+    for col in display_cols:
+        # Info icon for Model Name, Med. Len. and Med. Resp. Len.
+        if col == "Model Name":
+            html += (
+                f'<th>{col}'
+                '<span class="info-icon" title="Hovering the mouse displays additional details, and clicking the model name navigates to the corresponding page.">ⓘ</span>'
+                '</th>'
+            )
+        elif col == "Med. Len.":
+            html += (
+                f'<th>{col}'
+                '<span class="info-icon" title="Median token length of think and response for the model.">ⓘ</span>'
+                '</th>'
+            )
+        elif col == "Med. Resp. Len.":
+            html += (
+                f'<th>{col}'
+                '<span class="info-icon" title="Median token length of the model\'s responses (excluding think).">ⓘ</span>'
+                '</th>'
+            )
+        else:
+            html += f'<th>{col}</th>'
+    html += '</tr></thead>\n<tbody>\n'
+
+    # --- Define number formatting function ---
+    from constants import NUMERIC_COLS_CATEGORY, NUMERIC_INT_COLS_CATEGORY
+    def format_leaderboard_cell(cell, col):
+        # Handle NaN/empty strings
+        if pd.isna(cell) or (isinstance(cell, str) and cell.strip() == ""):
+            return cell
+        try:
+            if col in NUMERIC_INT_COLS_CATEGORY:
+                # Integer (rounded)
+                return str(int(round(float(cell))))
+            elif col in NUMERIC_COLS_CATEGORY:
+                # Two decimal places
+                return "{:.2f}".format(float(cell))
+            else:
+                return str(cell)
+        except Exception:
+            return str(cell)
+    
+    for idx, row in df.iterrows():
+        html += '<tr>'
+        for col in display_cols:
+            cell = row[col]
+            if col == "Model Name":
+                # Gold/Silver/Bronze for 1/2/3
+                rank = row["Rank_Internal"]
+                if rank == 1:
+                    style = "color: #ffd700; font-weight: bold; text-shadow: 0 0 4px #fff2;"
+                elif rank == 2:
+                    style = "color: #b0b0b0; font-weight: bold;"
+                elif rank == 3:
+                    style = "color: #cd7f32; font-weight: bold;"
+                else:
+                    style = "color: #fff; font-weight: 600;"
+
+                # Badge HTML
+                model_type = row["Model Type"] if "Model Type" in row else "unknown"
+                think_type = row["Think"] if "Think" in row else "unknown"
+                type_value = row["Type"] if "Type" in row else "unknown"
+                from src.display.formatting import get_type_badge, get_think_badge, get_model_type_badge
+                badge_html = (
+                    get_type_badge(type_value)
+                    + get_model_type_badge(model_type)
+                    + get_think_badge(think_type)
+                )
+
+                display_name = get_display_model_name(str(cell))
+
+                # --- Start of new logic for tooltip ---
+                comment_value = ""
+                # Check if 'Comment' column exists and the value is not NaN/empty
+                if "Comment" in row and pd.notna(row["Comment"]) and str(row["Comment"]).strip() != "":
+                    comment_value = str(row["Comment"]).strip()
+                title_attribute = f' title="{comment_value}"' if comment_value else ""
+                # --- End of new logic for tooltip ---
+
+                # Link logic
+                link_value = row["Link"] if "Link" in row and pd.notna(row["Link"]) and str(row["Link"]).strip() != "" else None
+                if link_value:
+                    clickable_name = f'<a href="{link_value}" target="_blank" style="color:inherit;">{display_name}</a>'
+                else:
+                    clickable_name = display_name
+
+                html += f'<td><span style="{style}"{title_attribute}>{clickable_name}</span>{badge_html}</td>'
+            elif col == "Overall":
+                # Show stars
+                from src.display.formatting import get_score_stars
+                try:
+                    unique_id = row.get("Model Name", None)
+                    unique_id = unique_id.replace(" ", "_").replace("-", "_").replace("(", "_").replace(")", "_")
+                    cell_html = get_score_stars(float(cell), unique_id=unique_id)
+                except Exception:
+                    cell_html = str(cell)
+                html += f'<td>{cell_html}</td>'
+            else:
+                html += f'<td>{format_leaderboard_cell(cell, col)}</td>'
+        html += '</tr>\n'
+    html += '</tbody></table>'
+    # Wrap in scrollable div for sticky header
+    return f'<div class="leaderboard-table-container" style="max-height:900px;overflow-y:auto;">{html}</div>'
+
+def render_length_category_table(leaderboard_df=None):
+    """
+    Renders a Category selector and a table showing length stats for the selected category.
+    Uses Overall from leaderboard_df for ranking, coloring, and stars.
+    """
+    import gradio as gr
+
+    categories = get_length_category_list()
+    default_category = categories[0] if categories else ""
+    # Merge Overall from leaderboard_df
+    def get_merged_df(selected_category):
+        df_cat = get_length_category_df(selected_category) if selected_category else None
+        if leaderboard_df is not None and df_cat is not None:
+            df_merged = df_cat.copy()
+            # Use Overall and {Category} from leaderboard_df
+            overall_map = dict(zip(leaderboard_df["Model Name"], leaderboard_df["Overall"]))
+            category_map = dict(zip(leaderboard_df["Model Name"], leaderboard_df[selected_category]))
+            df_merged["Overall"] = df_merged["Model Name"].map(overall_map)
+            df_merged[selected_category] = df_merged["Model Name"].map(category_map)
+            # Also map Model Type and Think
+            if "Type" in leaderboard_df.columns:
+                type_map = dict(zip(leaderboard_df["Model Name"], leaderboard_df["Type"]))
+                df_merged["Type"] = df_merged["Model Name"].map(type_map)
+            if "Model Type" in leaderboard_df.columns:
+                model_type_map = dict(zip(leaderboard_df["Model Name"], leaderboard_df["Model Type"]))
+                df_merged["Model Type"] = df_merged["Model Name"].map(model_type_map)
+            if "Think" in leaderboard_df.columns:
+                think_map = dict(zip(leaderboard_df["Model Name"], leaderboard_df["Think"]))
+                df_merged["Think"] = df_merged["Model Name"].map(think_map)
+            # Remove rows with missing Overall or {Category}
+            df_merged = df_merged[df_merged["Overall"].notna() & df_merged[selected_category].notna()]
+            return df_merged
+        return df_cat
+
+    df = get_merged_df(default_category)
+
+    # Prepare med_len_map if possible
+    med_len_map = None
+    if leaderboard_df is not None and "Med. Len." in leaderboard_df.columns:
+        med_len_map = dict(zip(leaderboard_df["Model Name"], leaderboard_df["Med. Len."]))
+
+    with gr.Column():
+        category_selector = gr.Dropdown(
+            choices=categories,
+            value=default_category,
+            label="Select Category for Length Table",
+            interactive=True,
+        )
+
+    table_html = gr.HTML(
+        value=render_length_category_html(df, med_len_map=med_len_map) if df is not None else "<div>No data available.</div>",
+        elem_id="length-category-table"
+    )
+
+    def update_table(selected_category):
+        df = get_merged_df(selected_category)
+        html = render_length_category_html(df, med_len_map=med_len_map)
+        return html
+
+    category_selector.change(
+        fn=update_table,
+        inputs=[category_selector],
+        outputs=[table_html]
+    )
+
+    return {
+        "category_selector": category_selector,
+        "table_html": table_html,
+    }
+
+def create_leaderboard_tab(df, key):
+    """
+    df: DataFrame to display
+    key: "Category" or "Language"
+    column_selector_value: default columns to select
+    """
+    # Ensure df has Model, Model Type, Think columns for filtering
+    # No need to create Model column, only use Model Name
+    # Always ensure "Overall" column exists
+    if "Overall" not in df.columns:
+        return  # Or handle error appropriately
+    # No additional mapping needed since DataFrame already has columns
+
+    df_state = gr.State(df)
+
+    # Create DataFrame including badge information (for upper table)
+    df_badge = df.copy()
+    # If Overall values are in the range 0~1, convert to 0~100
+    if "Overall" in df_badge.columns and df_badge["Overall"].max() <= 1.0:
+        df_badge["Overall"] = df_badge["Overall"] * 100
+    # Remove Group column (only in display)
+    for col_to_drop in ["Group"]:
+        if col_to_drop in df_badge.columns:
+            df_badge = df_badge.drop(columns=[col_to_drop])
+    # Handle error if "Overall" column does not exist
+    if "Overall" not in df_badge.columns:
+        return  # Or handle error appropriately
+    # Always sort by "Overall"
+    # 1. Sort so that empty strings come to the top first
+    df_badge = df_badge.sort_values("Overall", key=lambda x: (x == "").astype(int))
+    # 2. Then sort the actual values in descending order (empty strings are already at the top, so no effect)
+    df_badge = df_badge.sort_values("Overall", ascending=False, kind="mergesort").reset_index(drop=True)
+    df_badge["Rank"] = df_badge.index + 1
+    # Reorder "Rank" column to be right after "Model Name"
+    cols = df_badge.columns.tolist()
+    if "Model Name" in cols and "Rank" in cols:
+        model_name_idx = cols.index("Model Name")
+        cols.remove("Rank")
+        cols.insert(model_name_idx + 1, "Rank")
+        df_badge = df_badge[cols]
+        
+    with gr.Row():
+        # Type Selector (Open/Proprietary)
+        type_choices = ["Open", "Proprietary"]
+        type_selector = gr.CheckboxGroup(
+            choices=type_choices,
+            value=type_choices,
+            label="Select Type (Open/Proprietary)"
+        )
+
+        # Model Type Selector (Instruct/Think/Hybrid)
+        model_type_choices = ["Instruct", "Think", "Hybrid"]
+        model_type_selector = gr.CheckboxGroup(
+            choices=model_type_choices,
+            value=model_type_choices,
+            label="Select Model Type (Instruct/Think/Hybrid)"
+        )
+        # Think Selector (On/Off)
+        think_choices = ["On", "Off"]
+        think_selector = gr.CheckboxGroup(
+            choices=think_choices,
+            value=think_choices,
+            label="Select Think Mode (On/Off)"
+        )
+        # Add Gradio component for selecting sort criteria (always descending)
+        # For language leaderboard, dynamically extract language columns + Avg. Len., Parameter Size (B)
+        
+        if key == "Language":
+            import re
+            language_columns = [col for col in df_badge.columns if re.fullmatch(r"[A-Z]{2}", col) or col == "VI"]
+            available_sort_columns = ["Overall", "Med. Len.", "Med. Resp. Len.", "Parameter Size (B)"] + language_columns
+        else:
+            category_columns = [
+                "Overall", "Med. Len.", "Med. Resp. Len.", "Parameter Size (B)", "Content Generation", "Editing", "Data Analysis", "Reasoning",
+                "Hallucination", "Safety", "Repetition", "Summarization", "Translation", "Multi-Turn"
+            ]
+            available_sort_columns = [col for col in category_columns if col in df_badge.columns]
+       
+        sort_col_dropdown = gr.Dropdown(
+            choices=available_sort_columns,
+            value="Overall",
+            label="Sort by",
+            interactive=True,
+        )
+
+    # Sorting function
+    leaderboard_html = render_leaderboard_html(df_badge.round(3), overall_col="Overall", key=key)
+    leaderboard_html_comp = gr.HTML(value=leaderboard_html, elem_id="leaderboard-table")
+
+    # Filtering logic for new selectors
+    def unified_filter(types, model_types, thinks, df, sort_col):
+        # Apply search filter first
+        filtered = df.copy()
+        if "Type" in filtered.columns and (not types or len(types) == 0):
+            types = filtered["Type"].unique().tolist()
+        if "Model Type" in filtered.columns and (not model_types or len(model_types) == 0):
+            model_types = filtered["Model Type"].unique().tolist()
+        if "Think" in filtered.columns and (not thinks or len(thinks) == 0):
+            thinks = filtered["Think"].unique().tolist()
+        # Defensive: always ensure "Overall" exists
+        if "Type" in filtered.columns:
+            filtered["Type"] = filtered["Type"].fillna("").astype(str)
+            types_norm = [v.lower().strip() for v in types]
+            filtered = filtered[filtered["Type"].str.lower().str.strip().isin(types_norm)]
+        if "Model Type" in filtered.columns:
+            filtered["Model Type"] = filtered["Model Type"].fillna("").astype(str)
+            model_types_norm = [v.lower().strip() for v in model_types]
+            filtered = filtered[filtered["Model Type"].str.lower().str.strip().isin(model_types_norm)]
+        if "Think" in filtered.columns:
+            filtered["Think"] = filtered["Think"].fillna("").astype(str)
+            thinks_norm = [v.lower().strip() for v in thinks]
+            filtered = filtered[filtered["Think"].str.lower().str.strip().isin(thinks_norm)]
+        if "Overall" not in filtered.columns:
+            html = "<div style='color:red'>No 'Overall' column found in data. Please check your input data.</div>"
+            return html, sort_col
+        # Always sort in descending order
+        # To make empty strings come to the top, replace them with np.inf and sort descending
+        sort_col_for_sort = filtered[sort_col].replace('', np.inf).astype(float)
+        filtered = filtered.assign(sort_col_tmp=sort_col_for_sort)
+        filtered = filtered.sort_values('sort_col_tmp', ascending=False, kind="mergesort").reset_index(drop=True)
+        filtered = filtered.drop(columns=['sort_col_tmp'])
+        # Add "Rank" column and reorder it to be right after "Model Name"
+        filtered["Rank"] = filtered.index + 1
+        cols = filtered.columns.tolist()
+        if "Model Name" in cols and "Rank" in cols:
+            model_name_idx = cols.index("Model Name")
+            cols.remove("Rank")
+            cols.insert(model_name_idx + 1, "Rank")
+            filtered = filtered[cols]
+        # Always remove Group column
+        for col_to_drop in ["Group"]:
+            if col_to_drop in filtered.columns:
+                filtered = filtered.drop(columns=[col_to_drop])
+        filtered._sort_col = sort_col
+        # Extract top-5 models (currently sorted in descending order)
+        top5_models = []
+        if sort_col in filtered.columns and "Model Name" in filtered.columns:
+            # 1. Sort so that empty strings come to the top first
+            sort_col_for_sort = filtered[sort_col].replace('', np.inf).astype(float)
+            filtered_df_sorted = filtered.assign(sort_col_tmp=sort_col_for_sort)
+            filtered_df_sorted = filtered_df_sorted.sort_values('sort_col_tmp', ascending=False, kind="mergesort").reset_index(drop=True)
+            top5_models = filtered_df_sorted["Model Name"].tolist()[:5]
+        return render_leaderboard_html(filtered, overall_col="Overall", key=key), sort_col, top5_models
+
+    # Download CSV function
+    def dataframe_to_csv(data):
+        import pandas as pd
+        # Convert if data is not a DataFrame
+        if isinstance(data, pd.DataFrame):
+            df = data.copy() # Create a copy to avoid modifying the original DataFrame in memory
+        else:
+            df = pd.DataFrame(data)
+
+        # Apply get_display_model_name to the "Model Name" column if it exists
+        if "Model Name" in df.columns:
+            df["Model Name"] = df["Model Name"].apply(get_display_model_name)
+
+        csv_path = f"truebench_{key}.csv"
+        df.to_csv(csv_path, index=False)
+        return csv_path
+
+    # Add DownloadButton (using CSS class)
+    with gr.Row():
+        with gr.Column(scale=1):
+            pass  # Empty space
+        with gr.Column(scale=0):
+            download_btn = gr.DownloadButton(
+                label="📥 Download to CSV",
+                value=dataframe_to_csv,
+                inputs=[df_state],
+                visible=True,
+                elem_classes=["custom-download-btn"]
+            )
+    
+    # Add custom CSS
+    custom_css = """
+    <style>
+    .custom-download-btn >>> a {
+        background: #e3e6f3 !important;
+        color: #222 !important;
+        border: 1px solid rgba(0, 0, 0, 0.1) !important;
+        border-radius: 6px !important;
+        padding: 1px 1px !important;
+        font-size: 13px !important;
+        font-weight: bold !important;
+        text-shadow: 0 1px 1px rgba(0,0,0,0.1) !important;
+        margin: 0 3px 3px 0 !important;
+    }
+    .custom-download-btn:hover {
+        background: #f5f6fa !important;
+        box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1) !important;
+    }
+    </style>
+    """
+    gr.HTML(custom_css)
+
+    sort_col_dropdown.change(
+        fn=unified_filter,
+        inputs=[type_selector, model_type_selector, think_selector, df_state, sort_col_dropdown],
+        outputs=[leaderboard_html_comp, sort_col_dropdown, gr.State()]  # Add top5_models
+    )
+    type_selector.change(
+        fn=unified_filter,
+        inputs=[type_selector, model_type_selector, think_selector, df_state, sort_col_dropdown],
+        outputs=[leaderboard_html_comp, sort_col_dropdown, gr.State()]
+    )
+    model_type_selector.change(
+        fn=unified_filter,
+        inputs=[type_selector, model_type_selector, think_selector, df_state, sort_col_dropdown],
+        outputs=[leaderboard_html_comp, sort_col_dropdown, gr.State()]
+    )
+    think_selector.change(
+        fn=unified_filter,
+        inputs=[type_selector, model_type_selector, think_selector, df_state, sort_col_dropdown],
+        outputs=[leaderboard_html_comp, sort_col_dropdown, gr.State()]
+    )
+
+    return {
+        "type_selector": type_selector,
+        "model_type_selector": model_type_selector,
+        "think_selector": think_selector,
+        "leaderboard_html_comp": leaderboard_html_comp,
+        "sort_col_dropdown": sort_col_dropdown,
+        "df_state": df_state,
+        "unified_filter": unified_filter  # Exposed for direct external call
+    }

utils.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+import yaml
+import json
+import gradio as gr
+from huggingface_hub import whoami
+
+def get_profile(profile: gr.OAuthProfile | None) -> str:
+    if profile is None:
+        return "Anonymous"
+    return profile.username
+
+def get_organizations(oauth_token: gr.OAuthToken | None) -> str:
+    if oauth_token is None:
+        return "No Organization"
+    org_names = [org["name"] for org in whoami(oauth_token.token)["orgs"]]
+    return org_names
+
+def get_profile_and_organizations(profile: gr.OAuthProfile | None, oauth_token: gr.OAuthToken | None) -> tuple[str, str]:
+    if profile is None:
+        output_profile = "Anonymous"
+    else:
+        output_profile = profile.username
+    
+    if oauth_token is None:
+        output_org = "No Organization"
+    else:
+        output_org = [org["name"] for org in whoami(oauth_token.token)["orgs"]]
+    
+    return output_profile, output_org
+
+def download_with_restart(snapshot_download_func, repo_id, local_dir, repo_type, token, restart_func):
+    try:
+        snapshot_download_func(
+            repo_id=repo_id,
+            local_dir=local_dir,
+            repo_type=repo_type,
+            tqdm_class=None,
+            etag_timeout=30,
+            token=token
+        )
+    except Exception:
+        restart_func()

vis_utils.py

@@ -0,0 +1,723 @@
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from plotly.graph_objs._figure import Figure
+from typing import Optional, List, Dict, Any
+from src.display.formatting import get_display_model_name
+
+SORT_COLUMN_MAP = {
+    "Average Accuracy": "Avg AC",
+    "Tool Selection Quality": "Avg TSQ", 
+    "Session Cost": "Avg Total Cost"
+}
+
+def get_theme_colors(theme: str = "light") -> Dict[str, Any]:
+    """Return color settings for the given theme."""
+    if theme == "dark":
+        return {
+            "paper_bg": "#181c3a",  # darker blue-gray
+            "plot_bg": "#181c3a",
+            "legend_font_color": "#F5F6F7",
+            "legend_bg": 'rgba(35,36,74,0.92)',  # slightly lighter than bg, but still dark
+            "annotation_color": '#F5F6F7'
+        }
+    else:
+        return {
+            "paper_bg": "#23244a",  # deep blue-gray
+            "plot_bg": "#23244a",
+            "legend_font_color": "#F5F6F7",
+            "legend_bg": 'rgba(35,36,74,0.92)',  # match bg for harmony
+            "annotation_color": '#F5F6F7'
+        }
+
+def create_empty_radar_chart(message: str) -> Figure:
+    """Create an empty radar chart with a message."""
+    fig = go.Figure()
+    fig.add_annotation(
+        text=f"📊 {message}",
+        xref="paper", yref="paper",
+        x=0.5, y=0.5,
+        xanchor='center', yanchor='middle',
+        font=dict(
+            size=18, 
+            color="#94A3B8",
+            family="Verdana, sans-serif"
+        ),
+        showarrow=False,
+        bgcolor="rgba(245, 246, 247, 0.05)",
+        bordercolor="rgba(245, 246, 247, 0.2)",
+        borderwidth=1,
+        borderpad=20
+    )
+    fig.update_layout(
+        paper_bgcolor="#01091A",
+        plot_bgcolor="rgba(245, 246, 247, 0.02)", 
+        height=800,
+        width=800,
+        margin=dict(t=100, b=80, l=80, r=80),
+        title=dict(
+            text="<b>Domain Performance Chart</b>",
+            x=0.5,
+            y=0.97,
+            font=dict(
+                size=22, 
+                family="Verdana, sans-serif", 
+                color="#F5F6F7",
+                weight=700
+            ),
+        ),
+        annotations=[
+            dict(
+                text="TRUEBench",
+                xref="paper", yref="paper",
+                x=0.98, y=0.02,
+                xanchor='right', yanchor='bottom',
+                font=dict(size=10, color='#64748B'),
+                showarrow=False
+            )
+        ]
+    )
+    return fig
+
+def create_len_overall_scatter(
+    df: pd.DataFrame,
+    selected_models: Optional[List[str]] = None,
+    max_models: int = 30,
+    y_col: str = "Overall",
+    length_data: Optional[dict] = None,
+    theme: str = "light",
+    x_axis_data_source: str = "Med. Len."
+) -> Figure:
+    """
+    Create scatter plot showing Med. Len. vs selected y_col for up to 10 selected models.
+    Each dot is colored by Think (normal/reasoning), and the legend is by Think.
+    DataFrame must include an 'Think' column.
+    length_data: JSON data containing model length information by category
+    theme: "light" or "dark" (default: "light")
+    """
+    import plotly.express as px
+    import json
+
+    # Defensive: check required columns
+    required_cols = ['Model Name', 'Med. Len.', 'Med. Resp. Len.', y_col]
+    for col in required_cols:
+        if col not in df.columns:
+            return create_empty_radar_chart(f"Column '{col}' not found in data")
+    # Think column check
+    think_col = None
+    for candidate in ['Think']:
+        if candidate in df.columns:
+            think_col = candidate
+            break
+    if think_col is None:
+        return create_empty_radar_chart("Column 'Think' not found in data")
+    # Filter by selected_models
+    if selected_models is not None and len(selected_models) > 0:
+        df_filtered = df[df['Model Name'].isin(selected_models)].copy()
+    else:
+        # Default: top-N by Overall
+        df_filtered = df.copy()
+        df_filtered = df_filtered.sort_values('Overall', ascending=False).head(max_models)
+    if df_filtered.empty:
+        return create_empty_radar_chart(f"No data available for {x_axis_data_source} vs {y_col} analysis")
+
+    # Determine x-axis data based on x_axis_data_source
+    x_axis_col_name = x_axis_data_source # Use this for the DataFrame column
+    length_data_key = 'Med' if x_axis_data_source == "Med. Len." else 'Med Resp'
+
+    if y_col == "Overall":
+        # For 'Overall' category, prefer direct DataFrame column reading
+        df_filtered[x_axis_col_name] = pd.to_numeric(df_filtered[x_axis_col_name], errors='coerce')
+    elif length_data:
+        # For other categories, use length_data if available
+        df_filtered[x_axis_col_name] = df_filtered['Model Name'].apply(
+            lambda x: length_data.get(x, {}).get(y_col, {}).get(length_data_key, 0)
+        )
+    else:
+        # Fallback if no length_data and not 'Overall' (though this case should ideally be handled by required_cols)
+        df_filtered[x_axis_col_name] = pd.to_numeric(df_filtered[x_axis_col_name], errors='coerce')
+
+    df_filtered[y_col] = pd.to_numeric(df_filtered[y_col], errors='coerce')
+    if 'Type' in df_filtered.columns:
+        df_filtered = df_filtered[df_filtered['Type'] != 'Proprietary']
+    if 'Parameter Size (B)' in df_filtered.columns:
+        df_filtered['Parameter Size (B)'] = pd.to_numeric(df_filtered['Parameter Size (B)'], errors='coerce')
+        min_size = 20
+        max_size = 80
+        param_sizes = df_filtered['Parameter Size (B)'].fillna(5)
+        log_sizes = np.log10(param_sizes)
+        log_min = np.log10(5)
+        log_max = np.log10(param_sizes.max())
+        marker_sizes = min_size + ((log_sizes - log_min) / (log_max - log_min)) * (max_size - min_size)
+    else:
+        marker_sizes = [30] * len(df_filtered)
+
+    legend_name_map = {
+        'On': 'Thinking',
+        'Off': 'Non-Thinking'
+    }
+    color_palette = {
+        "Thinking": "#FCE39B",
+        "Non-Thinking": "#FF9185"
+    }
+    df_filtered['MarkerType'] = df_filtered['Parameter Size (B)'].apply(
+        lambda x: 'circle' if pd.notna(x) else 'star'
+    )
+    df_filtered['ThinkDisplay'] = df_filtered['Think'].map(legend_name_map).fillna(df_filtered['Think'])
+    prefix_map = {
+        'circle': 'Open',
+        'star': 'Proprietary'
+    }
+    combinations = df_filtered[['ThinkDisplay', 'MarkerType']].drop_duplicates()
+    marker_order = {'circle': 0, 'star': 1}
+    think_order = {'Thinking': 0, 'Non-Thinking': 1}
+    combinations['sort_key'] = combinations.apply(
+        lambda row: (marker_order.get(row['MarkerType'], 99), think_order.get(row['ThinkDisplay'], 99)),
+        axis=1
+    )
+    combinations = combinations.sort_values('sort_key')
+
+    fig = go.Figure()
+    legend_shown = set()
+    median_x = df_filtered[x_axis_col_name].median()
+    median_y = df_filtered[y_col].median()
+
+    x_axis_display_name = x_axis_data_source.replace("Med.", "Median").replace("Len.", "Length")
+
+    fig.add_vline(
+        x=median_x,
+        line_dash="dash",
+        line_color="#64748B",
+        opacity=0.6,
+        line_width=1.5,
+        annotation_text=f"{x_axis_display_name}",
+        annotation_position="top right",
+        annotation_font=dict(size=10, color="#64748B")
+    )
+    fig.add_hline(
+        y=median_y,
+        line_dash="dash",
+        line_color="#64748B",
+        opacity=0.6,
+        line_width=1.5,
+        annotation_text=f"Median {y_col}",
+        annotation_position="bottom right",
+        annotation_font=dict(size=10, color="#64748B")
+    )
+
+    for _, row in combinations.iterrows():
+        think = row['ThinkDisplay']
+        marker_type = row['MarkerType']
+        prefix = prefix_map.get(marker_type, '')
+        legend_name = f"{prefix} {think}"
+        sub_df = df_filtered[
+            (df_filtered['ThinkDisplay'] == think) &
+            (df_filtered['MarkerType'] == marker_type)
+        ]
+        color = color_palette.get(think, "#1098F7")
+        sub_marker_sizes = (
+            marker_sizes[sub_df.index]
+            if 'Parameter Size (B)' in df_filtered.columns and marker_type == 'circle'
+            else [30] * len(sub_df)
+        )
+        show_legend = legend_name not in legend_shown
+        legend_shown.add(legend_name)
+        fig.add_trace(go.Scatter(
+            x=sub_df[x_axis_col_name],
+            y=sub_df[y_col],
+            mode='markers+text',
+            name=legend_name,
+            legendgroup=legend_name,
+            showlegend=show_legend,
+            marker_symbol=marker_type,
+            marker=dict(
+                size=sub_marker_sizes,
+                color=color,
+                opacity=0.85,
+                line=dict(width=2, color='#01091A')
+            ),
+            text=sub_df['Model Name'].apply(get_display_model_name),
+            textposition="top center",
+            textfont=dict(size=10, color='#94A3B8'),
+            hovertemplate="<b>%{text}</b><br>" +
+                        f"{x_axis_display_name}: "+"%{x:.2f}<br>" +
+                        f"{y_col}: "+"%{y:.2f}<br>" +
+                        f"Think: {legend_name}<br>" +
+                        ("Parameter Size: %{customdata}B<br>" if marker_type == 'circle' else "") +
+                        "<extra></extra>",
+            customdata=sub_df['Parameter Size (B)'].values if marker_type == 'circle' else None
+        ))
+
+    # Theme colors
+    theme_colors = get_theme_colors(theme)
+    fig.update_layout(
+        title=dict(
+            text=f"<b>{y_col} {x_axis_display_name} vs Category Score</b>",
+            x=0.5,
+            y=0.97,
+            font=dict(size=22, family="Verdana, sans-serif", color=theme_colors["legend_font_color"], weight=700)
+        ),
+        xaxis=dict(
+            title=dict(
+                text=f"<b>{y_col} {x_axis_display_name}</b>",
+                font=dict(size=16, color=theme_colors["legend_font_color"])
+            ),
+            tickfont=dict(size=12, color="#94A3B8"),
+            gridcolor="rgba(245, 246, 247, 0.1)",
+            zerolinecolor="rgba(245, 246, 247, 0.2)"
+        ),
+        yaxis=dict(
+            title=dict(
+                text=f"<b>{y_col} Score</b>",
+                font=dict(size=16, color=theme_colors["legend_font_color"])
+            ),
+            tickfont=dict(size=12, color="#94A3B8"),
+            gridcolor="rgba(245, 246, 247, 0.1)",
+            zerolinecolor="rgba(245, 246, 247, 0.2)"
+        ),
+        paper_bgcolor=theme_colors["paper_bg"],
+        plot_bgcolor=theme_colors["plot_bg"],
+        height=900,
+        width=1450,
+        showlegend=True,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1,
+            xanchor="center",
+            x=0.5,
+            font=dict(size=12, family="Verdana, sans-serif", color=theme_colors["legend_font_color"]),
+            bgcolor=theme_colors["legend_bg"],
+            bordercolor='rgba(245, 246, 247, 0.2)',
+            borderwidth=1
+        ),
+        margin=dict(t=100, b=80, l=80, r=80)
+    )
+    return fig
+
+def create_language_radar_chart(
+    df: pd.DataFrame,
+    metric_type: str,
+    selected_models: Optional[List[str]] = None,
+    max_models: int = 5,
+    theme: str = "light"
+) -> Figure:
+    """
+    Create a radar chart showing model performance across languages for the selected models.
+    theme: "light" or "dark" (default: "light")
+    """
+    language_domains = ['KO', 'EN', 'JA', 'ZH', 'PL', 'DE', 'PT', 'ES', 'FR', 'IT', 'RU', 'VI']
+    if selected_models is None or len(selected_models) == 0:
+        actual_metric_type = SORT_COLUMN_MAP.get(metric_type, metric_type)
+        if actual_metric_type in df.columns:
+            selected_models = df.nlargest(max_models, actual_metric_type)['Model Name'].tolist()
+        else:
+            selected_models = df.head(max_models)['Model Name'].tolist()
+    selected_models = selected_models[:max_models]
+    harmonious_palette_light = [
+        {'fill': 'rgba(79,143,198,0.25)', 'line': '#4F8FC6', 'name': 'BlueGray'},
+        {'fill': 'rgba(109,213,237,0.25)', 'line': '#6DD5ED', 'name': 'SkyBlue'},
+        {'fill': 'rgba(162,89,247,0.25)', 'line': '#A259F7', 'name': 'Violet'},
+        {'fill': 'rgba(67,233,123,0.25)', 'line': '#43E97B', 'name': 'Mint'},
+        {'fill': 'rgba(255,215,0,0.20)', 'line': '#FFD700', 'name': 'Gold'}
+    ]
+    harmonious_palette_dark = [
+        {'fill': 'rgba(144,202,249,0.25)', 'line': '#90CAF9', 'name': 'LightBlue'},
+        {'fill': 'rgba(128,203,196,0.25)', 'line': '#80CBC4', 'name': 'Mint'},
+        {'fill': 'rgba(179,157,219,0.25)', 'line': '#B39DDB', 'name': 'Lavender'},
+        {'fill': 'rgba(244,143,177,0.25)', 'line': '#F48FB1', 'name': 'Pink'},
+        {'fill': 'rgba(255,213,79,0.20)', 'line': '#FFD54F', 'name': 'Gold'}
+    ]
+    palette = harmonious_palette_light if theme == "light" else harmonious_palette_dark
+    fig = go.Figure()
+    for idx, model_name in enumerate(selected_models):
+        model_data = df[df['Model Name'] == model_name]
+        if model_data.empty:
+            continue
+        model_row = model_data.iloc[0]
+        values = []
+        for lang in language_domains:
+            val = model_row[lang] if lang in model_row else 0
+            if pd.isna(val) or val == '':
+                val = 0
+            else:
+                val = float(val)
+            values.append(val)
+        values_plot = values + [values[0]]
+        domains_plot = language_domains + [language_domains[0]]
+        colors = palette[idx % len(palette)]
+        fig.add_trace(
+            go.Scatterpolar(
+                r=values_plot,
+                theta=domains_plot,
+                fill='toself',
+                fillcolor=colors['fill'],
+                line=dict(
+                    color=colors['line'],
+                    width=3,
+                    shape='spline',
+                    smoothing=0.5
+                ),
+                marker=dict(
+                    size=10,
+                    color=colors['line'],
+                    symbol='circle',
+                    line=dict(width=2, color='#01091A' if theme == "light" else '#e3e6f3')
+                ),
+                name=get_display_model_name(model_name),
+                mode="lines+markers",
+                hovertemplate="<b>%{fullData.name}</b><br>" +
+                             "<span style='color: #94A3B8'>%{theta}</span><br>" +
+                             "<b style='font-size: 12px'>%{r:.3f}</b><br>" +
+                             "<extra></extra>",
+                hoverlabel=dict(
+                    bgcolor="rgba(1, 9, 26, 0.95)" if theme == "dark" else "rgba(227,230,243,0.95)",
+                    bordercolor=colors['line'],
+                    font=dict(color="#F5F6F7" if theme == "dark" else "#23244a", size=12, family="Verdana, sans-serif")
+                )
+            )
+        )
+    max_range = 100.0
+    tick_vals = [i * max_range / 5 for i in range(6)]
+    tick_text = [f"{val:.2f}" for val in tick_vals]
+    theme_colors = get_theme_colors(theme)
+    fig.update_layout(
+        polar=dict(
+            bgcolor=theme_colors["plot_bg"],
+            domain=dict(x=[0,1], y=[0,1]),
+            radialaxis=dict(
+                visible=True,
+                range=[0, max_range],
+                showline=True,
+                linewidth=2,
+                linecolor='rgba(245, 246, 247, 0.2)',
+                gridcolor='rgba(245, 246, 247, 0.1)',
+                gridwidth=1,
+                tickvals=tick_vals,
+                ticktext=tick_text,
+                tickfont=dict(
+                    size=11,
+                    color='#94A3B8',
+                    family="'Geist Mono', monospace"
+                ),
+                tickangle=0
+            ),
+            angularaxis=dict(
+                showline=True,
+                linewidth=2,
+                linecolor='rgba(245, 246, 247, 0.2)',
+                gridcolor='rgba(245, 246, 247, 0.08)',
+                tickfont=dict(
+                    size=14,
+                    family="Verdana, sans-serif",
+                    color=theme_colors["legend_font_color"],
+                    weight=600
+                ),
+                ticktext=[
+                    "📝 Content Gen",
+                    "✂️ Editing",
+                    "📊 Data Analysis",
+                    "🧠 Reasoning",
+                    "🦄 Hallucination",
+                    "🛡️ Safety",
+                    "🔁 Repetition",
+                    "📝 Summarization",
+                    "🌐 Translation",
+                    "💬 Multi-Turn"
+                ],
+                rotation=90,
+                direction="clockwise",
+            ),
+        ),
+        showlegend=True,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=-0.15,
+            xanchor="center",
+            x=0.5,
+            font=dict(
+                size=12,
+                family="Verdana, sans-serif",
+                color=theme_colors["legend_font_color"]
+            ),
+            bgcolor=theme_colors["legend_bg"],
+            bordercolor='rgba(245, 246, 247, 0.2)',
+            borderwidth=1,
+            itemsizing='constant',
+            itemwidth=30
+        ),
+        title=dict(
+            text=f"<b>Language Performance</b>",
+            x=0.5,
+            y=0.97,
+            font=dict(
+                size=22,
+                family="Verdana, sans-serif",
+                color=theme_colors["legend_font_color"],
+                weight=700
+            ),
+        ),
+        paper_bgcolor=theme_colors["paper_bg"],
+        plot_bgcolor=theme_colors["plot_bg"],
+        height=900,
+        width=1450,
+        margin=dict(t=100, b=80, l=80, r=80),
+        annotations=[
+            dict(
+                text="TRUEBench",
+                xref="paper", yref="paper",
+                x=0.98, y=0.02,
+                xanchor='right', yanchor='bottom',
+                font=dict(size=10, color=theme_colors["annotation_color"]),
+                showarrow=False
+            )
+        ]
+    )
+    return fig
+
+def load_leaderboard_data() -> pd.DataFrame:
+    """Load and prepare the leaderboard data (Category)."""
+    from src.data_loader import get_category_dataframe
+    return get_category_dataframe(processed=True)
+
+def load_leaderboard_language_data() -> pd.DataFrame:
+    """Load and prepare the leaderboard data (Language)."""
+    from src.data_loader import get_language_dataframe
+    return get_language_dataframe(processed=True)
+
+def create_domain_radar_chart(
+    df: pd.DataFrame,
+    metric_type: str,
+    selected_models: Optional[List[str]] = None,
+    max_models: int = 5,
+    theme: str = "light"
+) -> Figure:
+    """
+    Create a radar chart showing model performance across domains for the selected metric.
+    theme: "light" or "dark" (default: "light")
+    """
+    actual_metric_type = SORT_COLUMN_MAP.get(metric_type, metric_type)
+    domain_mapping = {
+        'Avg AC': {
+            'Content Generation': '📝 Content Generation',
+            'Editing': '✂️ Editing',
+            'Data Analysis': '📊 Data Analysis',
+            'Reasoning': '🧠 Reasoning',
+            'Hallucination': '🦄 Hallucination',
+            'Safety': '🛡️ Safety',
+            'Repetition': '🔁 Repetition',
+            'Summarization': '📝 Summarization',
+            'Translation': '🌐 Translation',
+            'Multi-Turn': '💬 Multi-Turn'
+        },
+        'Avg TSQ': {
+            'Content Generation': 'Content Generation',
+            'Editing': 'Editing',
+            'Data Analysis': 'Data Analysis',
+            'Reasoning': 'Reasoning',
+            'Hallucination': 'Hallucination',
+            'Safety': 'Safety',
+            'Repetition': 'Repetition',
+            'Summarization': 'Summarization',
+            'Translation': 'Translation',
+            'Multi-Turn': 'Multi-Turn'
+        },
+        'Avg Total Cost': {
+            'Content Generation': 'Content Generation',
+            'Editing': 'Editing',
+            'Data Analysis': 'Data Analysis',
+            'Reasoning': 'Reasoning',
+            'Hallucination': 'Hallucination',
+            'Safety': 'Safety',
+            'Repetition': 'Repetition',
+            'Summarization': 'Summarization',
+            'Translation': 'Translation',
+            'Multi-Turn': 'Multi-Turn'
+        },
+        'Avg Session Duration': {
+            'Content Generation': 'Content Generation',
+            'Editing': 'Editing',
+            'Data Analysis': 'Data Analysis',
+            'Reasoning': 'Reasoning',
+            'Hallucination': 'Hallucination',
+            'Safety': 'Safety',
+            'Repetition': 'Repetition',
+            'Summarization': 'Summarization',
+            'Translation': 'Translation',
+            'Multi-Turn': 'Multi-Turn'
+        },
+        'Avg Turns': {
+            'Content Generation': 'Content Generation',
+            'Editing': 'Editing',
+            'Data Analysis': 'Data Analysis',
+            'Reasoning': 'Reasoning',
+            'Hallucination': 'Hallucination',
+            'Safety': 'Safety',
+            'Repetition': 'Repetition',
+            'Summarization': 'Summarization',
+            'Translation': 'Translation',
+            'Multi-Turn': 'Multi-Turn'
+        }
+    }
+    if actual_metric_type not in domain_mapping:
+        return create_empty_radar_chart(f"Domain breakdown not available for {metric_type}")
+    if selected_models is None or len(selected_models) == 0:
+        if actual_metric_type in df.columns:
+            selected_models = df.nlargest(max_models, actual_metric_type)['Model Name'].tolist()
+        else:
+            selected_models = df.head(max_models)['Model Name'].tolist()
+    selected_models = selected_models[:max_models]
+    domains = list(domain_mapping[actual_metric_type].keys())
+    domain_columns = list(domain_mapping[actual_metric_type].values())
+    harmonious_palette_light = [
+        {'fill': 'rgba(79,143,198,0.25)', 'line': '#4F8FC6', 'name': 'BlueGray'},
+        {'fill': 'rgba(109,213,237,0.25)', 'line': '#6DD5ED', 'name': 'SkyBlue'},
+        {'fill': 'rgba(162,89,247,0.25)', 'line': '#A259F7', 'name': 'Violet'},
+        {'fill': 'rgba(67,233,123,0.25)', 'line': '#43E97B', 'name': 'Mint'},
+        {'fill': 'rgba(255,215,0,0.20)', 'line': '#FFD700', 'name': 'Gold'}
+    ]
+    harmonious_palette_dark = [
+        {'fill': 'rgba(144,202,249,0.25)', 'line': '#90CAF9', 'name': 'LightBlue'},
+        {'fill': 'rgba(128,203,196,0.25)', 'line': '#80CBC4', 'name': 'Mint'},
+        {'fill': 'rgba(179,157,219,0.25)', 'line': '#B39DDB', 'name': 'Lavender'},
+        {'fill': 'rgba(244,143,177,0.25)', 'line': '#F48FB1', 'name': 'Pink'},
+        {'fill': 'rgba(255,213,79,0.20)', 'line': '#FFD54F', 'name': 'Gold'}
+    ]
+    palette = harmonious_palette_light if theme == "light" else harmonious_palette_dark
+    fig = go.Figure()
+    for idx, model_name in enumerate(selected_models):
+        model_data = df[df['Model Name'] == model_name]
+        if model_data.empty:
+            continue
+        model_row = model_data.iloc[0]
+        values = []
+        for domain, _ in zip(domains, domain_columns):
+            if domain in df.columns and domain in model_row:
+                val = model_row[domain]
+                if pd.isna(val) or val == '':
+                    val = 0
+                else:
+                    val = float(val)
+                values.append(val)
+            else:
+                values.append(0)
+        values_plot = values + [values[0]]
+        domains_plot = domains + [domains[0]]
+        colors = palette[idx % len(palette)]
+        fig.add_trace(
+            go.Scatterpolar(
+                r=values_plot,
+                theta=domains_plot,
+                fill='toself',
+                fillcolor=colors['fill'],
+                line=dict(
+                    color=colors['line'],
+                    width=3,
+                    shape='spline',
+                    smoothing=0.5
+                ),
+                marker=dict(
+                    size=10,
+                    color=colors['line'],
+                    symbol='circle',
+                    line=dict(width=2, color='#01091A' if theme == "light" else '#e3e6f3')
+                ),
+                name=get_display_model_name(model_name),
+                mode="lines+markers",
+                hovertemplate="<b>%{fullData.name}</b><br>" +
+                             "<span style='color: #94A3B8'>%{theta}</span><br>" +
+                             "<b style='font-size: 12px'>%{r:.3f}</b><br>" +
+                             "<extra></extra>",
+                hoverlabel=dict(
+                    bgcolor="rgba(1, 9, 26, 0.95)" if theme == "dark" else "rgba(227,230,243,0.95)",
+                    bordercolor=colors['line'],
+                    font=dict(color="#F5F6F7" if theme == "dark" else "#23244a", size=12, family="Verdana, sans-serif")
+                )
+            )
+        )
+    max_range = 100.0
+    tick_vals = [i * max_range / 5 for i in range(6)]
+    tick_text = [f"{val:.2f}" for val in tick_vals]
+    theme_colors = get_theme_colors(theme)
+    fig.update_layout(
+        polar=dict(
+            bgcolor=theme_colors["plot_bg"],
+            radialaxis=dict(
+                visible=True,
+                range=[0, max_range],
+                showline=True,
+                linewidth=2,
+                linecolor='rgba(245, 246, 247, 0.2)',
+                gridcolor='rgba(245, 246, 247, 0.1)',
+                gridwidth=1,
+                tickvals=tick_vals,
+                ticktext=tick_text,
+                tickfont=dict(
+                    size=11, 
+                    color='#94A3B8',
+                    family="'Geist Mono', monospace"
+                ),
+                tickangle=0
+            ),
+            angularaxis=dict(
+                showline=True,
+                linewidth=2,
+                linecolor='rgba(245, 246, 247, 0.2)',
+                gridcolor='rgba(245, 246, 247, 0.08)',
+                tickfont=dict(
+                    size=14, 
+                    family="Verdana, sans-serif",
+                    color=theme_colors["legend_font_color"],
+                    weight=600
+                ),
+                rotation=90,
+                direction="clockwise",
+            ),
+        ),
+        showlegend=True,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=-0.15,
+            xanchor="center",
+            x=0.5,
+            font=dict(
+                size=12,
+                family="Verdana, sans-serif",
+                color=theme_colors["legend_font_color"]
+            ),
+            bgcolor=theme_colors["legend_bg"],
+            bordercolor='rgba(245, 246, 247, 0.2)',
+            borderwidth=1,
+            itemsizing='constant',
+            itemwidth=30
+        ),
+        title=dict(
+            text=f"<b>Category Performance</b>",
+            x=0.5,
+            y=0.97,
+            font=dict(
+                size=22, 
+                family="Verdana, sans-serif", 
+                color=theme_colors["legend_font_color"],
+                weight=700
+            ),
+        ),
+        paper_bgcolor=theme_colors["paper_bg"],
+        plot_bgcolor=theme_colors["plot_bg"],
+        height=900,
+        width=1450,
+        margin=dict(t=100, b=80, l=80, r=80),
+        annotations=[
+            dict(
+                text="TRUEBench",
+                xref="paper", yref="paper",
+                x=0.98, y=0.02,
+                xanchor='right', yanchor='bottom',
+                font=dict(size=10, color=theme_colors["annotation_color"]),
+                showarrow=False
+            )
+        ]
+    )
+    return fig