Delete dump_tensor.py

dump_tensor.py

@@ -1,97 +0,0 @@
-#!/usr/bin/env python3
-"""Dump one tensor from a source GGUF (F16/BF16/F32) as raw little-endian
-float32, for feeding to ./bound.
-
-Usage:
-    python3 dump_tensor.py model-f16.gguf blk.2.attn_output.weight out.f32
-    python3 dump_tensor.py model-f16.gguf --list
-"""
-import struct, sys, os
-import numpy as np
-
-# Reuse the parsing helpers from the requantizer so the layout stays in sync.
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from hexstate_requantize import (
-    GGUF_MAGIC, GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_BF16,
-    TYPE_BLOCK_SIZE, TYPE_BLOCK_BYTES,
-    read_string, read_kv_value, align_offset, bf16_to_f32, f16_to_f32,
-)
-
-
-def load(path):
-    with open(path, 'rb') as f:
-        assert struct.unpack('<I', f.read(4))[0] == GGUF_MAGIC, "bad GGUF magic"
-        struct.unpack('<I', f.read(4))[0]                    # version
-        n_tensors = struct.unpack('<Q', f.read(8))[0]
-        n_kv = struct.unpack('<Q', f.read(8))[0]
-        for _ in range(n_kv):
-            read_string(f)
-            read_kv_value(f, struct.unpack('<I', f.read(4))[0])
-
-        infos = []
-        for _ in range(n_tensors):
-            name = read_string(f)
-            n_dims = struct.unpack('<I', f.read(4))[0]
-            dims = [struct.unpack('<Q', f.read(8))[0] for _ in range(n_dims)]
-            ttype = struct.unpack('<I', f.read(4))[0]
-            offset = struct.unpack('<Q', f.read(8))[0]
-            n_el = 1
-            for d in dims:
-                n_el *= d
-            bs = TYPE_BLOCK_SIZE.get(ttype, 1)
-            bb = TYPE_BLOCK_BYTES.get(ttype, 4)
-            infos.append({'name': name, 'dims': dims, 'type': ttype,
-                          'offset': offset, 'n_elements': n_el,
-                          'data_size': ((n_el + bs - 1) // bs) * bb})
-        return infos, align_offset(f.tell())
-
-
-def main():
-    if len(sys.argv) < 3:
-        print(__doc__)
-        sys.exit(1)
-    gguf = sys.argv[1]
-    infos, data_start = load(gguf)
-
-    if sys.argv[2] == '--list':
-        for ti in infos:
-            print(f"  {ti['name']:<50s} type={ti['type']:<3d} "
-                  f"dims={ti['dims']} n={ti['n_elements']:,}")
-        return
-
-    want = sys.argv[2]
-    out = sys.argv[3] if len(sys.argv) > 3 else 'tensor.f32'
-    ti = next((t for t in infos if t['name'] == want), None)
-    if ti is None:
-        print(f"no tensor named {want!r}; run with --list")
-        sys.exit(1)
-
-    with open(gguf, 'rb') as f:
-        f.seek(data_start + ti['offset'])
-        raw = f.read(ti['data_size'])
-
-    if ti['type'] == GGML_TYPE_F32:
-        a = np.frombuffer(raw, dtype=np.float32).copy()
-    elif ti['type'] == GGML_TYPE_F16:
-        a = f16_to_f32(raw, ti['n_elements'])
-    elif ti['type'] == GGML_TYPE_BF16:
-        a = bf16_to_f32(raw, ti['n_elements'])
-    else:
-        print(f"tensor is type {ti['type']} (already quantized) — "
-              f"dump from the F16/BF16 source GGUF instead")
-        sys.exit(1)
-
-    a = np.ascontiguousarray(a[:ti['n_elements']], dtype=np.float32)
-    a.tofile(out)
-    sigma = float(np.sqrt(np.mean(a.astype(np.float64) ** 2)))
-    v = a.astype(np.float64) ** 2
-    kurt = float(np.mean(v * v) / (np.mean(v) ** 2)) if np.mean(v) > 0 else 3.0
-    print(f"  wrote {out}: {a.size:,} elements, dims={ti['dims']}")
-    print(f"  sigma    = {sigma:.6e}")
-    print(f"  kurtosis = {kurt:.2f}   (gaussian = 3)")
-    print()
-    print(f"  next:  ./bound --file {out}")
-
-
-if __name__ == '__main__':
-    main()