Upload 6 files

__init__.py

@@ -24,6 +24,7 @@ from .factored import (
 from .gguf import (
     GGUFReader,
     expand_importance,
+    is_q1_0_eligible,
     is_q2k_eligible,
     is_q4_0_eligible,
     lookup_imatrix,
@@ -31,6 +32,7 @@ from .gguf import (
     target_quant_type,
 )
 from .pipeline import Q2KQuantizer, QuantizedTensor, TensorStats
+from .q1_0 import Q1_0_BLOCK_BYTES, QK1_0, dequantize_q1_0_bytes, quantize_tensor_q1_0
 from .q2k import Q2KBlock, QK_K, dequantize_params, pack_codes, unpack_codes
 from .q4_0 import QK4_0, dequantize_q4_0_bytes, quantize_tensor_q4_0
 
@@ -56,11 +58,16 @@ __all__ = [
     "factor_q2k_block",
     "GGUFReader",
     "expand_importance",
+    "is_q1_0_eligible",
     "is_q2k_eligible",
     "is_q4_0_eligible",
     "lookup_imatrix",
     "read_imatrix",
     "target_quant_type",
+    "QK1_0",
+    "Q1_0_BLOCK_BYTES",
+    "dequantize_q1_0_bytes",
+    "quantize_tensor_q1_0",
     "QK4_0",
     "dequantize_q4_0_bytes",
     "quantize_tensor_q4_0",

__main__.py

@@ -128,7 +128,8 @@ def _run_gguf(args, cfg: HPCConfig) -> None:
             verbose=True,
         )
         print(
-            f"wrote {args.output}: {int(stats.get('q2_k', 0))} Q2_K + {int(stats.get('q4_0', 0))} Q4_0 "
+            f"wrote {args.output}: {int(stats.get('q2_k', 0))} Q2_K + {int(stats.get('q4_0', 0))} Q4_0 + "
+            f"{int(stats.get('q1_0', 0))} Q1_0 "
             f"({int(stats['quantized'])}/{int(stats['tensors'])} tensors), rmse={stats['rmse']:.6e}"
         )
         return
@@ -253,9 +254,9 @@ def main() -> None:
     parser.add_argument("--no-spectral", action="store_true", help="disable spectral/DC objective")
     parser.add_argument(
         "--format",
-        choices=("mixed", "q4_0", "q2_k"),
+        choices=("mixed", "mixed_q1", "q1_0", "q4_0", "q2_k"),
         default=None,
-        help="quantization format mode: mixed (Q2_K if eligible else Q4_0), q4_0 (pure Q4_0), or q2_k (pure Q2_K)",
+        help="quantization format mode: mixed (Q2_K+Q4_0), mixed_q1 (Q1_0+Q4_0), q1_0 (pure Q1_0), q4_0 (pure Q4_0), or q2_k (pure Q2_K)",
     )
     parser.add_argument("--no-q4-fallback", action="store_true", help="disable Q4_0 fallback for non-256-aligned tensors")
     parser.add_argument("--keep-embd", action="store_true", help="keep token_embd/output.weight at source precision")

config.py

@@ -120,6 +120,6 @@ class HPCConfig:
             raise ValueError("workers must be >= 0 (0 = auto CPU count)")
         if self.device not in ("auto", "cuda", "cpu") and not self.device.startswith("cuda:"):
             raise ValueError("device must be 'auto', 'cuda', 'cuda:N', or 'cpu'")
-        if self.quant_format not in ("mixed", "q4_0", "q2_k"):
-            raise ValueError("quant_format must be 'mixed', 'q4_0', or 'q2_k'")
+        if self.quant_format not in ("mixed", "mixed_q1", "q1_0", "q4_0", "q2_k"):
+            raise ValueError("quant_format must be 'mixed', 'mixed_q1', 'q1_0', 'q4_0', or 'q2_k'")
         return self

gguf.py

@@ -23,6 +23,7 @@ import numpy as np
 
 from .q2k import QK_K, blocks_to_bytes, dequantize_params_batch, unpack_codes
 from .q4_0 import Q4_0_BLOCK_BYTES, QK4_0, quantize_tensor_q4_0
+from .q1_0 import QK1_0, Q1_0_BLOCK_BYTES, quantize_tensor_q1_0
 
 GGUF_MAGIC = 0x46554747
 DEFAULT_ALIGNMENT = 32
@@ -36,6 +37,7 @@ GGML_TYPE_Q5_1 = 7
 GGML_TYPE_Q8_0 = 8
 GGML_TYPE_Q2_K = 10
 GGML_TYPE_BF16 = 30
+GGML_TYPE_Q1_0 = 41
 
 TYPE_NAME = {
     GGML_TYPE_F32: "F32",
@@ -47,6 +49,7 @@ TYPE_NAME = {
     GGML_TYPE_Q8_0: "Q8_0",
     GGML_TYPE_Q2_K: "Q2_K",
     GGML_TYPE_BF16: "BF16",
+    GGML_TYPE_Q1_0: "Q1_0",
 }
 
 BLOCK_SIZE = {
@@ -59,6 +62,7 @@ BLOCK_SIZE = {
     GGML_TYPE_Q5_1: 32,
     GGML_TYPE_Q8_0: 32,
     GGML_TYPE_Q2_K: QK_K,
+    GGML_TYPE_Q1_0: QK1_0,
 }
 BLOCK_BYTES = {
     GGML_TYPE_F32: 4,
@@ -70,6 +74,7 @@ BLOCK_BYTES = {
     GGML_TYPE_Q5_1: 24,
     GGML_TYPE_Q8_0: 34,
     GGML_TYPE_Q2_K: 84,
+    GGML_TYPE_Q1_0: Q1_0_BLOCK_BYTES,
 }
 TYPE_BPW = {
     GGML_TYPE_F32: 32.0,
@@ -81,6 +86,7 @@ TYPE_BPW = {
     GGML_TYPE_Q4_1: 5.0,
     GGML_TYPE_Q4_0: 4.5,
     GGML_TYPE_Q2_K: 2.625,
+    GGML_TYPE_Q1_0: 1.125,
     11: 3.4375,  # Q3_K
     12: 4.5,     # Q4_K
     13: 5.5,     # Q5_K
@@ -110,6 +116,7 @@ SUPPORTED_READ_TYPES = {
     GGML_TYPE_Q4_0,
     GGML_TYPE_Q8_0,
     GGML_TYPE_Q2_K,
+    GGML_TYPE_Q1_0,
 }
 
 
@@ -309,6 +316,11 @@ def _dequantize(raw: bytes, ti: TensorInfo) -> np.ndarray:
         high = (qs >> 4).astype(np.float32) - 8.0
         q = np.concatenate([low, high], axis=1)
         return (d[:, None] * q).reshape(-1)
+    if t == GGML_TYPE_Q1_0:
+        blocks = np.frombuffer(raw, dtype=np.uint8).reshape(-1, Q1_0_BLOCK_BYTES)
+        d = blocks[:, :2].copy().view("<f2").reshape(-1, 1).astype(np.float32)
+        bits = np.unpackbits(blocks[:, 2:], axis=1, bitorder="little")[:, :QK1_0].astype(np.float32)
+        return (d * (bits * 2.0 - 1.0)).reshape(-1)
     if t == GGML_TYPE_Q2_K:
         blocks = np.frombuffer(raw, dtype=np.uint8).reshape(-1, 84)
         n = blocks.shape[0]
@@ -461,6 +473,24 @@ def is_q4_0_eligible(
     return n_elements >= QK4_0 and n_elements % QK4_0 == 0
 
 
+def is_q1_0_eligible(
+    name: str,
+    dims: tuple[int, ...],
+    include_embd: bool = True,
+) -> bool:
+    """True for 128-aligned 2D/3D weight tensors eligible for Q1_0."""
+    if _is_skipped_metadata_tensor(name, dims):
+        return False
+    if _is_embd_or_head(name) and not include_embd:
+        return False
+    if len(dims) < 2 or dims[0] % QK1_0 != 0:
+        return False
+    n_elements = 1
+    for d in dims:
+        n_elements *= int(d)
+    return n_elements >= QK1_0 and n_elements % QK1_0 == 0
+
+
 def target_quant_type(
     name: str,
     dims: tuple[int, ...],
@@ -477,12 +507,34 @@ def target_quant_type(
       tensors (and embeddings/head if quantize_embd_q4) -> Q4_0.
     * 'q4_0': all 32-aligned eligible weight tensors -> Q4_0.
     * 'q2_k': only Q2_K-eligible tensors -> Q2_K; everything else copied.
+    * 'q1_0': all 128-aligned eligible weight tensors -> Q1_0.
 
     Never promotes a lower-bit source tensor to a higher-bit target format
     (e.g., a Q2_K source tensor is never re-quantized to Q4_0).
     """
     tgt: str | None = None
-    if quant_format == "q4_0":
+    if quant_format == "q1_0":
+        if is_q1_0_eligible(name, dims, include_embd=quantize_embd_q4):
+            tgt = "Q1_0"
+        elif enable_q4_fallback and is_q4_0_eligible(
+            name, dims, include_embd=quantize_embd_q4, promote_attn=False
+        ):
+            tgt = "Q4_0"
+    elif quant_format == "mixed_q1":
+        if promote_attn_q4 and _is_attention_projection(name) and is_q4_0_eligible(
+            name, dims, include_embd=quantize_embd_q4, promote_attn=True
+        ):
+            tgt = "Q4_0"
+        elif _is_embd_or_head(name):
+            if quantize_embd_q4 and is_q4_0_eligible(name, dims, include_embd=True):
+                tgt = "Q4_0"
+        elif is_q1_0_eligible(name, dims, include_embd=False):
+            tgt = "Q1_0"
+        elif enable_q4_fallback and is_q4_0_eligible(
+            name, dims, include_embd=quantize_embd_q4, promote_attn=False
+        ):
+            tgt = "Q4_0"
+    elif quant_format == "q4_0":
         if is_q4_0_eligible(
             name, dims, include_embd=quantize_embd_q4, allow_q2k_tensors=True
         ):
@@ -504,7 +556,7 @@ def target_quant_type(
 
     if tgt is not None and source_type is not None:
         src_bpw = source_type_bpw(int(source_type))
-        tgt_bpw = 2.625 if tgt == "Q2_K" else 4.5
+        tgt_bpw = {"Q2_K": 2.625, "Q4_0": 4.5, "Q1_0": 1.125}[tgt]
         if src_bpw <= tgt_bpw + 1.0e-6:
             return None
     return tgt
@@ -565,7 +617,9 @@ def write_quantized_gguf(
                 )
                 if target_fmt is None:
                     src_bpw = source_type_bpw(ti.type)
-                    if q_format == "q4_0" and len(ti.dims) >= 2 and ti.dims[0] % QK4_0 == 0 and src_bpw > 4.5:
+                    if q_format == "q1_0" and len(ti.dims) >= 2 and ti.dims[0] % QK1_0 == 0 and src_bpw > 1.125:
+                        target_fmt = "Q1_0"
+                    elif q_format == "q4_0" and len(ti.dims) >= 2 and ti.dims[0] % QK4_0 == 0 and src_bpw > 4.5:
                         target_fmt = "Q4_0"
                     elif len(ti.dims) >= 2 and ti.dims[0] % QK_K == 0 and ti.n_elements % QK_K == 0 and src_bpw > 2.625:
                         target_fmt = "Q2_K"
@@ -607,6 +661,11 @@ def write_quantized_gguf(
             out_type = GGML_TYPE_Q4_0
             out_size = n_blocks * Q4_0_BLOCK_BYTES
             total_planned_blocks += max(1, n_blocks // 8)
+        elif fmt == "Q1_0":
+            n_blocks = ti.n_elements // QK1_0
+            out_type = GGML_TYPE_Q1_0
+            out_size = n_blocks * Q1_0_BLOCK_BYTES
+            total_planned_blocks += max(1, n_blocks // 32)
         else:
             out_type = ti.type
             out_size = ti.n_bytes
@@ -614,7 +673,9 @@ def write_quantized_gguf(
         data_offset = _align(data_offset + out_size, alignment)
 
     has_q2k = any(fmt == "Q2_K" for fmt in plan)
-    ftype_code = 10 if has_q2k else 2  # 10 = MOSTLY_Q2_K, 2 = MOSTLY_Q4_0
+    has_q1_0 = any(fmt == "Q1_0" for fmt in plan)
+    # 10 = MOSTLY_Q2_K, 2 = MOSTLY_Q4_0, 40 = MOSTLY_Q1_0
+    ftype_code = 10 if has_q2k else (40 if has_q1_0 else 2)
     kv_pairs = []
     for key, vtype, raw in reader.kv_pairs:
         if quantized_count and key == "general.file_type" and vtype == 4:
@@ -629,6 +690,7 @@ def write_quantized_gguf(
     total_quantized = 0
     total_q2k = 0
     total_q4_0 = 0
+    total_q1_0 = 0
     total_elements = 0
     completed_planned_blocks = 0
     model_t0 = time.time()
@@ -811,6 +873,78 @@ def write_quantized_gguf(
                         q4_rmse,
                         has_imat,
                     )
+            elif fmt == "Q1_0":
+                t_blocks_q1 = ti.n_elements // QK1_0
+                eff_tb = max(1, t_blocks_q1 // 32)
+                raw_imp = lookup_imatrix(imat, ti.name) if imat is not None else None
+                has_imat = raw_imp is not None and raw_imp.size == ti.row_width
+                written_bytes = 0
+                sse_q1 = 0.0
+                done_q1_blks = 0
+                t_q1_start = time.time()
+
+                for x_chunk, row, _r0, _r1 in reader.iter_tensor_row_chunks(ti.name, max_elements=8_388_608):
+                    if stop_event is not None and stop_event.is_set():
+                        raise InterruptedError("Quantization cancelled by user")
+                    imp_chunk = expand_importance(raw_imp, x_chunk.size, row) if has_imat else None
+                    q1_bytes, nb_chunk, chunk_rmse = quantize_tensor_q1_0(
+                        x_chunk, importance=imp_chunk, cfg=cfg
+                    )
+                    fout.write(q1_bytes)
+                    written_bytes += len(q1_bytes)
+                    sse_q1 += (chunk_rmse * chunk_rmse) * x_chunk.size
+                    done_q1_blks += nb_chunk
+                    if stage_callback is not None:
+                        frac = done_q1_blks / max(t_blocks_q1, 1)
+                        eff_blocks = completed_planned_blocks + frac * eff_tb
+                        elapsed_model = max(time.time() - model_t0, 1.0e-6)
+                        model_rate = eff_blocks / elapsed_model
+                        model_eta = max(total_planned_blocks - eff_blocks, 0.0) / max(model_rate, 1.0e-6)
+                        el_q1 = max(time.time() - t_q1_start, 1.0e-6)
+                        r_q1 = done_q1_blks / el_q1
+                        eta_q1 = (t_blocks_q1 - done_q1_blks) / max(r_q1, 1.0e-6)
+                        stage_callback(
+                            idx + 1,
+                            len(out_infos),
+                            ti,
+                            {
+                                "phase": "Q1_0: Analog + WLS + Sieve/Viterbi + FP16-ULP Quantization",
+                                "done": done_q1_blks,
+                                "total": t_blocks_q1,
+                                "detail": f"blk {done_q1_blks:,}/{t_blocks_q1:,} ({r_q1:.0f} blk/s) rmse={chunk_rmse:.6e}",
+                                "rate": r_q1,
+                                "eta": eta_q1,
+                                "rmse": chunk_rmse,
+                                "sigma": float(np.sqrt(np.mean(x_chunk.astype(np.float64) ** 2))),
+                                "model_pct": 100.0 * eff_blocks / max(total_planned_blocks, 1),
+                                "model_eta": model_eta,
+                                "model_done_blocks": int(eff_blocks),
+                                "model_total_blocks": total_planned_blocks,
+                            },
+                        )
+
+                if written_bytes != out_size:
+                    raise RuntimeError(f"{ti.name}: Q1_0 payload size mismatch")
+                completed_planned_blocks += eff_tb
+                q1_rmse = float(np.sqrt(sse_q1 / ti.n_elements))
+                total_rmse += sse_q1
+                total_elements += ti.n_elements
+                total_quantized += 1
+                total_q1_0 += 1
+                if verbose:
+                    print(
+                        f"  Q1_0 {ti.name:48s} row={ti.row_width:6d} "
+                        f"rmse={q1_rmse:.6e} imatrix={'yes' if has_imat else 'no'}"
+                    )
+                if progress_callback is not None:
+                    progress_callback(
+                        idx + 1,
+                        len(out_infos),
+                        ti.name,
+                        "Q1_0",
+                        q1_rmse,
+                        has_imat,
+                    )
             else:
                 if stage_callback is not None:
                     stage_callback(
@@ -836,6 +970,7 @@ def write_quantized_gguf(
         "quantized": float(total_quantized),
         "q2_k": float(total_q2k),
         "q4_0": float(total_q4_0),
+        "q1_0": float(total_q1_0),
         "elements": float(total_elements),
         "rmse": rmse,
     }

gui.py

@@ -36,9 +36,13 @@ from hpc_quantize_v2 import (
     Q2KQuantizer,
     cuda_device_name,
     cuda_is_available,
+    dequantize_q1_0_bytes,
+    dequantize_q4_0_bytes,
     expand_importance,
     factor_only_solve,
     lookup_imatrix,
+    quantize_tensor_q1_0,
+    quantize_tensor_q4_0,
     read_imatrix,
 )
 from hpc_quantize_v2.gguf import is_q2k_eligible, target_quant_type, write_quantized_gguf
@@ -65,7 +69,7 @@ def _fmt_eta(seconds: float) -> str:
 class HPCQuantizeGUI:
     def __init__(self, root: tk.Tk) -> None:
         self.root = root
-        self.root.title("HPC-Quantize V2 — Factored Q2_K & Geometry-Preserving Analog Engine")
+        self.root.title("HPC-Quantize V2 — Factored Q1_0 / Q2_K / Q4_0 & Geometry-Preserving Analog Engine")
         self.root.geometry("1260x900")
         self.root.minsize(1040, 740)
 
@@ -259,7 +263,7 @@ class HPCQuantizeGUI:
         mid.add(right_pane, weight=3)
 
         # Left: Engine & Factorization Options
-        opt_frame = ttk.LabelFrame(left_pane, text="2. Factored Q2_K & Analog Controls", padding=8)
+        opt_frame = ttk.LabelFrame(left_pane, text="2. Factored Q1_0 / Q2_K / Q4_0 & Analog Controls", padding=8)
         opt_frame.pack(fill=tk.BOTH, expand=True, padx=(0, 6))
 
         mode_row = ttk.Frame(opt_frame)
@@ -276,16 +280,18 @@ class HPCQuantizeGUI:
         fmt_row.pack(fill=tk.X, pady=(0, 4))
         ttk.Label(fmt_row, text="Quant Format:").pack(side=tk.LEFT, padx=(0, 8))
         for lbl, val in (
-            ("Mixed (Q2_K if eligible, else Q4_0)", "mixed"),
-            ("Pure Q4_0", "q4_0"),
-            ("Pure Q2_K", "q2_k"),
+            ("Mixed Q2_K + Q4_0", "mixed"),
+            ("Mixed Q1_0 + Q4_0", "mixed_q1"),
+            ("Pure Q1_0 (1.125 bpw)", "q1_0"),
+            ("Pure Q2_K (2.625 bpw)", "q2_k"),
+            ("Pure Q4_0 (4.500 bpw)", "q4_0"),
         ):
             ttk.Radiobutton(
                 fmt_row,
                 text=lbl,
                 variable=self.quant_format_var,
                 value=val,
-                command=self._populate_tensor_tree,
+                command=self._on_format_changed,
             ).pack(side=tk.LEFT, padx=3)
 
         opt_row = ttk.Frame(opt_frame)
@@ -390,7 +396,7 @@ class HPCQuantizeGUI:
         filter_entry = ttk.Entry(search_row, textvariable=self.filter_var)
         filter_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
         filter_entry.bind("<KeyRelease>", lambda _e: self._populate_tensor_tree())
-        for label, val in (("All", "ALL"), ("Q2_K", "Q2_K"), ("Q4_0", "Q4_0"), ("Copy", "COPY")):
+        for label, val in (("All", "ALL"), ("Q1_0", "Q1_0"), ("Q2_K", "Q2_K"), ("Q4_0", "Q4_0"), ("Copy", "COPY")):
             ttk.Radiobutton(
                 search_row,
                 text=label,
@@ -411,6 +417,7 @@ class HPCQuantizeGUI:
         self.tree.heading("q2k", text="Target")
         self.tree.heading("imat", text="iMatrix")
         self.tree.heading("state", text="Live Status / RMSE")
+        self.tree.tag_configure("Q1_0", foreground="#fbbf24")
         self.tree.tag_configure("Q2_K", foreground="#93c5fd")
         self.tree.tag_configure("Q4_0", foreground="#34d399")
         self.tree.tag_configure("Copy", foreground="#9ca3af")
@@ -537,6 +544,27 @@ class HPCQuantizeGUI:
             self.output_var.set(str(default_gguf.with_name("Raon-Q2K.gguf").resolve()))
             self.inspect_files()
 
+    def _default_out_suffix(self) -> str:
+        fmt = self.quant_format_var.get()
+        if fmt == "q1_0":
+            return "-Q1_0.gguf"
+        if fmt == "mixed_q1":
+            return "-Q1_0-Q4_0.gguf"
+        if fmt == "q4_0":
+            return "-Q4_0.gguf"
+        return "-Q2K.gguf"
+
+    def _on_format_changed(self) -> None:
+        cur_out = self.output_var.get().strip()
+        gguf_p = self.gguf_var.get().strip()
+        if gguf_p and (
+            not cur_out
+            or any(cur_out.endswith(sfx) for sfx in ("-Q2K.gguf", "-Q1_0.gguf", "-Q1_0-Q4_0.gguf", "-Q4_0.gguf"))
+        ):
+            p = Path(gguf_p)
+            self.output_var.set(str(p.with_name(f"{p.stem}{self._default_out_suffix()}")))
+        self._populate_tensor_tree()
+
     def _browse_gguf(self) -> None:
         path = filedialog.askopenfilename(
             title="Select Source GGUF",
@@ -546,7 +574,7 @@ class HPCQuantizeGUI:
             self.gguf_var.set(path)
             p = Path(path)
             if not self.output_var.get():
-                self.output_var.set(str(p.with_name(f"{p.stem}-Q2K.gguf")))
+                self.output_var.set(str(p.with_name(f"{p.stem}{self._default_out_suffix()}")))
             self.inspect_files()
 
     def _browse_imatrix(self) -> None:
@@ -677,6 +705,7 @@ class HPCQuantizeGUI:
         filt = self.filter_var.get().strip().lower()
         plan_filt = self.plan_filter_var.get()
         n_q2, n_q4, n_copy = 0, 0, 0
+        n_q1 = 0
         for ti in self._reader.tensors:
             tgt = target_quant_type(
                 ti.name,
@@ -691,6 +720,8 @@ class HPCQuantizeGUI:
                 n_q2 += 1
             elif tgt == "Q4_0":
                 n_q4 += 1
+            elif tgt == "Q1_0":
+                n_q1 += 1
             else:
                 n_copy += 1
 
@@ -711,7 +742,7 @@ class HPCQuantizeGUI:
             state_str = (
                 f"Pending ({tgt_label})"
                 if tgt
-                else (f"Keep {ti.type_name} (<= target)" if ti.type_name in ("Q2_K", "Q4_0") else "Passthrough")
+                else (f"Keep {ti.type_name} (<= target)" if ti.type_name in ("Q1_0", "Q2_K", "Q4_0") else "Passthrough")
             )
             self.tree.insert(
                 "",
@@ -729,7 +760,7 @@ class HPCQuantizeGUI:
                 ),
             )
         self.status_var.set(
-            f"Plan ({self.quant_format_var.get().upper()}): {n_q2} Q2_K | {n_q4} Q4_0 | {n_copy} Copy (Total: {len(self._reader.tensors)} tensors)"
+            f"Plan ({self.quant_format_var.get().upper()}): {n_q1} Q1_0 | {n_q2} Q2_K | {n_q4} Q4_0 | {n_copy} Copy (Total: {len(self._reader.tensors)} tensors)"
         )
 
     def _select_all_eligible(self) -> None:
@@ -837,6 +868,30 @@ class HPCQuantizeGUI:
                     raw = lookup_imatrix(imat, tname)
                     if raw is not None:
                         imp = expand_importance(raw, x.size, row)
+                if cfg.quant_format in ("q1_0", "mixed_q1"):
+                    raw_q1, nb_q1, rmse_q1 = quantize_tensor_q1_0(x, importance=imp, cfg=cfg)
+                    np.savez_compressed(
+                        out_path,
+                        q1_0_bytes=np.frombuffer(raw_q1, dtype=np.uint8),
+                        dequantized=dequantize_q1_0_bytes(raw_q1, nb_q1),
+                        rmse=np.float32(rmse_q1),
+                    )
+                    self._log_queue.put(
+                        ("done", f"Saved Q1_0 {out_path} (RMSE={rmse_q1:.6e}, {time.time() - t0:.1f}s)")
+                    )
+                    return
+                if cfg.quant_format == "q4_0":
+                    raw_q4, nb_q4, rmse_q4 = quantize_tensor_q4_0(x, importance=imp, cfg=cfg)
+                    np.savez_compressed(
+                        out_path,
+                        q4_0_bytes=np.frombuffer(raw_q4, dtype=np.uint8),
+                        dequantized=dequantize_q4_0_bytes(raw_q4, nb_q4),
+                        rmse=np.float32(rmse_q4),
+                    )
+                    self._log_queue.put(
+                        ("done", f"Saved Q4_0 {out_path} (RMSE={rmse_q4:.6e}, {time.time() - t0:.1f}s)")
+                    )
+                    return
                 res = quantizer.quantize(
                     x,
                     importance=imp,
@@ -880,7 +935,7 @@ class HPCQuantizeGUI:
             self._log_queue.put(
                 (
                     "done",
-                    f"Wrote {out_path}: {int(stats.get('q2_k', 0))} Q2_K + {int(stats.get('q4_0', 0))} Q4_0 "
+                    f"Wrote {out_path}: {int(stats.get('q1_0', 0))} Q1_0 + {int(stats.get('q2_k', 0))} Q2_K + {int(stats.get('q4_0', 0))} Q4_0 "
                     f"({int(stats['quantized'])}/{int(stats['tensors'])} tensors), "
                     f"overall RMSE={stats['rmse']:.6e} ({dt_sec:.1f}s)",
                 )
@@ -1024,7 +1079,7 @@ class HPCQuantizeGUI:
                 done, total, name, action, rmse, has_imat = payload  # type: ignore[misc]
                 self.model_progress_var.set(100.0 * done / max(total, 1))
                 self.tensor_progress_var.set(100.0)
-                if action in ("Q2_K", "Q4_0") and rmse is not None:
+                if action in ("Q1_0", "Q2_K", "Q4_0") and rmse is not None:
                     self._update_tree_row_state(name, f"{action} (RMSE={rmse:.4e})")
                     self._log(
                         f"[{done}/{total}] FINISHED {name:42s} -> {action} RMSE={rmse:.6e} (iMatrix={'yes' if has_imat else 'no'})"

q1_0.py

@@ -0,0 +1,429 @@
+"""Full HPC V2 Q1_0 quantizer (CUDA GPU + Vectorized CPU).
+
+Implements the complete HPC-Quantize V2 decision stack for ``Q1_0`` (128 weights
+per 18-byte block = 1.125 bpw, matching ``block_q1_0`` in ``llama.cpp``):
+
+1. **Geometry-Preserving Analog + WLS Seeds**:
+   Finds optimal ``d*`` from the llama.cpp reference ``mean(|x|)``, importance-
+   weighted WLS ``sum(w*|x|)/sum(w)``, and an iso-moment companded analog of
+   each 128-weight block (including negative-scale sign-flip starts ``-d``).
+2. **24-Candidate Scale Lattice & Extended Spectral Objective**:
+   Evaluates 24 scale multipliers (mapped to 6 symbolic quhit states) on
+   importance-weighted SSE + D6/Vesica fold pyramid + DC penalty.
+3. **6-State Sequential Sieve & 6-State Viterbi DP**:
+   Runs the 6-state sequential Sieve with parity back-action and a 6-state
+   Viterbi dynamic program with free-energy bin reduction and Manhattan
+   transition penalty across the block chain.
+4. **Asymmetric Sign-Flip fp16-ULP Polish & Closed-Form Vesica/DC Shaping**:
+   Polishes ``d`` over ``+/-8`` fp16 ULPs of both ``+d`` and ``-d``, and
+   applies closed-form 1-D quadratic Vesica + DC bit-flip projection bounded by
+   ``sse_budget`` plus a strict monotone candidate floor.
+"""
+
+from __future__ import annotations
+
+from math import ceil
+import numpy as np
+
+try:
+    import torch
+except ImportError:  # pragma: no cover
+    torch = None  # type: ignore[assignment]
+
+from .config import HPCConfig
+from .cuda_backend import cuda_is_available
+from .factored import MULTS_D
+from .fp16 import from_fp16_bits, nearest_int, to_fp16_bits
+from .sieve import sieve_measure_chain, subblock_chain_edges
+from .viterbi import robust_temperature
+
+QK1_0 = 128
+Q1_0_BLOCK_BYTES = 18
+Q1_N_CAND = 24
+Q1_N_STATES = 6
+
+_BIT_WEIGHTS = (1 << np.arange(8, dtype=np.uint8))[None, None, :]
+
+
+def _pack_q1_bits_np(q_u8: np.ndarray) -> np.ndarray:
+    """Pack (B, 128) uint8 bits {0, 1} into (B, 16) LSB-first bytes."""
+    B = q_u8.shape[0]
+    bits = (q_u8.reshape(B, 16, 8) & 1).astype(np.uint8)
+    return np.sum(bits * _BIT_WEIGHTS, axis=2, dtype=np.uint8)
+
+
+def dequantize_q1_0_bytes(raw: bytes | np.ndarray, n_blocks: int) -> np.ndarray:
+    """Decode GGML Q1_0 blocks into float32 weights."""
+    blocks = np.frombuffer(raw, dtype=np.uint8).reshape(n_blocks, Q1_0_BLOCK_BYTES)
+    d = blocks[:, :2].copy().view("<f2").reshape(n_blocks, 1).astype(np.float32)
+    qs = blocks[:, 2:]
+    bits = np.unpackbits(qs, axis=1, bitorder="little")[:, :QK1_0].astype(np.float32)
+    signs = bits * 2.0 - 1.0
+    return (d * signs).reshape(-1)
+
+
+def _q1_sieve_and_viterbi(cand_errors: np.ndarray, cfg: HPCConfig) -> np.ndarray:
+    """6-state sequential Sieve + 6-state Viterbi DP over Q1_0 candidate lattice."""
+    B = cand_errors.shape[0]
+    if cfg.optimizer != "hpc" or B < 2:
+        return np.argmin(cand_errors, axis=1).astype(np.int64)
+
+    max_gb = min(int(cfg.graph_max_blocks), 512)
+    stride = max(1, ceil(B / max_gb))
+    gb = ceil(B / stride)
+    temp = max(float(robust_temperature(cand_errors, cfg)), 1.0e-12)
+
+    pad = gb * stride - B
+    ce = cand_errors.astype(np.float64)
+    if pad > 0:
+        ce = np.concatenate([ce, np.full((pad, Q1_N_CAND), np.inf, dtype=np.float64)], axis=0)
+    ce_grouped = ce.reshape(gb, stride, Q1_N_STATES, 4)
+
+    group_min = np.min(ce_grouped, axis=(1, 3))  # (gb, 6)
+    finite = np.isfinite(ce_grouped)
+    counts = np.sum(finite, axis=(1, 3))
+    valid = (counts > 0) & np.isfinite(group_min)
+    gm_b = np.where(np.isfinite(group_min), group_min, 0.0)[:, None, :, None]
+    shifted = np.where(finite, (ce_grouped - gm_b) / (2.0 * temp), np.inf)
+    sums = np.sum(np.exp(-shifted), axis=(1, 3))
+    mean_exp = np.maximum(sums / np.maximum(counts, 1), 1.0e-300)
+    bin_err = np.where(valid, group_min - 2.0 * temp * np.log(mean_exp), np.inf)
+
+    agg = np.mean(np.where(finite, ce_grouped, 0.0), axis=1).reshape(gb, Q1_N_CAND)
+    mn = np.min(agg, axis=1, keepdims=True)
+    coeff = np.exp(-np.clip((agg - mn) / (2.0 * temp), 0.0, 80.0)).reshape(gb, Q1_N_STATES, 4)
+    amps = np.sum(coeff, axis=2)
+    norms = np.linalg.norm(amps, axis=1, keepdims=True)
+    amps = np.where(norms > 1.0e-30, amps / np.maximum(norms, 1.0e-30), 1.0 / np.sqrt(6.0))
+
+    marg, _ = sieve_measure_chain(
+        amps,
+        subblock_chain_edges(gb),
+        same_penalty=cfg.same_penalty,
+        log_slack=cfg.log_slack,
+        deterministic=True,
+    )
+    m_tot = np.sum(marg, axis=1, keepdims=True)
+    pm = np.where(m_tot > 1.0e-30, marg / np.maximum(m_tot, 1.0e-30), 1.0 / 6.0)
+    log_prior = np.log(pm + 1.0e-30)
+
+    fin_err = bin_err[np.isfinite(bin_err)]
+    scale_err = max(float(fin_err.mean()) if fin_err.size else 1.0e-10, 1.0e-20)
+    local = np.where(np.isfinite(bin_err), bin_err - cfg.viterbi_beta * scale_err * log_prior, np.inf)
+
+    states = np.arange(Q1_N_STATES)
+    trans = cfg.viterbi_alpha * scale_err * np.abs(states[None, :] - states[:, None])
+    dp = np.full((gb, Q1_N_STATES), np.inf, dtype=np.float64)
+    back = np.zeros((gb, Q1_N_STATES), dtype=np.int64)
+    dp[0] = local[0]
+    for gi in range(1, gb):
+        totals = dp[gi - 1][:, None] + trans
+        best_sp = np.argmin(totals, axis=0)
+        best_val = totals[best_sp, states]
+        dp[gi] = np.where(np.isfinite(best_val), best_val + local[gi], np.inf)
+        back[gi] = best_sp
+
+    path = np.zeros(gb, dtype=np.int64)
+    if np.any(np.isfinite(dp[-1])):
+        path[-1] = int(np.argmin(dp[-1]))
+        for gi in range(gb - 2, -1, -1):
+            path[gi] = back[gi + 1, path[gi + 1]]
+
+    ce_bins = cand_errors.reshape(B, Q1_N_STATES, 4)
+    bin_local_arg = np.argmin(ce_bins, axis=2)
+    blk_gi = np.arange(B) // stride
+    chosen_bin = path[blk_gi]
+    chosen_cand = chosen_bin * 4 + bin_local_arg[np.arange(B), chosen_bin]
+
+    global_best = np.argmin(cand_errors, axis=1).astype(np.int64)
+    cur_e = cand_errors[np.arange(B), chosen_cand]
+    g_e = cand_errors[np.arange(B), global_best]
+    return np.where(g_e < cur_e * cfg.greedy_override_ratio, global_best, chosen_cand)
+
+
+def _quantize_q1_0_hpc_cpu(
+    X: np.ndarray, W: np.ndarray, cfg: HPCConfig
+) -> tuple[bytes, float]:
+    """Full HPC V2 Q1_0 pipeline on CPU for a chunk of (B, 128) blocks."""
+    B = X.shape[0]
+    X_f32 = X.astype(np.float32)
+    W_f32 = W.astype(np.float32)
+    lam_dc = (float(cfg.dc_lambda) / QK1_0) if cfg.use_spectral else 0.0
+    lam_vw = (float(cfg.vw_lambda) / QK1_0) if cfg.use_spectral else 0.0
+    half = QK1_0 // 2
+
+    # 1. Analog + WLS seed for d* (testing mean, weighted WLS, and companded analog):
+    d_mean = np.mean(np.abs(X_f32), axis=1).astype(np.float32)
+    wsum = np.maximum(np.sum(W_f32, axis=1, keepdims=True), 1.0e-30)
+    d_wls_init = (np.sum(W_f32 * np.abs(X_f32), axis=1, keepdims=True) / wsum)[:, 0].astype(np.float32)
+    mu = np.sum(W_f32 * X_f32, axis=1, keepdims=True) / wsum
+    var = np.sum(W_f32 * (X_f32 - mu) ** 2, axis=1, keepdims=True) / wsum
+    sig = np.sqrt(np.maximum(var, 1.0e-30))
+    x_comp = mu + sig * 1.85 * np.tanh((X_f32 - mu) / (1.85 * sig))
+    d_analog = (np.sum(W_f32 * np.abs(x_comp), axis=1, keepdims=True) / wsum)[:, 0].astype(np.float32)
+
+    wls_d = d_mean.copy()
+    best_seed_sse = np.full(B, np.inf, dtype=np.float64)
+    for d_start in (d_mean, d_wls_init, d_analog, -d_analog):
+        d = d_start.astype(np.float64)
+        for _ in range(2):
+            q = np.where(d[:, None] >= 0.0, X_f32 >= 0.0, X_f32 < 0.0).astype(np.int64)
+            c = (2 * q - 1).astype(np.float64)
+            num = np.sum(W_f32 * X_f32 * c, axis=1, dtype=np.float64)
+            den = np.sum(W_f32, axis=1, dtype=np.float64)
+            valid = den > 1.0e-30
+            d = np.where(valid, num / np.where(valid, den, 1.0), 0.0)
+        df = from_fp16_bits(to_fp16_bits(d.astype(np.float32)))
+        q = np.where(df[:, None] >= 0.0, X_f32 >= 0.0, X_f32 < 0.0).astype(np.float32)
+        c_f = 2.0 * q - 1.0
+        e = X_f32 - df[:, None] * c_f
+        sse = np.sum(W_f32 * e * e, axis=1, dtype=np.float64)
+        take = sse < best_seed_sse
+        best_seed_sse = np.where(take, sse, best_seed_sse)
+        wls_d = np.where(take, df, wls_d)
+
+    # 2. 24-Candidate Field with Extended Spectral Objective:
+    cand_d16 = to_fp16_bits(wls_d[:, None] * MULTS_D[None, :])  # (B, 24)
+    cand_d = from_fp16_bits(cand_d16)                           # (B, 24)
+    q_c = np.where(cand_d[:, :, None] >= 0.0, X_f32[:, None, :] >= 0.0, X_f32[:, None, :] < 0.0).astype(np.float32)
+    c_c = 2.0 * q_c - 1.0
+    e_c = X_f32[:, None, :] - cand_d[:, :, None] * c_c          # (B, 24, 128)
+    sse_c = np.sum(W_f32[:, None, :] * e_c * e_c, axis=2)
+    if cfg.use_spectral and (lam_dc > 0.0 or lam_vw > 0.0):
+        v_c = e_c[:, :, :half] + e_c[:, :, half:]
+        dc_c = np.sum(e_c, axis=2)
+        cand_errors = (sse_c + lam_vw * np.sum(v_c * v_c, axis=2) + lam_dc * dc_c * dc_c).astype(np.float32)
+    else:
+        cand_errors = sse_c.astype(np.float32)
+
+    # 3. 6-State Sieve + 6-State Viterbi DP:
+    best_cand = _q1_sieve_and_viterbi(cand_errors, cfg)
+    rows = np.arange(B)
+    d_sel = cand_d[rows, best_cand]
+
+    # 4. Asymmetric Sign-Flip fp16-ULP Polish (+/-8 ULPs around +d_sel, -d_sel, and d_mean):
+    rad = max(int(cfg.ulp_radius), 4)
+    deltas = np.arange(-rad, rad + 1, dtype=np.int32)
+    pos_b = np.clip(to_fp16_bits(np.abs(d_sel)).astype(np.int32)[:, None] + deltas[None, :], 0, 0x7BFF).astype(np.uint16)
+    neg_b = (pos_b | np.uint16(0x8000)).astype(np.uint16)
+    ref_b = np.clip(to_fp16_bits(np.abs(d_mean)).astype(np.int32)[:, None] + deltas[None, :], 0, 0x7BFF).astype(np.uint16)
+    all_b = np.concatenate([pos_b, neg_b, ref_b], axis=1)
+    all_d = from_fp16_bits(all_b)
+    q_u = np.where(all_d[:, :, None] >= 0.0, X_f32[:, None, :] >= 0.0, X_f32[:, None, :] < 0.0).astype(np.uint8)
+    c_u = 2.0 * q_u.astype(np.float32) - 1.0
+    e_u = X_f32[:, None, :] - all_d[:, :, None] * c_u
+    sse_u = np.sum(W_f32[:, None, :] * e_u * e_u, axis=2, dtype=np.float64)
+    pick_u = np.argmin(sse_u, axis=1)
+    best_d16 = all_b[rows, pick_u]
+    best_d = all_d[rows, pick_u]
+    best_q = q_u[rows, pick_u].astype(np.int64)
+
+    # 5. Closed-Form 1-D Quadratic Vesica + DC Bit-Flip Projection within sse_budget:
+    if cfg.use_spectral and (lam_vw > 0.0 or lam_dc > 0.0):
+        c_f = (2 * best_q - 1).astype(np.float64)
+        d_f64 = best_d.astype(np.float64)[:, None]
+        e = X_f32.astype(np.float64) - d_f64 * c_f
+        sse_live = np.sum(W_f32 * e * e, axis=1, dtype=np.float64)
+        sse_cap = sse_live * (1.0 + cfg.sse_budget)
+        v = e[:, :half] + e[:, half:]
+        dc = np.sum(e, axis=1)
+        denom = 2.0 * (W_f32 + lam_vw + lam_dc) * (d_f64 * d_f64)
+        act_b = np.abs(d_f64) > 1.0e-15
+        s_den = np.where(act_b & (denom > 1.0e-30), denom, 1.0)
+        v_full = np.concatenate([v, v], axis=1)
+        grad = d_f64 * (W_f32 * e + lam_vw * v_full + lam_dc * dc[:, None])
+        dq = np.where(act_b, nearest_int((grad / s_den).astype(np.float32)), 0)
+        q_new = np.clip(best_q + dq, 0, 1)
+        c_new = (2 * q_new - 1).astype(np.float64)
+        e_new = X_f32.astype(np.float64) - d_f64 * c_new
+        sse_new = np.sum(W_f32 * e_new * e_new, axis=1, dtype=np.float64)
+        v_new = e_new[:, :half] + e_new[:, half:]
+        dc_new = np.sum(e_new, axis=1)
+        spec_old = lam_vw * np.sum(v * v, axis=1) + lam_dc * dc * dc
+        spec_new = lam_vw * np.sum(v_new * v_new, axis=1) + lam_dc * dc_new * dc_new
+        accept = (sse_new <= sse_cap) & ((sse_new + spec_new) < (sse_live + spec_old) - 1.0e-15)
+        best_q = np.where(accept[:, None], q_new, best_q)
+
+    best_q_u8 = best_q.astype(np.uint8)
+    out = np.empty((B, Q1_0_BLOCK_BYTES), dtype=np.uint8)
+    out[:, :2] = best_d16.astype("<u2").view(np.uint8).reshape(B, 2)
+    out[:, 2:] = _pack_q1_bits_np(best_q_u8)
+
+    deq_final = best_d[:, None] * (2.0 * best_q_u8.astype(np.float32) - 1.0)
+    raw_sse = float(np.sum((X_f32 - deq_final) ** 2, dtype=np.float64))
+    return out.tobytes(), raw_sse
+
+
+def _quantize_q1_0_hpc_cuda(
+    X_np: np.ndarray, W_np: np.ndarray, dev: "torch.device", cfg: HPCConfig
+) -> tuple[bytes, float]:
+    """Full HPC V2 Q1_0 pipeline on CUDA GPU for a chunk of (B, 128) blocks."""
+    B = X_np.shape[0]
+    lam_dc = (float(cfg.dc_lambda) / QK1_0) if cfg.use_spectral else 0.0
+    lam_vw = (float(cfg.vw_lambda) / QK1_0) if cfg.use_spectral else 0.0
+    half = QK1_0 // 2
+
+    with torch.no_grad():
+        X = torch.from_numpy(X_np).to(dev, dtype=torch.float32)
+        W = torch.from_numpy(W_np).to(dev, dtype=torch.float32)
+
+        # 1. Analog + WLS seed (including negative-scale sign-flip starts):
+        d_mean = torch.mean(torch.abs(X), dim=1)
+        wsum = torch.clamp(torch.sum(W, dim=1, keepdim=True), min=1.0e-30)
+        d_wls_init = (torch.sum(W * torch.abs(X), dim=1, keepdim=True) / wsum).squeeze(1)
+        mu = torch.sum(W * X, dim=1, keepdim=True) / wsum
+        var = torch.sum(W * (X - mu) ** 2, dim=1, keepdim=True) / wsum
+        sig = torch.sqrt(torch.clamp(var, min=1.0e-30))
+        x_comp = mu + sig * 1.85 * torch.tanh((X - mu) / (1.85 * sig))
+        d_analog = (torch.sum(W * torch.abs(x_comp), dim=1, keepdim=True) / wsum).squeeze(1)
+
+        wls_d = d_mean.clone()
+        best_seed_sse = torch.full((B,), float("inf"), dtype=torch.float32, device=dev)
+        for d_start in (d_mean, d_wls_init, d_analog, -d_analog):
+            d = d_start.clone()
+            for _ in range(2):
+                q = torch.where(d[:, None] >= 0.0, X >= 0.0, X < 0.0)
+                c = torch.where(q, 1.0, -1.0)
+                num = torch.sum(W * X * c, dim=1)
+                den = torch.sum(W, dim=1)
+                valid = den > 1.0e-30
+                d = torch.where(valid, num / torch.where(valid, den, torch.ones_like(den)), torch.zeros_like(den))
+            df = d.to(torch.float16).to(torch.float32)
+            q = torch.where(df[:, None] >= 0.0, X >= 0.0, X < 0.0)
+            c = torch.where(q, 1.0, -1.0)
+            e = X - df[:, None] * c
+            sse = torch.sum(W * e * e, dim=1)
+            take = sse < best_seed_sse
+            best_seed_sse = torch.where(take, sse, best_seed_sse)
+            wls_d = torch.where(take, df, wls_d)
+
+        # 2. 24-Candidate Field with Extended Spectral Objective on GPU:
+        mults = torch.tensor(MULTS_D, dtype=torch.float32, device=dev)
+        cand_d = (wls_d[:, None] * mults[None, :]).to(torch.float16).to(torch.float32)  # (B, 24)
+        q_c = torch.where(cand_d[:, :, None] >= 0.0, X[:, None, :] >= 0.0, X[:, None, :] < 0.0)
+        c_c = torch.where(q_c, 1.0, -1.0)
+        e_c = X[:, None, :] - cand_d[:, :, None] * c_c
+        sse_c = torch.sum(W[:, None, :] * e_c * e_c, dim=2)
+        if cfg.use_spectral and (lam_dc > 0.0 or lam_vw > 0.0):
+            v_c = e_c[:, :, :half] + e_c[:, :, half:]
+            dc_c = torch.sum(e_c, dim=2)
+            cand_err_t = sse_c + lam_vw * torch.sum(v_c * v_c, dim=2) + lam_dc * dc_c * dc_c
+        else:
+            cand_err_t = sse_c
+
+        # 3. 6-State Sieve + 6-State Viterbi DP:
+        best_cand_np = _q1_sieve_and_viterbi(cand_err_t.cpu().numpy(), cfg)
+        best_cand_t = torch.from_numpy(best_cand_np).to(dev)
+        rows = torch.arange(B, device=dev)
+        d_sel = cand_d[rows, best_cand_t]
+
+        # 4. Asymmetric Sign-Flip fp16-ULP Polish (+/-8 ULPs around +d_sel, -d_sel, and d_mean):
+        rad = max(int(cfg.ulp_radius), 4)
+        deltas = torch.arange(-rad, rad + 1, dtype=torch.int32, device=dev)
+        abs_bits = torch.abs(d_sel).to(torch.float16).view(torch.int16).to(torch.int32) & 0x7FFF
+        ref_bits = torch.abs(d_mean).to(torch.float16).view(torch.int16).to(torch.int32) & 0x7FFF
+        pos_b = torch.clamp(abs_bits[:, None] + deltas[None, :], 0, 0x7BFF)
+        neg_b = pos_b | 0x8000
+        mean_b = torch.clamp(ref_bits[:, None] + deltas[None, :], 0, 0x7BFF)
+        all_b = torch.cat([pos_b, neg_b, mean_b], dim=1)
+        all_d = all_b.to(torch.int16).view(torch.float16).to(torch.float32)
+        q_u = torch.where(all_d[:, :, None] >= 0.0, X[:, None, :] >= 0.0, X[:, None, :] < 0.0).to(torch.uint8)
+        c_u = 2.0 * q_u.to(torch.float32) - 1.0
+        e_u = X[:, None, :] - all_d[:, :, None] * c_u
+        sse_u = torch.sum(W[:, None, :] * e_u * e_u, dim=2)
+        pick_u = torch.argmin(sse_u, dim=1)
+        best_d16 = all_b[rows, pick_u]
+        best_d = all_d[rows, pick_u]
+        best_q = q_u[rows, pick_u].to(torch.int64)
+
+        # 5. Closed-Form 1-D Quadratic Vesica + DC Bit-Flip Projection within sse_budget:
+        if cfg.use_spectral and (lam_vw > 0.0 or lam_dc > 0.0):
+            d_col = best_d[:, None]
+            e = X - d_col * (2.0 * best_q.to(torch.float32) - 1.0)
+            sse_live = torch.sum(W * e * e, dim=1)
+            sse_cap = sse_live * (1.0 + float(cfg.sse_budget))
+            v = e[:, :half] + e[:, half:]
+            dc = torch.sum(e, dim=1)
+            denom = 2.0 * (W + lam_vw + lam_dc) * (d_col * d_col)
+            act_b = torch.abs(d_col) > 1.0e-15
+            s_den = torch.where(act_b & (denom > 1.0e-30), denom, torch.ones_like(denom))
+            v_full = torch.cat([v, v], dim=1)
+            grad = d_col * (W * e + lam_vw * v_full + lam_dc * dc[:, None])
+            sh_dq = (grad / s_den) + 12582912.0
+            dq = torch.where(
+                act_b,
+                ((sh_dq.view(torch.int32) & 0x007FFFFF) - 0x00400000).to(torch.int64),
+                torch.zeros_like(best_q),
+            )
+            q_new = torch.clamp(best_q + dq, 0, 1)
+            e_new = X - d_col * (2.0 * q_new.to(torch.float32) - 1.0)
+            sse_new = torch.sum(W * e_new * e_new, dim=1)
+            v_new = e_new[:, :half] + e_new[:, half:]
+            dc_new = torch.sum(e_new, dim=1)
+            spec_old = lam_vw * torch.sum(v * v, dim=1) + lam_dc * dc * dc
+            spec_new = lam_vw * torch.sum(v_new * v_new, dim=1) + lam_dc * dc_new * dc_new
+            accept = (sse_new <= sse_cap) & ((sse_new + spec_new) < (sse_live + spec_old) - 1.0e-12)
+            best_q = torch.where(accept[:, None], q_new, best_q)
+
+        best_q_u8 = best_q.to(torch.uint8)
+        deq_fin = best_d[:, None] * (2.0 * best_q_u8.to(torch.float32) - 1.0)
+        raw_sse = float(torch.sum((X - deq_fin) ** 2, dtype=torch.float64).item())
+
+        d16_np = best_d16.to(torch.int16).cpu().numpy().view(np.uint16)
+        q_np = best_q_u8.cpu().numpy()
+        out = np.empty((B, Q1_0_BLOCK_BYTES), dtype=np.uint8)
+        out[:, :2] = d16_np.astype("<u2").view(np.uint8).reshape(B, 2)
+        out[:, 2:] = _pack_q1_bits_np(q_np)
+        return out.tobytes(), raw_sse
+
+
+def quantize_tensor_q1_0(
+    weights: np.ndarray,
+    importance: np.ndarray | None = None,
+    cfg: HPCConfig | None = None,
+    chunk_blocks: int = 65536,
+) -> tuple[bytes, int, float]:
+    """Quantize a tensor to GGML Q1_0 using the full HPC V2 pipeline."""
+    cfg = cfg or HPCConfig()
+    x = np.asarray(weights, dtype=np.float32).ravel()
+    if x.size == 0 or x.size % QK1_0 != 0:
+        raise ValueError("Q1_0 requires a non-empty weight count divisible by 128")
+    n_blocks = x.size // QK1_0
+    X = x.reshape(n_blocks, QK1_0)
+
+    if importance is not None:
+        imp = np.asarray(importance, dtype=np.float32).ravel()
+        if imp.size != x.size:
+            raise ValueError("importance length must match weight count")
+        W_raw = imp.reshape(n_blocks, QK1_0)
+    else:
+        W_raw = None
+
+    use_cuda = cfg.device != "cpu" and cuda_is_available() and (
+        cfg.device.startswith("cuda") or (cfg.device == "auto" and n_blocks >= 64)
+    )
+    dev = torch.device("cuda" if cfg.device == "auto" else cfg.device) if use_cuda else None
+
+    chunks: list[bytes] = []
+    total_sse = 0.0
+    for start in range(0, n_blocks, chunk_blocks):
+        stop = min(start + chunk_blocks, n_blocks)
+        Xb = X[start:stop]
+        sig2 = np.mean(Xb * Xb, axis=1, keepdims=True)
+        if W_raw is None:
+            Wb = np.sqrt(sig2 + Xb * Xb)
+        else:
+            wr = W_raw[start:stop]
+            Wb = np.sqrt(np.maximum(wr, 1.0e-6)) * np.sqrt(sig2 + Xb * Xb) if cfg.temper_imatrix else wr
+        wm = np.mean(Wb, axis=1, keepdims=True)
+        Wb = np.where(wm > 1.0e-30, Wb / np.maximum(wm, 1.0e-30), 1.0).astype(np.float32)
+
+        if use_cuda and dev is not None:
+            raw_b, sse_b = _quantize_q1_0_hpc_cuda(Xb, Wb, dev, cfg)
+        else:
+            raw_b, sse_b = _quantize_q1_0_hpc_cpu(Xb, Wb, cfg)
+        chunks.append(raw_b)
+        total_sse += sse_b
+
+    rmse = float(np.sqrt(total_sse / x.size))
+    return b"".join(chunks), n_blocks, rmse