feat: enhance submission tab with detailed instructions and improved model information input fields

app.py

@@ -14,6 +14,7 @@ from src.about import (
     EVALUATION_QUEUE_TEXT,
     INTRODUCTION_TEXT,
     LLM_BENCHMARKS_TEXT,
+    SUBMISSION_INSTRUCTIONS_TEXT,
     TITLE,
 )
 from src.backend.app import create_app
@@ -23,6 +24,7 @@ from src.display.css_html_js import (
     backend_status_js,
     custom_css,
 )
+from src.display.formatting import styled_error
 from src.display.utils import (
     BASE_COLS,
     BENCHMARK_COLS,
@@ -358,31 +360,53 @@ def create_submit_tab(tab_id: int, demo: gr.Blocks):
                         )
         with gr.Row():
             gr.Markdown("# ✉️✨ Submit your model here!", elem_classes="markdown-text")
-
         with gr.Row():
-            search_name = gr.Textbox(label="search model name", placeholder="user/model_name")
+            gr.Markdown(SUBMISSION_INSTRUCTIONS_TEXT, elem_classes="markdown-text")
 
-        with gr.Row():
-            table = gr.Dataframe(
-                headers=["Model Name", "Pipeline", "Downloads", "Likes"],
-                datatype=["str", "str", "number", "number"],
-                interactive=False,
-                wrap=True,
-                label="click model name to select",
-            )
+        # ========== Section 1: Steps 1-7 (Model Information) ==========
+        with gr.Accordion("📋 Model Information (Steps 1-7)", open=True):
+            with gr.Row():
+                search_name = gr.Textbox(label="1. Search model name", placeholder="org/model_name")
 
