Upload 6 files

gui.py

@@ -327,10 +327,12 @@ class HPCQuantizeGUI:
         mode_row.pack(fill=tk.X, pady=(0, 4))
         ttk.Label(mode_row, text="Target Scope:").pack(side=tk.LEFT, padx=(0, 8))
         ttk.Radiobutton(
-            mode_row, text="All Eligible Tensors", variable=self.mode_var, value="all"
+            mode_row, text="All Eligible Tensors", variable=self.mode_var, value="all",
+            command=self._on_scope_changed,
         ).pack(side=tk.LEFT, padx=4)
         ttk.Radiobutton(
-            mode_row, text="Selected Tensor(s)", variable=self.mode_var, value="selected"
+            mode_row, text="Selected Tensor(s)", variable=self.mode_var, value="selected",
+            command=self._on_scope_changed,
         ).pack(side=tk.LEFT, padx=4)
 
         fmt_row = ttk.Frame(opt_frame)
@@ -511,7 +513,7 @@ class HPCQuantizeGUI:
         self.tree.column("q2k", width=48, anchor=tk.CENTER)
         self.tree.column("imat", width=56, anchor=tk.CENTER)
         self.tree.column("state", width=165, anchor=tk.W)
-        self.tree.bind("<<TreeviewSelect>>", lambda _e: self._update_cli_preview())
+        self.tree.bind("<<TreeviewSelect>>", self._on_tree_selection)
 
         tree_scroll = ttk.Scrollbar(browser_frame, orient=tk.VERTICAL, command=self.tree.yview)
         self.tree.configure(yscrollcommand=tree_scroll.set)
@@ -878,7 +880,93 @@ class HPCQuantizeGUI:
             self._reader = None
             self._log(f"GGUF inspect error: {exc}")
 
+    def _plan_target(self, ti, chosen: set[str], scope_selected: bool):
+        tgt = target_quant_type(
+            ti.name,
+            ti.dims,
+            enable_q4_fallback=bool(self.q4_fallback_var.get()) and self.quant_format_var.get() not in ("q2_k", "q3_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(),
+            source_type=ti.type,
+            custom_quant_map=self._custom_map_for_plan(),
+        )
+        if scope_selected and ti.name not in chosen:
+            return None
+        return tgt
+
+    def _on_scope_changed(self) -> None:
+        self._refresh_plan_view()
+        self._update_cli_preview()
+
+    def _on_tree_selection(self, _event=None) -> None:
+        if self.mode_var.get() == "selected":
+            self._refresh_plan_view()
+        self._update_cli_preview()
+
+    def _refresh_plan_view(self) -> None:
+        if self._reader is None:
+            return
+        chosen = self._selected_tensor_names()
+        scope_selected = self.mode_var.get() == "selected"
+        n_q2, n_q3, n_q4, n_copy = 0, 0, 0, 0
+        n_q1 = 0
+        planned_bytes = 0
+        for ti in self._reader.tensors:
+            tgt = self._plan_target(ti, chosen, scope_selected)
+            if tgt == "Q2_K":
+                n_q2 += 1
+            elif tgt == "Q3_K":
+                n_q3 += 1
+            elif tgt == "Q4_0":
+                n_q4 += 1
+            elif tgt == "Q1_0":
+                n_q1 += 1
+            else:
+                n_copy += 1
+
+            if tgt == "Q2_K":
+                planned_bytes += (ti.n_elements // QK_K) * 84
+            elif tgt == "Q3_K":
+                planned_bytes += (ti.n_elements // QK3_K) * Q3_K_BLOCK_BYTES
+            elif tgt == "Q4_0":
+                planned_bytes += (ti.n_elements // QK4_0) * 18
+            elif tgt == "Q1_0":
+                planned_bytes += (ti.n_elements // QK1_0) * Q1_0_BLOCK_BYTES
+            else:
+                planned_bytes += ti.n_bytes
+
+            if not self.tree.exists(ti.name):
+                continue
+            tgt_label = tgt if tgt else "Copy"
+            if scope_selected and ti.name not in chosen:
+                state_str = "Not selected (copy)"
+            else:
+                state_str = (
+                    f"Pending ({tgt_label})"
+                    if tgt
+                    else (f"Keep {ti.type_name} (<= target)" if ti.type_name in ("Q1_0", "Q2_K", "Q3_K", "Q4_0") else "Passthrough")
+                )
+            vals = list(self.tree.item(ti.name, "values"))
+            vals[4] = tgt_label
+            vals[6] = state_str
+            self.tree.item(ti.name, tags=(tgt_label,), values=vals)
+
+        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 "
+            f"(Total: {len(self._reader.tensors)} tensors, est. {planned_text})"
+        )
+
     def _populate_tensor_tree(self) -> None:
+        chosen = self._selected_tensor_names()
+        scope_selected = self.mode_var.get() == "selected"
         self.tree.delete(*self.tree.get_children())
         if self._reader is None:
             return
@@ -888,16 +976,7 @@ class HPCQuantizeGUI:
         n_q1 = 0
         planned_bytes = 0
         for ti in self._reader.tensors:
-            tgt = target_quant_type(
-                ti.name,
-                ti.dims,
-                enable_q4_fallback=bool(self.q4_fallback_var.get()) and self.quant_format_var.get() not in ("q2_k", "q3_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(),
-                source_type=ti.type,
-                custom_quant_map=self._custom_map_for_plan(),
-            )
+            tgt = self._plan_target(ti, chosen, scope_selected)
             if tgt == "Q2_K":
                 n_q2 += 1
             elif tgt == "Q3_K":
@@ -934,11 +1013,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", "Q3_K", "Q4_0") else "Passthrough")
-            )
+            if scope_selected and ti.name not in chosen:
+                state_str = "Not selected (copy)"
+            else:
+                state_str = (
+                    f"Pending ({tgt_label})"
+                    if tgt
+                    else (f"Keep {ti.type_name} (<= target)" if ti.type_name in ("Q1_0", "Q2_K", "Q3_K", "Q4_0") else "Passthrough")
+                )
             self.tree.insert(
                 "",
                 tk.END,
@@ -954,14 +1036,18 @@ class HPCQuantizeGUI:
                     state_str,
                 ),
             )
+        keep_selected = [n for n in chosen if self.tree.exists(n)]
+        if keep_selected:
+            self.tree.selection_set(keep_selected)
         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()}): {n_q1} Q1_0 | {n_q2} Q2_K | {n_q3} Q3_K | {n_q4} Q4_0 | {n_copy} Copy "
+            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 "
             f"(Total: {len(self._reader.tensors)} tensors, est. {planned_text})"
         )
 
@@ -1030,9 +1116,10 @@ class HPCQuantizeGUI:
         self.bench_btn.configure(state=tk.DISABLED)
         self.stop_btn.configure(state=tk.NORMAL)
         self.status_var.set("Starting quantization...")
+        scope_text = "all eligible tensors" if selected is None else f"{len(selected)} selected tensor(s)"
         self._log(
             f"Starting quantization: source={Path(gguf_path).name} -> output={Path(out_path).name} "
-            f"(cand={cfg.n_cand_d}x{cfg.n_cand_m}, analogs={cfg.use_weight_analogs}, "
+            f"(scope={scope_text}, cand={cfg.n_cand_d}x{cfg.n_cand_m}, analogs={cfg.use_weight_analogs}, "
             f"coupled={cfg.factor_coupled_q2k}, optimizer={cfg.optimizer.upper()})"
         )