nx_nofloat_qwen_text_gate.nx source
↩ module page · 124 lines · 9165 B
1// nx_nofloat_qwen_text_gate.nx -- GRAND FINALE: text -> text through the sovereign no-float Qwen2.5-0.5B.
2// input text -> BPE encode (nx_nofloat_tok) -> token ids -> embed + 24 layers + norm + LM head
3// (nx_nofloat_llm) -> argmax -> BPE decode (nx_nofloat_tok) -> predicted next-token TEXT.
4// Composes the two canonical libraries (DRY -- no inline copies). 100% sovereign integer no-float, end to end.
5// HONEST: the prediction is the no-float forward's output; faithfulness vs reference Qwen is component-verified
6// (matmul 2 ulps, RoPE matches ref) + the remaining full-H2H. ASCII prompt (byte-level space map = follow-on).
7// No hw writes (Rule 26). expect_exit: 0 license_tier: ORIGINAL
8import "nx_syscalls.nx"
9import "nx_tier.nx"
10import "nx_le.nx"
11import "nx_tensor.nx"
12import "nx_gguf.nx"
13import "nx_gguf_load.nx"
14import "nx_gguf_meta.nx"
15import "nx_nofloat_llm.nx"
16import "nx_nofloat_tok.nx"
17import "nx_gate_verdict.nx"
18import "nx_stage_path.nx"
19
20func tx_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
21func tx_num(v: i64) -> i64 { let b: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(1,"-" as *u8,1)} let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} var i: i64=0; while i<k{b[i]=t[k-1-i];i=i+1} sys_write(1,b,k); return 0 }
22func tx_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
23
24func main() -> i64 {
25 tx_puts("GRAND FINALE: text -> text through the sovereign no-float Qwen2.5-0.5B (encode -> 24L forward -> decode)\n\n" as *u8)
26 let path: *u8 = sp_path("nx_real_model.gguf" as *u8, sys_mmap(SP_PATH_MAX))
27 sp_skip_unless("NOFLOAT-QWEN-TEXT-GATE" as *u8, path)
28 let len_out: *i64 = sys_mmap(8) as *i64
29 len_out[0]=0
30 let buf: *u8 = sys_read_file(path, len_out)
31
32 let ne: i64=896
33 let qd: i64=896
34 let kvd: i64=128
35 let fd: i64=4864
36 let MAXT: i64=16
37 var ntok: i64=0
38 var ran: i64=0
39 var argmax_idx: i64=0
40 var ids_valid: i64=0
41 var pred_len: i64=0
42 var pred_off: i64=0
43 var encbuf: *u8 = sys_mmap(8)
44 let ids: *i64 = sys_mmap(MAXT*8) as *i64
45 if buf != (0 as *u8) { if len_out[0] > 1000 {
46 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
47 if nx_gguf_parse(buf, len_out[0], hdr) == NX_GGUF_OK {
48 let voff: *i64 = sys_mmap(8) as *i64; let vty: *i64 = sys_mmap(8) as *i64
49 var mfirst: i64=0; var nm: i64=0; var vfirst: i64=0; var vocab: i64=0
50 let km: *u8 = "tokenizer.ggml.merges\x00" as *u8
51 let kt: *u8 = "tokenizer.ggml.tokens\x00" as *u8
52 if nx_gguf_meta_find(buf, len_out[0], hdr, km, tx_slen(km), voff, vty)==NX_GMETA_OK { nm=nx_gguf_meta_array_count(buf, voff[0]); mfirst=nx_gguf_meta_array_first_elt_off(buf, voff[0]) }
53 if nx_gguf_meta_find(buf, len_out[0], hdr, kt, tx_slen(kt), voff, vty)==NX_GMETA_OK { vocab=nx_gguf_meta_array_count(buf, voff[0]); vfirst=nx_gguf_meta_array_first_elt_off(buf, voff[0]) }
54 // forward tensors
55 let nt: *u8 = "token_embd.weight\x00" as *u8; let no: *u8 = "output.weight\x00" as *u8; let nn: *u8 = "output_norm.weight\x00" as *u8
56 let ie: nx_int=nx_gguf_find_tensor(hdr, nt, 17); let io: nx_int=nx_gguf_find_tensor(hdr, no, 13); let inn: nx_int=nx_gguf_find_tensor(hdr, nn, 18)
57 if ie>=0 { if io>=0 { if inn>=0 { if nm>0 { if vocab>0 {
58 let te: *NxGgufTensorInfo=nx_gguf_tensor_at(hdr, ie); let te_base: i64=hdr.data_off+te.offset; let te_ty: i64=te.ggml_type
59 let oh: *NxGgufTensorInfo=nx_gguf_tensor_at(hdr, io); let oh_base: i64=hdr.data_off+oh.offset; let oh_ty: i64=oh.ggml_type
60 let gout: *i64=sys_mmap(ne*8) as *i64; load_named_q16(buf, hdr, nn, 18, gout, ne)
61 // ---- ENCODE "hello" ----
62 let input: *u8 = "The sky is\x00" as *u8
63 encbuf=input
64 let ilen: i64 = tx_slen(input)
65 let tokp: *i64=sys_mmap(MAXT*8) as *i64; let tokl: *i64=sys_mmap(MAXT*8) as *i64
66 ntok = tk_bpe_encode(buf, mfirst, nm, vfirst, vocab, input, ilen, tokp, tokl, ids)
67 var vi: i64=0; ids_valid=1; while vi<ntok { if ids[vi]<0 { ids_valid=0 } vi=vi+1 }
68 if ntok>=1 { if ids_valid==1 {
69 let T: i64=ntok
70 let cfgA: *i64=sys_mmap(8*8) as *i64; cfgA[0]=T; cfgA[1]=ne; cfgA[2]=14; cfgA[3]=2; cfgA[4]=64; cfgA[5]=qd; cfgA[6]=kvd; cfgA[7]=8192
71 let cfgF: *i64=sys_mmap(4*8) as *i64; cfgF[0]=T; cfgF[1]=ne; cfgF[2]=fd
72 let wb: *i64=sys_mmap(12*8) as *i64
73 wb[0]=sys_mmap(ne*8) as i64; wb[1]=sys_mmap(qd*ne*8) as i64; wb[2]=sys_mmap(kvd*ne*8) as i64; wb[3]=sys_mmap(kvd*ne*8) as i64; wb[4]=sys_mmap(ne*qd*8) as i64
74 wb[5]=sys_mmap(ne*8) as i64; wb[6]=sys_mmap(ne*fd*8) as i64; wb[7]=sys_mmap(ne*fd*8) as i64; wb[8]=sys_mmap(fd*ne*8) as i64
75 wb[9]=sys_mmap(qd*8) as i64; wb[10]=sys_mmap(kvd*8) as i64; wb[11]=sys_mmap(kvd*8) as i64
76 let sb: *i64=sys_mmap(14*8) as *i64
77 sb[0]=sys_mmap(MAXT*ne*8) as i64; sb[1]=sys_mmap(MAXT*qd*8) as i64; sb[2]=sys_mmap(MAXT*kvd*8) as i64; sb[3]=sys_mmap(MAXT*kvd*8) as i64; sb[4]=sys_mmap(MAXT*qd*8) as i64
78 sb[5]=sys_mmap(MAXT*8) as i64; sb[6]=sys_mmap(MAXT*8) as i64; sb[7]=sys_mmap(MAXT*ne*8) as i64; sb[8]=sys_mmap(MAXT*fd*8) as i64; sb[9]=sys_mmap(MAXT*fd*8) as i64
79 sb[10]=sys_mmap(MAXT*fd*8) as i64; sb[11]=sys_mmap(MAXT*ne*8) as i64; sb[12]=sys_mmap(MAXT*ne*8) as i64; sb[13]=sys_mmap(MAXT*ne*8) as i64
80 let nmbuf: *u8=sys_mmap(64); let freqs: *i64=sys_mmap(32*8) as *i64; rope_freqs(freqs, 64)
81 let tmp: *i64=sys_mmap(64*256*8) as *i64; let row: *i64=sys_mmap(ne*8) as *i64
82 // ---- EMBED ----
83 let x: *i64=sys_mmap(MAXT*ne*8) as *i64
84 var i: i64=0; while i<T { dequant_row(buf, te_base, te_ty, ids[i], ne, ((x as i64)+i*ne*8) as *i64, tmp); i=i+1 }
85 // ---- 24 LAYERS ----
86 let hidden: *i64=sys_mmap(MAXT*ne*8) as *i64
87 run_stack(buf, hdr, x, hidden, wb, sb, nmbuf, freqs, cfgA, cfgF, 24, 0)
88 // ---- FINAL NORM (last token) + LM HEAD -> argmax ----
89 let normed: *i64=sys_mmap(ne*8) as *i64; rmsnorm_gamma_row(hidden, gout, (T-1)*ne, ne, normed, 0)
90 var maxl: i64=0; var v: i64=0
91 while v<vocab { dequant_row(buf, oh_base, oh_ty, v, ne, row, tmp); var s: i64=0; var k: i64=0; while k<ne { s=s+(normed[k]*row[k]); k=k+1 } let lg: i64=s>>16; if v==0 { maxl=lg; argmax_idx=0 } else { if lg>maxl { maxl=lg; argmax_idx=v } } v=v+1 }
92 // ---- DECODE argmax ----
93 pred_off = tk_decode_off(buf, vfirst, argmax_idx)
94 pred_len = nx_gguf_meta_read_string_len(buf, pred_off)
95 ran=1
96 } }
97 } } } } }
98 }
99 } }
100
101 tx_puts(" input text = '"); if encbuf != (0 as *u8) { sys_write(1, encbuf, tx_slen(encbuf)) } tx_puts("' encoded -> "); tx_num(ntok); tx_puts(" token(s): [")
102 var w: i64=0; while w<ntok { tx_num(ids[w]); if w<ntok-1 { tx_puts(", ") } w=w+1 } tx_puts("]\n")
103 tx_puts(" >>> sovereign no-float Qwen predicted next token = id "); tx_num(argmax_idx); tx_puts(" = '")
104 if pred_len>0 { sys_write(1, nx_gguf_meta_read_string_ptr(buf, pred_off), pred_len) }
105 tx_puts("'\n\n")
106
107 var pass: i64=0
108 var ttl: i64=0
109 ttl=ttl+1; tx_puts(" T1 BPE-encoded the text prompt to valid token ids (lib tk_bpe_encode): "); if ntok>=1 { if ids_valid==1 { pass=pass+1; tx_puts("PASS\n") } else { tx_puts("FAIL\n") } } else { tx_puts("FAIL\n") }
110 ttl=ttl+1; tx_puts(" T2 ran the full 24-layer no-float forward on the encoded prompt (lib run_stack): "); if ran==1 { pass=pass+1; tx_puts("PASS\n") } else { tx_puts("FAIL\n") }
111 ttl=ttl+1; tx_puts(" T3 predicted a VALID next token id (0 <= argmax < vocab): "); if argmax_idx>=0 { if argmax_idx<151936 { pass=pass+1; tx_puts("PASS\n") } else { tx_puts("FAIL\n") } } else { tx_puts("FAIL\n") }
112 ttl=ttl+1; tx_puts(" T4 DECODED the prediction back to non-empty text (full text->text loop closed): "); if pred_len>0 { pass=pass+1; tx_puts("PASS\n") } else { tx_puts("FAIL\n") }
113
114 tx_puts("NX-NOFLOAT-QWEN-TEXT-GATE passed "); tx_num(pass); tx_puts("/"); tx_num(ttl)
115 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
116 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
117 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
118 let ctr__dry: *i64 = gv_ctr()
119 ctr__dry[0] = pass
120 ctr__dry[1] = ttl
121 let rc__dry: i64 = gv_verdict("NOFLOAT-QWEN-TEXT-GATE" as *u8, ctr__dry, "TEXT -> sovereign no-float Qwen -> TEXT, end-to-end: encode + 24-layer forward + decode, all integer)" as *u8)
122 sys_exit(rc__dry)
123 return rc__dry
124}