Recognize ROCmFP4/ROCmFPX GGUF quants

These are AMD ROCm floating-point block-quant formats from the
ciru-ai/ROCmFPX fork; stock llama.cpp cannot run them. Add their
effective bits-per-weight to the quant table (4.34 for ROCmFP4,
7.08 for ROCmFPX), derived from the real chadrock3.6 GGUF file
sizes (reproduces 14.82 GiB / 31.42 GiB within rounding).

quant_from_filename already matches the longer names first, so
the chadrock filenames resolve to ROCmFP4/ROCmFPX correctly.
command_preview switches to the rocmfpx-llama-server runner and
adds a note that the pinned ROCmFPX build is required. The UI
fetch handler now syncs the Quantization dropdown to the quant
detected from the chosen GGUF filename. Four new tests.

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -60,25 +60,41 @@ def list_gguf_files(repo_id: str, hf_token: str):
 
 
 def fetch_arch(repo_id: str, filename: str, hf_token: str):
-    """Range-read a GGUF header from HF and return editable arch fields."""
+    """Range-read a GGUF header from HF and return editable arch fields.
+
+    Also returns a gr.update for the Quantization dropdown that syncs it to the
+    quant detected from the filename (e.g. ROCmFP4/ROCmFPX) — a no-op when the
+    filename has no recognized quant token, so the user's manual pick is kept.
+    The GGUF header's tensor types for ROCm formats use custom IDs stock
+    llama.cpp does not map, so the filename is the reliable source here.
+    """
+    detected = quant_from_filename(filename) if filename else None
+    if detected and detected not in QUANT_CHOICES:
+        detected = None
+    quant_update = gr.update(value=detected) if detected else gr.update()
     if not repo_id or not filename:
-        return _empty_arch_fields(), "Pick a GGUF file first."
+        return _empty_arch_fields(), "Pick a GGUF file first.", quant_update
     try:
         meta = parse_hf_range(
             repo_id.strip(), filename, token=hf_token or None
         )
     except Exception as e:  # noqa: BLE001
-        return _empty_arch_fields(), f"Error reading GGUF header: {e}"
+        return _empty_arch_fields(), f"Error reading GGUF header: {e}", quant_update
+    quant_note = f", quant {detected}" if detected else ""
     if not meta.n_layer:
