Revert to keep stock llama compatibility

__main__.py

@@ -53,14 +53,6 @@ def _config_from_args(args) -> HPCConfig:
         cfg.therm_lambda_tilt = float(args.thermal_tilt)
     if args.pin_dc:
         cfg.pin_dc = True
-    if getattr(args, "segment", False):
-        cfg.segment = True
-    if getattr(args, "segment_k", None) is not None:
-        cfg.segment_k = int(args.segment_k)
-    if getattr(args, "segment_iters", None) is not None:
-        cfg.segment_iters = int(args.segment_iters)
-    if getattr(args, "segment_table", None) is not None:
-        cfg.segment_table_size = int(args.segment_table)
     if args.no_q4_fallback:
         cfg.enable_q4_fallback = False
     if args.keep_embd:
@@ -312,32 +304,6 @@ def main() -> None:
         help="zero-DC pin (Q2_K free lunch): re-solve (d, m) on the exact dc=0 line "
         "after assembly/thermal; strictly lowers SSE while driving row-DC residual to ~0",
     )
-    parser.add_argument(
-        "--segment",
-        action="store_true",
-        help="band-major superblock segmentation for Q2_K / Q3_K (emits HPCQ.SEG.V1 label channels)",
-    )
-    parser.add_argument(
-        "--segment-k",
-        type=int,
-        default=None,
-        metavar="K",
-        help="band count k for superblock segmentation (default 16)",
-    )
-    parser.add_argument(
-        "--segment-iters",
-        type=int,
-        default=None,
-        metavar="N",
-        help="proxy fixed-point rounds for superblock segmentation (default 4)",
-    )
-    parser.add_argument(
-        "--segment-table",
-        type=int,
-        default=None,
-        metavar="M",
-        help="generalized permutation lookup table size per tensor (default 256 = +0.031 bpw; 0 = full per-block)",
-    )
     parser.add_argument(
         "--format",
         choices=("mixed", "mixed_q1", "custom", "q1_0", "q3_k", "q4_0", "q2_k"),

config.py

@@ -103,18 +103,6 @@ class HPCConfig:
     # (the Q2_K closed-form pin never spends any).  0 disables the expense.
     pin_budget: float = 0.05
 
-    # ---- self-describing segmentation (V2-only, opt-in) -----------------
-    # Per-superblock deterministic band clustering.  Labels are a pure
-    # function of the block's own dequantized values, so the decoder
-    # recovers the slot->position permutation by recomputation -- no
-    # sidecar, GGUF layout untouched.  Q2_K / Q3_K use segment_k bands
-    # over the 256-weight superblock; Q4_0's 32-wide unit block uses k=1
-    # (ascending value order).
-    segment: bool = False
-    segment_k: int = 16
-    segment_iters: int = 4
-    segment_table_size: int = 256
-
     # ---- seed clamp -----------------------------------------------------
     clamp_kurtosis_off: float = 6.0
     clamp_kurtosis_soft: float = 20.0
@@ -172,13 +160,6 @@ class HPCConfig:
             raise ValueError("therm_t_decay must lie in (0, 1)")
         if self.therm_lambda_tilt < 1.0:
             raise ValueError("therm_lambda_tilt must be >= 1.0 (1.0 = off)")
-        if self.segment:
-            if not (2 <= self.segment_k <= 256):
-                raise ValueError("segment_k must lie in [2, 256]")
-            if self.segment_iters < 1:
-                raise ValueError("segment_iters must be >= 1")
-            if self.segment_table_size < 0 or (0 < self.segment_table_size < 4) or self.segment_table_size > 65535:
-                raise ValueError("segment_table_size must be 0 (full per-block) or lie in [4, 65535]")
         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", "mixed_q1", "custom", "q1_0", "q3_k", "q4_0", "q2_k"):

gguf.py

@@ -26,16 +26,8 @@ from .q2k import QK_K, blocks_to_bytes, dequantize_params_batch, unpack_codes
 from .q3_k import Q3_K_BLOCK_BYTES, QK3_K, dequantize_q3_k_bytes, quantize_tensor_q3_k
 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
-from .segmentation import (
-    label_channel_bytes,
-    pack_label_channel,
-    recover_order,
-    scatter_to_original,
-    unpack_label_channel,
-)
 
 GGUF_MAGIC = 0x46554747
-SEG_KV_PREFIX = "HPCQ.SEG.V1."
 DEFAULT_ALIGNMENT = 32
 
 GGML_TYPE_F32 = 0
@@ -282,15 +274,10 @@ class GGUFReader:
 
     def read_tensor(self, name: str) -> tuple[np.ndarray, int]:
         raw = self.read_tensor_raw(name)
-        x = _dequantize(raw, self.info(name))
-        return self._unsegment(x, name), self.info(name).row_width
+        return _dequantize(raw, self.info(name)), self.info(name).row_width
 
     def iter_tensor_row_chunks(self, name: str, max_elements: int = 8_388_608):
-        """Stream a tensor in row-aligned float32 chunks to bound peak RAM.
-
-        Chunks are unsegmented: if the tensor carries an HPCQ label channel,
-        each yielded chunk is scattered back to original order.
-        """
+        """Stream a tensor in row-aligned float32 chunks to bound peak RAM."""
         ti = self.info(name)
         row = ti.row_width
         blk = BLOCK_SIZE[ti.type]
@@ -298,10 +285,6 @@ class GGUFReader:
             x, r = self.read_tensor(name)
             yield x, r, 0, ti.n_elements // max(r, 1)
             return
-        seg_2d = None
-        seg = self.seg_labels(name)
-        if seg is not None:
-            seg_2d = seg[0]
         n_rows = ti.n_elements // row
         rows_per_chunk = max(1, max_elements // row)
         bytes_per_row = (row // blk) * BLOCK_BYTES[ti.type]
@@ -314,69 +297,8 @@ class GGUFReader:
                 raw = f.read(chunk_bytes)
                 if len(raw) != chunk_bytes:
                     raise ValueError(f"{name}: truncated tensor data")
-                sub = _dequantize(raw, TensorInfo(ti.name, (chunk_elems,), ti.type, 0))
-                if seg_2d is not None:
-                    b0 = r0 * (row // blk)
-                    b1 = b0 + (r1 - r0) * (row // blk)
-                    sub = _scatter_rows(sub, seg_2d[b0:b1])
-                yield sub, row, r0, r1
-
-    def _seg_content(self, name: str) -> bytes | None:
-        """Raw packed label channel bytes for ``name`` (undecoded KV value)."""
-        for key, vtype, raw in self.kv_pairs:
-            if key == SEG_KV_PREFIX + name:
-                if vtype == 8:
-                    # legacy: string value, u64 length prefix then raw bytes
-                    if len(raw) < 8:
-                        raise ValueError(f"{name}: corrupt label channel KV")
-                    return raw[8:]
-                if vtype == 9:
-                    # uint8 array: u32 element type + u64 count + data
-                    if len(raw) < 12:
-                        raise ValueError(f"{name}: corrupt label channel KV")
-                    if struct.unpack("<I", raw[:4])[0] != 0:
-                        raise ValueError(f"{name}: label channel array is not uint8")
-                    n = struct.unpack("<Q", raw[4:12])[0]
-                    if len(raw) < 12 + n:
-                        raise ValueError(f"{name}: truncated label channel array")
-                    return raw[12 : 12 + n]
-                raise ValueError(f"{name}: label channel KV has bad type {vtype}")
-        return None
-        return None
-
-    def seg_labels(self, name: str) -> tuple[np.ndarray, int] | None:
-        """Decode a tensor's label channel (labels per ORIGINAL position).
-
-        Returns ``(labels_2d, k)`` where ``labels_2d`` is shaped
-        ``(n_blocks, block_qk)``, or ``None`` when no channel is present.
-        """
-        content = self._seg_content(name)
-        if content is None:
-            return None
-        ti = self.info(name)
-        if ti.type not in (GGML_TYPE_Q2_K, GGML_TYPE_Q3_K):
-            raise ValueError(f"{name}: label channel on non-segmentable type {ti.type_name}")
-        blk = QK_K if ti.type == GGML_TYPE_Q2_K else QK3_K
-        k, labels = unpack_label_channel(content)
-        if labels.size != ti.n_elements:
-            raise ValueError(
-                f"{name}: label channel size {labels.size} != tensor elements {ti.n_elements}"
-            )
-        return labels.reshape(ti.n_elements // blk, blk), k
-
-    def _unsegment(self, x: np.ndarray, name: str) -> np.ndarray:
-        seg = self.seg_labels(name)
-        if seg is None:
-            return x
-        return _scatter_rows(x, seg[0])
-
-
-def _scatter_rows(x: np.ndarray, labels_2d: np.ndarray) -> np.ndarray:
-    """Scatter slot-order values back to original positions via the channel."""
-    out = scatter_to_original(
-        x.reshape(labels_2d.shape).astype(np.float32), recover_order(labels_2d)
-    )
-    return out.reshape(-1)
+                sub_ti = TensorInfo(ti.name, (chunk_elems,), ti.type, 0)
+                yield _dequantize(raw, sub_ti), row, r0, r1
 
 
 def _dequantize(raw: bytes, ti: TensorInfo) -> np.ndarray:
@@ -796,9 +718,6 @@ def write_quantized_gguf(
     attn_q4 = bool(getattr(cfg, "promote_attn_q4", False))
     q_format = str(getattr(cfg, "quant_format", "mixed"))
     custom_map = getattr(cfg, "custom_quant_map", None) or None
-    seg_active = bool(getattr(cfg, "segment", False))
-    seg_k = max(2, int(getattr(cfg, "segment_k", 16)))
-    seg_table_size = int(getattr(cfg, "segment_table_size", 256))
 
     plan: list[str | None] = []
     quantized_count = 0
@@ -893,27 +812,11 @@ def write_quantized_gguf(
     ftype_code = 11 if has_q3k else (10 if has_q2k else (40 if has_q1_0 else 2))
     kv_pairs = []
     for key, vtype, raw in reader.kv_pairs:
-        if key.startswith(SEG_KV_PREFIX):
-            continue
         if quantized_count and key == "general.file_type" and vtype == 4:
             raw = struct.pack("<I", ftype_code)
         elif quantized_count and key == "general.quantization_version" and vtype == 4:
             raw = struct.pack("<I", 2)
         kv_pairs.append((key, vtype, raw))
-    # Reserve label channels for every planned segmented tensor so the KV
-    # section layout is final before data streaming; contents are patched
-    # in place (same length) after each tensor is quantized.
-    seg_reserve: dict[str, int] = {}
-    if seg_active:
-        for ti, fmt in zip(reader.tensors, plan):
-            if fmt in ("Q2_K", "Q3_K"):
-                key = SEG_KV_PREFIX + ti.name
-                content_len = label_channel_bytes(ti.n_elements, seg_k, seg_table_size)
-                seg_reserve[key] = content_len
-                # GGUF uint8 array: u32 element type + u64 count + zeros
-                kv_pairs.append(
-                    (key, 9, struct.pack("<I", 0) + struct.pack("<Q", content_len) + bytes(content_len))
-                )
 
     output_path = Path(output_path)
     output_path.parent.mkdir(parents=True, exist_ok=True)
@@ -928,22 +831,10 @@ def write_quantized_gguf(
     model_t0 = time.time()
     with output_path.open("wb") as fout:
         fout.write(struct.pack("<IIQQ", GGUF_MAGIC, reader.version, len(out_infos), len(kv_pairs)))
-        seg_patch_offsets: dict[str, int] = {}
         for key, vtype, raw in kv_pairs:
             _write_string(fout, key)
             fout.write(struct.pack("<I", vtype))
-            if key in seg_reserve:
-                seg_patch_offsets[key] = fout.tell()
             fout.write(raw)
-
-        def _patch_seg_kv(fout, key: str, labels: np.ndarray) -> None:
-            packed = pack_label_channel(labels, seg_k, seg_table_size)
-            if len(packed) != seg_reserve.get(key, -1):
-                raise RuntimeError(f"{key}: label channel size {len(packed)} != reserved")
-            pos = fout.tell()
-            fout.seek(seg_patch_offsets[key] + 12)  # skip u32 array type + u64 count
-            fout.write(packed)
-            fout.seek(pos)
         for ti, out_type, out_size, offset in out_infos:
             _write_string(fout, ti.name)
             fout.write(struct.pack("<I", len(ti.dims)))
@@ -1027,8 +918,6 @@ def write_quantized_gguf(
                 if len(payload) != out_size:
                     raise RuntimeError(f"{ti.name}: Q2_K payload size mismatch")
                 fout.write(payload)
-                if seg_active and res.segment_labels is not None:
-                    _patch_seg_kv(fout, SEG_KV_PREFIX + ti.name, res.segment_labels)
                 total_rmse += res.stats.rmse * res.stats.rmse * x.size
                 total_elements += x.size
                 total_quantized += 1
@@ -1056,26 +945,14 @@ def write_quantized_gguf(
                 sse_q3 = 0.0
                 done_q3_blks = 0
                 t_q3_start = time.time()
-                q3_labels: list[np.ndarray] = []
 
-                q3_max_elems = ti.n_elements if seg_active else 8_388_608
-                for x_chunk, row, _r0, _r1 in reader.iter_tensor_row_chunks(ti.name, max_elements=q3_max_elems):
+                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
-                    if seg_active:
-                        q3_bytes, nb_chunk, chunk_rmse, chunk_labels = quantize_tensor_q3_k(
-                            x_chunk,
-                            importance=imp_chunk,
-                            cfg=cfg,
-                            chunk_blocks=8192,
-                            return_labels=True,
-                        )
-                        q3_labels.append(np.asarray(chunk_labels, dtype=np.int64).ravel())
-                    else:
-                        q3_bytes, nb_chunk, chunk_rmse = quantize_tensor_q3_k(
-                            x_chunk, importance=imp_chunk, cfg=cfg, chunk_blocks=8192
-                        )
+                    q3_bytes, nb_chunk, chunk_rmse = quantize_tensor_q3_k(
+                        x_chunk, importance=imp_chunk, cfg=cfg, chunk_blocks=8192
+                    )
                     fout.write(q3_bytes)
                     written_bytes += len(q3_bytes)
                     sse_q3 += (chunk_rmse * chunk_rmse) * x_chunk.size
@@ -1111,8 +988,6 @@ def write_quantized_gguf(
 
                 if written_bytes != out_size:
                     raise RuntimeError(f"{ti.name}: Q3_K payload size mismatch")
-                if seg_active:
-                    _patch_seg_kv(fout, SEG_KV_PREFIX + ti.name, np.concatenate(q3_labels))
                 completed_planned_blocks += eff_tb
                 q3_rmse = float(np.sqrt(sse_q3 / ti.n_elements))
                 total_rmse += sse_q3

gui.py

@@ -70,12 +70,10 @@ from hpc_quantize_v2 import (
     read_imatrix,
 )
 from hpc_quantize_v2.gguf import (
-    SEG_KV_PREFIX,
     is_q1_0_eligible,
     is_q2k_eligible,
     is_q3_k_eligible,
     is_q4_0_eligible,
-    label_channel_bytes,
     target_quant_type,
     tensor_type_key,
     write_quantized_gguf,
@@ -186,10 +184,6 @@ class HPCQuantizeGUI:
         self.thermal_var = tk.IntVar(value=0)
         self.thermal_tilt_var = tk.DoubleVar(value=1.0)
         self.pin_dc_var = tk.BooleanVar(value=False)
-        self.segment_var = tk.BooleanVar(value=False)
-        self.segment_k_var = tk.IntVar(value=16)
-        self.segment_iters_var = tk.IntVar(value=4)
-        self.segment_table_var = tk.IntVar(value=256)
 
         self.cli_preview_var = tk.StringVar()
         self.status_var = tk.StringVar(value="Ready.")
@@ -223,16 +217,8 @@ class HPCQuantizeGUI:
             self.promote_attn_q4_var,
             self.quant_format_var,
             self.thermal_var,
-            self.thermal_tilt_var,
-            self.pin_dc_var,
-            self.segment_var,
-            self.segment_k_var,
-            self.segment_iters_var,
-            self.segment_table_var,
         ):
             v.trace_add("write", lambda *_: self._update_cli_preview())
-        for v in (self.segment_var, self.segment_k_var, self.segment_table_var):
-            v.trace_add("write", lambda *_: self._refresh_plan_view())
 
     def _apply_theme(self) -> None:
         style = ttk.Style(self.root)
@@ -497,30 +483,10 @@ class HPCQuantizeGUI:
             text="Pin DC residual to 0 (Q2_K free lunch)",
             variable=self.pin_dc_var,
         ).grid(row=3, column=0, columnspan=2, sticky=tk.W, padx=4, pady=1)
-        ttk.Checkbutton(
-            spec_f,
-            text="Band-Major Segmentation (Q2_K / Q3_K)",
-            variable=self.segment_var,
-        ).grid(row=3, column=2, columnspan=2, sticky=tk.W, padx=4, pady=1)
-        ttk.Label(spec_f, text="Seg Bands (k):").grid(row=4, column=0, sticky=tk.W, padx=4, pady=2)
-        ttk.Spinbox(
-            spec_f, from_=2, to=16, increment=1, textvariable=self.segment_k_var, width=8
-        ).grid(row=4, column=1, sticky=tk.EW, padx=4, pady=2)
-        ttk.Label(spec_f, text="Seg Iters:").grid(row=4, column=2, sticky=tk.W, padx=4, pady=2)
-        ttk.Spinbox(
-            spec_f, from_=1, to=12, increment=1, textvariable=self.segment_iters_var, width=8
-        ).grid(row=4, column=3, sticky=tk.EW, padx=4, pady=2)
-        ttk.Label(spec_f, text="Seg Lookup Table (0=full):").grid(row=5, column=0, columnspan=2, sticky=tk.W, padx=4, pady=2)
-        ttk.Combobox(
-            spec_f,
-            textvariable=self.segment_table_var,
-            values=(0, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096),
-            width=8,
-        ).grid(row=5, column=2, columnspan=2, sticky=tk.EW, padx=4, pady=2)
         ttk.Label(
             spec_f, text="(λ multiplier ≥1 during thermal anneal; ~1e2–1e3 ≈ zero-coherent-residual '0-error' anneal)",
             foreground="#93c5fd",
-        ).grid(row=6, column=0, columnspan=4, sticky=tk.W, padx=4, pady=(0, 2))
+        ).grid(row=4, column=0, columnspan=4, sticky=tk.W, padx=4, pady=(0, 2))
 
         # Right: GGUF Tensor Browser
         browser_frame = ttk.LabelFrame(right_pane, text="3. GGUF Tensor Inspector & Live Status", padding=8)
@@ -850,10 +816,6 @@ class HPCQuantizeGUI:
             therm_passes=max(0, int(self.thermal_var.get())),
             therm_lambda_tilt=max(1.0, float(self.thermal_tilt_var.get())),
             pin_dc=bool(self.pin_dc_var.get()),
-            segment=bool(self.segment_var.get()),
-            segment_k=max(2, int(self.segment_k_var.get())),
-            segment_iters=max(1, int(self.segment_iters_var.get())),
-            segment_table_size=max(0, int(self.segment_table_var.get())),
             quant_format=self.quant_format_var.get(),
             custom_quant_map=self._custom_map_for_plan() or {},
             enable_q4_fallback=bool(self.q4_fallback_var.get()) and self.quant_format_var.get() not in ("q2_k", "q3_k"),
@@ -907,14 +869,6 @@ class HPCQuantizeGUI:
             cmd += ["--thermal-tilt", str(float(self.thermal_tilt_var.get()))]
         if self.pin_dc_var.get():
             cmd += ["--pin-dc"]
-        if self.segment_var.get():
-            cmd += ["--segment"]
-            if int(self.segment_k_var.get()) != 16:
-                cmd += ["--segment-k", str(int(self.segment_k_var.get()))]
-            if int(self.segment_iters_var.get()) != 4:
-                cmd += ["--segment-iters", str(int(self.segment_iters_var.get()))]
-            if int(self.segment_table_var.get()) != 256:
-                cmd += ["--segment-table", str(int(self.segment_table_var.get()))]
         cmd.append("--verbose")
         return " ".join(shlex.quote(part) for part in cmd)
 
@@ -978,43 +932,6 @@ class HPCQuantizeGUI:
             self._refresh_plan_view()
         self._update_cli_preview()
 
-    def _estimate_seg_bytes(self, ti, tgt: str | None) -> int:
-        if not bool(self.segment_var.get()) or tgt not in ("Q2_K", "Q3_K"):
-            return 0
-        try:
-            seg_k = max(2, int(self.segment_k_var.get()))
-        except Exception:
-            seg_k = 16
-        try:
-            seg_tbl = max(0, int(self.segment_table_var.get()))
-        except Exception:
-            seg_tbl = 256
-        content_len = label_channel_bytes(ti.n_elements, seg_k, seg_tbl)
-        key_len = len((SEG_KV_PREFIX + ti.name).encode("utf-8"))
-        return 8 + key_len + 4 + 12 + content_len
-
-    def _format_size_summary(self, planned_bytes: int, total_seg_bytes: int) -> str:
-        if planned_bytes >= 1024 ** 3:
-            planned_text = f"{planned_bytes / (1024 ** 3):.2f} GiB"
-        elif planned_bytes >= 1024 ** 2:
-            planned_text = f"{planned_bytes / (1024 ** 2):.1f} MiB"
-        else:
-            planned_text = f"{planned_bytes / 1024:.1f} KiB"
-        if total_seg_bytes > 0:
-            try:
-                seg_tbl = max(0, int(self.segment_table_var.get()))
-            except Exception:
-                seg_tbl = 256
-            if total_seg_bytes >= 1024 ** 3:
-                seg_txt = f"+{total_seg_bytes / (1024 ** 3):.2f} GiB"
-            elif total_seg_bytes >= 1024 ** 2:
-                seg_txt = f"+{total_seg_bytes / (1024 ** 2):.1f} MiB"
-            else:
-                seg_txt = f"+{total_seg_bytes / 1024:.1f} KiB"
-            lut_lbl = f"LUT={seg_tbl}" if seg_tbl > 0 else "full"
-            planned_text = f"{planned_text} [seg {seg_txt}, {lut_lbl}]"
-        return planned_text
-
     def _refresh_plan_view(self) -> None:
         if self._reader is None:
             return
@@ -1022,8 +939,7 @@ class HPCQuantizeGUI:
         scope_selected = self.mode_var.get() == "selected"
         n_q2, n_q3, n_q4, n_copy = 0, 0, 0, 0
         n_q1 = 0
-        planned_bytes = int(getattr(self._reader, "data_start", 0))
-        total_seg_bytes = 0
+        planned_bytes = 0
         for ti in self._reader.tensors:
             tgt = self._plan_target(ti, chosen, scope_selected)
             if tgt == "Q2_K":
@@ -1047,9 +963,6 @@ class HPCQuantizeGUI:
                 planned_bytes += (ti.n_elements // QK1_0) * Q1_0_BLOCK_BYTES
             else:
                 planned_bytes += ti.n_bytes
-            seg_b = self._estimate_seg_bytes(ti, tgt)
-            planned_bytes += seg_b
-            total_seg_bytes += seg_b
 
             if not self.tree.exists(ti.name):
                 continue
@@ -1067,7 +980,12 @@ class HPCQuantizeGUI:
             vals[6] = state_str
             self.tree.item(ti.name, tags=(tgt_label,), values=vals)
 
-        planned_text = self._format_size_summary(planned_bytes, total_seg_bytes)
+        if planned_bytes >= 1024 ** 3:
+            planned_text = f"{planned_bytes / (1024 ** 3):.2f} GiB"
+        elif planned_bytes >= 1024 ** 2:
+            planned_text = f"{planned_bytes / (1024 ** 2):.1f} MiB"
+        else:
+            planned_text = f"{planned_bytes / 1024:.1f} KiB"
         scope_text = "selected" if scope_selected else "all"
         self.status_var.set(
             f"Plan ({self.quant_format_var.get().upper()}, {scope_text}): {n_q1} Q1_0 | {n_q2} Q2_K | {n_q3} Q3_K | {n_q4} Q4_0 | {n_copy} Copy "
@@ -1084,8 +1002,7 @@ class HPCQuantizeGUI:
         plan_filt = self.plan_filter_var.get()
         n_q2, n_q3, n_q4, n_copy = 0, 0, 0, 0
         n_q1 = 0
-        planned_bytes = int(getattr(self._reader, "data_start", 0))
-        total_seg_bytes = 0
+        planned_bytes = 0
         for ti in self._reader.tensors:
             tgt = self._plan_target(ti, chosen, scope_selected)
             if tgt == "Q2_K":
@@ -1109,9 +1026,6 @@ class HPCQuantizeGUI:
                 planned_bytes += (ti.n_elements // QK1_0) * Q1_0_BLOCK_BYTES
             else:
                 planned_bytes += ti.n_bytes
-            seg_b = self._estimate_seg_bytes(ti, tgt)
-            planned_bytes += seg_b
-            total_seg_bytes += seg_b
 
             tgt_label = tgt if tgt else "Copy"
             if plan_filt != "ALL" and tgt_label.upper() != plan_filt:
@@ -1153,7 +1067,12 @@ class HPCQuantizeGUI:
         keep_selected = [n for n in chosen if self.tree.exists(n)]
         if keep_selected:
             self.tree.selection_set(keep_selected)
-        planned_text = self._format_size_summary(planned_bytes, total_seg_bytes)
+        if planned_bytes >= 1024 ** 3:
+            planned_text = f"{planned_bytes / (1024 ** 3):.2f} GiB"
+        elif planned_bytes >= 1024 ** 2:
+            planned_text = f"{planned_bytes / (1024 ** 2):.1f} MiB"
+        else:
+            planned_text = f"{planned_bytes / 1024:.1f} KiB"
         scope_text = "selected" if scope_selected else "all"
         self.status_var.set(
             f"Plan ({self.quant_format_var.get().upper()}, {scope_text}): {n_q1} Q1_0 | {n_q2} Q2_K | {n_q3} Q3_K | {n_q4} Q4_0 | {n_copy} Copy "

pipeline.py

@@ -2,7 +2,6 @@
 
 Pipeline stages (mirroring the C engine, with V2 fixes):
 
-0. self-describing per-superblock segmentation (opt-in, ``cfg.segment``);
 1. kurtosis-gated outlier clamp and batched GGML seeds;
 2. vectorised WLS superblock solve;
 3. factored candidate field + standalone factored floor;
@@ -73,8 +72,6 @@ class TensorStats:
     factor_floor_used: int
     candidate_floor_used: int
     therm_improved: int = 0
-    segment_rounds: int = 0
-    segment_flips: int = 0
 
 
 @dataclass(slots=True)
@@ -87,22 +84,10 @@ class QuantizedTensor:
     factor_objectives: np.ndarray
     config: HPCConfig
     stats: TensorStats
-    segment_perm: np.ndarray | None = None
-    segment_labels: np.ndarray | None = None
 
     def dequantize(self) -> np.ndarray:
         return np.concatenate([b.dequantize() for b in self.blocks])
 
-    def dequantize_original(self) -> np.ndarray:
-        """Consumer-side reconstruction: scatter dequantized slots back to
-        original positions using the stored label channel (exact)."""
-        if self.segment_perm is None:
-            return self.dequantize()
-        Xh = np.stack([b.dequantize() for b in self.blocks])
-        out = np.empty_like(Xh)
-        np.put_along_axis(out, self.segment_perm, Xh, axis=1)
-        return out.ravel()
-
 
 def _phase2_wls(X, W, seeds, cfg: HPCConfig):
     n = X.shape[0]
@@ -879,39 +864,6 @@ class Q2KQuantizer:
         x = x.ravel()
         n_blocks = x.size // QK_K
 
-        seg_perm = None
-        seg_labels = None
-        seg_rounds = 0
-        seg_flips = 0
-
-        if cfg.segment:
-            from .segmentation import apply_order, q2k_proxy_cfg, segment_stage
-
-            _emit(
-                "Phase 0: Band-Major Segmentation & Lookup Table",
-                0,
-                n_blocks,
-                f"Building {cfg.segment_table_size}-entry LUT & assigning {n_blocks:,} superblocks (k={cfg.segment_k})",
-            )
-            X_p = x.reshape(n_blocks, QK_K)
-            imp2d = (
-                None
-                if importance is None
-                else np.asarray(importance, dtype=np.float32).ravel().reshape(n_blocks, QK_K)
-            )
-            clamp_val0 = float(seed_clamp_value(x, cfg))
-            proxy = q2k_proxy_cfg(clamp_val0, cfg)
-            seg_perm, seg_labels, seg_rounds = segment_stage(
-                X_p, imp2d, cfg, proxy, max(2, int(cfg.segment_k))
-            )
-            X_p = apply_order(X_p, seg_perm).astype(np.float32)
-            x = np.ascontiguousarray(X_p.ravel())
-            if imp2d is not None:
-                importance = np.ascontiguousarray(
-                    apply_order(imp2d, seg_perm).astype(np.float32).ravel()
-                )
-            X_p = None
-
         if cfg.device != "cpu":
             from .cuda_backend import cuda_is_available, quantize_cuda
 
@@ -920,7 +872,7 @@ class Q2KQuantizer:
             ):
                 dev_str = "cuda" if cfg.device == "auto" else cfg.device
                 res = quantize_cuda(
-                    x if seg_labels is not None else weights,
+                    weights,
                     importance,
                     row_width,
                     cfg,
@@ -928,17 +880,6 @@ class Q2KQuantizer:
                     stop_event=stop_event,
                     device=dev_str,
                 )
-                if seg_perm is not None:
-                    from .segmentation import band_labels
-
-                    n_chk = min(n_blocks, 256)
-                    Xh = np.stack([b.dequantize() for b in res.blocks[:n_chk]]).astype(np.float64)
-                    labels_slot = np.take_along_axis(seg_labels[:n_chk], seg_perm[:n_chk], axis=1)
-                    labels_rec = band_labels(Xh, max(2, int(cfg.segment_k)))
-                    res.stats.segment_rounds = seg_rounds
-                    res.stats.segment_flips = int(np.count_nonzero(labels_rec != labels_slot))
-                    res.segment_perm = seg_perm
-                    res.segment_labels = seg_labels
                 if cfg.verbose:
                     _report(res.stats)
                 return res
@@ -1258,17 +1199,6 @@ class Q2KQuantizer:
             else:
                 weighted += float(np.dot(W[i].astype(np.float64), e * e))
 
-        if seg_perm is not None:
-            # informational: how many labels a channelless decoder would
-            # mis-derive from the stored slot values
-            from .segmentation import band_labels
-
-            n_chk = min(n_blocks, 256)
-            Xh = np.stack([b.dequantize() for b in blocks[:n_chk]]).astype(np.float64)
-            labels_slot = np.take_along_axis(seg_labels[:n_chk], seg_perm[:n_chk], axis=1)
-            labels_rec = band_labels(Xh, max(2, int(cfg.segment_k)))
-            seg_flips = int(np.count_nonzero(labels_rec != labels_slot))
-
         rmse = float(np.sqrt(total_sse / x.size))
         stats = TensorStats(
             n_blocks=n_blocks,
@@ -1281,8 +1211,6 @@ class Q2KQuantizer:
             factor_floor_used=factor_floor_used,
             candidate_floor_used=candidate_floor_used,
             therm_improved=therm_improved,
-            segment_rounds=seg_rounds,
-            segment_flips=seg_flips,
         )
         _emit(
             "Phase 5: Tensor Complete",
@@ -1309,8 +1237,6 @@ class Q2KQuantizer:
             factor_objectives=factor_objectives,
             config=cfg,
             stats=stats,
-            segment_perm=seg_perm,
-            segment_labels=seg_labels,
         )
         if cfg.verbose:
             _report(stats)
@@ -1332,8 +1258,6 @@ def _stack_blocks(blocks):
 
 def _report(stats: TensorStats) -> None:
     extra = f" therm={stats.therm_improved}" if stats.therm_improved else ""
-    if stats.segment_rounds:
-        extra += f" seg(rounds={stats.segment_rounds}, flips={stats.segment_flips})"
     print(
         f"Q2_K V2: blocks={stats.n_blocks} rmse={stats.rmse:.6e} "
         f"rmse/sigma={stats.rmse_over_sigma:.5f} temp={stats.temperature:.3e} "

q3_k.py

@@ -983,17 +983,12 @@ def quantize_tensor_q3_k(
     importance: np.ndarray | None = None,
     cfg: HPCConfig | None = None,
     chunk_blocks: int | None = None,
-    return_labels: bool = False,
-):
+) -> tuple[bytes, int, float]:
     """Quantize a tensor to GGML Q3_K using the full HPC V2 pipeline.
 
     ``chunk_blocks`` (256-weight super-blocks per chunk) defaults to
     ``Q3_K_CHUNK_BLOCKS_CUDA`` on the GPU path (same weights-per-chunk as the
     Q4_0 reference) and ``Q3_K_CHUNK_BLOCKS_CPU`` on the CPU path.
-
-    With ``return_labels=True`` returns ``(payload, n_blocks, rmse, labels)``
-    where ``labels`` is the segmentation label channel (one band id per
-    original position, or None when segmentation is off).
     """
     cfg = cfg or HPCConfig()
     x = np.asarray(weights, dtype=np.float32).ravel()
@@ -1010,22 +1005,6 @@ def quantize_tensor_q3_k(
     else:
         W_raw = None
 
-    if cfg.segment:
-        from .segmentation import apply_order, band_labels, q3k_proxy, segment_stage
-
-        seg_order, seg_labels, seg_rounds = segment_stage(
-            X, W_raw, cfg, q3k_proxy, max(2, int(cfg.segment_k))
-        )
-        X = np.ascontiguousarray(apply_order(X.astype(np.float64), seg_order)).astype(np.float32)
-        if W_raw is not None:
-            W_raw = np.ascontiguousarray(
-                apply_order(W_raw.astype(np.float64), seg_order)
-            ).astype(np.float32)
-    else:
-        seg_order = None
-        seg_labels = None
-        seg_rounds = 0
-
     cuda_ok = cfg.device != "cpu" and cuda_is_available()
     use_cuda = cuda_ok and (
         cfg.device.startswith("cuda") or (cfg.device == "auto" and n_blocks >= 64)
@@ -1062,22 +1041,4 @@ def quantize_tensor_q3_k(
         total_sse += sse_b
 
     rmse = float(np.sqrt(total_sse / x.size))
-
-    if cfg.segment:
-        n_chk = min(n_blocks, 256)
-        raw_chk = b"".join(chunks)[: n_chk * Q3_K_BLOCK_BYTES]
-        xh = np.asarray(dequantize_q3_k_bytes(raw_chk, n_chk), dtype=np.float64).reshape(
-            n_chk, QK3_K
-        )
-        labels_slot = np.take_along_axis(seg_labels[:n_chk], seg_order[:n_chk], axis=1)
-        labels_rec = band_labels(xh, max(2, int(cfg.segment_k)))
-        seg_flips = int(np.count_nonzero(labels_rec != labels_slot))
-        _log.info(
-            "Q3_K segmentation: rounds=%d channelless flips=%d rmse=%.6e",
-            seg_rounds, seg_flips, rmse,
-        )
-
-    payload = b"".join(chunks)
-    if return_labels:
-        return payload, n_blocks, rmse, seg_labels
-    return payload, n_blocks, rmse
+    return b"".join(chunks), n_blocks, rmse

q4_0.py

@@ -28,8 +28,6 @@ per 18-byte block = 4.5 bpw):
 from __future__ import annotations
 
 from math import ceil
-import logging
-
 import numpy as np
 
 try:
@@ -50,8 +48,6 @@ QK4_0 = 32
 Q4_0_BLOCK_BYTES = 18
 Q4_N_CAND = 24
 Q4_N_STATES = 6
-
-_log = logging.getLogger(__name__)
 Q4_N_LEVELS = 16
 
 
@@ -587,16 +583,6 @@ def quantize_tensor_q4_0(
     else:
         W_raw = None
 
-    if cfg.segment:
-        # Q4_0's unit block (32 weights, one scale+min) has no per-band
-        # sub-scale dof to align, position-ascending k=1 layout is the
-        # identity permutation, and the permutation channel would pay 8
-        # bits per weight for nothing.  Explicit no-op for now.
-        _log.info(
-            "Q4_0 segmentation disabled: unit blocks (d, min) have no band dof "
-            "to align (k=1 layout is the identity)"
-        )
-
     use_cuda = cfg.device != "cpu" and cuda_is_available() and (
         cfg.device.startswith("cuda") or (cfg.device == "auto" and n_blocks >= 64)
     )