-        with gr.Row():
-            with gr.Column():
-                model_name_textbox = gr.Textbox(label="Model name", placeholder="user/model_name")
-                revision_name_textbox = gr.Textbox(label="Revision commit", placeholder="main")
-                _model_type = gr.Dropdown(
-                    choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
-                    label="Model type",
-                    multiselect=False,
-                    value=None,
-                    interactive=True,
+            with gr.Row():
+                table = gr.Dataframe(
+                    headers=["Model Name", "Pipeline", "Downloads", "Likes"],
+                    datatype=["str", "str", "number", "number"],
+                    interactive=False,
+                    wrap=True,
+                    label="2. Click model name to select",
                 )
 
+            with gr.Row():
+                with gr.Column():
+                    model_name_textbox = gr.Textbox(label="2. Model name (auto-filled)", placeholder="org/model_name")
+                    revision_name_textbox = gr.Textbox(label="3. Revision commit (Optional)", placeholder="main")
+                    model_type = gr.Dropdown(
+                        choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
+                        label="4. Model type",
+                        multiselect=False,
+                        value=None,
+                        interactive=True,
+                    )
+                    precision = gr.Dropdown(
+                        choices=[i.value.name for i in Precision if i != Precision.Unknown],
+                        label="5. Precision",
+                        multiselect=False,
+                        value="float16",
+                        interactive=True,
+                    )
+                    weight_type = gr.Dropdown(
+                        choices=[i.value.name for i in WeightType],
+                        label="6. Weights type",
+                        multiselect=False,
+                        value="Original",
+                        interactive=True,
+                    )
+                    base_model_name_textbox = gr.Textbox(
+                        label="7. Base model (Optional, for delta or adapter weights)",
+                        placeholder="org/model_name",
+                    )
+
                 def search_models(query):
                     if not query.strip():
                         return []
@@ -401,6 +425,43 @@ def create_submit_tab(tab_id: int, demo: gr.Blocks):
             search_name.change(fn=search_models, inputs=search_name, outputs=table)
             table.select(fn=on_select, inputs=table, outputs=model_name_textbox)
 
+        # ========== Section 2: Steps 8-10 (Benchmark Evaluation Results) ==========
+        with gr.Accordion("📊 Benchmark Evaluation Results (Steps 8-10)", open=True):
+            gr.Markdown(
+                "**8-9. Select benchmarks and fill in evaluation result values**\n\n"
+                "Fill in the form below to submit your benchmark evaluation results."
+            )
+
+            # Simple form for benchmark results
+            benchmarks = get_benchmarks()
+            benchmark_results_form = []
+            for benchmark in benchmarks:
+                with gr.Row():
+                    benchmark_checkbox = gr.Checkbox(
+                        label=f"{benchmark.title} ({benchmark.key})",
+                        value=False,
+                    )
+                    result_input = gr.Number(
+                        label="Result Value",
+                        value=None,
+                        interactive=True,
+                        visible=False,
+                    )
+
+                    def make_visibility_fn(_result_comp):
+                        def toggle_visibility(checked):
+                            return gr.update(visible=checked)
+
+                        return toggle_visibility
+
+                    benchmark_checkbox.change(
+                        fn=make_visibility_fn(result_input),
+                        inputs=benchmark_checkbox,
+                        outputs=result_input,
+                    )
+                    benchmark_results_form.append((benchmark, benchmark_checkbox, result_input))
+
+            # JSON upload as alternative
             def file_to_json_str(file) -> str:
                 """
                 读取上传的 JSON 文件并返回字符串
@@ -422,14 +483,15 @@ def create_submit_tab(tab_id: int, demo: gr.Blocks):
                     raise gr.Error(f"Error reading JSON file: {str(e)}") from e
 
             json_upload = gr.File(
-                label="Upload JSON file",
+                label="Or upload JSON file (alternative to form above)",
                 file_types=[".json"],
                 type="filepath",
+                visible=False,
             )
             json_str = gr.Textbox(
                 label="JSON Content",
-                placeholder="JSON content will appear here after upload",
-                lines=10,
+                placeholder='{"config": {...}, "results": {...}}',
+                lines=15,
                 interactive=True,
                 visible=False,
             )
@@ -439,61 +501,140 @@ def create_submit_tab(tab_id: int, demo: gr.Blocks):
                 outputs=json_str,
             )
 
-        with gr.Column():
-            precision = gr.Dropdown(
-                choices=[i.value.name for i in Precision if i != Precision.Unknown],
-                label="Precision",
-                multiselect=False,
-                value="float16",
-                interactive=True,
-            )
-            weight_type = gr.Dropdown(
-                choices=[i.value.name for i in WeightType],
-                label="Weights type",
-                multiselect=False,
-                value="Original",
-                interactive=True,
-            )
-            base_model_name_textbox = gr.Textbox(label="Base model (for delta or adapter weights)")
-            commit_textbox = gr.Textbox(label="Commits")
-
-            submit_button = gr.Button("Submit Eval")
-            submission_result = gr.Markdown()
-            submit_button.click(
-                add_new_submit,
-                [
-                    model_name_textbox,
-                    base_model_name_textbox,
-                    revision_name_textbox,
-                    precision,
-                    weight_type,
-                    json_str,
-                    commit_textbox,
-                ],
-                submission_result,
-            )
+        # ========== Submit Section ==========
+        with gr.Row():
+            commit_textbox = gr.Textbox(label="Commit Message (Optional)", placeholder="Optional commit message")
+
+        def build_json_from_form(
+            model_name: str,
+            revision: str,
+            precision: str,
+            benchmark_checkbox_values: list,
+            benchmark_result_values: list,
+        ) -> str:
+            """Build JSON from form inputs"""
+            import json
+
+            if not model_name or not model_name.strip():
+                raise ValueError("Model name is required")
+
+            # Extract model_key from model_name (simple conversion)
+            model_key = model_name.lower().replace("/", "_").replace("-", "_")
+
+            # Build config
+            config = {
+                "model_name": model_name,
+                "model_key": model_key,
+                "model_dtype": f"torch.{precision}" if precision else None,
+                "model_sha": revision or "main",
+                "model_args": None,
+            }
+
+            # Build results: {benchmark_key: {metric: value}}
+            results = {}
+            benchmarks_list = get_benchmarks()
+            for benchmark, checkbox_checked, result_value in zip(
+                benchmarks_list, benchmark_checkbox_values, benchmark_result_values, strict=True
+            ):
+                if checkbox_checked and result_value is not None:
+                    # Use "acc" as the default metric (can be extended)
+                    results[benchmark.key] = {"acc": float(result_value)}
+
+            if not results:
+                raise ValueError("At least one benchmark result is required")
+
+            return json.dumps({"config": config, "results": results}, indent=2, ensure_ascii=False)
+
+        def submit_with_form_or_json(
+            model: str,
+            base_model: str,
+            revision: str,
+            precision: str,
+            weight_type: str,
+            model_type: str,  # Currently not used but kept for future use
+            json_str: str,
+            commit_message: str,
+            *benchmark_values,
+        ):
+            """Submit with either form data or JSON"""
+            import json
+
+            # If JSON is provided, use it; otherwise build from form
+            if json_str and json_str.strip():
+                try:
+                    # Validate JSON
+                    json.loads(json_str)
+                    final_json = json_str
+                except json.JSONDecodeError:
+                    return styled_error("Invalid JSON format. Please check your JSON content.")
+            else:
+                # Build JSON from form
+                # benchmark_values contains pairs of (checkbox_value, result_value) for each benchmark
+                benchmarks_list = get_benchmarks()
+                if len(benchmark_values) != len(benchmarks_list) * 2:
+                    return styled_error("Invalid benchmark form data. Please check your inputs.")
+
+                # Split into checkbox values and result values
+                benchmark_checkbox_values = [benchmark_values[i] for i in range(0, len(benchmark_values), 2)]
+                benchmark_result_values = [benchmark_values[i] for i in range(1, len(benchmark_values), 2)]
 
-            # Backend status indicator
-            backend_status = gr.HTML(
-                value=get_backend_status_undefined_html(),
-                elem_id="backend-status-container",
-            )
-            # trigger button to bind the click event
-            status_trigger = gr.Button(elem_id="backend-status-trigger-btn", visible=False)
-            status_trigger.click(
-                fn=lambda: check_backend_health()[1],
-                inputs=None,
-                outputs=backend_status,
-            )
-            # load external JavaScript file
-            js_content = backend_status_js()
-            status_trigger_js_html = f'<script>{js_content}</script>'
-            gr.HTML(status_trigger_js_html, visible=False)
-            demo.load(
-                fn=lambda: check_backend_health()[1],
-                inputs=None,
-                outputs=backend_status,
-            )
+                try:
+                    final_json = build_json_from_form(
+                        model, revision, precision, benchmark_checkbox_values, benchmark_result_values
+                    )
+                except ValueError as e:
+                    return styled_error(str(e))
+                except Exception as e:
+                    return styled_error(f"Error building JSON: {str(e)}")
+
+            # Call the submit function
+            return add_new_submit(model, base_model, revision, precision, weight_type, final_json, commit_message)
+
+        submit_button = gr.Button("10. Submit Eval", variant="primary")
+        submission_result = gr.Markdown()
+
+        # Collect all inputs for submission
+        all_inputs = [
+            model_name_textbox,
+            base_model_name_textbox,
+            revision_name_textbox,
+            precision,
+            weight_type,
+            model_type,
+            json_str,
+            commit_textbox,
+        ]
+        # Add benchmark form inputs
+        for _, checkbox, result_input in benchmark_results_form:
+            all_inputs.extend([checkbox, result_input])
+
+        submit_button.click(
+            fn=submit_with_form_or_json,
+            inputs=all_inputs,
+            outputs=submission_result,
+        )
+
+        # Backend status indicator
+        backend_status = gr.HTML(
+            value=get_backend_status_undefined_html(),
+            elem_id="backend-status-container",
+        )
+        # trigger button to bind the click event
+        status_trigger = gr.Button(elem_id="backend-status-trigger-btn", visible=False)
+        status_trigger.click(
+            fn=lambda: check_backend_health()[1],
+            inputs=None,
+            outputs=backend_status,
+        )
+        # load external JavaScript file
+        js_content = backend_status_js()
+        status_trigger_js_html = f'<script>{js_content}</script>'
+        gr.HTML(status_trigger_js_html, visible=False)
+        demo.load(
+            fn=lambda: check_backend_health()[1],
+            inputs=None,
+            outputs=backend_status,
+        )
 
 
 def main():

src/about.py

@@ -63,3 +63,20 @@ CITATION_BUTTON_TEXT = dedent("""
   year={2025}
 }
 """).strip()
+
+# --------------------------------------
+
+SUBMISSION_INSTRUCTIONS_TEXT = dedent("""
+## Submission Instructions
+
+1. Fill in the model name to search for on the HuggingFace Hub. (e.g. `qwen/qwen3-vl-8b-instruct`   )
+2. Select the model from search results, and check the model name autofilled below (e.g. `Qwen/Qwen3-VL-8B-Instruct`).
+3. (Optional) Fill in the revision commit of the model. If not filled, means using the latest `main` branch.
+4. Select the model type. (e.g. `pretrained`)
+5. Select the precision of the model. (e.g. `bfloat16`)
+6. Select the weights type of the model. (defaults to `Original`)
+7. (Optional) Fill in the base model name for **delta** or **adapter** weights. (e.g. `Qwen/Qwen3-VL-8B-Instruct`)
+8. Select a benchmark to evaluate on, and fill in the evaluation result value (e.g. `0.5` for `VSI-bench` `acc`).
+9. (Optional) click **[+]** button to add more benchmarks & evaluation result values.
+10. Click the **Submit Eval** button to submit the evaluation request.
+""")