nx_nofloat_qwen_text_gate.nx source
↩ module page · 122 lines · 9079 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"
18
19func 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 }
20func 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 }
21func tx_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
22
23func main() -> i64 {
24 tx_puts("GRAND FINALE: text -> text through the sovereign no-float Qwen2.5-0.5B (encode -> 24L forward -> decode)\n\n" as *u8)
25 let path: *u8 = "/home/elderwesto/nx_stage/nx_real_model.gguf\x00" as *u8
26 let len_out: *i64 = sys_mmap(8) as *i64
27 len_out[0]=0
28 let buf: *u8 = sys_read_file(path, len_out)
29
30 let ne: i64=896
31 let qd: i64=896
32 let kvd: i64=128
33 let fd: i64=4864
34 let MAXT: i64=16
35 var ntok: i64=0
36 var ran: i64=0
37 var argmax_idx: i64=0
38 var ids_valid: i64=0
39 var pred_len: i64=0
40 var pred_off: i64=0
41 var encbuf: *u8 = sys_mmap(8)
42 let ids: *i64 = sys_mmap(MAXT*8) as *i64
43 if buf != (0 as *u8) { if len_out[0] > 1000 {
44 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
45 if nx_gguf_parse(buf, len_out[0], hdr) == NX_GGUF_OK {
46 let voff: *i64 = sys_mmap(8) as *i64; let vty: *i64 = sys_mmap(8) as *i64
47 var mfirst: i64=0; var nm: i64=0; var vfirst: i64=0; var vocab: i64=0
48 let km: *u8 = "tokenizer.ggml.merges\x00" as *u8
49 let kt: *u8 = "tokenizer.ggml.tokens\x00" as *u8
50 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]) }
51 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]) }
52 // forward tensors
53 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
54 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)
55 if ie>=0 { if io>=0 { if inn>=0 { if nm>0 { if vocab>0 {
56 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
57 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
58 let gout: *i64=sys_mmap(ne*8) as *i64; load_named_q16(buf, hdr, nn, 18, gout, ne)
59 // ---- ENCODE "hello" ----
60 let input: *u8 = "The sky is\x00" as *u8
61 encbuf=input
62 let ilen: i64 = tx_slen(input)
63 let tokp: *i64=sys_mmap(MAXT*8) as *i64; let tokl: *i64=sys_mmap(MAXT*8) as *i64
64 ntok = tk_bpe_encode(buf, mfirst, nm, vfirst, vocab, input, ilen, tokp, tokl, ids)
65 var vi: i64=0; ids_valid=1; while vi<ntok { if ids[vi]<0 { ids_valid=0 } vi=vi+1 }
66 if ntok>=1 { if ids_valid==1 {
67 let T: i64=ntok
68 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
69 let cfgF: *i64=sys_mmap(4*8) as *i64; cfgF[0]=T; cfgF[1]=ne; cfgF[2]=fd
70 let wb: *i64=sys_mmap(12*8) as *i64
71 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
72 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
73 wb[9]=sys_mmap(qd*8) as i64; wb[10]=sys_mmap(kvd*8) as i64; wb[11]=sys_mmap(kvd*8) as i64
74 let sb: *i64=sys_mmap(14*8) as *i64
75 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
76 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
77 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
78 let nmbuf: *u8=sys_mmap(64); let freqs: *i64=sys_mmap(32*8) as *i64; rope_freqs(freqs, 64)
79 let tmp: *i64=sys_mmap(64*256*8) as *i64; let row: *i64=sys_mmap(ne*8) as *i64
80 // ---- EMBED ----
81 let x: *i64=sys_mmap(MAXT*ne*8) as *i64
82 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 }
83 // ---- 24 LAYERS ----
84 let hidden: *i64=sys_mmap(MAXT*ne*8) as *i64
85 run_stack(buf, hdr, x, hidden, wb, sb, nmbuf, freqs, cfgA, cfgF, 24, 0)
86 // ---- FINAL NORM (last token) + LM HEAD -> argmax ----
87 let normed: *i64=sys_mmap(ne*8) as *i64; rmsnorm_gamma_row(hidden, gout, (T-1)*ne, ne, normed, 0)
88 var maxl: i64=0; var v: i64=0
89 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 }
90 // ---- DECODE argmax ----
91 pred_off = tk_decode_off(buf, vfirst, argmax_idx)
92 pred_len = nx_gguf_meta_read_string_len(buf, pred_off)
93 ran=1
94 } }
95 } } } } }
96 }
97 } }
98
99 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): [")
100 var w: i64=0; while w<ntok { tx_num(ids[w]); if w<ntok-1 { tx_puts(", ") } w=w+1 } tx_puts("]\n")
101 tx_puts(" >>> sovereign no-float Qwen predicted next token = id "); tx_num(argmax_idx); tx_puts(" = '")
102 if pred_len>0 { sys_write(1, nx_gguf_meta_read_string_ptr(buf, pred_off), pred_len) }
103 tx_puts("'\n\n")
104
105 var pass: i64=0
106 var ttl: i64=0
107 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") }
108 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") }
109 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") }
110 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") }
111
112 tx_puts("NX-NOFLOAT-QWEN-TEXT-GATE passed "); tx_num(pass); tx_puts("/"); tx_num(ttl)
113 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
114 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
115 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
116 let ctr__dry: *i64 = gv_ctr()
117 ctr__dry[0] = pass
118 ctr__dry[1] = ttl
119 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)
120 sys_exit(rc__dry)
121 return rc__dry
122}