File size: 16,395 Bytes
722b862
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
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()