Spaces:
Running
Running
Download gguf_layer_swapper.py from Naphula/model_tools: direct link, hf CLI and curl.
- Browser
- Download file 16.4 kB
-
https://huggingface.co/spaces/Naphula/model_tools/resolve/main/gguf_layer_swapper.py
- Command line
-
hf download hf://spaces/Naphula/model_tools/gguf_layer_swapper.py
-
curl -L -o gguf_layer_swapper.py https://huggingface.co/spaces/Naphula/model_tools/resolve/main/gguf_layer_swapper.py
16.4 kB
| 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("<Double-1>", 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() |