Fall back to summed tensor element counts for params

Many GGUFs omit general.parameter_count, leaving params at 0 and
blocking the compute step with "incomplete architecture". Sum the
product of tensor dims from the GGUF tensor-info section and use it
as a params fallback when the explicit field is missing.

- parse_header_with_tensors: parse metadata + walk tensor infos,
returning (meta, total_elems) or -1 if the tensor section is
unreachable in the buffer.
- metadata_to_arch takes total_tensor_elems and falls back to it.
- Bump the range read from 1 MiB to 32 MiB (tokenizer-heavy GGUFs push
the tensor section past 10 MiB); parse_hf_range retries once at
64 MiB if the first read can't reach the tensors.

Verified against DavidAU/Qwen3.6-27B-... (26.90B) and
jcbtc/chadrock3.6-27B-... (27.32B) — both now auto-populate params.
Three new tests.

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

tests/test_vramcalc.py

@@ -16,7 +16,7 @@ from vramcalc import (
     format_bytes,
 )
 from vramcalc.presets import PRESETS
-from vramcalc.gguf import parse_header_bytes, metadata_to_arch
+from vramcalc.gguf import parse_header_bytes, parse_header_with_tensors, metadata_to_arch
 
 
 def test_quant_table_has_common_types():
@@ -320,4 +320,85 @@ def test_gguf_parse_header_includes_general_name():
     meta = parse_header_bytes(buf)
     arch = metadata_to_arch(meta)
     assert arch.name == "Test Model"
-    assert arch.architecture == "qwen35"
+    assert arch.architecture == "qwen35"
+
+
+def test_gguf_params_fallback_from_tensor_elems():
+    # No general.parameter_count; metadata_to_arch should fall back to summed
+    # tensor element counts.
+    import struct
+
+    def s(x): return x.encode("utf-8")
+    buf = b""
+    buf += struct.pack("<I", 0x46554747)  # GGUF
+    buf += struct.pack("<I", 3)           # version
+    buf += struct.pack("<Q", 2)           # tensor_count = 2
+    buf += struct.pack("<Q", 1)           # kv_count = 1
+    # kv: "general.architecture" = "llama"
+    k = s("general.architecture")
+    buf += struct.pack("<Q", len(k)) + k
+    buf += struct.pack("<I", 8)
+    v = s("llama")
+    buf += struct.pack("<Q", len(v)) + v
+    # tensor 1: name "t1", 2 dims (4, 8) -> 32 elems
+    n1 = s("t1")
+    buf += struct.pack("<Q", len(n1)) + n1
+    buf += struct.pack("<I", 2)           # n_dims
+    buf += struct.pack("<Q", 4)
+    buf += struct.pack("<Q", 8)
+    buf += struct.pack("<I", 0)           # dtype F32
+    buf += struct.pack("<Q", 0)           # offset
+    # tensor 2: name "t2", 1 dim (68) -> 68 elems
+    n2 = s("t2")
+    buf += struct.pack("<Q", len(n2)) + n2
+    buf += struct.pack("<I", 1)
+    buf += struct.pack("<Q", 68)
+    buf += struct.pack("<I", 0)
+    buf += struct.pack("<Q", 32)
+    meta, total = parse_header_with_tensors(buf)
+    assert total == 32 + 68
+    arch = metadata_to_arch(meta, total)
+    # no general.parameter_count -> fallback kicks in
+    assert arch.params == 100
+
+
+def test_gguf_params_prefers_explicit_parameter_count():
+    # When general.parameter_count is present, it wins over the tensor sum.
+    import struct
+
+    def s(x): return x.encode("utf-8")
+    buf = b""
+    buf += struct.pack("<I", 0x46554747)  # GGUF
+    buf += struct.pack("<I", 3)           # version
+    buf += struct.pack("<Q", 0)           # tensor_count
+    buf += struct.pack("<Q", 1)           # kv_count
+    k = s("general.parameter_count")
+    buf += struct.pack("<Q", len(k)) + k
+    buf += struct.pack("<I", 10)          # UINT64
+    buf += struct.pack("<Q", 7_000_000_000)
+    meta, total = parse_header_with_tensors(buf)
+    assert meta["general.parameter_count"] == 7_000_000_000
+    arch = metadata_to_arch(meta, total_tensor_elems=123)  # fallback ignored
+    assert arch.params == 7_000_000_000
+
+
+def test_gguf_tensor_section_unreachable_returns_minus_one():
+    # Buffer too small to reach the tensor section -> total == -1, no fallback.
+    import struct
+
+    def s(x): return x.encode("utf-8")
+    buf = b""
+    buf += struct.pack("<I", 0x46554747)
+    buf += struct.pack("<I", 3)
+    buf += struct.pack("<Q", 3)           # tensor_count > 0
+    buf += struct.pack("<Q", 1)           # kv_count
+    k = s("general.architecture")
+    buf += struct.pack("<Q", len(k)) + k
+    buf += struct.pack("<I", 8)
+    v = s("llama")
+    buf += struct.pack("<Q", len(v)) + v
+    # truncate so the tensor section is unreachable (don't append tensors)
+    meta, total = parse_header_with_tensors(buf)
+    assert total == -1
+    arch = metadata_to_arch(meta, total)
+    assert arch.params == 0  # negative fallback is treated as no fallback

