Add files via upload

layer_path.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""
+Explicit Layer Path GGUF Surgery
+
+You provide the exact sequence of layers the model should execute.
+No ambiguous range notation — just list the layers.
+
+Examples:
+    # Normal 40-layer model (identity, for testing)
+    python layer_path.py model.gguf out.gguf -p 0,1,2,...,39
+
+    # Duplicate layers 13-16 once (same as RYS with i=13,j=17)
+    python layer_path.py model.gguf out.gguf -p 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,13,14,15,16,17,18,...,39
+
+    # Repeat layer 13 four times
+    python layer_path.py model.gguf out.gguf -p 0,1,...,12,13,13,13,13,14,15,...,39
+
+    # Triple-pass layers 13-16
+    python layer_path.py model.gguf out.gguf -p 0,1,...,16,13,14,15,16,13,14,15,16,17,...,39
+
+    # Shorthand: use .. to fill in sequential ranges
+    python layer_path.py model.gguf out.gguf -p 0..16,13,14,15,16,13,14,15,16,17..39
+
+Usage:
+    python layer_path.py input.gguf output.gguf -p "0..16,13,14,15,16,17..39" -v
+"""
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+import numpy as np
+from tqdm import tqdm
+
+import gguf
+from gguf import GGUFReader, GGUFWriter, GGUFValueType
+
+
+BLK_PATTERN = re.compile(r'^blk\.(\d+)\.(.+)$')
+
+
+def get_field_value(reader, key):
+    field = reader.get_field(key)
+    if field is None:
+        return None
+    return field.contents()
+
+
+def parse_layer_path(path_str: str) -> list[int]:
+    """
+    Parse a layer path string into a list of layer indices.
+
+    Supports:
+        - Individual numbers: 0,1,2,13,13,14
+        - Ranges with ..: 0..16 expands to 0,1,2,...,16 (inclusive)
+        - Mixed: 0..12,13,13,13,14..39
+
+    Whitespace is ignored.
+    """
+    path_str = path_str.replace(' ', '')
+    layers = []
+
+    for part in path_str.split(','):
+        part = part.strip()
+        if not part:
+            continue
+
+        if '..' in part:
+            # Range: start..end (inclusive)
+            pieces = part.split('..')
+            if len(pieces) != 2:
+                raise ValueError(f"Invalid range: '{part}'. Use 'start..end'")
+            start = int(pieces[0])
+            end = int(pieces[1])
+            if start > end:
+                raise ValueError(f"Invalid range: {start}..{end} (start > end)")
+            layers.extend(range(start, end + 1))
+        else:
+            layers.append(int(part))
+
+    return layers
+
+
+def build_gguf_from_path(input_path: str, output_path: str,
+                         layer_path: list[int], verbose: bool = False):
+    """
+    Create a new GGUF where the forward pass follows the given layer path.
+    """
+    reader = GGUFReader(input_path, 'r')
+
+    arch = get_field_value(reader, gguf.Keys.General.ARCHITECTURE)
+    block_count_key = f'{arch}.block_count'
+    orig_block_count = get_field_value(reader, block_count_key)
+
+    # Validate all layer indices
+    for idx in layer_path:
+        if idx < 0 or idx >= orig_block_count:
+            raise ValueError(
+                f"Layer {idx} out of range (model has {orig_block_count} layers, 0..{orig_block_count-1})"
+            )
+
+    new_block_count = len(layer_path)
+
+    if verbose:
+        print(f"Architecture: {arch}")
+        print(f"Original layers: {orig_block_count}")
+        print(f"New layer count: {new_block_count}")
+        print(f"Layer path: {layer_path}")
+
+        # Show which layers are repeated
+        from collections import Counter
+        counts = Counter(layer_path)
+        repeated = {k: v for k, v in counts.items() if v > 1}
+        if repeated:
+            print(f"Repeated layers: {dict(sorted(repeated.items()))}")
+        else:
+            print("No repeated layers (just a reorder)")
+
+    # layer_map: new_position -> original_layer_index
+    layer_map = {new_idx: orig_idx for new_idx, orig_idx in enumerate(layer_path)}
+
+    # Create writer
+    writer = GGUFWriter(output_path, arch=arch, endianess=reader.endianess)
+
+    alignment = get_field_value(reader, gguf.Keys.General.ALIGNMENT)
+    if alignment is not None:
+        writer.data_alignment = alignment
+
+    # Copy metadata, override block count
+    for field in reader.fields.values():
+        if field.name == gguf.Keys.General.ARCHITECTURE or field.name.startswith('GGUF.'):
+            continue
+        val_type = field.types[0]
+        sub_type = field.types[-1] if val_type == GGUFValueType.ARRAY else None
+        if field.name == block_count_key:
+            writer.add_key_value(field.name, new_block_count, val_type)
+        else:
+            val = field.contents()
+            if val is not None:
+                writer.add_key_value(field.name, val, val_type, sub_type=sub_type)
+
+    # Organize tensors by layer
+    non_block_tensors = []
+    block_tensors = {}
+
+    for tensor in reader.tensors:
+        match = BLK_PATTERN.match(tensor.name)
+        if match:
+            layer_idx = int(match.group(1))
+            suffix = match.group(2)
+            if layer_idx not in block_tensors:
+                block_tensors[layer_idx] = []
+            block_tensors[layer_idx].append((suffix, tensor))
+        else:
+            non_block_tensors.append(tensor)
+
+    pre_block = [t for t in non_block_tensors if 'output' not in t.name]
+    post_block = [t for t in non_block_tensors if 'output' in t.name]
+
+    # Add tensor infos and build write order
+    total_bytes = 0
+    block_write_order = []
+
+    for tensor in pre_block:
+        writer.add_tensor_info(tensor.name, tensor.data.shape, tensor.data.dtype,
+                               tensor.data.nbytes, tensor.tensor_type)
+        total_bytes += tensor.n_bytes
+
+    for new_idx in range(new_block_count):
+        orig_idx = layer_map[new_idx]
+        if orig_idx not in block_tensors:
+            raise ValueError(f"No tensors found for original layer {orig_idx}")
+        for suffix, tensor in block_tensors[orig_idx]:
+            new_name = f"blk.{new_idx}.{suffix}"
+            writer.add_tensor_info(new_name, tensor.data.shape, tensor.data.dtype,
+                                   tensor.data.nbytes, tensor.tensor_type)
+            total_bytes += tensor.n_bytes
+            block_write_order.append(tensor)
+
+    for tensor in post_block:
+        writer.add_tensor_info(tensor.name, tensor.data.shape, tensor.data.dtype,
+                               tensor.data.nbytes, tensor.tensor_type)
+        total_bytes += tensor.n_bytes
+
+    # Write
+    writer.write_header_to_file()
+    writer.write_kv_data_to_file()
+    writer.write_ti_data_to_file()
+
+    bar = tqdm(desc="Writing GGUF", total=total_bytes, unit="B", unit_scale=True)
+
+    for tensor in pre_block:
+        writer.write_tensor_data(tensor.data)
+        bar.update(tensor.n_bytes)
+
+    for tensor in block_write_order:
+        writer.write_tensor_data(tensor.data)
+        bar.update(tensor.n_bytes)
+
+    for tensor in post_block:
+        writer.write_tensor_data(tensor.data)
+        bar.update(tensor.n_bytes)
+
+    bar.close()
+    writer.close()
+
+    if verbose:
+        out_size = Path(output_path).stat().st_size / (1024**3)
+        print(f"Done. Output: {out_size:.2f} GiB")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Build GGUF with explicit layer execution path",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Duplicate layers 13-16 once (RYS style)
+  %(prog)s model.gguf out.gguf -p "0..16,13,14,15,16,17..39"
+
+  # Triple-pass layers 13-16
+  %(prog)s model.gguf out.gguf -p "0..16,13,14,15,16,13,14,15,16,17..39"
+
+  # Repeat just layer 13 four times
+  %(prog)s model.gguf out.gguf -p "0..12,13,13,13,13,14..39"
+
+  # Skip layer 5 entirely
+  %(prog)s model.gguf out.gguf -p "0..4,6..39"
+        """
+    )
+    parser.add_argument("input", help="Input GGUF file")
+    parser.add_argument("output", help="Output GGUF file")
+    parser.add_argument("-p", "--path", required=True,
+                        help="Layer execution path (e.g. '0..16,13,14,15,16,17..39')")
+    parser.add_argument("-v", "--verbose", action="store_true")
+    args = parser.parse_args()
+
+    layer_path = parse_layer_path(args.path)
+    print(f"Model: {args.input}")
+    print(f"Output: {args.output}")
+    print(f"Layer path ({len(layer_path)} layers): {layer_path}")
+
+    build_gguf_from_path(args.input, args.output, layer_path, args.verbose)
+
+
+if __name__ == "__main__":
+    main()