add model-free.

Signed-off-by: lkk12014402 <kaokao.lv@intel.com>

app.py

@@ -86,7 +86,7 @@ from src.leaderboard.read_auto_pipeline_results import (
 )
 from src.populate import get_auto_pipeline_results_df, get_evaluation_queue_df
 from src.scripts.update_all_request_files import update_dynamic_files
-from src.submission.check_validity import GPU_COUNT_CHOICES, GPU_HARDWARE_CHOICES, CONTAINER_DISK_SIZE_CHOICES
+from src.submission.check_validity import GPU_COUNT_CHOICES, GPU_HARDWARE_CHOICES, CONTAINER_DISK_SIZE_CHOICES, EXPORT_FORMAT_CHOICES
 from src.tools.plots import (
     compute_metrics_summary,
     create_scheme_accuracy_chart,
@@ -119,7 +119,7 @@ from src.app_helpers.pipeline_table import (
 )
 from src.app_helpers.queues import filter_failed_quant_df, refresh_pipeline_leaderboard, refresh_queue_tables
 from src.app_helpers.sidebar import render_sidebar_menu
-from src.app_helpers.submissions import submit_model, submit_quant
+from src.app_helpers.submissions import submit_model, submit_quant, analyze_model
 from src.app_helpers.zip_stream import register_routes as register_zip_route
 
 
@@ -529,9 +529,9 @@ with demo:
                             elem_id="quant-scheme-select",
                         )
                         quant_method = gr.Dropdown(
-                            choices=["RTN (Round-To-Nearest)", "Tuning (AutoRound, recommended)"],
+                            choices=["RTN (Round-To-Nearest)", "Tuning (AutoRound, recommended)", "Model-Free (RTN, no calibration)"],
                             label="Quantization Method",
-                            info='Tuning uses AutoRound calibration (default iters=200) to significantly improve quantized model accuracy. <a href="https://github.com/intel/auto-round" target="_blank" rel="noopener">Details ↗</a>',
+                            info='Tuning uses AutoRound calibration (default iters=200) to significantly improve quantized model accuracy. Model-Free is a fast weight-only RTN path for weight-only schemes (W4A16/MXFP4/MXFP8), restricted to whitelisted users. <a href="https://github.com/intel/auto-round" target="_blank" rel="noopener">Details ↗</a>',
                             multiselect=False,
                             value="RTN (Round-To-Nearest)",
                             interactive=True,
@@ -567,6 +567,36 @@ with demo:
                             interactive=True,
                             elem_id="cuda-devices-quant",
                         )
+                        export_format_quant = gr.Dropdown(
+                            choices=EXPORT_FORMAT_CHOICES,
+                            label="Export Format",
+                            value=EXPORT_FORMAT_CHOICES[0],
+                            info="Quantized model save format. Auto = auto_round.",
+                            interactive=True,
+                            elem_id="export-format-quant",
+                        )
+                        ignore_layers_quant = gr.Textbox(
+                            label="Ignore Layers (advanced)",
+                            placeholder="e.g. lm_head,block_sparse_moe.gate,self_attn",
+                            info="Comma-separated module substrings to skip. Empty = recommended defaults. Overrides defaults when set.",
+                            value="",
+                            interactive=True,
+                            elem_id="ignore-layers-quant",
+                        )
+                        layer_config_quant = gr.Textbox(
+                            label="Layer Config — mixed precision (advanced)",
+                            placeholder="e.g. {block_sparse_moe.experts:{bits:4,data_type:mx_fp}}",
+                            info="auto-round layer_config JSON for per-module precision. Empty = uniform scheme.",
+                            value="",
+                            interactive=True,
+                            elem_id="layer-config-quant",
+                        )
+                        analyze_button_quant = gr.Button(
+                            "🔍 Analyze Structure",
+                            variant="secondary",
+                            interactive=True,
+                            elem_id="analyze-button-quant",
+                        )
                     with gr.Column(scale=1, min_width=160, elem_classes=["submit-col"]):
                         submit_button = gr.Button(
                             "Submit",
@@ -580,6 +610,11 @@ with demo:
                             elem_classes=["submit-star-nudge"],
                         )
                 submission_result = gr.Markdown(visible=False)