vramcalc/__init__.py

@@ -10,6 +10,7 @@ from .gpu import GpuBudget, gpu_split, fit_gpus, GpuSplitResult
 from .gguf import (
     GGUFMetadata,
     parse_header_bytes,
+    parse_header_with_tensors,
     parse_local_file,
     parse_hf_range,
     metadata_to_arch,
@@ -38,6 +39,7 @@ __all__ = [
     "fit_gpus",
     "GGUFMetadata",
     "parse_header_bytes",
+    "parse_header_with_tensors",
     "parse_local_file",
     "parse_hf_range",
     "metadata_to_arch",

vramcalc/gguf.py

@@ -146,6 +146,64 @@ def parse_header_bytes(buf: bytes) -> dict[str, object]:
     return meta
 
 
+def parse_header_with_tensors(buf: bytes):
+    """Parse metadata KV and sum tensor element counts from the header.
+
+    Returns (meta_dict, total_tensor_elems). The tensor-info section follows
+    the metadata: each tensor is name(str) + n_dims(u32) + dims[n](u64) +
+    dtype(u32) + offset(u64). We sum product(dims) across all tensors. The
+    buffer must cover the metadata *and* the full tensor-info section for the
+    sum to be correct — tokenizer-heavy GGUFs push the tensor section past
+    10 MiB, so callers should read >= ~32 MiB. If the read is too small to
+    reach the tensor section we return -1 (unreachable) so callers can tell
+    "incomplete" from "zero tensors".
+
+    Used as a fallback for `params` when general.parameter_count is absent.
+    """
+    r = _Reader(buf)
+    magic = r.u32()
+    if magic != GGUF_MAGIC:
+        raise ValueError(f"not a GGUF file (magic={magic:#x})")
+    version = r.u32()
+    if version < 1 or version > 3:
+        raise ValueError(f"unsupported GGUF version {version}")
+    tensor_count = r.u64()
+    kv_count = r.u64()
+    meta: dict[str, object] = {}
+    for _ in range(kv_count):
+        if r.eof():
+            return meta, 0
+        key = r.string()
+        t = r.u32()
+        try:
+            meta[key] = r.value(t)
+        except (EOFError, ValueError):
+            # ran out of buffer in metadata; tensor section unreachable
+            return meta, 0
+    total = 0
+    parsed = 0
+    for _ in range(tensor_count):
+        if r.eof():
+            break
+        try:
+            r.string()                 # tensor name
+            n_dims = r.u32()
+            elems = 1
+            for _ in range(n_dims):
+                elems *= r.u64()       # dims multiply, not add
+            total += elems
+            r.u32()                    # dtype
+            r.u64()                    # data offset
+            parsed += 1
+        except (EOFError, ValueError):
+            break
+    # If we couldn't reach any tensor infos, signal failure with -1 so callers
+    # can distinguish "unreachable" from "0 tensors".
+    if parsed == 0 and tensor_count > 0:
+        return meta, -1
+    return meta, total
+
+
 def _coerce_int(v: object) -> int:
     if isinstance(v, bool):
         return int(v)
@@ -160,8 +218,16 @@ def _coerce_float(v: object) -> float:
     return 0.0
 
 
-def metadata_to_arch(meta: dict[str, object]) -> GGUFMetadata:
-    """Project raw GGUF metadata into the architecture fields we need."""
+def metadata_to_arch(
+    meta: dict[str, object], total_tensor_elems: int | None = None
+) -> GGUFMetadata:
+    """Project raw GGUF metadata into the architecture fields we need.
+
+    `total_tensor_elems` (from parse_header_with_tensors) is used as a fallback
+    for `params` when general.parameter_count is absent. A negative value means
+    the tensor section was unreachable (range read too small); treat as no
+    fallback.
+    """
     arch_name = str(meta.get("general.architecture", "") or "")
     p = f"{arch_name}." if arch_name else ""
 
@@ -183,22 +249,26 @@ def metadata_to_arch(meta: dict[str, object]) -> GGUFMetadata:
     m.n_expert_used = _coerce_int(g("expert_used_count"))
     # MTP: not always in GGUF metadata; leave 0 unless present
     m.n_mtp = _coerce_int(g("mtp.count") or g("n_mtp"))
-    # parameter count
+    # parameter count: prefer general.parameter_count; fall back to summed
+    # tensor element counts when the GGUF omits it (many GGUFs do).
     m.params = _coerce_int(meta.get("general.parameter_count", 0))
+    if not m.params and total_tensor_elems and total_tensor_elems > 0:
+        m.params = int(total_tensor_elems)
     return m
 
 
-def parse_local_file(path: str, max_bytes: int = 1 << 20) -> GGUFMetadata:
+def parse_local_file(path: str, max_bytes: int = 1 << 25) -> GGUFMetadata:
     with open(path, "rb") as f:
         buf = f.read(max_bytes)
-    return metadata_to_arch(parse_header_bytes(buf))
+    meta, total = parse_header_with_tensors(buf)
+    return metadata_to_arch(meta, total)
 
 
 def parse_hf_range(
     repo_id: str,
     filename: str,
     *,
-    max_bytes: int = 1 << 20,
+    max_bytes: int = 1 << 25,
     token: str | None = None,
     revision: str = "main",
     timeout: float = 30.0,
@@ -206,7 +276,10 @@ def parse_hf_range(
     """Range-read the first `max_bytes` of a GGUF file from the HF Hub.
 
     Uses a HTTP Range request against the resolve URL so we never download the
-    full model. Requires the `requests` package.
+    full model. Requires the `requests` package. Reads up to 32 MiB of the
+    header by default (enough to cover tokenizer-heavy metadata plus the full
+    tensor-info section, so we can sum tensor element counts as a params
+    fallback when general.parameter_count is absent).
     """
     import requests
 
@@ -217,4 +290,13 @@ def parse_hf_range(
     resp = requests.get(url, headers=headers, timeout=timeout, stream=True)
     resp.raise_for_status()
     buf = resp.content
-    return metadata_to_arch(parse_header_bytes(buf))
+    meta, total = parse_header_with_tensors(buf)
+    # If the read was too small to reach the tensor section, retry once with a
+    # larger read so the params fallback can work for tokenizer-heavy GGUFs.
+    if not meta.get("general.parameter_count") and total == -1:
+        big = 1 << 26  # 64 MiB
+        headers["Range"] = f"bytes=0-{big - 1}"
+        resp = requests.get(url, headers=headers, timeout=timeout, stream=True)
+        resp.raise_for_status()
+        meta, total = parse_header_with_tensors(resp.content)
+    return metadata_to_arch(meta, total)