update scheme.

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

app.py

@@ -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, analyze_model
+from src.app_helpers.submissions import submit_model, submit_quant, analyze_model, guard_method_scheme
 from src.app_helpers.zip_stream import register_routes as register_zip_route
 
 
@@ -520,9 +520,9 @@ with demo:
                         model_name_textbox = gr.Textbox(label="Model name", placeholder="org/model-name", elem_id="model-input-quant")
                     with gr.Column(scale=2):
                         compute_type = gr.Dropdown(
-                            choices=["MXFP4", "NVFP4", "INT4 (W4A16)"],
+                            choices=["MXFP4", "MXFP8", "NVFP4", "INT4 (W4A16)"],
                             label="Quantization Scheme",
-                            info='Follows the AutoRound approach. <a href="https://github.com/intel/auto-round" target="_blank" rel="noopener">See AutoRound for details ↗</a>',
+                            info='Global weight precision. Combine MXFP8 (global) + a Layer Config that overrides experts to MXFP4 for mixed precision. <a href="https://github.com/intel/auto-round" target="_blank" rel="noopener">See AutoRound for details ↗</a>',
                             multiselect=False,
                             value="INT4 (W4A16)",
                             interactive=True,
@@ -698,6 +698,18 @@ with demo:
                 outputs=[analysis_result_quant, ignore_layers_quant, layer_config_quant],
             )
 
+            # Keep Method compatible with Scheme (Model-Free only for weight-only schemes).
+            compute_type.change(
+                fn=guard_method_scheme,
+                inputs=[compute_type, quant_method],
+                outputs=[quant_method],
+            )
+            quant_method.change(
+                fn=guard_method_scheme,
+                inputs=[compute_type, quant_method],
+                outputs=[quant_method],
+            )
+
             with gr.Column():
                 with gr.Row(elem_classes=["filter-row"]):
                     my_submissions_quant_cb = gr.Checkbox(

src/app_helpers/submissions.py

@@ -24,6 +24,10 @@ from src.submission.model_analysis import analyze_model_structure, render_analys
 
 logger = logging.getLogger(__name__)
 
+# Wall-clock guard for the "Analyze Structure" button so the UI never hangs on a
+# pathologically large / slow-to-fetch safetensors index.
+ANALYZE_TIMEOUT_SEC = 90
+
 
 def _parse_model_size_input(model_size_input):
     """Parse an optional user-provided param count.
@@ -159,14 +163,32 @@ def analyze_model(model, ignore_current=None, layercfg_current=None,
     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.
+
+    A wall-clock timeout guards against pathologically large models whose
+    safetensors index is huge/slow to fetch (the UI must never hang).
     """
     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)
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex:
+            fut = ex.submit(analyze_model_structure, model.strip(), "main", token)
+            res = fut.result(timeout=ANALYZE_TIMEOUT_SEC)
         md = render_analysis_markdown(res)
+    except concurrent.futures.TimeoutError:
+        return (
+            gr.update(
+                value=(
+                    f"⏱️ Analysis timed out after {ANALYZE_TIMEOUT_SEC}s — this model's "
+                    "safetensors index is very large or the Hub is slow. Please retry, or "
+                    "define Ignore Layers / Layer Config manually."
+                ),
+                visible=True,
+            ),
+            gr.update(), gr.update(),
+        )
     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()
