nx_nofloat_qwen_forward_gate.nx source

1// nx_nofloat_qwen_forward_gate.nx -- CAPSTONE: a COMPLETE sovereign no-float Qwen2.5-0.5B forward. 2// token ids -> embed (token_embd) -> 24 transformer layers -> final RMSNorm (output_norm) -> LM head 3// (output.weight, streamed over 151936 vocab) -> argmax = predicted next token. 4// ALL building blocks come from the canonical library nx_nofloat_llm.nx (DRY -- no copy-paste debt; one 5// correct accumulate-then-shift matmul). This file is just the wiring + the test. expect_exit: 0 ORIGINAL 6import "nx_syscalls.nx" 7import "nx_tier.nx" 8import "nx_le.nx" 9import "nx_tensor.nx" 10import "nx_gguf.nx" 11import "nx_gguf_load.nx" 12import "nx_nofloat_llm.nx" 13import "nx_gate_verdict.nx" 14 15func fw_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } 16func fw_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 } 17 18func main() -> i64 { 19 fw_puts("CAPSTONE: a COMPLETE sovereign no-float Qwen2.5-0.5B forward (lib nx_nofloat_llm; embed->24L->norm->head->argmax)\n\n" as *u8) 20 let path: *u8 = "/home/elderwesto/nx_stage/nx_real_model.gguf\x00" as *u8 21 let len_out: *i64 = sys_mmap(8) as *i64 22 len_out[0]=0 23 let buf: *u8 = sys_read_file(path, len_out) 24 25 let T: i64=2 26 let ne: i64=896 27 let qd: i64=896 28 let kvd: i64=128 29 let fd: i64=4864 30 let N: i64=24 31 let cfgA: *i64 = sys_mmap(8*8) as *i64 32 cfgA[0]=T; cfgA[1]=ne; cfgA[2]=14; cfgA[3]=2; cfgA[4]=64; cfgA[5]=qd; cfgA[6]=kvd; cfgA[7]=8192 33 let cfgF: *i64 = sys_mmap(4*8) as *i64 34 cfgF[0]=T; cfgF[1]=ne; cfgF[2]=fd 35 36 var ran: i64=0 37 var nlayers: i64=0 38 var vocab: i64=0 39 var argmax_idx: i64=0 40 var max_logit: i64=0 41 var min_logit: i64=0 42 var hid_overflow: i64=0 43 var det_ok: i64=0 44 let tmp: *i64 = sys_mmap(64*256*8) as *i64 45 let row: *i64 = sys_mmap(ne*8) as *i64 46 if buf != (0 as *u8) { if len_out[0] > 1000 { 47 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader 48 if nx_gguf_parse(buf, len_out[0], hdr) == NX_GGUF_OK { 49 let nt: *u8 = "token_embd.weight\x00" as *u8; let ti_e: nx_int = nx_gguf_find_tensor(hdr, nt, 17) 50 let nn: *u8 = "output_norm.weight\x00" as *u8; let ti_n: nx_int = nx_gguf_find_tensor(hdr, nn, 18) 51 let no: *u8 = "output.weight\x00" as *u8; let ti_o: nx_int = nx_gguf_find_tensor(hdr, no, 13) 52 if ti_e>=0 { if ti_n>=0 { if ti_o>=0 { 53 let te: *NxGgufTensorInfo = nx_gguf_tensor_at(hdr, ti_e); let te_base: i64=hdr.data_off+te.offset; let te_ty: i64=te.ggml_type 54 let oh: *NxGgufTensorInfo = nx_gguf_tensor_at(hdr, ti_o); let oh_base: i64=hdr.data_off+oh.offset; let oh_ty: i64=oh.ggml_type; vocab=oh.dim_1 55 let gout: *i64 = sys_mmap(ne*8) as *i64 56 load_named_q16(buf, hdr, nn, 18, gout, ne) 57 let wb: *i64 = sys_mmap(12*8) as *i64 58 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 59 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 60 wb[9]=sys_mmap(qd*8) as i64; wb[10]=sys_mmap(kvd*8) as i64; wb[11]=sys_mmap(kvd*8) as i64 61 let sb: *i64 = sys_mmap(14*8) as *i64 62 sb[0]=sys_mmap(T*ne*8) as i64; sb[1]=sys_mmap(T*qd*8) as i64; sb[2]=sys_mmap(T*kvd*8) as i64; sb[3]=sys_mmap(T*kvd*8) as i64; sb[4]=sys_mmap(T*qd*8) as i64 63 sb[5]=sys_mmap(T*8) as i64; sb[6]=sys_mmap(T*8) as i64; sb[7]=sys_mmap(T*ne*8) as i64; sb[8]=sys_mmap(T*fd*8) as i64; sb[9]=sys_mmap(T*fd*8) as i64 64 sb[10]=sys_mmap(T*fd*8) as i64; sb[11]=sys_mmap(T*ne*8) as i64; sb[12]=sys_mmap(T*ne*8) as i64; sb[13]=sys_mmap(T*ne*8) as i64 65 let nm: *u8 = sys_mmap(64) 66 let freqs: *i64 = sys_mmap(32*8) as *i64 67 rope_freqs(freqs, 64) 68 // 1. EMBED a 2-token sequence 69 let tids: *i64 = sys_mmap(8) as *i64; tids[0]=9001; tids[1]=137 70 let x: *i64 = sys_mmap(T*ne*8) as *i64 71 var ii: i64=0; while ii<T { dequant_row(buf, te_base, te_ty, tids[ii], ne, ((x as i64)+ii*ne*8) as *i64, tmp); ii=ii+1 } 72 // 2. 24 TRANSFORMER LAYERS 73 let hidden: *i64 = sys_mmap(T*ne*8) as *i64 74 run_stack(buf, hdr, x, hidden, wb, sb, nm, freqs, cfgA, cfgF, N, 0) 75 nlayers=N 76 // 3. FINAL NORM on the last token 77 let normed: *i64 = sys_mmap(ne*8) as *i64 78 rmsnorm_gamma_row(hidden, gout, (T-1)*ne, ne, normed, 0) 79 // 4. LM HEAD -> logits -> argmax (stream vocab) 80 var v: i64=0 81 while v<vocab { 82 dequant_row(buf, oh_base, oh_ty, v, ne, row, tmp) 83 var s: i64=0; var k: i64=0; while k<ne { s=s+(normed[k]*row[k]); k=k+1 } 84 let lg: i64=s>>16 85 if v==0 { max_logit=lg; min_logit=lg; argmax_idx=0 } else { if lg>max_logit { max_logit=lg; argmax_idx=v } if lg<min_logit { min_logit=lg } } 86 v=v+1 87 } 88 dequant_row(buf, oh_base, oh_ty, argmax_idx, ne, row, tmp) 89 var s2: i64=0; var k2: i64=0; while k2<ne { s2=s2+(normed[k2]*row[k2]); k2=k2+1 } 90 if (s2>>16)==max_logit { det_ok=1 } 91 let BOUND: i64=1099511627776 92 ii=0; while ii<T*ne { var a: i64=hidden[ii]; if a<0 { a=0-a } if a>=BOUND { hid_overflow=hid_overflow+1 } ii=ii+1 } 93 ran=1 94 } } } 95 } 96 } } 97 98 fw_puts(" forward ran="); fw_num(ran); fw_puts(" layers="); fw_num(nlayers); fw_puts(" vocab="); fw_num(vocab); fw_puts("\n"); 99 fw_puts(" >>> PREDICTED NEXT TOKEN (argmax) = "); fw_num(argmax_idx); fw_puts(" max_logit="); fw_num(max_logit); fw_puts(" min_logit="); fw_num(min_logit); fw_puts(" hidden_overflow="); fw_num(hid_overflow); fw_puts("\n\n"); 100 101 var pass: i64=0 102 var ttl: i64=0 103 ttl=ttl+1; fw_puts(" T1 full forward ran end-to-end on real weights (embed + 24 layers + norm + head, via lib): "); if ran==1 { if nlayers==24 { pass=pass+1; fw_puts("PASS\n") } else { fw_puts("FAIL\n") } } else { fw_puts("FAIL\n") } 104 ttl=ttl+1; fw_puts(" T2 argmax is a VALID next-token id (0 <= argmax < vocab, vocab>=100000): "); if argmax_idx>=0 { if argmax_idx<vocab { if vocab>=100000 { pass=pass+1; fw_puts("PASS\n") } else { fw_puts("FAIL\n") } } else { fw_puts("FAIL\n") } } else { fw_puts("FAIL\n") } 105 ttl=ttl+1; fw_puts(" T3 logits non-degenerate + hidden STABLE through 24 layers (no overflow): "); if max_logit != min_logit { if hid_overflow==0 { pass=pass+1; fw_puts("PASS\n") } else { fw_puts("FAIL\n") } } else { fw_puts("FAIL\n") } 106 ttl=ttl+1; fw_puts(" T4 DETERMINISTIC (head recompute identical; stack/embed proven det in their gates): "); if det_ok==1 { pass=pass+1; fw_puts("PASS\n") } else { fw_puts("FAIL\n") } 107 108 fw_puts("NX-NOFLOAT-QWEN-FORWARD-GATE passed "); fw_num(pass); fw_puts("/"); fw_num(ttl) 109 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check 110 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled 111 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify. 112 let ctr__dry: *i64 = gv_ctr() 113 ctr__dry[0] = pass 114 ctr__dry[1] = ttl 115 let rc__dry: i64 = gv_verdict("NOFLOAT-QWEN-FORWARD-GATE" as *u8, ctr__dry, "complete sovereign no-float Qwen forward, built from the canonical nx_nofloat_llm library -- no copy-paste debt)" as *u8) 116 sys_exit(rc__dry) 117 return rc__dry 118}