+                analysis_result_quant = gr.Markdown(
+                    visible=False,
+                    elem_id="analysis-result-quant",
+                    elem_classes=["analysis-panel"],
+                )
                 dup_inline_quant = gr.Markdown(
                     visible=False,
                     elem_id="dup-inline-quant",
@@ -638,9 +673,12 @@ with demo:
                     gpu_count_quant,
                     container_disk_quant,
                     cuda_devices_quant,
+                    export_format_quant,
+                    ignore_layers_quant,
+                    layer_config_quant,
                 ],
                 [submission_result, model_name_textbox, submit_button, dup_inline_quant, license_warning_quant],
-                js="""(signal, model, revision, priv, scheme, method, size, hw, cnt, disk, cuda) => {
+                js="""(signal, model, revision, priv, scheme, method, size, hw, cnt, disk, cuda, expfmt, ignore, layercfg) => {
                     // Only clear pending_submit when NOT redirecting to OAuth
                     if (signal !== 'TRIGGER') sessionStorage.removeItem('pending_submit');
                     // Fallback: read model from DOM if Gradio internal state is empty
@@ -649,10 +687,17 @@ with demo:
                         var input = document.querySelector('#model-input-quant input, #model-input-quant textarea');
                         if (input && input.value.trim()) model = input.value.trim();
                     }
-                    return [signal, model, revision, priv, scheme, method, size, hw, cnt, disk, cuda];
+                    return [signal, model, revision, priv, scheme, method, size, hw, cnt, disk, cuda, expfmt, ignore, layercfg];
                 }""",
             )  # revision_name_textbox is hidden, always "main"
 
+            # Analyze model structure → show report + pre-fill ignore/layer_config suggestions.
+            analyze_button_quant.click(
+                fn=analyze_model,
+                inputs=[model_name_textbox, ignore_layers_quant, layer_config_quant],
+                outputs=[analysis_result_quant, ignore_layers_quant, layer_config_quant],
+            )
+
             with gr.Column():
                 with gr.Row(elem_classes=["filter-row"]):
                     my_submissions_quant_cb = gr.Checkbox(

src/app_helpers/submissions.py

@@ -15,7 +15,12 @@ from src.app_helpers.auth import check_intel_org, is_whitelisted
 from src.display.formatting import styled_error
 from src.envs import SIZE_WHITELIST, WHITELIST
 from src.submission.submit import add_new_eval, add_new_quant
-from src.submission.check_validity import is_b200_hardware, validate_cuda_visible_devices
+from src.submission.check_validity import (
+    is_b200_hardware, validate_cuda_visible_devices, resolve_export_format,
+    is_model_free_supported_scheme, MODEL_FREE_METHOD,
+    validate_ignore_layers, validate_layer_config,
+)
+from src.submission.model_analysis import analyze_model_structure, render_analysis_markdown
 
 logger = logging.getLogger(__name__)
 
@@ -145,6 +150,37 @@ def _resolve_overrides(oauth_token, hardware_choice, gpu_count_choice, container
     return hw_override, count_override, disk_override, cuda_devices
 
 
+def analyze_model(model, ignore_current=None, layercfg_current=None,
+                  oauth_token: gr.OAuthToken | None = None):
+    """Button handler: analyze a model's structure and show it in the UI.
+
+    Returns a 3-tuple of Gradio updates for
+    ``[analysis_panel, ignore_layers_textbox, layer_config_textbox]``.
+    The recommended ignore/layer_config are pre-filled ONLY when the target
+    textbox is currently empty, so a user's own edits are never clobbered.
+    Read-only and safe; gated in the UI to whitelisted users.
+    """
+    if not model or not model.strip():
+        return gr.update(value="Please enter a model name first.", visible=True), gr.update(), gr.update()
+
+    token = oauth_token.token if oauth_token else None
+    try:
+        res = analyze_model_structure(model.strip(), token=token)
+        md = render_analysis_markdown(res)
+    except Exception as e:  # never let the button crash the app
+        logger.warning("[analyze_model] failed for %s: %s", model, e)
+        return gr.update(value=f"Analysis error: {e}", visible=True), gr.update(), gr.update()
+
+    ign_upd = gr.update()
+    lc_upd = gr.update()
+    if res.ok:
+        if (not ignore_current or not ignore_current.strip()) and res.recommended_ignore_layers:
+            ign_upd = gr.update(value=res.recommended_ignore_layers)
+        if (not layercfg_current or not layercfg_current.strip()) and res.recommended_layer_config:
+            lc_upd = gr.update(value=res.recommended_layer_config)
+    return gr.update(value=md, visible=True), ign_upd, lc_upd
+
+
 def _empty_result():
     """Five outputs that signal "no progress" to the streaming UI."""
     return "", gr.update(), gr.update(interactive=True), gr.update(), gr.update()
@@ -252,6 +288,9 @@ def submit_quant(
     signal, model, revision, private, quant_scheme, quant_method_choice, model_size_input,
     hardware_choice, gpu_count_choice, container_disk_size_choice,
     cuda_visible_devices_choice=None,
+    export_format_choice=None,
+    ignore_layers_choice=None,
+    layer_config_choice=None,
     oauth_token: gr.OAuthToken | None = None,
 ):
     """Wrapper that parses the optional model-size field and calls