@@ -181,9 +203,24 @@ def analyze_model(model, ignore_current=None, layercfg_current=None,
     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()
+def guard_method_scheme(scheme_choice, method_choice):
+    """Proactively keep the Method compatible with the Scheme.
+
+    Model-Free only supports weight-only schemes (W4A16/MXFP4/MXFP8). If the user
+    picks an incompatible scheme (e.g. NVFP4) while Method is Model-Free, reset the
+    method to RTN and surface a non-blocking notice. Returns a ``gr.update`` for the
+    method dropdown. The authoritative check still runs server-side in ``submit_quant``.
+    """
+    if method_choice and "Model-Free" in method_choice and not is_model_free_supported_scheme(scheme_choice):
+        try:
+            gr.Info(f"Model-Free doesn't support {scheme_choice}; switched Method to RTN.")
+        except Exception:
+            pass
+        return gr.update(value="RTN (Round-To-Nearest)")
+    return gr.update()
+
+
+
 
 
 def _bail_with_error(message):

src/submission/check_validity.py

@@ -526,6 +526,15 @@ SUPPORTED_QUANT_SCHEMES: dict[str, QuantSchemeSpec] = {
         script="ITREX",
         detector=lambda cfg: (False, ""),   # input models are FP — no pre-quant detection
     ),
+    "MXFP8": QuantSchemeSpec(
+        name="MXFP8",
+        precision="8bit",
+        weight_dtype="mxfp8",
+        bits=8,
+        hardware="gpu",
+        script="ITREX",
+        detector=lambda cfg: (False, ""),   # input models are FP — no pre-quant detection
+    ),
     # ── Add future schemes here ──────────────────────────────────────
     # "INT8 (W8A16)": QuantSchemeSpec(
     #     name="INT8 (W8A16)", precision="8bit", weight_dtype="int8",

src/submission/model_analysis.py

@@ -10,32 +10,40 @@ Given a HuggingFace model id, this inspects the model's ``config.json`` and the
 * 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.
+The structure comes from the **safetensors index** (``model.safetensors.index.json``) —
+a single small JSON that lists every tensor name and its shard. No weights, shapes, or
+dtypes are downloaded, so even 100+ shard / trillion-param models are analyzed in seconds.
+Module types are inferred from tensor names (Linear / Embedding / Norm / Bias).
 """
 from __future__ import annotations
 
+import json
 import logging
 import re
 from dataclasses import dataclass, field
 
-from huggingface_hub import get_safetensors_metadata
+from huggingface_hub import HfApi, hf_hub_download
+from huggingface_hub.utils import EntryNotFoundError
 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.
+# Collapse per-layer AND per-expert indices so
+# ``...layers.12.mlp.experts.37.gate_proj.weight`` and
+# ``...layers.0.mlp.experts.5.gate_proj.weight`` bucket to one module.
 _LAYER_IDX_RE = re.compile(r"\.\d+\.")
+# Also collapse a trailing ``.<digits>`` (e.g. ``oe_embed_proj0`` style is rare;
+# handles names like ``...experts.37`` with no suffix).
+_TRAIL_IDX_RE = re.compile(r"\.\d+$")
 
 
 @dataclass
-class CategoryStat:
-    name: str
-    params: int = 0
-    tensors_2d: int = 0
-    tensors_total: int = 0
+class ModuleStat:
+    """One normalized module (layer/expert indices collapsed to N)."""
+    name: str            # e.g. "...layers.N.block_sparse_moe.experts.N.gate_proj"
+    category: str = ""
+    kind: str = ""       # "Linear" | "Embedding" | "Norm (1D)" | "Bias (1D)"
+    count: int = 0       # how many real tensors collapsed into this row
 
 
 @dataclass
@@ -49,13 +57,15 @@ class ModelAnalysis:
     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)
+    num_tensors: int = 0
+    modules: list[ModuleStat] = field(default_factory=list)
+    recommended_ignore_layers: str = ""
+    recommended_layer_config: str = ""
+    modules: list[ModuleStat] = field(default_factory=list)
     recommended_ignore_layers: str = ""
     recommended_layer_config: str = ""
 
@@ -148,91 +158,215 @@ def analyze_model_structure(model_id: str, revision: str = "main", token: str |
     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:
+    # 2. Tensor NAMES only — from the safetensors index (one small JSON), so even
+    #    194-shard / trillion-param models are analyzed in seconds. No weights, no
+    #    shapes/dtypes downloaded. Falls back to a single-file header for unsharded models.
+    names, err = _list_tensor_names(model_id, revision, token)
+    if err:
         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."
-        )
+        res.error = err
         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)
+    res.num_tensors = len(names)
+    mods: dict[str, ModuleStat] = {}
+    cat_present: set[str] = set()
+    for tname in names:
+        # Collapse layer + expert indices: any ".<digits>." and a trailing ".<digits>".
+        norm = _TRAIL_IDX_RE.sub(".N", _LAYER_IDX_RE.sub(".N.", tname))
+        cat = _categorize(norm)
+        cat_present.add(cat)
+        mkey = _module_key(norm)
+        ms = mods.get(mkey)
+        if ms is None:
+            ms = ModuleStat(name=mkey, category=cat, kind=_kind_from_name(mkey))
+            mods[mkey] = ms
+        ms.count += 1
+
+    # Order modules by category (structural grouping), then name — reads like the
+    # reference "model structure" table rather than a params ranking.
+    cat_rank = {c: i for i, c in enumerate(_CATEGORY_ORDER)}
+    res.modules = sorted(mods.values(), key=lambda m: (cat_rank.get(m.category, 99), m.name))
+
+    # 3. Derived traits (from names + config).
+    res.is_moe = ("moe_experts" in cat_present) or bool(res.num_experts)
+    res.has_shared_experts = "shared_experts" in cat_present
+    res.has_attn_indexer = "attn_indexer" in cat_present
+    res.has_vision = "vision" in cat_present
+
+    # 4. Suggested controls (optional; derived from REAL module names → precise substrings).
+    res.recommended_ignore_layers, res.recommended_layer_config = _recommend(res, cat_present, mods)
     return res
 
 
-def _recommend(res: ModelAnalysis, cats: dict[str, CategoryStat]) -> tuple[str, str]:
-    """Produce a recommended ignore_layers list + mixed-precision layer_config.
+def _list_tensor_names(model_id: str, revision: str, token: str | None):
+    """Return ``(names, error)`` — the model's tensor names without downloading weights.
+
+    Strategy (fast → fallback):
+      1. ``model.safetensors.index.json`` (sharded) → ``weight_map`` keys. One file.
+      2. a single ``*.safetensors`` file → read just its header via the HfApi.
+    Never downloads weight bytes.
+    """
+    api = HfApi(token=token)
+    # 1. Sharded index (covers the vast majority of large models).
+    for index_name in ("model.safetensors.index.json", "pytorch_model.bin.index.json"):
+        try:
+            path = hf_hub_download(model_id, index_name, revision=revision, token=token)
+            with open(path) as f:
+                data = json.load(f)
+            wm = data.get("weight_map") or {}
+            if wm:
+                return list(wm.keys()), None
+        except EntryNotFoundError:
+            continue
+        except Exception as e:
+            logger.warning("[analyze] index read failed for %s (%s): %s", model_id, index_name, e)
+
+    # 2. Single-file safetensors → header only.
+    try:
+        files = api.list_repo_files(model_id, revision=revision)
+        st_files = [f for f in files if f.endswith(".safetensors")]
+        if st_files:
+            meta = api.parse_safetensors_file_metadata(model_id, st_files[0], revision=revision)
+            return list((meta.tensors or {}).keys()), None
+        # No safetensors at all.
+        return [], (
+            "No safetensors found (model may be GGUF / pytorch_model.bin only). "
+            "Structure analysis needs a safetensors checkpoint."
+        )
+    except Exception as e:
+        return [], (
+            f"Could not read model index/metadata: {e}. "
+            "The model may be gated/private (log in) or lack safetensors."
+        )
+
+
+def _module_key(norm_name: str) -> str:
+    """Normalized tensor name → module key (drop trailing .weight/.bias/.scale)."""
+    for suf in (".weight", ".bias", ".weight_scale", ".weight_packed", ".scale", ".g_idx", ".qweight", ".qzeros", ".scales"):
+        if norm_name.endswith(suf):
+            return norm_name[: -len(suf)]
+    return norm_name
+
+
+def _kind_from_name(tname: str) -> str:
+    """Infer the module type from its name only (no shape needed).
+
+    Mirrors the human 'type' column in the reference structure tables.
+    """
+    n = tname.lower()
+    if "lm_head" in n:
+        return "Linear (head)"
+    if "embed" in n or "wte" in n or "word_embeddings" in n:
+        return "Embedding"
+    if n.endswith("_bias") or n.endswith(".bias") or "correction_bias" in n:
+        return "Bias (1D)"
+    if "norm" in n or "layernorm" in n or "ln_f" in n or "ln_1" in n or "ln_2" in n:
+        return "Norm (1D)"
+    # Everything else that carries weights is a Linear/projection in these models
+    # (q/k/v/o_proj, gate, experts w1/w2/w3, fc1/fc2, router classifier, …).
+    return "Linear"
+
+
+def _rel_name(module_key: str) -> str:
+    """Strip the model wrapper + the ``layers.N.`` prefix to get a substring a user
+    can paste into ignore_layers. e.g.
+    ``language_model.model.layers.N.block_sparse_moe.gate`` → ``block_sparse_moe.gate``.
+    """
+    key = module_key
+    for pre in ("language_model.model.", "language_model.", "model.model.", "model.", "transformer."):
+        if key.startswith(pre):
+            key = key[len(pre):]
+            break
+    # Drop everything up to and including the first ``layers.N.``
+    key = re.sub(r"^.*?layers\.N\.", "", key)
+    return key
+
+
+def _char_lcp(strings: list[str]) -> str:
+    """Character-level longest common prefix (used to fold sibling leaves into one
+    precise substring, e.g. self_attn.index_q_proj + self_attn.index_k_proj →
+    ``self_attn.index_``)."""
+    if not strings:
+        return ""
+    s1, s2 = min(strings), max(strings)
+    i = 0
+    while i < len(s1) and i < len(s2) and s1[i] == s2[i]:
+        i += 1
+    return s1[:i]
+
+
+def _ignore_token_for(category_keys: list[str]) -> str | None:
+    """Turn a category's real module keys into ONE precise ignore substring.
+
+    Uses the relative names (after ``layers.N.``); if there are several siblings,
+    a character-level common prefix yields a safe substring (never the bare last
+    segment like ``gate`` which would also hit ``gate_proj``).
+    """
+    rels = sorted({_rel_name(k) for k in category_keys})
+    rels = [r for r in rels if r]
+    if not rels:
+        return None
+    if len(rels) == 1:
+        return rels[0]
+    lcp = _char_lcp(rels)
+    # Require a reasonably specific prefix; otherwise just return the shortest name.
+    if len(lcp) >= 4:
+        return lcp
+    return min(rels, key=len)
+
+
+def _experts_layer_config_key(expert_keys: list[str]) -> str:
+    """Derive the precise ``layer_config`` key for routed experts from real names.
+
+    e.g. ``block_sparse_moe.experts.N.gate_proj`` → ``block_sparse_moe.experts``;
+    ``mlp.experts.N.gate_proj`` → ``mlp.experts``. Using ``<parent>.experts``
+    (not bare ``experts``) keeps it precise and never touches ``shared_experts``.
+    """
+    for k in expert_keys:
+        rel = _rel_name(k)
+        segs = rel.split(".")
+        for i, s in enumerate(segs):
+            if s == "experts":
+                return ".".join(segs[max(0, i - 1):i + 1]) if i > 0 else "experts"
+    return "experts"
+
+
+def _keys_in(mods: dict, category: str) -> list[str]:
+    return [k for k, m in mods.items() if m.category == category]
+
+
+def _recommend(res: ModelAnalysis, cat_present: set, mods: dict) -> tuple[str, str]:
+    """Produce suggested ignore_layers + mixed-precision layer_config using the
+    model's REAL module names, so the substrings are precise and safe.
+
+    Critical: never emit a bare last segment like ``gate`` — under auto-round's
+    substring matching that would also hit ``gate_proj`` (a dense-MLP projection).
+    We derive ``<parent>.gate`` / ``self_attn.index_`` etc. from actual names.
 
     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: lm_head, router/gate, vision tower, projectors, attention indexer.
+      * embeddings + norms are auto-skipped by AutoRound (not listed).
+      * MoE routed experts → MXFP4 via layer_config; the rest stay at the global scheme.
     """
     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")
+    for cat in ("lm_head", "router_gate", "vision", "projector", "attn_indexer"):
+        if cat in cat_present:
+            tok = _ignore_token_for(_keys_in(mods, cat))
+            if tok:
+                ignore.append(tok)
     # Deduplicate, preserve order.
-    seen = set()
+    seen: set[str] = 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}}"
+    if res.is_moe and "moe_experts" in cat_present:
+        key = _experts_layer_config_key(_keys_in(mods, "moe_experts"))
+        layer_config = f"{{{key}:{{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}"
@@ -247,7 +381,6 @@ def render_analysis_markdown(res: ModelAnalysis) -> str:
         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:
