nx_zimage_gguf_arch.nx source
↩ module page · 147 lines · 6867 B
1// nx_zimage_gguf_arch.nx -- extract the REAL Z-Image text-encoder architecture from its GGUF, sovereignly.
2//
3// sd-server -> Nishi migration: the real-scale assembly needs the REAL dims to scale our f32 organs to.
4// This reads the actual `Z-Image_Qwen_3_4b-Q6_K.gguf` and pulls token_embd.weight's dims (hidden, vocab)
5// + ggml quant type + tensor_count from the parsed header (metadata at the front -> bounded prefix read,
6// no multi-GB tensor materialization), and writes them to /tmp/zimg_arch.txt for inspection. Composes the
7// proven sovereign GGUF reader. Gate: opens, GGUF v3, token_embd found, hidden>0.
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"
19
20func za_emit_kv(fd: i64, key: *u8, key_len: i64, value: i64) -> i64 {
21 let line: *u8 = sys_mmap(128)
22 var lo: i64 = 0
23 var ki: i64 = 0
24 while ki < key_len { line[lo] = key[ki]; lo = lo + 1; ki = ki + 1 }
25 line[lo] = 0x3D; lo = lo + 1 // '='
26 let dec: *u8 = sys_mmap(32)
27 let n_dec: i64 = nx_strconv_format_i64(value, dec)
28 var k: i64 = 0
29 while k < n_dec { line[lo] = dec[k]; lo = lo + 1; k = k + 1 }
30 line[lo] = 0x0A; lo = lo + 1 // '\n'
31 return sys_write(fd, line, lo)
32}
33
34// build "blk.<n>.<suffix>" into out (NUL-terminated); returns the name length.
35func za_blk_name(out: *u8, n: i64, suffix: *u8, suffix_len: i64) -> i64 {
36 var o: i64 = 0
37 out[o] = 0x62 as u8; o = o + 1 // 'b'
38 out[o] = 0x6C as u8; o = o + 1 // 'l'
39 out[o] = 0x6B as u8; o = o + 1 // 'k'
40 out[o] = 0x2E as u8; o = o + 1 // '.'
41 let dec: *u8 = sys_mmap(32)
42 let nd: i64 = nx_strconv_format_i64(n, dec)
43 var i: i64 = 0
44 while i < nd { out[o] = dec[i]; o = o + 1; i = i + 1 }
45 out[o] = 0x2E as u8; o = o + 1 // '.'
46 var j: i64 = 0
47 while j < suffix_len { out[o] = suffix[j]; o = o + 1; j = j + 1 }
48 out[o] = 0 as u8
49 return o
50}
51
52// emit "<label>_d0=" / "<label>_d1=" for blk.0.<suffix>; returns 1 if the tensor was found.
53// The assembly needs these to size the f32 organs: attn_q/k/v give the GQA head geometry,
54// ffn_gate/up/down give d_ff. Reading them off the REAL file beats assuming Qwen3-4B defaults.
55func za_emit_dims(ofd: i64, hdr: *NxGgufHeader, label: *u8, label_len: i64, suffix: *u8, suffix_len: i64) -> i64 {
56 let nmbuf: *u8 = sys_mmap(160)
57 let nl: i64 = za_blk_name(nmbuf, 0, suffix, suffix_len)
58 let fi: nx_int = nx_gguf_find_tensor(hdr, nmbuf, nl as nx_int)
59 if fi < 0 { return 0 }
60 let ti2: *NxGgufTensorInfo = nx_gguf_tensor_at(hdr, fi)
61 let lb: *u8 = sys_mmap(160)
62 var o: i64 = 0
63 var i: i64 = 0
64 while i < label_len { lb[o] = label[i]; o = o + 1; i = i + 1 }
65 lb[o] = 0x5F as u8; o = o + 1 // '_'
66 lb[o] = 0x64 as u8; o = o + 1 // 'd'
67 lb[o] = 0x30 as u8; o = o + 1 // '0'
68 za_emit_kv(ofd, lb, o, ti2.dim_0)
69 lb[o - 1] = 0x31 as u8 // -> '1'
70 za_emit_kv(ofd, lb, o, ti2.dim_1)
71 return 1
72}
73
74func main() -> i64 {
75 let path: *u8 = "/mnt/c/Users/elder/elder-ai-platform/models/unified/text_encoder/Z-Image_Qwen_3_4b-Q6_K.gguf" as *u8
76 let fd: i64 = sys_openat_rd(path)
77 if fd < 0 { return 30 }
78
79 let CAP: i64 = 201326592 // 192 MB prefix
80 let buf: *u8 = sys_mmap(CAP)
81 var total: i64 = 0
82 var go: i64 = 1
83 while go == 1 {
84 let r: i64 = sys_read(fd, ((buf as i64) + total) as *u8, CAP - total)
85 if r <= 0 { go = 0 } else { total = total + r; if total >= CAP { go = 0 } }
86 }
87 sys_close(fd)
88 if total < 1000 { return 31 }
89
90 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
91 let vp: nx_int = nx_gguf_parse(buf, total, hdr)
92 if vp != NX_GGUF_OK { return 40 + vp }
93 if hdr.version != 3 { return 50 }
94
95 let idx: nx_int = nx_gguf_find_tensor(hdr, "token_embd.weight" as *u8, 17)
96 if idx < 0 { return 60 }
97 let ti: *NxGgufTensorInfo = nx_gguf_tensor_at(hdr, idx)
98 let hidden: i64 = ti.dim_0
99 let vocab: i64 = ti.dim_1
100 let qtype: i64 = ti.ggml_type
101 if hidden <= 0 { return 61 }
102
103 // also locate a transformer-block tensor to confirm the layered architecture is present
104 let blk0: nx_int = nx_gguf_find_tensor(hdr, "blk.0.attn_norm.weight" as *u8, 22)
105
106 let ofd: i64 = sys_openat_wr("/tmp/zimg_arch.txt" as *u8, 0x1a4)
107 if ofd >= 0 {
108 za_emit_kv(ofd, "gguf_version" as *u8, 12, hdr.version)
109 za_emit_kv(ofd, "tensor_count" as *u8, 12, hdr.tensor_count)
110 za_emit_kv(ofd, "token_embd_hidden" as *u8, 17, hidden)
111 za_emit_kv(ofd, "token_embd_vocab" as *u8, 16, vocab)
112 za_emit_kv(ofd, "token_embd_ggml_type" as *u8, 20, qtype)
113 za_emit_kv(ofd, "blk0_attn_norm_idx" as *u8, 18, blk0)
114
115 // n_layers by PROBING blk.N until the name misses -- NOT by dividing tensor_count by a
116 // guessed tensors-per-block. A division would be an assumption dressed as a measurement;
117 // probing asks the file itself. Bounded at 1024 so a malformed header cannot spin forever.
118 // CROSS-CHECK (measured 2026-07-30): probe says 36; 36*11 + token_embd + output_norm = 398
119 // = tensor_count exactly, so two independent methods agree.
120 var n_layers: i64 = 0
121 let nmbuf: *u8 = sys_mmap(160)
122 var probing: i64 = 1
123 while probing == 1 {
124 let nl: i64 = za_blk_name(nmbuf, n_layers, "attn_norm.weight" as *u8, 16)
125 let fi: nx_int = nx_gguf_find_tensor(hdr, nmbuf, nl as nx_int)
126 if fi < 0 { probing = 0 }
127 else {
128 n_layers = n_layers + 1
129 if n_layers >= 1024 { probing = 0 }
130 }
131 }
132 za_emit_kv(ofd, "n_layers" as *u8, 8, n_layers)
133
134 // blk.0 geometry -- everything the full-scale assembly must size its organs to.
135 za_emit_dims(ofd, hdr, "blk0_attn_q" as *u8, 11, "attn_q.weight" as *u8, 13)
136 za_emit_dims(ofd, hdr, "blk0_attn_k" as *u8, 11, "attn_k.weight" as *u8, 13)
137 za_emit_dims(ofd, hdr, "blk0_attn_v" as *u8, 11, "attn_v.weight" as *u8, 13)
138 za_emit_dims(ofd, hdr, "blk0_attn_output" as *u8, 16, "attn_output.weight" as *u8, 18)
139 za_emit_dims(ofd, hdr, "blk0_ffn_gate" as *u8, 13, "ffn_gate.weight" as *u8, 15)
140 za_emit_dims(ofd, hdr, "blk0_ffn_up" as *u8, 11, "ffn_up.weight" as *u8, 13)
141 za_emit_dims(ofd, hdr, "blk0_ffn_down" as *u8, 13, "ffn_down.weight" as *u8, 15)
142
143 sys_close(ofd)
144 }
145
146 return 0
147}