nx_llm_loopb_gate.nx source

1// nx_llm_loopb_gate.nx -- THE LOOP-B CLOSURE: load OUR sovereignly-trained model (nx_f32_qwen2_train_gate's 2// /tmp/nx_ours_qwen.gguf) via the arch-config NO-FLOAT inference and GENERATE -- proving train (ours, f32 tape) 3// -> gguf-export -> serve (ours, 100pct-integer) end to end. If our integer inference reproduces the sequence 4// the f32 trainer learned ('the quick brown fox...'), the whole sovereign loop is closed: we train a model AND 5// run it, all our own stack, no PyTorch, no CUDA, no float lib on the serve path. Dims come from the gguf 6// metadata (arch-config), so nothing is hardcoded to this specific model. 7// T1 arch-config load reads OUR metadata (qwen2 d=16 layers=2 1-head). 8// T2 all 27 tensors present + loadable by name. 9// T3 GENERATE on the no-float integer forward reproduces the trained corpus (>=30/44 chars) = LOOP-B CLOSED. 10// expect_exit: 0 license_tier: ORIGINAL 11import "nx_syscalls.nx" 12import "nx_tier.nx" 13import "nx_le.nx" 14import "nx_tensor.nx" 15import "nx_gguf.nx" 16import "nx_gguf_load.nx" 17import "nx_gguf_meta.nx" 18import "nx_nofloat_llm.nx" 19import "nx_nofloat_arch.nx" 20 21func lw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } 22func ln2(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 } 23func lslen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n } 24 25func main() -> i64 { 26 lw("=== nx_llm_loopb_gate: load OUR trained Qwen2 gguf -> generate on the sovereign no-float inference (loop-b) ===\n" as *u8) 27 var pass: i64=0; var total: i64=0 28 let path: *u8="/tmp/nx_ours_qwen.gguf\x00" as *u8 29 let len_out: *i64=sys_mmap(8) as *i64; len_out[0]=0 30 let buf: *u8=sys_read_file(path, len_out) 31 if buf==(0 as *u8) { lw("OUR MODEL ABSENT -- run nx_f32_qwen2_train_gate first to export it\n" as *u8); return 1 } 32 let hdr: *NxGgufHeader=sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader 33 if nx_gguf_parse(buf, len_out[0], hdr) != NX_GGUF_OK { lw("PARSE FAIL\n" as *u8); return 1 } 34 35 // T1 arch-config from OUR metadata 36 let cfg: *i64=sys_mmap(16*8) as *i64; let arch: *u8=sys_mmap(64) 37 if nac_read_config(buf, len_out[0], hdr, cfg, arch) != 0 { lw("CONFIG FAIL\n" as *u8); return 1 } 38 let ne: i64=cfg[0]; let NL: i64=cfg[1]; let NH: i64=cfg[2]; let NKV: i64=cfg[3]; let hd: i64=cfg[4]; let qd: i64=cfg[5]; let kvd: i64=cfg[6]; let fd: i64=cfg[7]; let scale: i64=cfg[8] 39 lw(" our model arch='" as *u8); lw(arch); lw("' d=" as *u8); ln2(ne); lw(" layers=" as *u8); ln2(NL); lw(" heads=" as *u8); ln2(NH); lw(" hd=" as *u8); ln2(hd); lw(" ffn=" as *u8); ln2(fd); lw(" scale_q16=" as *u8); ln2(scale); lw("\n" as *u8) 40 total=total+1; if ne>=1 { if NL>=1 { if NH==1 { pass=pass+1; lw(" [PASS] " as *u8) } else { lw(" [FAIL] " as *u8) } } else { lw(" [FAIL] " as *u8) } } else { lw(" [FAIL] " as *u8) } 41 lw("T1 arch-config read OUR metadata (dims from the gguf we wrote, nothing hardcoded)\n" as *u8) 42 43 // vocab from output.weight dim_1 44 let no: *u8="output.weight\x00" as *u8; let ti_o: nx_int=nx_gguf_find_tensor(hdr, no, 13); 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; let vocab: i64=oh.dim_1 45 let nt: *u8="token_embd.weight\x00" as *u8; let ti_e: nx_int=nx_gguf_find_tensor(hdr, nt, 17); 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 46 let nn: *u8="output_norm.weight\x00" as *u8; let ti_n: nx_int=nx_gguf_find_tensor(hdr, nn, 18) 47 // T2 all tensors present (probe a per-layer one + head/embed/norm) 48 let nq: *u8="blk.0.attn_q.weight\x00" as *u8; let nqb: *u8="blk.0.attn_q.bias\x00" as *u8; let nan: *u8="blk.0.attn_norm.weight\x00" as *u8; let ngate: *u8="blk.0.ffn_gate.weight\x00" as *u8 49 var okt: i64=1 50 if ti_e<0 { okt=0 } if ti_o<0 { okt=0 } if ti_n<0 { okt=0 } 51 if nx_gguf_find_tensor(hdr, nq, lslen(nq))<0 { okt=0 } if nx_gguf_find_tensor(hdr, nqb, lslen(nqb))<0 { okt=0 } if nx_gguf_find_tensor(hdr, nan, lslen(nan))<0 { okt=0 } if nx_gguf_find_tensor(hdr, ngate, lslen(ngate))<0 { okt=0 } 52 total=total+1; if okt==1 { pass=pass+1; lw(" [PASS] " as *u8) } else { lw(" [FAIL] " as *u8) } 53 lw("T2 all Qwen2 tensors present by name (token_embd/output/output_norm + blk.0.attn_q/.bias/.attn_norm/.ffn_gate)\n" as *u8) 54 55 let gout: *i64=sys_mmap(ne*8) as *i64; load_named_q16(buf, hdr, nn, 18, gout, ne) 56 // vocab map (id->char) written by the trainer 57 let vlen: *i64=sys_mmap(8) as *i64; let id2c: *u8=sys_read_file("/tmp/nx_ours_vocab.bin\x00" as *u8, vlen) 58 59 // scratch for a full T-token forward (MAXT covers the 44-char corpus) 60 let MAXT: i64=48 61 let wb: *i64=sys_mmap(12*8) as *i64 62 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 63 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 64 wb[9]=sys_mmap(qd*8) as i64; wb[10]=sys_mmap(kvd*8) as i64; wb[11]=sys_mmap(kvd*8) as i64 65 let sb: *i64=sys_mmap(14*8) as *i64 66 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 67 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 68 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 69 let nm: *u8=sys_mmap(64); let freqs: *i64=sys_mmap(32*8) as *i64; rope_freqs(freqs, hd) 70 let tmp: *i64=sys_mmap(64*256*8) as *i64 71 let x: *i64=sys_mmap(MAXT*ne*8) as *i64; let hout: *i64=sys_mmap(MAXT*ne*8) as *i64 72 let normed: *i64=sys_mmap(ne*8) as *i64; let idout: *i64=sys_mmap(8) as *i64; let lgout: *i64=sys_mmap(8) as *i64 73 let hp: *i64=sys_mmap(8*8) as *i64 74 75 // T3 GENERATE: autoregressive greedy from token 0 (matches the trainer's generation). Char id 0 = 't'. 76 let CLEN: i64=45 // corpus 'the quick brown fox jumps over the lazy dog. ' (44 gen chars after the seed) 77 let gseq: *i64=sys_mmap(MAXT*8) as *i64; gseq[0]=0; var glen: i64=1 78 while glen<CLEN { 79 let cfgA: *i64=sys_mmap(8*8) as *i64; cfgA[0]=glen; cfgA[1]=ne; cfgA[2]=NH; cfgA[3]=NKV; cfgA[4]=hd; cfgA[5]=qd; cfgA[6]=kvd; cfgA[7]=scale 80 let cfgF: *i64=sys_mmap(4*8) as *i64; cfgF[0]=glen; cfgF[1]=ne; cfgF[2]=fd 81 var ei: i64=0; while ei<glen { dequant_row(buf, te_base, te_ty, gseq[ei], ne, ((x as i64)+ei*ne*8) as *i64, tmp); ei=ei+1 } 82 run_stack(buf, hdr, x, hout, wb, sb, nm, freqs, cfgA, cfgF, NL, 0) 83 rmsnorm_gamma_row_q24(hout, gout, (glen-1)*ne, ne, normed, 0) 84 hp[0]=buf as i64; hp[1]=oh_base; hp[2]=oh_ty; hp[3]=normed as i64; hp[4]=vocab; hp[5]=ne; hp[6]=idout as i64; hp[7]=lgout as i64 85 let nx2: i64=head_argmax_pool(hp) 86 gseq[glen]=nx2; glen=glen+1 87 } 88 // decode via the vocab map 89 let corpus: *u8="the quick brown fox jumps over the lazy dog. \x00" as *u8 90 let gstr: *u8=sys_mmap(MAXT+8); var gi: i64=0 91 if (id2c as i64)!=0 { while gi<CLEN { let id: i64=gseq[gi]; if id<vlen[0] { gstr[gi]=id2c[id] } else { gstr[gi]=63 as u8 } gi=gi+1 } } 92 lw(" our-model generation on the no-float integer forward: '" as *u8); sys_write(1, gstr, CLEN); lw("'\n" as *u8) 93 var matchlen: i64=0; gi=1; while gi<CLEN { if gstr[gi]==corpus[gi] { matchlen=matchlen+1; gi=gi+1 } else { gi=CLEN } } 94 total=total+1; if matchlen>=30 { pass=pass+1; lw(" [PASS] " as *u8) } else { lw(" [FAIL] " as *u8) } 95 lw("T3 LOOP-B CLOSED: our trained model reproduced " as *u8); ln2(matchlen); lw("/" as *u8); ln2(CLEN-1); lw(" corpus chars ON OUR INTEGER INFERENCE (f32 train -> gguf -> Q16 serve)\n" as *u8) 96 97 lw("\n LOOP-B END TO END: a model WE trained (sovereign f32 tape autograd) -> gguf-exported (our writer) -> loaded\n" as *u8) 98 lw(" by arch-config metadata -> GENERATED on our 100pct-integer inference. No PyTorch, no CUDA, no float on the\n" as *u8) 99 lw(" serve path. f32-train->Q16-serve reproduces the learned text = the whole sovereign train->serve loop closes.\n" as *u8) 100 lw("NX-LLM-LOOPB verdict=" as *u8) 101 if pass==total { lw("GREEN passes=" as *u8); ln2(pass); lw("/" as *u8); ln2(total); lw(" -- OUR trained model runs + generates on OUR sovereign inference\n" as *u8); return 0 } 102 lw("RED passes=" as *u8); ln2(pass); lw("/" as *u8); ln2(total); lw("\n" as *u8); return 1 103}