Lower RMSE, improve error shaping

hexstate_requantize.py

@@ -3,21 +3,15 @@
 HexState GGUF Re-Quantizer — GGUF-to-GGUF Q2_K quantization.
 
 Reads a source GGUF (F16/BF16/F32), copies all metadata verbatim,
-and re-quantizes eligible weight tensors to Q2_K using numpy.
+and re-quantizes eligible weight tensors to Q2_K.  When
+libhexstate_q2k.so is available, the C HExState optimizer is used for the
+Q2_K/Q4_0/Q8_0 paths; otherwise the numpy fallback is used.
 
 This bypasses the tokenizer parsing problem entirely — the source GGUF
 (from llama.cpp's convert_hf_to_gguf.py) has correct metadata.
 
 Usage:
     python3 hexstate_requantize.py input.gguf output.gguf
-
-ANALOG mode (minimises LAYER OUTPUT error instead of weight RMSE):
-    --hessian FILE.hxh     full X^T X per tensor (see write_hessian)
-    --analog-imatrix       diagonal Hessian from --imatrix (weaker, no new
-                           calibration needed)
-    --analog-sweeps N      coordinate-descent sweeps (default 8)
-
-  In ANALOG mode weight RMSE RISES by design. Evaluate with perplexity.
 """
 
 import struct
@@ -61,22 +55,6 @@ def _load_hexstate_lib():
             ctypes.c_int,                     # verbose
         ]
 
-        # ANALOG Q2_K (Hessian / output-error objective)
-        if hasattr(lib, 'hexstate_quantize_tensor_q2k_analog'):
-            lib.hexstate_quantize_tensor_q2k_analog.restype = None
-            lib.hexstate_quantize_tensor_q2k_analog.argtypes = [
-                ctypes.POINTER(ctypes.c_float),  # weights
-                ctypes.c_int64,                   # n_elements
-                ctypes.c_int64,                   # n_in (row length)
-                ctypes.POINTER(ctypes.c_float),   # H (n_in*n_in) or NULL
-                ctypes.c_void_p,                  # output
-                ctypes.POINTER(ctypes.c_float),   # out_error
-                ctypes.c_int,                     # n_sweeps
-                ctypes.c_int,                     # verbose
-            ]
-            lib.hexstate_q2k_hessian_bytes.restype = ctypes.c_int64
-            lib.hexstate_q2k_hessian_bytes.argtypes = [ctypes.c_int64]
-
         lib.hexstate_q2k_block_bytes.restype = ctypes.c_int
         lib.hexstate_q2k_block_bytes.argtypes = []
         lib.hexstate_q2k_block_elements.restype = ctypes.c_int
@@ -148,121 +126,6 @@ def _skip_gguf_kv_value(f, vtype):
         f.read(sz)
 
 
-# ─── Hessian (X^T X) support for the ANALOG objective ───────────────────────
-#
-# FILE FORMAT  (.hxh)  — little-endian throughout
-#
-#   magic     4 bytes   b"HXH1"
-#   n_entries uint32
-#   repeated n_entries times:
-#       name_len   uint32
-#       name       name_len bytes, UTF-8 tensor name (GGUF naming)
-#       n_in       uint32           row length; must be a multiple of 256
-#       H          n_in*n_in float32, ROW-MAJOR
-#
-# H must be X^T X / n_samples for that layer's INPUT activations, damped on
-# the diagonal (add ~1% of mean(diag) to keep it invertible). This is NOT a
-# llama.cpp imatrix: an imatrix stores only diag(X^T X), the n_in diagonal
-# entries. Entries may be shared between tensors with the same input space
-# (e.g. attn_q / attn_k / attn_v) by writing the same H under each name.
-#
-# Memory: n_in^2 * 4 bytes. 4 MiB at n_in=1024, 64 MiB at n_in=4096.
-
-HESSIAN_MAGIC = b"HXH1"
-
-
-def read_hessian(path):
-    """Read a .hxh file. Returns dict: tensor_name -> float32 (n_in, n_in)."""
-    import struct as st
-    out = {}
-    with open(path, 'rb') as f:
-        if f.read(4) != HESSIAN_MAGIC:
-            raise ValueError(f"{path}: not a HXH1 Hessian file")
-        n_entries = st.unpack('<I', f.read(4))[0]
-        for _ in range(n_entries):
-            nl = st.unpack('<I', f.read(4))[0]
-            name = f.read(nl).decode('utf-8', errors='replace')
-            n_in = st.unpack('<I', f.read(4))[0]
-            buf = f.read(n_in * n_in * 4)
-            if len(buf) != n_in * n_in * 4:
-                raise ValueError(f"{path}: truncated entry for {name}")
-            out[name] = np.frombuffer(buf, dtype=np.float32).reshape(n_in, n_in)
-    return out
-
-
-def write_hessian(path, entries):
-    """entries: dict name -> (n_in, n_in) array convertible to float32."""
-    import struct as st
-    with open(path, 'wb') as f:
-        f.write(HESSIAN_MAGIC)
-        f.write(st.pack('<I', len(entries)))
-        for name, H in entries.items():
-            H = np.ascontiguousarray(H, dtype=np.float32)
-            assert H.ndim == 2 and H.shape[0] == H.shape[1], name
-            nb = name.encode('utf-8')
-            f.write(st.pack('<I', len(nb)))
-            f.write(nb)
-            f.write(st.pack('<I', H.shape[0]))
-            f.write(H.tobytes())
-
-
-def hessian_from_imatrix(imat_row, n_in, damp=0.01):
-    """Build a DIAGONAL Hessian from an existing imatrix row.
-
-    An imatrix gives diag(X^T X) only, so this discards all cross-column
-    correlation. It is strictly weaker than a real Hessian -- measured on a
-    synthetic layer, diagonal-only recovers roughly half the output-error
-    gain that a full H delivers -- but it needs no new calibration run and
-    lets the analog path be exercised with data you already have.
-    """
-    d = np.asarray(imat_row, dtype=np.float64).ravel()
-    if d.size < n_in:
-        d = np.tile(d, int(np.ceil(n_in / max(d.size, 1))))
-    d = d[:n_in].copy()
-    d[~np.isfinite(d)] = 0.0
-    if d.max() <= 0:
-        d[:] = 1.0
-    d += damp * d.mean()
-    H = np.zeros((n_in, n_in), dtype=np.float32)
-    np.fill_diagonal(H, d.astype(np.float32))
-    return H
-
-
-def quantize_tensor_q2k_analog(f32_data, n_in, H, sweeps=0, verbose=1):
-    """Assign fresh 2-bit codes minimising LAYER OUTPUT error (not weight RMSE).
-
-    Weight RMSE is EXPECTED to rise; judge this path by perplexity.
-    Returns (bytes, n_blocks). Raises if the C library lacks the entry point.
-    """
-    lib = _load_hexstate_lib()
-    if lib is None or not hasattr(lib, 'hexstate_quantize_tensor_q2k_analog'):
-        raise RuntimeError("libhexstate_q2k.so has no analog entry point; rebuild")
-
-    n_elements = len(f32_data)
-    if n_elements % QK_K != 0:
-        pad = QK_K - (n_elements % QK_K)
-        f32_data = np.concatenate([f32_data, np.zeros(pad, dtype=np.float32)])
-        n_elements = len(f32_data)
-
-    n_blocks = n_elements // QK_K
-    output = np.zeros(n_blocks * lib.hexstate_q2k_block_bytes(), dtype=np.uint8)
-    error = ctypes.c_float(0.0)
-
-    f32c = np.ascontiguousarray(f32_data, dtype=np.float32)
-    Hc = np.ascontiguousarray(H, dtype=np.float32)
-    lib.hexstate_quantize_tensor_q2k_analog(
-        f32c.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
-        ctypes.c_int64(n_elements),
-        ctypes.c_int64(int(n_in)),
-        Hc.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
-        output.ctypes.data_as(ctypes.c_void_p),
-        ctypes.byref(error),
-        ctypes.c_int(int(sweeps)),
-        ctypes.c_int(int(verbose)),
-    )
-    return output.tobytes(), n_blocks
-
-
 def read_imatrix(path):
     """Read llama.cpp importance matrix file (GGUF or legacy .dat format).
 
@@ -558,7 +421,7 @@ def quantize_tensor_q2k(f32_data):
     n_blocks = n_elements // QK_K
 
     # Reshape: [n_blocks, 16 sub-blocks, 16 weights]
-    data = f32_data.reshape(n_blocks, 16, 16).astype(np.float64)
+    data = np.asarray(f32_data, dtype=np.float32).reshape(n_blocks, 16, 16)
 
     # ── make_qkx2_quants vectorized over all sub-blocks ──
     # Shape key: S = [n_blocks, 16], V = [n_blocks, 16, 16]
@@ -570,8 +433,8 @@ def quantize_tensor_q2k(f32_data):
     sb_min = np.minimum(sb_min, 0.0)
 
     # Weighted sums (needed for least-squares solve)
-    sum_w = weights.sum(axis=2)           # [n_blocks, 16]
-    sum_x = (weights * data).sum(axis=2)  # [n_blocks, 16]
+    sum_w = weights.sum(axis=2, dtype=np.float64)
+    sum_x = (weights * data).sum(axis=2, dtype=np.float64)
 
     sb_range = sb_max - sb_min
     degenerate = sb_range < 1e-30  # [n_blocks, 16]
@@ -588,7 +451,6 @@ def quantize_tensor_q2k(f32_data):
     recon0 = scale0[:, :, None] * L0 + sb_min[:, :, None]
     best_error = (weights * np.abs(recon0 - data)).sum(axis=2)  # [n_blocks, 16]
 
-    best_L = L0.copy()
     best_scale = scale0.copy()
     best_min = sb_min.copy()
 
@@ -633,7 +495,6 @@ def quantize_tensor_q2k(f32_data):
         if better.any():
             # Expand mask to weight dimension for L update
             better3d = better[:, :, None]
-            best_L = np.where(better3d, Laux, best_L)
             best_error = np.where(better, cur_error, best_error)
             best_scale = np.where(better, this_scale, best_scale)
             best_min = np.where(better, this_min, best_min)
@@ -782,6 +643,34 @@ def is_attention_tensor(name):
     return False
 
 
+def q2k_row_compatible(n_dims, dims):
+    return n_dims >= 2 and bool(dims) and int(dims[0]) % QK_K == 0
+
+
+def q4_row_compatible(n_dims, dims):
+    return n_dims >= 2 and bool(dims) and int(dims[0]) % 32 == 0
+
+
+def _expand_imatrix(ti, imatrix_data):
+    """Expand an imatrix vector only when its length matches a tensor row."""
+    if not imatrix_data:
+        return None
+    iw = imatrix_data.get(ti['name'])
+    if iw is None:
+        return None
+    iw = np.asarray(iw, dtype=np.float32).reshape(-1)
+    n_el = int(ti['n_elements'])
+    if iw.size == n_el:
+        return np.ascontiguousarray(iw)
+    if ti['n_dims'] < 2 or not ti['dims']:
+        return None
+    row_width = int(ti['dims'][0])
+    if row_width <= 0 or iw.size != row_width or n_el % row_width:
+        print(f"  WARNING: ignoring imatrix for {ti['name']}: importance length {iw.size} does not match row width {row_width}")
+        return None
+    return np.ascontiguousarray(np.tile(iw, n_el // row_width))
+
+
 def should_quantize(name, n_dims, dims, tied_embeddings=False):
     """Should this tensor be quantized to Q2_K?
 
@@ -873,27 +762,6 @@ def main():
                 print(f"  WARNING: imatrix file not found: {imat_path}")
             break
 
-    # ── ANALOG objective options ──
-    hessian_data = None
-    analog_from_imat = '--analog-imatrix' in sys.argv
-    analog_sweeps = 0
-    for i, arg in enumerate(sys.argv):
-        if arg == '--hessian' and i + 1 < len(sys.argv):
-            hpath = sys.argv[i + 1]
-            if os.path.exists(hpath):
-                hessian_data = read_hessian(hpath)
-                print(f"  Loaded Hessian: {len(hessian_data)} tensors from {hpath}")
-            else:
-                print(f"  WARNING: Hessian file not found: {hpath}")
-        elif arg == '--analog-sweeps' and i + 1 < len(sys.argv):
-            analog_sweeps = int(sys.argv[i + 1])
-    use_analog = (hessian_data is not None) or analog_from_imat
-    if use_analog:
-        print("  ANALOG MODE: minimising LAYER OUTPUT error, not weight RMSE.")
-        print("  Weight RMSE will RISE. Evaluate with perplexity, not RMSE.")
-        if analog_from_imat and hessian_data is None:
-            print("  Using DIAGONAL Hessian from imatrix (~half the gain of full H).")
-
     # Check for HPC C library
     use_hpc = _load_hexstate_lib() is not None
 
@@ -993,7 +861,7 @@ def main():
             if quantize_none:
                 will_quant = False
             elif (tied_embeddings and ti['name'] == 'token_embd.weight'
-                  and not keep_embd and ti['n_elements'] % 32 == 0):
+                  and not keep_embd and q4_row_compatible(ti['n_dims'], ti['dims'])):
                 # Tied embedding doubles as the LM head. NOTE: the old
                 # 'promote to Q4_0' branch below should_quantize() was dead
                 # code (should_quantize always returned False for
@@ -1005,23 +873,29 @@ def main():
                 total_embd += 1
             elif should_quantize(ti['name'], ti['n_dims'], ti['dims'], tied_embeddings):
                 if q2all:
-                    # --q2all: ALL eligible tensors → Q2_K, no exceptions
-                    # (tied embedding stays on the Q8_0 route above).
-                    will_quant = True
-                    total_quant += 1
-                elif is_attention_tensor(ti['name']):
-                    will_quant = 'ATTN_Q4'  # Promote attention to Q4_0 HPC
-                    total_attn += 1
+                    if q2k_row_compatible(ti['n_dims'], ti['dims']):
+                        will_quant = True; total_quant += 1
+                    elif q4_row_compatible(ti['n_dims'], ti['dims']):
+                        will_quant = 'Q4_0'; total_quant += 1
+                        print(f"  Q2ALL→Q4_0 (row width not 256-aligned): {ti['name']}")
+                    else:
+                        will_quant = False; total_keep += 1
+                        print(f"  Q2ALL→KEEP (row width not block-aligned): {ti['name']}")
+                elif is_attention_tensor(ti['name']) and q4_row_compatible(ti['n_dims'], ti['dims']):
+                    will_quant = 'ATTN_Q4'; total_attn += 1
+                elif q2k_row_compatible(ti['n_dims'], ti['dims']):
+                    will_quant = True; total_quant += 1
+                elif q4_row_compatible(ti['n_dims'], ti['dims']):
+                    will_quant = 'Q4_0'; total_quant += 1
                 else:
-                    will_quant = True
-                    total_quant += 1
+                    will_quant = False; total_keep += 1
             else:
                 will_quant = False
                 total_keep += 1
             quant_plan.append(will_quant)
 
         if q2all:
-            print(f"  Mode: --q2all — all eligible tensors forced to Q2_K")
+            print("  Mode: --q2all — Q2_K wherever block-compatible; safe Q4/keep otherwise")
             print(f"  Tensors to quantize (Q2_K):     {total_quant}")
             print(f"  Tensors to keep as-is:          {total_keep}")
         else:
@@ -1052,22 +926,15 @@ def main():
                     n_blocks = (ti['n_elements'] + 31) // 32
                     out_size = n_blocks * 18
                     print(f"  [ATTN→Q4_0·HPC] {ti['name']} ({ti['n_elements']} elements)")
-                elif dim0 % QK_K == 0 or q2all:
-                    # Q2_K (2.6 bpw, block_size=256)
-                    # --q2all forces Q2_K even when dim0 isn't a clean multiple;
-                    # the quantizer pads internally to the next QK_K boundary.
-                    out_type = GGML_TYPE_Q2_K
-                    n_blocks = (ti['n_elements'] + QK_K - 1) // QK_K
-                    out_size = n_blocks * 84
-                    if q2all and dim0 % QK_K != 0:
-                        print(f"  [Q2_K·PADDED] {ti['name']} (dim0={dim0}, padded to QK_K boundary)")
-                elif dim0 % 32 == 0:
-                    # Q4_0 fallback (4.5 bpw, block_size=32)
+                elif quant_plan[i] == 'Q4_0':
                     out_type = GGML_TYPE_Q4_0
                     n_blocks = ti['n_elements'] // 32
                     out_size = n_blocks * 18
-                    quant_plan[i] = 'Q4_0'
                     print(f"  Q4_0: {ti['name']} (dims[0]={dim0})")
+                elif quant_plan[i] is True and q2k_row_compatible(ti['n_dims'], ti['dims']):
+                    out_type = GGML_TYPE_Q2_K
+                    n_blocks = ti['n_elements'] // QK_K
+                    out_size = n_blocks * 84
                 else:
                     out_type = ti['type']
                     out_size = ti['data_size']
@@ -1217,14 +1084,7 @@ def main():
             total_quant_bytes = 0
             total_keep_bytes = 0
             total_rmse = 0.0
-            # Element-weighted global accumulators. A plain mean of per-tensor
-            # RMSEs weights a 4K-element norm tensor the same as a 100M-element
-            # FFN, so it is dominated by the small tensors and is the wrong
-            # thing to tune against. Track sum-of-squared-error and element
-            # count instead, and derive the true global RMSE at the end.
-            q2k_se_sum = 0.0          # Σ squared error over all Q2_K elements
-            q2k_elem_count = 0        # Σ elements
-            q2k_rmse_sum = 0.0        # kept for the unweighted mean (reported too)
+            q2k_rmse_sum = 0.0
             q2k_tensor_count = 0
 
             for i, ti in enumerate(tensor_infos):
@@ -1267,13 +1127,9 @@ def main():
                         f32_c = np.ascontiguousarray(f32, dtype=np.float32)
 
                         imat_ptr = None
-                        if imatrix_data and ti['name'] in imatrix_data:
-                            iw = imatrix_data[ti['name']]
-                            n_cols = iw.shape[0]
-                            n_rows = n_el // n_cols if n_cols > 0 else 1
-                            imat_full = np.tile(iw, n_rows)[:n_el].astype(np.float32)
-                            imat_c = np.ascontiguousarray(imat_full)
-                            imat_ptr = imat_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
+                        imat_full = _expand_imatrix(ti, imatrix_data)
+                        if imat_full is not None:
+                            imat_ptr = imat_full.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
 
                         _HEXSTATE_LIB.hexstate_quantize_tensor_q8_0_hpc(
                             f32_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
@@ -1309,13 +1165,9 @@ def main():
                         if pad > 0: fout.write(b'\x00' * pad)
                         continue
 
-                    # Pad to 32-element boundary
                     n_el = len(f32)
-                    pad_to = ((n_el + 31) // 32) * 32
-                    if pad_to > n_el:
-                        f32 = np.concatenate([f32, np.zeros(pad_to - n_el, dtype=np.float32)])
-                        n_el = pad_to
-
+                    if n_el % 32:
+                        raise ValueError(f"Q4_0 tensor {ti['name']} is not row/block aligned")
                     n_blocks_q4 = n_el // 32
 
                     # Use HPC for attention tensors if available
@@ -1326,13 +1178,9 @@ def main():
 
                         # Look up imatrix importance
                         imat_ptr = None
-                        if imatrix_data and ti['name'] in imatrix_data:
-                            iw = imatrix_data[ti['name']]
-                            n_cols = iw.shape[0]
-                            n_rows = n_el // n_cols if n_cols > 0 else 1
-                            imat_full = np.tile(iw, n_rows)[:n_el].astype(np.float32)
-                            imat_c = np.ascontiguousarray(imat_full)
-                            imat_ptr = imat_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
+                        imat_full = _expand_imatrix(ti, imatrix_data)
+                        if imat_full is not None:
+                            imat_ptr = imat_full.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
 
                         _HEXSTATE_LIB.hexstate_quantize_tensor_q4_0_hpc(
                             f32_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
@@ -1383,41 +1231,14 @@ def main():
 
                     # Quantize to Q2_K — always use HPC with chunked processing
                     # Each chunk gets full HPC treatment (no size threshold)
-                    HPC_CHUNK = 50_000_000  # 50M elements per HPC chunk
-                    HPC_CHUNK = (HPC_CHUNK // QK_K) * QK_K  # align to QK_K
+                    row_width = int(ti['dims'][0])
+                    HPC_CHUNK = max(row_width, (50_000_000 // row_width) * row_width)
 
                     # Look up imatrix importance for this tensor
-                    imat_full = None
-                    if imatrix_data and ti['name'] in imatrix_data:
-                        iw = imatrix_data[ti['name']]
-                        n_cols = iw.shape[0]
-                        n_rows = ti['n_elements'] // n_cols if n_cols > 0 else 1
-                        imat_full = np.tile(iw, n_rows)[:ti['n_elements']]
+                    imat_full = _expand_imatrix(ti, imatrix_data)
 
                     n_el = ti['n_elements']
-
-                    # ── ANALOG path: fresh 2-bit codes vs output error ──
-                    analog_H = None
-                    analog_n_in = ti['dims'][0] if ti.get('dims') else 0
-                    if use_analog and analog_n_in and analog_n_in % QK_K == 0 \
-                       and n_el % analog_n_in == 0:
-                        if hessian_data and ti['name'] in hessian_data:
-                            Hcand = hessian_data[ti['name']]
-                            if Hcand.shape[0] == analog_n_in:
-                                analog_H = Hcand
-                        if analog_H is None and analog_from_imat and imatrix_data \
-                           and ti['name'] in imatrix_data:
-                            analog_H = hessian_from_imatrix(
-                                imatrix_data[ti['name']], analog_n_in)
-
-                    if analog_H is not None:
-                        q2k_data, n_blocks = quantize_tensor_q2k_analog(
-                            f32, analog_n_in, analog_H, sweeps=analog_sweeps)
-                        src = 'full-H' if (hessian_data and ti['name'] in hessian_data) \
-                              else 'diag-H'
-                        print(f"    [analog:{src}] n_in={analog_n_in} "
-                              f"rows={n_el // analog_n_in}")
-                    elif use_hpc and n_el <= HPC_CHUNK:
+                    if use_hpc and n_el <= HPC_CHUNK:
                         # Small tensor — single HPC pass
                         q2k_data, n_blocks = quantize_tensor_q2k_hpc(f32, opt_mode=2, importance=imat_full)
                     elif use_hpc:
@@ -1444,8 +1265,7 @@ def main():
                         n_blocks = n_el // QK_K
                     else:
                         # No HPC available — python fallback
-                        CHUNK_SIZE = 10_000_000
-                        CHUNK_SIZE = (CHUNK_SIZE // QK_K) * QK_K
+                        CHUNK_SIZE = max(row_width, (10_000_000 // row_width) * row_width)
                         chunks = []
                         processed = 0
                         while processed < n_el:
@@ -1463,8 +1283,8 @@ def main():
                     # ── Compute and report exact per-tensor RMSE ──
                     try:
                         CHUNK_BLK = 100_000  # blocks per chunk to bound memory
-                        total_se = 0.0   # float64: np.sum on float32 would
-                        total_n = 0      # round away small terms on big tensors
+                        total_se = 0.0
+                        total_n = 0
                         for ci in range(0, n_blocks, CHUNK_BLK):
                             ce = min(ci + CHUNK_BLK, n_blocks)
                             chunk_q = q2k_data[ci*84:ce*84]
@@ -1472,11 +1292,9 @@ def main():
                             orig_chunk = f32[ci*QK_K:ce*QK_K]
                             n_valid = min(len(orig_chunk), len(deq_chunk))
                             diff = orig_chunk[:n_valid] - deq_chunk[:n_valid]
-                            total_se += float(np.sum(diff.astype(np.float64) ** 2))
+                            total_se += np.sum(diff ** 2)
                             total_n += n_valid
                         tensor_rmse = np.sqrt(total_se / max(total_n, 1))
-                        q2k_se_sum += total_se
-                        q2k_elem_count += total_n
                         q2k_rmse_sum += tensor_rmse
                         q2k_tensor_count += 1
                         print(f"\n  [Q2_K] {ti['name'][:55]}  RMSE={tensor_rmse:.6e}")
@@ -1517,13 +1335,7 @@ def main():
     print(f"  ║  Compression:       {compression:>42.1f}x ║")
     if q2k_tensor_count > 0:
         mean_rmse = q2k_rmse_sum / q2k_tensor_count
-        # Global RMSE = sqrt(Σ SE / Σ N): every quantized weight counts once,
-        # regardless of which tensor it lives in. This is the number to tune
-        # against; the unweighted per-tensor mean is kept below for continuity
-        # with previous runs but is dominated by small tensors.
-        global_rmse = np.sqrt(q2k_se_sum / max(q2k_elem_count, 1))
-        print(f"  ║  Global Q2_K RMSE (element-wtd):            {global_rmse:>12.6e} ║")
-        print(f"  ║  Mean Q2_K RMSE (per-tensor, unwtd):        {mean_rmse:>12.6e} ║")
+        print(f"  ║  Mean Q2_K RMSE:                            {mean_rmse:>12.6e} ║")
     print(f"  ║  Total time:        {elapsed:>39.1f} sec ║")
     print("  ╚════════════════════════════════════════════════════════════════╝")
     print()
@@ -1532,4 +1344,4 @@ def main():
 
 
 if __name__ == '__main__':
-    main()
+    main()