@@ -272,8 +311,35 @@ def submit_quant(
         oauth_token, hardware_choice, gpu_count_choice, container_disk_size_choice,
         cuda_visible_devices_choice)
 
-    # Parse method choice → "RTN" or "TUNING"
-    if quant_method_choice and "Tuning" in quant_method_choice:
+    # Advanced quant-only options are whitelist-gated. Non-whitelist users'
+    # selections are ignored (fields omitted → pipeline defaults).
+    export_format = None
+    ignore_layers = None
+    layer_config = None
+    if is_whitelisted(oauth_token):
+        export_format = resolve_export_format(export_format_choice)
+        ignore_layers, ign_err = validate_ignore_layers(ignore_layers_choice)
+        if ign_err:
+            raise gr.Error(f"Invalid Ignore Layers: {ign_err}")
+        layer_config, lc_err = validate_layer_config(layer_config_choice)
+        if lc_err:
+            raise gr.Error(f"Invalid Layer Config: {lc_err}")
+
+    # Parse method choice → "RTN" | "TUNING" | "MODEL_FREE"
+    if quant_method_choice and "Model-Free" in quant_method_choice:
+        # Model-Free is restricted to whitelisted users and weight-only schemes.
+        if not is_whitelisted(oauth_token):
+            raise gr.Error(
+                "Model-Free quantization is restricted to whitelisted users. "
+                "Please choose RTN or Tuning."
+            )
+        if not is_model_free_supported_scheme(quant_scheme):
+            raise gr.Error(
+                f"Model-Free does not support scheme '{quant_scheme}'. "
+                "Supported: INT4 (W4A16), MXFP4, MXFP8 (weight-only only; NVFP4/FP8 not supported)."
+            )
+        method_override = MODEL_FREE_METHOD
+    elif quant_method_choice and "Tuning" in quant_method_choice:
         method_override = "TUNING"
     else:
         method_override = "RTN"
