import os import re import sys import threading import tkinter as tk from tkinter import ttk, filedialog, messagebox from typing import Dict, List, Set try: import tkinterdnd2 DND_FILES = tkinterdnd2.DND_FILES if hasattr(tkinterdnd2, "TkinterDnD") and hasattr(tkinterdnd2.TkinterDnD, "Tk"): BaseTkClass = tkinterdnd2.TkinterDnD.Tk elif hasattr(tkinterdnd2, "Tk"): BaseTkClass = tkinterdnd2.Tk else: BaseTkClass = tk.Tk HAS_DND = True except Exception: HAS_DND = False BaseTkClass = tk.Tk import numpy as np from gguf import GGUFReader, GGUFWriter def clean_path(path_str: str) -> str: path_str = path_str.strip() if path_str.startswith("{") and path_str.endswith("}"): path_str = path_str[1:-1] if (path_str.startswith('"') and path_str.endswith('"')) or \ (path_str.startswith("'") and path_str.endswith("'")): path_str = path_str[1:-1] return path_str.strip() class GGUFLayerSwapper(BaseTkClass): def __init__(self): super().__init__() self.title("GGUF Surgical Layer Swapper & Defect Isolator") self.geometry("1100x820") self.minsize(950, 700) self.path_stable_var = tk.StringVar(value=r"B:\24B\Cydonia-24B-v4x-Q8_0.gguf") self.path_suspect_var = tk.StringVar(value=r"B:\24B\Cydonia-24B-v4x-Q8_0\ReQuant2-Cydonia-24B-v4x-Q8_0.gguf") self.path_out_var = tk.StringVar(value=r"B:\24B\Graft_Tests\Swapped_Test.gguf") # Tree and Selection tracking self.reader_stable = None self.reader_suspect = None self.all_tensor_names: List[str] = [] self.selected_tensors: Set[str] = set() self._setup_ui() def _setup_ui(self): # 1. Top File Selection Area frame_files = ttk.LabelFrame(self, text="File Paths", padding=8) frame_files.pack(fill=tk.X, padx=10, pady=5) self._create_file_row(frame_files, "Stable Base GGUF (Original):", self.path_stable_var, 0) self._create_file_row(frame_files, "Suspect GGUF (To Test):", self.path_suspect_var, 1) self._create_file_row(frame_files, "Output Patched GGUF:", self.path_out_var, 2, save=True) btn_load = ttk.Button(frame_files, text="🔄 Read & Index GGUF Tensors", command=self.load_tensors) btn_load.grid(row=3, column=1, sticky=tk.W, pady=6) # 2. Main Middle Area (Tree on Left, Presets on Right) frame_mid = ttk.Frame(self, padding=5) frame_mid.pack(fill=tk.BOTH, expand=True, padx=10, pady=5) # Left: Hierarchical Tensor Tree frame_tree = ttk.LabelFrame(frame_mid, text="Model Tensor Hierarchy (Check items to inject SUSPECT weights)", padding=5) frame_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) self.tree = ttk.Treeview(frame_tree, selectmode="extended") self.tree["columns"] = ("source", "shape") self.tree.heading("#0", text="Layer / Tensor Structure", anchor=tk.W) self.tree.heading("source", text="Source Mode", anchor=tk.W) self.tree.heading("shape", text="Tensor Dimensions", anchor=tk.W) self.tree.column("#0", width=420) self.tree.column("source", width=140) self.tree.column("shape", width=160) tree_scroll = ttk.Scrollbar(frame_tree, orient=tk.VERTICAL, command=self.tree.yview) self.tree.configure(yscrollcommand=tree_scroll.set) self.tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) tree_scroll.pack(side=tk.RIGHT, fill=tk.Y) self.tree.bind("", self._on_tree_double_click) # Right: Batch Selector Panel frame_presets = ttk.LabelFrame(frame_mid, text="Fast Batch Selection Presets", padding=8) frame_presets.pack(side=tk.RIGHT, fill=tk.Y, padx=(10, 0)) ttk.Label(frame_presets, text="-- Quick Actions --", font=("Segoe UI", 9, "bold")).pack(pady=(2, 4)) ttk.Button(frame_presets, text="Select All Tensors", command=self._sel_all).pack(fill=tk.X, pady=2) ttk.Button(frame_presets, text="Clear All (100% Stable)", command=self._sel_none).pack(fill=tk.X, pady=2) ttk.Separator(frame_presets, orient=tk.HORIZONTAL).pack(fill=tk.X, pady=6) ttk.Label(frame_presets, text="-- Attention Projections --", font=("Segoe UI", 9, "bold")).pack(pady=(2, 4)) ttk.Button(frame_presets, text="Toggle All Q (attn_q)", command=lambda: self._toggle_regex(r"attn_q")).pack(fill=tk.X, pady=2) ttk.Button(frame_presets, text="Toggle All K (attn_k)", command=lambda: self._toggle_regex(r"attn_k")).pack(fill=tk.X, pady=2) ttk.Button(frame_presets, text="Toggle All V (attn_v)", command=lambda: self._toggle_regex(r"attn_v")).pack(fill=tk.X, pady=2) ttk.Button(frame_presets, text="Toggle All Out (attn_output)", command=lambda: self._toggle_regex(r"attn_output")).pack(fill=tk.X, pady=2) ttk.Separator(frame_presets, orient=tk.HORIZONTAL).pack(fill=tk.X, pady=6) ttk.Label(frame_presets, text="-- Feed-Forward (MLP) --", font=("Segoe UI", 9, "bold")).pack(pady=(2, 4)) ttk.Button(frame_presets, text="Toggle All Gate Proj", command=lambda: self._toggle_regex(r"ffn_gate")).pack(fill=tk.X, pady=2) ttk.Button(frame_presets, text="Toggle All Up Proj", command=lambda: self._toggle_regex(r"ffn_up")).pack(fill=tk.X, pady=2) ttk.Button(frame_presets, text="Toggle All Down Proj", command=lambda: self._toggle_regex(r"ffn_down")).pack(fill=tk.X, pady=2) ttk.Separator(frame_presets, orient=tk.HORIZONTAL).pack(fill=tk.X, pady=6) ttk.Label(frame_presets, text="-- Boundaries & Spans --", font=("Segoe UI", 9, "bold")).pack(pady=(2, 4)) ttk.Button(frame_presets, text="Toggle Embed & LM Head", command=lambda: self._toggle_regex(r"(token_embd|output\.weight)")).pack(fill=tk.X, pady=2) ttk.Button(frame_presets, text="Toggle Layers 0 to 19", command=lambda: self._toggle_layer_range(0, 19)).pack(fill=tk.X, pady=2) ttk.Button(frame_presets, text="Toggle Layers 20 to 39", command=lambda: self._toggle_layer_range(20, 39)).pack(fill=tk.X, pady=2) # 3. Bottom Actions & Progress frame_bot = ttk.Frame(self, padding=8) frame_bot.pack(fill=tk.X, padx=10, pady=5) self.lbl_stats = ttk.Label(frame_bot, text="Tensors selected for injection: 0 (100% STABLE)", font=("Segoe UI", 10, "bold")) self.lbl_stats.pack(side=tk.LEFT) self.btn_build = ttk.Button(frame_bot, text="🚀 Build Swapped Test GGUF", command=self.build_swapped_file) self.btn_build.pack(side=tk.RIGHT, padx=5, ipady=4) def _create_file_row(self, parent, text, var, row, save=False): ttk.Label(parent, text=text).grid(row=row, column=0, sticky=tk.W, pady=2) entry = ttk.Entry(parent, textvariable=var, width=80) entry.grid(row=row, column=1, sticky=tk.EW, padx=5, pady=2) cmd = (lambda: self._browse_save(var)) if save else (lambda: self._browse_open(var)) ttk.Button(parent, text="Browse...", command=cmd).grid(row=row, column=2, padx=2, pady=2) parent.columnconfigure(1, weight=1) def _browse_open(self, var): f = filedialog.askopenfilename(filetypes=[("GGUF Files", "*.gguf"), ("All Files", "*.*")]) if f: var.set(clean_path(f)) def _browse_save(self, var): f = filedialog.asksaveasfilename(defaultextension=".gguf", filetypes=[("GGUF Files", "*.gguf")]) if f: var.set(clean_path(f)) def load_tensors(self): f_stable = clean_path(self.path_stable_var.get()) f_suspect = clean_path(self.path_suspect_var.get()) if not os.path.isfile(f_stable) or not os.path.isfile(f_suspect): messagebox.showerror("Error", "Please make sure both Stable and Suspect GGUF files exist.") return self.tree.delete(*self.tree.get_children()) self.selected_tensors.clear() try: self.reader_stable = GGUFReader(f_stable) self.reader_suspect = GGUFReader(f_suspect) except Exception as e: messagebox.showerror("Error loading GGUF", str(e)) return self.all_tensor_names = [t.name for t in self.reader_stable.tensors] # Group by Blocks blocks: Dict[str, List] = {"Non-Layer / Global": []} for t in self.reader_stable.tensors: m = re.match(r"^blk\.(\d+)\.(.*)", t.name) if m: block_id = f"blk.{int(m.group(1)):02d}" blocks.setdefault(block_id, []).append(t) else: blocks["Non-Layer / Global"].append(t) for blk_name in sorted(blocks.keys()): parent_id = self.tree.insert("", tk.END, text=f"📂 {blk_name}", values=("STABLE (All)", "")) for t in blocks[blk_name]: self.tree.insert(parent_id, tk.END, iid=t.name, text=f" [ ] {t.name}", values=("STABLE", str(list(t.shape)))) self._update_stats() messagebox.showinfo("Loaded", f"Successfully indexed {len(self.all_tensor_names)} tensors across {len(blocks)} sections.") def _on_tree_double_click(self, event): item_id = self.tree.focus() if not item_id: return # If it's a leaf tensor if item_id in self.all_tensor_names: if item_id in self.selected_tensors: self.selected_tensors.remove(item_id) else: self.selected_tensors.add(item_id) self._refresh_tree_item(item_id) else: # It's a block folder: toggle all children children = self.tree.get_children(item_id) child_names = [c for c in children if c in self.all_tensor_names] all_selected = all(c in self.selected_tensors for c in child_names) for c in child_names: if all_selected: self.selected_tensors.discard(c) else: self.selected_tensors.add(c) self._refresh_tree_item(c) self._update_stats() def _refresh_tree_item(self, t_name: str): if t_name in self.selected_tensors: self.tree.item(t_name, text=f" [X] {t_name}", values=(">>> SUSPECT <<<", self.tree.item(t_name, "values")[1])) else: self.tree.item(t_name, text=f" [ ] {t_name}", values=("STABLE", self.tree.item(t_name, "values")[1])) def _toggle_regex(self, pattern: str): regex = re.compile(pattern) targets = [name for name in self.all_tensor_names if regex.search(name)] all_on = all(name in self.selected_tensors for name in targets) for name in targets: if all_on: self.selected_tensors.discard(name) else: self.selected_tensors.add(name) self._refresh_tree_item(name) self._update_stats() def _toggle_layer_range(self, start_idx: int, end_idx: int): for name in self.all_tensor_names: m = re.match(r"^blk\.(\d+)\.", name) if m: idx = int(m.group(1)) if start_idx <= idx <= end_idx: self.selected_tensors.add(name) self._refresh_tree_item(name) self._update_stats() def _sel_all(self): for name in self.all_tensor_names: self.selected_tensors.add(name) self._refresh_tree_item(name) self._update_stats() def _sel_none(self): self.selected_tensors.clear() for name in self.all_tensor_names: self._refresh_tree_item(name) self._update_stats() def _update_stats(self): total = len(self.all_tensor_names) sel = len(self.selected_tensors) pct = (sel / total * 100) if total else 0 self.lbl_stats.config(text=f"Tensors marked for SUSPECT injection: {sel}/{total} ({pct:.1f}%)") def build_swapped_file(self): f_stable = clean_path(self.path_stable_var.get()) f_suspect = clean_path(self.path_suspect_var.get()) f_out = clean_path(self.path_out_var.get()) if not self.reader_stable or not self.reader_suspect: messagebox.showwarning("Notice", "Please click 'Read & Index GGUF Tensors' first.") return os.makedirs(os.path.dirname(os.path.abspath(f_out)), exist_ok=True) self.btn_build.config(state=tk.DISABLED) threading.Thread(target=self._build_worker, args=(f_stable, f_suspect, f_out), daemon=True).start() def _build_worker(self, f_stable: str, f_suspect: str, f_out: str): try: stable_map = {t.name: t for t in self.reader_stable.tensors} suspect_map = {t.name: t for t in self.reader_suspect.tensors} arch_name = "llama" if "general.architecture" in self.reader_stable.fields: arch_val = self.reader_stable.fields["general.architecture"].contents() if isinstance(arch_val, (list, tuple, np.ndarray)): arch_name = str(arch_val[0]) else: arch_name = str(arch_val) writer = GGUFWriter(f_out, arch=arch_name) # Copy complete metadata from Stable base for field in self.reader_stable.fields.values(): if field.name in ("split.no", "split.count", "split.tensors.count", "general.architecture"): continue try: writer.add_key_value(field.name, field.contents(), field.types[0]) except Exception: pass tensors_to_write = [] for t_name in self.all_tensor_names: if t_name in self.selected_tensors and t_name in suspect_map: src_tensor = suspect_map[t_name] src_file = f_suspect else: src_tensor = stable_map[t_name] src_file = f_stable writer.add_tensor_info( name=src_tensor.name, tensor_shape=src_tensor.data.shape, tensor_dtype=src_tensor.data.dtype, tensor_nbytes=src_tensor.data.nbytes, raw_dtype=src_tensor.tensor_type ) tensors_to_write.append({ "name": src_tensor.name, "source_file": src_file, "offset": src_tensor.data_offset, "n_bytes": src_tensor.data.nbytes }) writer.write_header_to_file() writer.write_kv_data_to_file() writer.write_ti_data_to_file() writer.close() # Append aligned raw binary payloads ALIGNMENT = 32 fp_stable = open(f_stable, "rb") fp_suspect = open(f_suspect, "rb") CHUNK = 16 * 1024 * 1024 with open(f_out, "ab") as f_out_handle: for item in tensors_to_write: offset = f_out_handle.tell() pad = (ALIGNMENT - (offset % ALIGNMENT)) % ALIGNMENT if pad > 0: f_out_handle.write(b"\x00" * pad) src_fp = fp_suspect if item["source_file"] == f_suspect else fp_stable src_fp.seek(item["offset"]) rem = item["n_bytes"] while rem > 0: chunk = src_fp.read(min(rem, CHUNK)) f_out_handle.write(chunk) rem -= len(chunk) fp_stable.close() fp_suspect.close() messagebox.showinfo("Success", f"Created patched GGUF with {len(self.selected_tensors)} swapped tensors!\nSaved to: {f_out}") except Exception as e: messagebox.showerror("Build Error", str(e)) finally: self.btn_build.config(state=tk.NORMAL) if __name__ == "__main__": app = GGUFLayerSwapper() app.mainloop()