nx_zimage_dequant_block.nx source
↩ module page · 92 lines · 3799 B
1// nx_zimage_dequant_block.nx -- dequant a block of REAL Z-Image weight DATA into f32, sovereignly.
2//
3// sd-server -> Nishi migration: extends the real-weight bridge from METADATA to actual WEIGHT DATA. Reads
4// the real `Z-Image_Qwen_3_4b-Q6_K.gguf`, locates token_embd.weight (Q6_K, ggml_type 14), computes its
5// data location (hdr.data_off + ti.offset -- it's the first tensor so this is at the very start of the data
6// section, inside our bounded prefix), and dequantizes the FIRST Q6_K super-block (256 real embedding
7// values) with our own `nx_q6_k_to_f32`. Proves: real Z-Image quantized weights -> our dequant -> real,
8// finite, nonzero f32. Writes the first sample values to /tmp/zimg_dq.txt.
9// license_tier: ORIGINAL
10import "nx_syscalls.nx"
11import "nx_tier.nx"
12import "nx_le.nx"
13import "nx_strconv.nx"
14import "nx_tensor.nx"
15import "nx_gguf.nx"
16import "nx_gguf_load.nx"
17import "nx_gguf_meta.nx"
18import "nx_placement.nx"
19import "nx_gguf_load_lazy.nx"
20import "nx_q6_k_to_f32.nx"
21
22func zd_emit(fd: i64, key: *u8, key_len: i64, value: i64) -> i64 {
23 let line: *u8 = sys_mmap(64)
24 var lo: i64 = 0
25 var ki: i64 = 0
26 while ki < key_len { line[lo] = key[ki]; lo = lo + 1; ki = ki + 1 }
27 line[lo] = 0x3D; lo = lo + 1
28 let dec: *u8 = sys_mmap(32)
29 let n_dec: i64 = nx_strconv_format_i64(value, dec)
30 var k: i64 = 0
31 while k < n_dec { line[lo] = dec[k]; lo = lo + 1; k = k + 1 }
32 line[lo] = 0x0A; lo = lo + 1
33 return sys_write(fd, line, lo)
34}
35
36func main() -> i64 {
37 let path: *u8 = "/mnt/c/Users/elder/elder-ai-platform/models/unified/text_encoder/Z-Image_Qwen_3_4b-Q6_K.gguf" as *u8
38 let fd: i64 = sys_openat_rd(path)
39 if fd < 0 { return 30 }
40 let CAP: i64 = 201326592 // 192 MB prefix (covers metadata + start of data)
41 let buf: *u8 = sys_mmap(CAP)
42 var total: i64 = 0
43 var go: i64 = 1
44 while go == 1 {
45 let r: i64 = sys_read(fd, ((buf as i64) + total) as *u8, CAP - total)
46 if r <= 0 { go = 0 } else { total = total + r; if total >= CAP { go = 0 } }
47 }
48 sys_close(fd)
49 if total < 1000 { return 31 }
50
51 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
52 let vp: nx_int = nx_gguf_parse(buf, total, hdr)
53 if vp != NX_GGUF_OK { return 40 + vp }
54
55 let idx: nx_int = nx_gguf_find_tensor(hdr, "token_embd.weight" as *u8, 17)
56 if idx < 0 { return 60 }
57 let ti: *NxGgufTensorInfo = nx_gguf_tensor_at(hdr, idx)
58 if ti.ggml_type != 14 { return 61 } // expect Q6_K
59 let base_off: i64 = hdr.data_off + ti.offset
60 if base_off <= 0 { return 62 }
61 if base_off + 1024 > total { return 63 } // the super-block must be inside the prefix
62
63 // dequant the first Q6_K super-block (256 real embedding values)
64 let NV: i64 = 256
65 let out: *i64 = sys_mmap(NV * 8) as *i64
66 let dq: nx_int = nx_q6_k_to_f32(buf, base_off, NV, out)
67
68 // verify: all finite (exponent field not all-ones) and at least one nonzero (real weights)
69 var nz: i64 = 0
70 var i: i64 = 0
71 while i < NV {
72 let bits: i64 = out[i]
73 if (bits & 0x7F800000) == 0x7F800000 { return 80 } // Inf/NaN in the exponent
74 if bits != 0 { nz = 1 }
75 i = i + 1
76 }
77 if nz == 0 { return 81 }
78
79 // record a few real sample values (raw f32 bit patterns) for inspection
80 let ofd: i64 = sys_openat_wr("/tmp/zimg_dq.txt" as *u8, 0x1a4)
81 if ofd >= 0 {
82 zd_emit(ofd, "dequant_rc" as *u8, 10, dq)
83 zd_emit(ofd, "base_off" as *u8, 8, base_off)
84 zd_emit(ofd, "val0_bits" as *u8, 9, out[0])
85 zd_emit(ofd, "val1_bits" as *u8, 9, out[1])
86 zd_emit(ofd, "val2_bits" as *u8, 9, out[2])
87 zd_emit(ofd, "nonzero_flag" as *u8, 12, nz)
88 sys_close(ofd)
89 }
90
91 return 0
92}