Upload 5 files

__main__.py

@@ -22,6 +22,7 @@ from .config import HPCConfig
 from .factored import factor_only_solve
 from .gguf import (
     GGUFReader,
+    SUPPORTED_READ_TYPES,
     expand_importance,
     is_q2k_eligible,
     lookup_imatrix,
@@ -126,6 +127,8 @@ def _run_gguf(args, cfg: HPCConfig) -> None:
                 source_type=ti.type,
                 custom_quant_map=cfg.custom_quant_map or None,
             )
+            if tgt is not None and ti.type not in SUPPORTED_READ_TYPES:
+                tgt = None
             tag = tgt if tgt else "COPY"
             print(
                 f"  {tag:4s} {ti.name:48s} {ti.type_name:6s} "

gguf.py

@@ -51,6 +51,19 @@ TYPE_NAME = {
     GGML_TYPE_Q2_K: "Q2_K",
     GGML_TYPE_BF16: "BF16",
     GGML_TYPE_Q1_0: "Q1_0",
+    11: "Q3_K",
+    12: "Q4_K",
+    13: "Q5_K",
+    14: "Q6_K",
+    15: "Q8_K",
+    16: "IQ2_XXS",
+    17: "IQ2_XS",
+    18: "IQ3_XXS",
+    19: "IQ1_S",
+    20: "IQ4_NL",
+    21: "IQ3_S",
+    22: "IQ2_S",
+    23: "IQ4_XS",
 }
 
 BLOCK_SIZE = {
@@ -64,6 +77,11 @@ BLOCK_SIZE = {
     GGML_TYPE_Q8_0: 32,
     GGML_TYPE_Q2_K: QK_K,
     GGML_TYPE_Q1_0: QK1_0,
+    11: QK_K,  # Q3_K
+    12: QK_K,  # Q4_K
+    13: QK_K,  # Q5_K
+    14: QK_K,  # Q6_K
+    15: QK_K,  # Q8_K
 }
 BLOCK_BYTES = {
     GGML_TYPE_F32: 4,
@@ -76,6 +94,11 @@ BLOCK_BYTES = {
     GGML_TYPE_Q8_0: 34,
     GGML_TYPE_Q2_K: 84,
     GGML_TYPE_Q1_0: Q1_0_BLOCK_BYTES,
+    11: 110,  # Q3_K
+    12: 144,  # Q4_K
+    13: 176,  # Q5_K
+    14: 210,  # Q6_K
+    15: 292,  # Q8_K
 }
 TYPE_BPW = {
     GGML_TYPE_F32: 32.0,
@@ -127,6 +150,7 @@ class TensorInfo:
     dims: tuple[int, ...]
     type: int
     offset: int
+    raw_size: int | None = None
 
     @property
     def n_elements(self) -> int:
@@ -145,6 +169,8 @@ class TensorInfo:
 
     @property
     def n_bytes(self) -> int:
+        if self.raw_size is not None:
+            return self.raw_size
         if self.type not in BLOCK_SIZE:
             raise ValueError(f"unsupported GGUF type {self.type} ({self.type_name})")
         block = BLOCK_SIZE[self.type]
@@ -234,6 +260,18 @@ class GGUFReader:
             self.info_end = f.tell()
             self.alignment = int(self.metadata.get("general.alignment", DEFAULT_ALIGNMENT))
             self.data_start = _align(self.info_end, self.alignment)
+        file_size = self.path.stat().st_size
+        for i, ti in enumerate(self.tensors):
+            if ti.type in BLOCK_SIZE:
+                continue
+            end = (
+                self.tensors[i + 1].offset
+                if i + 1 < len(self.tensors)
+                else file_size - self.data_start
+            )
+            if end < ti.offset:
+                raise ValueError(f"{self.path}: tensor '{ti.name}' has an invalid offset")
+            ti.raw_size = end - ti.offset
         self._by_name = {ti.name: ti for ti in self.tensors}
 
     def info(self, name: str) -> TensorInfo:
@@ -1072,3 +1110,52 @@ def write_quantized_gguf(
         "elements": float(total_elements),
         "rmse": rmse,
     }
+
+
+def estimate_gguf_size(
+    reader: GGUFReader,
+    *,
+    enable_q4_fallback: bool = True,
+    quantize_embd_q4: bool = True,
+    promote_attn_q4: bool = False,
+    quant_format: str = "mixed",
+    custom_quant_map: dict[str, str] | None = None,
+) -> int:
+    """Return the projected byte size of a full-model quantized GGUF."""
+    plan: list[tuple[TensorInfo, str | None]] = []
+    for ti in reader.tensors:
+        tgt = target_quant_type(
+            ti.name,
+            ti.dims,
+            enable_q4_fallback=enable_q4_fallback,
+            quantize_embd_q4=quantize_embd_q4,
+            promote_attn_q4=promote_attn_q4,
+            quant_format=quant_format,
+            source_type=ti.type,
+            custom_quant_map=custom_quant_map,
+        )
+        if tgt is not None and ti.type not in SUPPORTED_READ_TYPES:
+            tgt = None
+        plan.append((ti, tgt))
+
+    header = 24
+    for key, _vtype, raw in reader.kv_pairs:
+        header += 8 + len(key.encode("utf-8")) + 4 + len(raw)
+    for ti, _tgt in plan:
+        header += 8 + len(ti.name.encode("utf-8")) + 4 + 8 * len(ti.dims) + 4 + 8
+    data_start = _align(header, reader.alignment)
+
+    offset = 0
+    final_end = data_start
+    for ti, tgt in plan:
+        if tgt == "Q2_K":
+            out_size = (ti.n_elements // QK_K) * 84
+        elif tgt == "Q4_0":
+            out_size = (ti.n_elements // QK4_0) * Q4_0_BLOCK_BYTES
+        elif tgt == "Q1_0":
+            out_size = (ti.n_elements // QK1_0) * Q1_0_BLOCK_BYTES
+        else:
+            out_size = ti.n_bytes
+        final_end = data_start + offset + out_size
+        offset = _align(offset + out_size, reader.alignment)
+    return final_end

gui.py

@@ -62,6 +62,8 @@ from hpc_quantize_v2 import (
     read_imatrix,
 )
 from hpc_quantize_v2.gguf import (
+    SUPPORTED_READ_TYPES,
+    estimate_gguf_size,
     is_q1_0_eligible,
     is_q2k_eligible,
     is_q4_0_eligible,
@@ -174,6 +176,7 @@ class HPCQuantizeGUI:
         self.sse_budget_var = tk.DoubleVar(value=0.0005)
 
         self.cli_preview_var = tk.StringVar()
+        self.custom_size_var = tk.StringVar(value="Projected GGUF size: load a source GGUF")
         self.status_var = tk.StringVar(value="Ready.")
         self.model_progress_var = tk.DoubleVar(value=0.0)
         self.tensor_progress_var = tk.DoubleVar(value=0.0)
@@ -363,6 +366,9 @@ class HPCQuantizeGUI:
         ttk.Label(
             self.custom_frame, textvariable=self.custom_hint_var, style="TeleKey.TLabel"
         ).pack(anchor=tk.W, pady=(4, 0))
+        ttk.Label(
+            self.custom_frame, textvariable=self.custom_size_var
+        ).pack(anchor=tk.W, pady=(2, 0))
 
         opt_row = ttk.Frame(opt_frame)
         opt_row.pack(fill=tk.X, pady=(0, 4))
@@ -713,10 +719,20 @@ class HPCQuantizeGUI:
             ).grid(row=r, column=c * 2 + 1, sticky=tk.W, padx=(0, 12), pady=1)
             rows += 1
 
-        self.custom_hint_var.set(
+        hint = (
             "Quantizable tensor types only; norms/1D tensors and other non-eligible "
             "weights are copied unchanged."
         )
+        unsupported = sorted(
+            {ti.type_name for ti in self._reader.tensors if ti.type not in SUPPORTED_READ_TYPES}
+        )
+        if unsupported:
+            hint += (
+                " Copy-only source formats (cannot down-quantize): "
+                + ", ".join(unsupported)
+                + "."
+            )
+        self.custom_hint_var.set(hint)
         self._update_cli_preview()
 
     def _on_custom_type_changed(self) -> None:
@@ -832,6 +848,31 @@ class HPCQuantizeGUI:
             self.cli_preview_var.set(self.build_cli_command())
         except Exception:
             pass
+        self._update_projected_size()
+
+    def _update_projected_size(self) -> None:
+        if self.quant_format_var.get() != "custom":
+            self.custom_size_var.set("Projected GGUF size: switch to Custom mode")
+            return
+        if self._reader is None:
+            self.custom_size_var.set("Projected GGUF size: load a source GGUF")
+            return
+        try:
+            size = estimate_gguf_size(
+                self._reader,
+                enable_q4_fallback=bool(self.q4_fallback_var.get())
+                and self.quant_format_var.get() != "q2_k",
+                quantize_embd_q4=bool(self.embd_q4_var.get()),
+                promote_attn_q4=bool(self.promote_attn_q4_var.get()),
+                quant_format=self.quant_format_var.get(),
+                custom_quant_map=self._custom_map_for_plan(),
+            )
+        except Exception as exc:
+            self.custom_size_var.set(f"Projected GGUF size: unavailable ({exc})")
+            return
+        self.custom_size_var.set(
+            f"Projected GGUF size: {size / 1024**3:.2f} GiB ({size / 1e9:.2f} GB)"
+        )
 
     def _copy_cli(self) -> None:
         cmd = self.cli_preview_var.get()
@@ -872,7 +913,7 @@ class HPCQuantizeGUI:
         n_q2, n_q4, n_copy = 0, 0, 0
         n_q1 = 0
         for ti in self._reader.tensors:
-            tgt = target_quant_type(
+            requested_tgt = target_quant_type(
                 ti.name,
                 ti.dims,
                 enable_q4_fallback=bool(self.q4_fallback_var.get()) and self.quant_format_var.get() != "q2_k",
@@ -882,6 +923,9 @@ class HPCQuantizeGUI:
                 source_type=ti.type,
                 custom_quant_map=self._custom_map_for_plan(),
             )
+            tgt = requested_tgt
+            if tgt is not None and ti.type not in SUPPORTED_READ_TYPES:
+                tgt = None
             if tgt == "Q2_K":
                 n_q2 += 1
             elif tgt == "Q4_0":
@@ -905,11 +949,14 @@ class HPCQuantizeGUI:
                 self._imatrix is not None
                 and lookup_imatrix(self._imatrix, ti.name) is not None
             )
-            state_str = (
-                f"Pending ({tgt_label})"
-                if tgt
-                else (f"Keep {ti.type_name} (<= target)" if ti.type_name in ("Q1_0", "Q2_K", "Q4_0") else "Passthrough")
-            )
+            if tgt:
+                state_str = f"Pending ({tgt_label})"
+            elif requested_tgt:
+                state_str = f"Copy {ti.type_name} (cannot dequantize for {requested_tgt})"
+            elif ti.type_name in ("Q1_0", "Q2_K", "Q4_0"):
+                state_str = f"Keep {ti.type_name} (<= target)"
+            else:
+                state_str = "Passthrough"
             self.tree.insert(
                 "",
                 tk.END,
@@ -946,6 +993,7 @@ class HPCQuantizeGUI:
                 custom_quant_map=self._custom_map_for_plan(),
             )
             is not None
+            and ti.type in SUPPORTED_READ_TYPES
             and self.tree.exists(ti.name)
         ]
         self.tree.selection_set(eligible_ids)
@@ -1029,6 +1077,10 @@ class HPCQuantizeGUI:
                 reader = GGUFReader(gguf_path)
                 tname = next(iter(selected))
                 ti = reader.info(tname)
+                if ti.type not in SUPPORTED_READ_TYPES:
+                    raise ValueError(
+                        f"{tname}: cannot dequantize source type {ti.type_name} for .npz export"
+                    )
                 x, row = reader.read_tensor(tname)
                 imp = None
                 if imat is not None: