nx_zimage_real_op.nx source
↩ module page · 95 lines · 3906 B
1// nx_zimage_real_op.nx -- run a REAL Z-Image weight vector through a REAL sovereign op, end-to-end.
2//
3// sd-server -> Nishi migration: closes the last conceptual link before the full-scale assembly -- proves
4// ACTUAL Z-Image weights flow through our GATED f32 organs and produce a CORRECT result. Dequantizes a full
5// embedding ROW (2560 real Q6_K values = the complete embedding of token 0) with our `nx_q6_k_to_f32`, then
6// RMS-normalizes it with our gated `nx_f32_rmsnorm`, and verifies the output is finite with mean(out^2) ~ 1
7// (the defining RMSNorm invariant). Real weights -> real op -> correct output, all sovereign, no third-party.
8// license_tier: ORIGINAL
9import "nx_syscalls.nx"
10import "nx_tier.nx"
11import "nx_le.nx"
12import "nx_strconv.nx"
13import "nx_tensor.nx"
14import "nx_gguf.nx"
15import "nx_gguf_load.nx"
16import "nx_gguf_meta.nx"
17import "nx_placement.nx"
18import "nx_gguf_load_lazy.nx"
19import "nx_q6_k_to_f32.nx"
20import "nx_f32.nx"
21import "nx_f32_div.nx"
22import "nx_f32_cvt.nx"
23import "nx_f32_rmsnorm.nx"
24
25func main() -> i64 {
26 let path: *u8 = "/mnt/c/Users/elder/elder-ai-platform/models/unified/text_encoder/Z-Image_Qwen_3_4b-Q6_K.gguf" as *u8
27 let fd: i64 = sys_openat_rd(path)
28 if fd < 0 { return 30 }
29 let CAP: i64 = 201326592
30 let buf: *u8 = sys_mmap(CAP)
31 var total: i64 = 0
32 var go: i64 = 1
33 while go == 1 {
34 let r: i64 = sys_read(fd, ((buf as i64) + total) as *u8, CAP - total)
35 if r <= 0 { go = 0 } else { total = total + r; if total >= CAP { go = 0 } }
36 }
37 sys_close(fd)
38 if total < 1000 { return 31 }
39
40 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
41 let vp: nx_int = nx_gguf_parse(buf, total, hdr)
42 if vp != NX_GGUF_OK { return 40 + vp }
43 let idx: nx_int = nx_gguf_find_tensor(hdr, "token_embd.weight" as *u8, 17)
44 if idx < 0 { return 60 }
45 let ti: *NxGgufTensorInfo = nx_gguf_tensor_at(hdr, idx)
46 if ti.ggml_type != 14 { return 61 }
47 let base_off: i64 = hdr.data_off + ti.offset
48 if base_off + 8192 > total { return 62 }
49
50 // dequant a FULL embedding row: hidden = 2560 real Q6_K values (10 super-blocks)
51 let HID: i64 = 2560
52 let embed: *i64 = sys_mmap(HID * 8) as *i64
53 nx_q6_k_to_f32(buf, base_off, HID, embed)
54
55 // run our gated RMSNorm on the REAL embedding (gamma = 1, eps = 1e-6)
56 let gamma: *i64 = sys_mmap(HID * 8) as *i64
57 var g: i64 = 0
58 while g < HID { gamma[g] = nx_i32_to_f32(1); g = g + 1 }
59 let eps: i64 = nx_f32_div(nx_i32_to_f32(1), nx_i32_to_f32(1000000))
60 let normed: *i64 = sys_mmap(HID * 8) as *i64
61 nx_f32_rmsnorm(embed, gamma, HID, eps, normed)
62
63 // verify: all finite AND mean(normed^2) ~ 1 (the RMSNorm defining property, proving the real op worked)
64 var ss: i64 = 0
65 var i: i64 = 0
66 while i < HID {
67 let b: i64 = normed[i]
68 if (b & 0x7F800000) == 0x7F800000 { return 80 } // Inf/NaN
69 ss = nx_f32_add(ss, nx_f32_mul(b, b))
70 i = i + 1
71 }
72 let ms: i64 = nx_f32_div(ss, nx_i32_to_f32(HID)) // mean of squares (should be ~1.0)
73 let one: i64 = nx_i32_to_f32(1)
74 let tolb: i64 = nx_f32_div(nx_i32_to_f32(1), nx_i32_to_f32(20)) & 0x7FFFFFFF // 0.05
75 if (nx_f32_sub(ms, one) & 0x7FFFFFFF) >= tolb { return 81 }
76
77 // record proof
78 let ofd: i64 = sys_openat_wr("/tmp/zimg_realop.txt" as *u8, 0x1a4)
79 if ofd >= 0 {
80 let line: *u8 = sys_mmap(96)
81 var lo: i64 = 0
82 let tag: *u8 = "real_embed_rmsnorm_ms_bits=" as *u8
83 var ti2: i64 = 0
84 while tag[ti2] != (0 as u8) { line[lo] = tag[ti2]; lo = lo + 1; ti2 = ti2 + 1 }
85 let dec: *u8 = sys_mmap(32)
86 let nd: i64 = nx_strconv_format_i64(ms, dec)
87 var k: i64 = 0
88 while k < nd { line[lo] = dec[k]; lo = lo + 1; k = k + 1 }
89 line[lo] = 0x0A; lo = lo + 1
90 sys_write(ofd, line, lo)
91 sys_close(ofd)
92 }
93
94 return 0
95}