-        return _arch_to_fields(meta), (
+        return (
+            _arch_to_fields(meta),
             "Parsed header but architecture fields look empty; "
-            "edit them manually below."
+            "edit them manually below.",
+            quant_update,
         )
-    return _arch_to_fields(meta), (
+    return (
+        _arch_to_fields(meta),
         f"Fetched {meta.architecture or 'model'}: "
         f"{meta.n_layer} layers, {meta.n_embd} embd, "
         f"{meta.n_head}/{meta.n_head_kv} heads, ctx {meta.training_ctx}, "
-        f"params {meta.params or 'n/a'}."
+        f"params {meta.params or 'n/a'}{quant_note}.",
+        quant_update,
     )
 
 
@@ -354,7 +370,7 @@ def build_ui():
         )
         fetch_btn.click(
             fn=fetch_arch, inputs=[repo_id, file_picker, hf_token],
-            outputs=[*arch_inputs, fetch_status],
+            outputs=[*arch_inputs, fetch_status, quant],
         ).then(
             fn=_store_arch, inputs=arch_inputs, outputs=arch_state
         )

tests/test_vramcalc.py

@@ -24,6 +24,11 @@ def test_quant_table_has_common_types():
         assert q in QUANT_BPW
 
 
+def test_quant_table_has_rocmfp_types():
+    for q in ["ROCmFP4", "ROCmFPX"]:
+        assert q in QUANT_BPW
+
+
 def test_quant_from_filename():
     assert quant_from_filename("Llama-3-8B-Instruct-Q4_K_M.gguf") == "Q4_K_M"
     assert quant_from_filename("model.Q5_K_S.gguf") == "Q5_K_S"
@@ -32,6 +37,25 @@ def test_quant_from_filename():
     assert quant_from_filename("model.gguf") is None
 
 
+def test_quant_from_filename_rocmfp():
+    # Real chadrock filenames — case-insensitive token match.
+    assert quant_from_filename(
+        "CHADROCK3.6-27B-Coder-MTP-ROCmFP4-STRIX_LEAN.gguf"
+    ) == "ROCmFP4"
+    assert quant_from_filename(
+        "CHADROCK3.6-35B-A3B-Coder-MTP-ROCmFPX-MoEQuality-7.08BPW.gguf"
+    ) == "ROCmFPX"
+    # plain ROCm with no FP version must not falsely match ROCmFP4/FPX
+    assert quant_from_filename("model-ROCM.gguf") is None
+
+
+def test_weight_bytes_rocmfp4_matches_real_file():
+    # 27B Strix Lean: 14,817,251,680 bytes for 27,320,697,856 tensor elems.
+    # Effective bpw from the real file -> weight estimate reproduces file size.
+    b = weight_bytes(27_320_697_856, "ROCmFP4")
+    assert 14.6e9 < b < 15.0e9  # ~14.82 GiB file size
+
+
 def test_weight_bytes():
     # 8B params at Q4_K_M (4.84375 bpw) -> ~4.84 GB
     b = weight_bytes(8_000_000_000, "Q4_K_M")
@@ -224,6 +248,17 @@ def test_command_preview_yarn_when_target_exceeds():
     assert "--rope-freq-scale 0.5" in cmd
 
 
+def test_command_preview_rocmfp_uses_custom_runner():
+    arch = PRESETS["Llama-3 8B"]
+    from vramcalc import Inputs
+    for q in ("ROCmFP4", "ROCmFPX"):
+        cmd = command_preview(arch, Inputs(quant=q, n_ctx=8192,
+                                           gpu_vram_gb=[24.0]))
+        # custom runner, not stock llama-server
+        assert cmd.startswith("rocmfpx-llama-server")
+        assert "ROCmFPX" in cmd  # warning note present
+
+
 def test_format_bytes():
     assert "GiB" in format_bytes(5 << 30)
     assert "MiB" in format_bytes(5 << 20)

vramcalc/quant.py

@@ -48,6 +48,17 @@ QUANT_BPW: dict[str, float] = {
     "F16": 16.0,
     "BF16": 16.0,
     "F32": 32.0,
+    # AMD ROCm floating-point block quants (ciru-ai/ROCmFPX fork types).
+    # These are *effective* bits-per-weight = real_file_size * 8 / total_params,
+    # measured from the jcbtc/chadrock3.6 ROCmFP4/FPX GGUFs. They are higher than
+    # the nominal 4.0/8.0 because the typical model is a hybrid attention+SSM
+    # (Mamba) qwen35 with co-stored F32 state/conv tensors and mixed tensor types
+    # (the 35B FPX file is mostly Q6_K experts + ROCmFPX attention). Using the
+    # effective BPW reproduces the real file size, which is what a VRAM estimate
+    # needs. NOTE: stock llama.cpp cannot run these — they require the pinned
+    # ciru-ai/ROCmFPX runner; see command_preview for the warning.
+    "ROCmFP4": 4.34,   # 27B Strix Lean: 14.82 GB / 27.32B params
+    "ROCmFPX": 7.08,   # 35B A3B MoEQuality: model card states 7.08 BPW
 }
 
 

vramcalc/report.py

@@ -160,9 +160,17 @@ def format_bytes(n: float) -> str:
     return f"{n:.0f} B"
 
 
+# AMD ROCm floating-point block quants that stock llama.cpp cannot run. They
+# require the pinned ciru-ai/ROCmFPX runner (see
+# https://github.com/ciru-ai/ROCmFPX). Listed so command_preview can flag it.
+ROCMFP_QUANTS = {"ROCmFP4", "ROCmFPX"}
+
+
 def command_preview(arch: ModelArch, inp: Inputs) -> str:
     """Generate a llama.cpp launch command from the current inputs."""
-    parts = ["llama-server"]
+    is_rocmfp = inp.quant in ROCMFP_QUANTS
+    runner = "rocmfpx-llama-server" if is_rocmfp else "llama-server"
+    parts = [runner]
     parts.append(f"-m model-{inp.quant}.gguf")
     parts.append(f"-c {inp.n_ctx}")
     parts.append("-ngl 999")  # full offload assumption
@@ -196,4 +204,9 @@ def command_preview(arch: ModelArch, inp: Inputs) -> str:
         parts.extend(yarn_args)
     if arch.n_mtp > 0:
         parts.append(f"--mtp {arch.n_mtp}")
+    if is_rocmfp:
+        parts.append(
+            f"# NOTE: {inp.quant} needs the ciru-ai/ROCmFPX runner "
+            f"(stock llama.cpp cannot read these tensor types)."
+        )
     return " \\\n  ".join(parts)