@@ -256,6 +389,7 @@ def render_analysis_markdown(res: ModelAnalysis) -> str:
         lines.append(f"| hidden_size | {res.hidden_size} |")
     if res.vocab_size is not None:
         lines.append(f"| vocab_size | {res.vocab_size} |")
+    lines.append(f"| Tensors (total) | {res.num_tensors} |")
     traits = []
     if res.is_moe:
         traits.append("MoE")
@@ -269,27 +403,33 @@ def render_analysis_markdown(res: ModelAnalysis) -> str:
         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} |")
+    # Module schema — the model's composition, grouped by category. Layer & expert
+    # indices are shown as `N`. These are the exact substrings a user pastes into
+    # Ignore Layers / Layer Config.
+    lines.append("#### Model structure — modules (normalized: layer & expert indices = `N`)\n")
+    lines.append("Use these names to craft **Ignore Layers** / **Layer Config** substrings.\n")
+    lines.append("| Module | Type | Category | Count |")
+    lines.append("|---|---|---|---:|")
+    _MAX_ROWS = 80
+    shown = res.modules[:_MAX_ROWS]
+    for ms in shown:
+        label = _CATEGORY_LABELS.get(ms.category, ms.category)
+        lines.append(f"| `{ms.name}` | {ms.kind} | {label} | {ms.count} |")
+    if len(res.modules) > _MAX_ROWS:
+        lines.append(f"| … | | | *(+{len(res.modules) - _MAX_ROWS} more)* |")
     lines.append("")
 
-    # Recommendations
-    lines.append("#### Recommended quantization controls\n")
+    # Suggested controls (optional; users can define their own from the table above)
+    lines.append("#### Suggested quantization controls (optional)\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)*")
+        lines.append("- **Ignore Layers:** *(nothing extra suggested — defaults are fine)*")
     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. "
+    lines.append("> Suggestions only — review against the module table above before submitting. "
                  "Norms (1D) and embeddings are skipped automatically by AutoRound.")
     return "\n".join(lines)
+