@@ -329,6 +395,9 @@ def submit_quant(
             gpu_count_override=count_override,
             container_disk_size=disk_override,
             cuda_visible_devices=cuda_devices,
+            export_format=export_format,
+            ignore_layers=ignore_layers,
+            layer_config=layer_config,
             submitted_by=username,
             submitted_orgs=orgs,
             user_token=oauth_token.token if oauth_token else None,

src/submission/check_validity.py

@@ -723,6 +723,139 @@ GPU_COUNT_CHOICES: list[str] = ["Auto", "1", "2", "4", "8"]
 # Container disk size choices for whitelisted users (GB).
 CONTAINER_DISK_SIZE_CHOICES: list[str] = ["Auto", "200", "400", "600", "800", "1000", "1500", "2000"]
 
+# Export format choices for whitelisted users (auto-round save_quantized format).
+# "Auto" defers to the pipeline default (auto_round).
+EXPORT_FORMAT_AUTO = "Auto (auto_round)"
+EXPORT_FORMAT_CHOICES: list[str] = [EXPORT_FORMAT_AUTO, "auto_round", "llm_compressor"]
+
+
+def resolve_export_format(choice: str | None) -> str | None:
+    """Map an Export Format UI choice to an entry value.
+
+    Returns ``None`` for the "Auto" default (so the entry omits the field and
+    the pipeline uses its built-in default), else the concrete format string.
+    """
+    if not choice or choice.startswith("Auto"):
+        return None
+    if choice in ("auto_round", "llm_compressor"):
+        return choice
+    return None
+
+
+# ── Model-Free quantization method ───────────────────────────────────────
+# auto-round model-free is weight-only RTN and only supports these schemes
+# (see auto_round/compressors/model_free.py). NVFP4/FP8/GGUF are NOT supported.
+MODEL_FREE_METHOD = "MODEL_FREE"
+_MODEL_FREE_SUPPORTED_SCHEMES = {"W2A16", "W4A16", "W8A16", "MXFP4", "MXFP8"}
+
+# UI scheme label → normalized scheme name (mirrors auto.sh's scheme_map).
+_UI_SCHEME_TO_NORMALIZED = {
+    "INT4 (W4A16)": "W4A16",
+    "INT8 (W8A16)": "W8A16",
+    "INT4 (W4A8)": "W4A8",
+    "MXFP4": "MXFP4",
+    "MXFP8": "MXFP8",
+    "NVFP4": "NVFP4",
+}
+
+
+def normalize_scheme_name(scheme_ui: str | None) -> str:
+    """Normalize a UI scheme label (e.g. 'INT4 (W4A16)') to 'W4A16'."""
+    if not scheme_ui:
+        return ""
+    s = scheme_ui.strip()
+    return _UI_SCHEME_TO_NORMALIZED.get(s, s)
+
+
+def is_model_free_supported_scheme(scheme_ui: str | None) -> bool:
+    """Whether *scheme_ui* is a weight-only scheme supported by model-free."""
+    return normalize_scheme_name(scheme_ui) in _MODEL_FREE_SUPPORTED_SCHEMES
+
+
+# ── Custom ignore layers & mixed-precision layer_config ──────────────────
+# Ignore-layer tokens are module-name substrings, e.g.
+# "lm_head,block_sparse_moe.gate,self_attn.index_q_proj". Allow only characters
+# that appear in module names + wildcard, and reject anything shell-hostile
+# (these values are forwarded into the quantize command line downstream).
+_IGNORE_TOKEN_RE = re.compile(r"^[A-Za-z0-9_.*\-]+$")
+# layer_config is auto-round's relaxed JSON, e.g.
+# "{block_sparse_moe.experts:{bits:4,data_type:mx_fp}}". We do a syntactic
+# sanity check here; auto-round does the authoritative parse at runtime.
+_LAYER_CONFIG_RE = re.compile(r"^[A-Za-z0-9_.,:{}\s\"'\-]+$")
+_MAX_IGNORE_TOKENS = 64
+_MAX_LAYER_CONFIG_LEN = 2000
+
+
+def validate_ignore_layers(raw: str | None) -> tuple[str | None, str | None]:
+    """Validate/normalize a comma-separated ignore-layers list.
+
+    Returns ``(normalized, error)`` with exactly one non-None.
+      - empty/None → ``(None, None)`` (use pipeline defaults)
+      - each token must match ``[A-Za-z0-9_.*-]+``; duplicates are dropped
+    """
+    if raw is None:
+        return None, None
+    text = raw.strip()
+    if text == "":
+        return None, None
+    tokens = [t.strip() for t in text.split(",")]
+    out: list[str] = []
+    seen: set[str] = set()
+    for tok in tokens:
+        if tok == "":
+            continue  # tolerate stray/trailing commas
+        if not _IGNORE_TOKEN_RE.match(tok):
+            return None, (
+                f"Invalid ignore-layer token '{tok}': only letters, digits, '_', '.', "
+                "'*' and '-' are allowed."
+            )
+        if tok not in seen:
+            seen.add(tok)
+            out.append(tok)
+    if not out:
+        return None, None
+    if len(out) > _MAX_IGNORE_TOKENS:
+        return None, f"Too many ignore-layer tokens (max {_MAX_IGNORE_TOKENS})."
+    return ",".join(out), None
+
+
+def validate_layer_config(raw: str | None) -> tuple[str | None, str | None]:
+    """Syntactically validate a mixed-precision ``layer_config`` string.
+
+    Accepts auto-round's relaxed JSON, e.g.
+    ``{block_sparse_moe.experts:{bits:4,data_type:mx_fp}}``. This is a sanity
+    check only (balanced braces + safe charset); auto-round performs the real
+    parse via ``parse_layer_config_arg`` at quantization time.
+
+    Returns ``(normalized, error)`` with exactly one non-None.
+    """
+    if raw is None:
+        return None, None
+    text = raw.strip()
+    if text == "":
+        return None, None
+    if len(text) > _MAX_LAYER_CONFIG_LEN:
+        return None, f"layer_config too long (max {_MAX_LAYER_CONFIG_LEN} chars)."
+    if not (text.startswith("{") and text.endswith("}")):
+        return None, "layer_config must be a JSON-like object wrapped in { }."
+    if not _LAYER_CONFIG_RE.match(text):
+        return None, (
+            "layer_config contains disallowed characters. Use only module names, "
+            "digits, and { } : , . _ - (e.g. {experts:{bits:4,data_type:mx_fp}})."
+        )
+    # Balanced-brace check
+    depth = 0
+    for ch in text:
+        if ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+            if depth < 0:
+                return None, "layer_config has unbalanced braces."
+    if depth != 0:
+        return None, "layer_config has unbalanced braces."
+    return text, None
+
 # Reverse lookup: display name → short name
 _GPU_DISPLAY_TO_SHORT: dict[str, str] = {v: k for k, v in GPU_DISPLAY_NAMES.items()}
 

src/submission/model_analysis.py

@@ -0,0 +1,295 @@
+# Copyright and license: follows the repository's existing convention.
+"""Download-free model structure & parameter analysis for quantization planning.
+
+Given a HuggingFace model id, this inspects the model's ``config.json`` and the
+**safetensors headers only** (no weight download) to produce:
+
+* a per-category parameter distribution (MoE experts, shared experts, attention,
+  router/gate, dense MLP, lm_head, embeddings, vision, norms, …), matching the
+  format of the mixed-precision reference docs, and
+* recommended ``ignore_layers`` / mixed-precision ``layer_config`` presets a user
+  can drop straight into the advanced submission fields.
+
+The heavy lifting uses ``huggingface_hub.get_safetensors_metadata`` which reads
+only the safetensors headers (tensor name + shape + dtype), so even trillion-param
+models are analyzed without downloading weights.
+"""
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass, field
+
+from huggingface_hub import get_safetensors_metadata
+from transformers import AutoConfig
+
+logger = logging.getLogger(__name__)
+
+# Collapse per-layer indices so ``...layers.12.self_attn.q_proj.weight`` and
+# ``...layers.0.self_attn.q_proj.weight`` bucket together.
+_LAYER_IDX_RE = re.compile(r"\.\d+\.")
+
+
+@dataclass
+class CategoryStat:
+    name: str
+    params: int = 0
+    tensors_2d: int = 0
+    tensors_total: int = 0
+
+
+@dataclass
+class ModelAnalysis:
+    model_id: str
+    ok: bool = True
+    error: str | None = None
+    architectures: list[str] = field(default_factory=list)
+    model_type: str = ""
+    hidden_size: int | None = None
+    num_layers: int | None = None
+    num_experts: int | None = None
+    vocab_size: int | None = None
+    total_params: int = 0
+    is_moe: bool = False
+    has_shared_experts: bool = False
+    has_attn_indexer: bool = False
+    has_vision: bool = False
+    approximate: bool = False
+    categories: list[CategoryStat] = field(default_factory=list)
+    recommended_ignore_layers: str = ""
+    recommended_layer_config: str = ""
+
+
+# ── Categorization ────────────────────────────────────────────────────────
+# Order matters: the first matching rule wins. Each rule is (category, predicate).
+def _categorize(norm_name: str) -> str:
+    n = norm_name
+    # Routers / gates first (must beat gate_proj which is a normal MLP proj).
+    if (".gate." in n or n.endswith(".gate") or n.endswith(".gate.weight")
+            or ".router" in n or n.endswith(".router")) and "gate_proj" not in n and "gate_up_proj" not in n:
+        return "router_gate"
+    if "shared_expert" in n:
+        return "shared_experts"
+    if ".experts." in n or n.endswith(".experts") or ".block_sparse_moe.experts" in n:
+        return "moe_experts"
+    if "vision" in n or "visual" in n or "vit" in n:
+        return "vision"
+    if "lm_head" in n:
+        return "lm_head"
+    if "embed" in n or "wte" in n or "word_embeddings" in n:
+        return "embeddings"
+    if "self_attn" in n or ".attn." in n or "attention" in n:
+        if "index" in n or "indexer" in n:
+            return "attn_indexer"
+        if "norm" in n:
+            return "norm"
+        return "self_attn"
+    if "mtp" in n:
+        return "mtp"
+    if "projector" in n or "patch_merge" in n or "multi_modal" in n:
+        return "projector"
+    if "mlp" in n or "feed_forward" in n or "ffn" in n:
+        return "dense_mlp"
+    if "norm" in n or "layernorm" in n or "ln_" in n:
+        return "norm"
+    return "other"
+
+
+_CATEGORY_ORDER = [
+    "moe_experts", "shared_experts", "dense_mlp", "self_attn", "attn_indexer",
+    "router_gate", "mtp", "vision", "projector", "lm_head", "embeddings",
+    "norm", "other",
+]
+
+_CATEGORY_LABELS = {
+    "moe_experts": "MoE routed experts",
+    "shared_experts": "MoE shared experts",
+    "dense_mlp": "Dense MLP",
+    "self_attn": "Attention (q/k/v/o)",
+    "attn_indexer": "Attention indexer (sparse)",
+    "router_gate": "Router / gate",
+    "mtp": "MTP module",
+    "vision": "Vision tower",
+    "projector": "Projector / merger",
+    "lm_head": "lm_head",
+    "embeddings": "Embeddings",
+    "norm": "Norms (1D, auto-skipped)",
+    "other": "Other",
+}
+
+
+def _cfg_get(cfg, *attrs, default=None):
+    """Read the first present attribute from a config or its nested text_config."""
+    sources = [cfg]
+    if hasattr(cfg, "text_config") and cfg.text_config is not None:
+        sources.append(cfg.text_config)
+    for src in sources:
+        for a in attrs:
+            v = getattr(src, a, None)
+            if v is not None:
+                return v
+    return default
+
+
+def analyze_model_structure(model_id: str, revision: str = "main", token: str | None = None) -> ModelAnalysis:
+    """Analyze *model_id* without downloading weights. Never raises."""
+    res = ModelAnalysis(model_id=model_id)
+
+    # 1. Config (best-effort; some fields inform MoE detection & the report).
+    try:
+        cfg = AutoConfig.from_pretrained(model_id, revision=revision, token=token, trust_remote_code=True)
+        arch = getattr(cfg, "architectures", None) or []
+        res.architectures = list(arch)
+        res.model_type = getattr(cfg, "model_type", "") or ""
+        res.hidden_size = _cfg_get(cfg, "hidden_size", "n_embd", "d_model")
+        res.num_layers = _cfg_get(cfg, "num_hidden_layers", "n_layer", "num_layers")
+        res.num_experts = _cfg_get(cfg, "num_experts", "num_local_experts", "n_routed_experts", "moe_num_experts")
+        res.vocab_size = _cfg_get(cfg, "vocab_size")
+    except Exception as e:
+        logger.warning("[analyze] config load failed for %s: %s", model_id, e)
+
+    # 2. Per-tensor metadata from safetensors headers (no weight download).
+    try:
+        meta = get_safetensors_metadata(model_id, revision=revision, token=token)
+    except Exception as e:
+        res.ok = False
+        res.error = (
+            f"Could not read safetensors metadata: {e}. "
+            "The model may lack safetensors (e.g. GGUF/pytorch_model.bin) or be gated/private."
+        )
+        return res
+
+    # Map filename → {tensor_name: TensorInfo} for shapes/dtypes/param counts.
+    cats: dict[str, CategoryStat] = {c: CategoryStat(c) for c in _CATEGORY_ORDER}
+    total = 0
+    for fname, fmeta in (meta.files_metadata or {}).items():
+        for tname, tinfo in (fmeta.tensors or {}).items():
+            pc = int(getattr(tinfo, "parameter_count", 0) or 0)
+            shape = list(getattr(tinfo, "shape", []) or [])
+            norm = _LAYER_IDX_RE.sub(".N.", tname)
+            cat = _categorize(norm)
+            cs = cats[cat]
+            cs.params += pc
+            cs.tensors_total += 1
+            if len(shape) == 2:
+                cs.tensors_2d += 1
+            total += pc
+
+    res.total_params = total
+    res.categories = [cats[c] for c in _CATEGORY_ORDER if cats[c].tensors_total > 0]
+
+    # 3. Derived traits.
+    res.is_moe = cats["moe_experts"].tensors_total > 0 or bool(res.num_experts)
+    res.has_shared_experts = cats["shared_experts"].tensors_total > 0
+    res.has_attn_indexer = cats["attn_indexer"].tensors_total > 0
+    res.has_vision = cats["vision"].tensors_total > 0
+
+    # 4. Recommendations.
+    res.recommended_ignore_layers, res.recommended_layer_config = _recommend(res, cats)
+    return res
+
+
+def _recommend(res: ModelAnalysis, cats: dict[str, CategoryStat]) -> tuple[str, str]:
+    """Produce a recommended ignore_layers list + mixed-precision layer_config.
+
+    Heuristic (from the reference mixed-precision docs):
+      * Always skip/ignore: lm_head, embeddings (type-skipped), router/gate, norms (1D).
+      * Vision tower, projectors, attention indexer → ignore (keep bf16).
+      * MoE routed experts → low-bit (MXFP4); shared experts → higher precision
+        via layer_config (MXFP8) when present.
+    """
+    ignore: list[str] = []
+    if cats["lm_head"].tensors_total:
+        ignore.append("lm_head")
+    if cats["router_gate"].tensors_total:
+        # Common router names; users can trim to their model's exact name.
+        ignore.append("gate")
+    if cats["vision"].tensors_total:
+        ignore.append("vision_tower")
+    if cats["projector"].tensors_total:
+        ignore.append("multi_modal_projector")
+        ignore.append("patch_merge")
+    if cats["attn_indexer"].tensors_total:
+        ignore.append("indexer")
+    # Deduplicate, preserve order.
+    seen = set()
+    ignore = [x for x in ignore if not (x in seen or seen.add(x))]
+
+    layer_config = ""
+    if res.is_moe and cats["moe_experts"].tensors_total:
+        # Route the routed experts to MXFP4; leave the rest at the global scheme.
+        # 'experts' matches routed experts without touching 'shared_experts'.
+        layer_config = "{experts:{bits:4,data_type:mx_fp}}"
+
+    return ",".join(ignore), layer_config
+
+
+# ── Markdown rendering ─────────────────────────────────────────────────────
+def _fmt_b(params: int) -> str:
+    if params >= 1e9:
+        return f"{params / 1e9:.2f} B"
+    if params >= 1e6:
+        return f"{params / 1e6:.2f} M"
+    return str(params)
+
+
+def render_analysis_markdown(res: ModelAnalysis) -> str:
+    if not res.ok:
+        return f"### ⚠️ Model structure analysis failed\n\n{res.error}"
+
+    lines: list[str] = []
+    lines.append(f"### 🔍 Model structure — `{res.model_id}`\n")
+
+    # Overview
+    lines.append("| Field | Value |")
+    lines.append("|---|---|")
+    if res.architectures:
+        lines.append(f"| Architecture | `{', '.join(res.architectures)}` |")
+    if res.model_type:
+        lines.append(f"| model_type | `{res.model_type}` |")
+    lines.append(f"| Total parameters (measured) | **{_fmt_b(res.total_params)}** |")
+    if res.num_layers is not None:
+        lines.append(f"| Layers | {res.num_layers} |")
+    if res.num_experts:
+        lines.append(f"| Experts | {res.num_experts} |")
+    if res.hidden_size is not None:
+        lines.append(f"| hidden_size | {res.hidden_size} |")
+    if res.vocab_size is not None:
+        lines.append(f"| vocab_size | {res.vocab_size} |")
+    traits = []
+    if res.is_moe:
+        traits.append("MoE")
+    if res.has_shared_experts:
+        traits.append("shared-experts")
+    if res.has_attn_indexer:
+        traits.append("sparse-attn-indexer")
+    if res.has_vision:
+        traits.append("vision")
+    if traits:
+        lines.append(f"| Traits | {', '.join(traits)} |")
+    lines.append("")
+
+    # Parameter distribution
+    lines.append("#### Parameter distribution by module category\n")
+    lines.append("| Category | Params | Share | 2D-linear tensors |")
+    lines.append("|---|---:|---:|---:|")
+    total = res.total_params or 1
+    for cs in sorted(res.categories, key=lambda c: c.params, reverse=True):
+        share = 100.0 * cs.params / total
+        label = _CATEGORY_LABELS.get(cs.name, cs.name)
+        lines.append(f"| {label} | {_fmt_b(cs.params)} | {share:.2f}% | {cs.tensors_2d} |")
+    lines.append("")
+
+    # Recommendations
+    lines.append("#### Recommended quantization controls\n")
+    if res.recommended_ignore_layers:
+        lines.append(f"- **Ignore Layers:** `{res.recommended_ignore_layers}`")
+    else:
+        lines.append("- **Ignore Layers:** *(defaults are fine — nothing extra to skip)*")
+    if res.recommended_layer_config:
+        lines.append(f"- **Layer Config (mixed precision):** `{res.recommended_layer_config}`")
+        lines.append("  - routes MoE routed experts to MXFP4 while the rest stay at the global scheme.")
+    lines.append("")
+    lines.append("> These are suggestions — review against your model's exact module names before submitting. "
+                 "Norms (1D) and embeddings are skipped automatically by AutoRound.")
+    return "\n".join(lines)

src/submission/submit.py

@@ -722,6 +722,9 @@ def add_new_quant(
     gpu_count_override: int | None = None,
     container_disk_size: str | None = None,
     cuda_visible_devices: str | None = None,
+    export_format: str | None = None,
+    ignore_layers: str | None = None,
+    layer_config: str | None = None,
     submitted_by: str = "",
     submitted_orgs: list[str] | None = None,
     user_token: str | None = None,
@@ -964,6 +967,12 @@ def add_new_quant(
     }
     if container_disk_size:
         quant_entry["container_disk_size"] = container_disk_size
+    if export_format:
+        quant_entry["export_format"] = export_format
+    if ignore_layers:
+        quant_entry["ignore_layers"] = ignore_layers
+    if layer_config:
+        quant_entry["layer_config"] = layer_config
     _apply_b200_local_fields(quant_entry, quant_gpu_type, cuda_visible_devices)
 
     supplementary = _get_supplementary_info(