nx_nofloat_quant_gate.nx source

1// nx_nofloat_quant_gate.nx -- CAP-NF-QUANT: post-training QUANTIZATION for efficient sovereign inference, 2// grounded in the BitNet research (nfs_bitnet158.raw / nfs_intquant.raw: ternary {-1,0,1} and integer-only 3// inference match full precision). Train the near-optimal 3-category grammar LM (Q16), then quantize its 4// weights to INT8 (per-tensor symmetric, scale=maxabs/127) and TERNARY {-1,0,1} (scale=mean|W|), and measure 5// how much held-out quality (CE) survives. 6// T1 INT8 preserves quality: int8 held-out CE ~= full-precision CE (within ~0.15 nats). 7// T2 INT8 stays near-OPTIMAL: int8 CE << uniform ln(8)=2079 (efficient 8-bit inference works). 8// T3 TERNARY carries the signal: ternary CE < uniform (1.58-bit weights still model the grammar; honest: 9// ternary loses more than int8 on a tiny model -- the BitNet "matches at scale" claim is a SCALE result). 10// Pure integer Q16. Sovereign: nx_nofloat_autograd + nx_syscalls. expect_exit: 0 11import "nx_nofloat_autograd.nx" 12import "nx_syscalls.nx" 13import "nx_gate_emit_lib.nx" 14import "nx_gate_verdict.nx" 15const Q16: i64 = 65536 16const UNIFORM_MNAT: i64 = 2079 // ln(8) 17const FLOOR_MNAT: i64 = 964 // avg(ln2,ln3,ln3) 18 19 20func dini(a: *i64, n: i64, sd: i64) -> i64 { var i: i64=0; while i<n { a[i]=(((i*7+sd*13+1)%11)-5)*13107; i=i+1 } return 0 } 21func lcg(st: *i64) -> i64 { st[0]=(st[0]*1103515245 + 12345) & 2147483647; return (st[0] >> 15) } 22func iabs(x: i64) -> i64 { if x<0 { return 0-x } return x } 23func qround(src: i64, scale: i64) -> i64 { if scale<=0 { return 0 } if src>=0 { return (src + scale/2)/scale } return (src - scale/2)/scale } 24// INT8 per-tensor symmetric quantize+dequantize: src(Q16) -> 8-bit levels [-127,127] -> dequantized(Q16) 25func quant_int8(src: *i64, dst: *i64, n: i64) -> i64 { 26 var mx: i64=0; var i: i64=0; while i<n { let a: i64=iabs(src[i]); if a>mx { mx=a } i=i+1 } 27 if mx==0 { i=0; while i<n { dst[i]=0; i=i+1 } return 0 } 28 var scale: i64=mx/127; if scale==0 { scale=1 } 29 i=0; while i<n { var q: i64=qround(src[i],scale); if q>127 { q=127 } if q<0-127 { q=0-127 } dst[i]=q*scale; i=i+1 } 30 return 0 31} 32// TERNARY {-1,0,1} quantize+dequantize (BitNet b1.58 style: scale = mean|W|) 33func quant_ternary(src: *i64, dst: *i64, n: i64) -> i64 { 34 var s: i64=0; var i: i64=0; while i<n { s=s+iabs(src[i]); i=i+1 } 35 var scale: i64=s/n; if scale==0 { scale=1 } 36 i=0; while i<n { var q: i64=qround(src[i],scale); if q>1 { q=1 } if q<0-1 { q=0-1 } dst[i]=q*scale; i=i+1 } 37 return 0 38} 39func make_stream(S: *i64, tgt: *i64, P: i64, st: *i64) -> i64 { 40 var i: i64=0 41 while i<P { let c: i64=i%3; if c==0 { S[i]=lcg(st)%2 } if c==1 { S[i]=2+lcg(st)%3 } if c==2 { S[i]=5+lcg(st)%3 } i=i+1 } 42 i=0; while i<P-1 { tgt[i]=S[i+1]; i=i+1 } tgt[P-1]=S[0] 43 return 0 44} 45func clm_fwd(tape: *i64, vals: *i64, st: *i64, W: *i64, ids: *i64, tgt: *i64, T: i64, dm: i64, V: i64, scale: i64, leaves: *i64) -> i64 { 46 let E: *i64=W[0] as *i64; let Wq: *i64=W[1] as *i64; let Wk: *i64=W[2] as *i64; let Wv: *i64=W[3] as *i64; let Wo: *i64=W[4] as *i64; let Wlm: *i64=W[5] as *i64 47 st[0]=0; st[1]=0 48 let nE: i64=nfa_leaf(tape,vals,st,V,dm,E,0) 49 let nWq: i64=nfa_leaf(tape,vals,st,dm,dm,Wq,0) 50 let nWk: i64=nfa_leaf(tape,vals,st,dm,dm,Wk,0) 51 let nWv: i64=nfa_leaf(tape,vals,st,dm,dm,Wv,0) 52 let nWo: i64=nfa_leaf(tape,vals,st,dm,dm,Wo,0) 53 let nWlm: i64=nfa_leaf(tape,vals,st,dm,V,Wlm,0) 54 let nX: i64=nfa_embed(tape,vals,st,nE,ids,T) 55 let nXn: i64=nfa_rmsnorm_rows(tape,vals,st,nX) 56 let nQ: i64=nfa_matmul(tape,vals,st,nXn,nWq) 57 let nK: i64=nfa_matmul(tape,vals,st,nXn,nWk) 58 let nV: i64=nfa_matmul(tape,vals,st,nXn,nWv) 59 let nQr: i64=nfa_rope(tape,vals,st,nQ) 60 let nKr: i64=nfa_rope(tape,vals,st,nK) 61 let nS: i64=nfa_matmul_nt(tape,vals,st,nQr,nKr) 62 let nSs: i64=nfa_cmul(tape,vals,st,nS,scale) 63 let nA: i64=nfa_softmax_rows(tape,vals,st,nSs,1) 64 let nO: i64=nfa_matmul(tape,vals,st,nA,nV) 65 let nOp: i64=nfa_matmul(tape,vals,st,nO,nWo) 66 let nH: i64=nfa_vadd(tape,vals,st,nX,nOp) 67 let nHn: i64=nfa_rmsnorm_rows(tape,vals,st,nH) 68 let nLg: i64=nfa_matmul(tape,vals,st,nHn,nWlm) 69 let nLoss: i64=nfa_softce_rows(tape,vals,st,nLg,tgt) 70 leaves[0]=nE; leaves[1]=nWq; leaves[2]=nWk; leaves[3]=nWv; leaves[4]=nWo; leaves[5]=nWlm; leaves[6]=nLg 71 return nLoss 72} 73func step_all(tape: *i64, grads: *i64, W: *i64, WN: *i64, leaves: *i64, lr: i64, clip: i64, gb: *i64) -> i64 { 74 var i: i64=0 75 while i<6 { let ar: *i64=W[i] as *i64; let cn: i64=WN[i]; let nd: i64=leaves[i]; var c: i64=0; while c<cn { var g: i64=nfa_grad(tape,grads,nd,c); if g>clip{g=clip} if g<0-clip{g=0-clip} gb[c]=g; c=c+1 } nfa_sgd(ar,gb,cn,lr); i=i+1 } 76 return 0 77} 78func do_train(tape: *i64, vals: *i64, grads: *i64, st: *i64, W: *i64, WN: *i64, S: *i64, tgt: *i64, P: i64, dm: i64, V: i64, scale: i64, leaves: *i64, gb: *i64, steps: i64, sdat: *i64) -> i64 { 79 var ep: i64=0 80 while ep < steps { make_stream(S,tgt,P,sdat); let nl: i64=clm_fwd(tape,vals,st,W,S,tgt,P-1,dm,V,scale,leaves); nfa_backward(tape,vals,grads,st[0],nl); step_all(tape,grads,W,WN,leaves,6554,262144,gb); ep=ep+1 } 81 return 0 82} 83// ternary QAT (BitNet b1.58 recipe): forward uses ternary-quantized weights (Wt), gradients update the 84// full-precision SHADOW weights W2 (straight-through estimator: quantization treated as identity in backward). 85// So W2 learns to be ROBUST to ternary quantization -- which naive post-training ternary can't be. 86func do_train_qat(tape: *i64, vals: *i64, grads: *i64, st: *i64, W2: *i64, Wt: *i64, WN: *i64, S: *i64, tgt: *i64, P: i64, dm: i64, V: i64, scale: i64, leaves: *i64, gb: *i64, steps: i64, sdat: *i64) -> i64 { 87 var ep: i64=0 88 while ep < steps { 89 make_stream(S,tgt,P,sdat) 90 var i: i64=0; while i<6 { quant_ternary(W2[i] as *i64, Wt[i] as *i64, WN[i]); i=i+1 } // quantize shadow -> ternary 91 let nl: i64=clm_fwd(tape,vals,st,Wt,S,tgt,P-1,dm,V,scale,leaves) // forward with ternary weights 92 nfa_backward(tape,vals,grads,st[0],nl) 93 step_all(tape,grads,W2,WN,leaves,6554,262144,gb) // STE: grads(Wt) -> update shadow W2 94 ep=ep+1 95 } 96 return 0 97} 98func eval_ce(tape: *i64, vals: *i64, st: *i64, W: *i64, S: *i64, tgt: *i64, P: i64, dm: i64, V: i64, scale: i64, leaves: *i64, N: i64, sdat: *i64) -> i64 { 99 var acc: i64=0; var e: i64=0 100 while e<N { make_stream(S,tgt,P,sdat); let nl: i64=clm_fwd(tape,vals,st,W,S,tgt,P-1,dm,V,scale,leaves); acc=acc+nfa_val(tape,vals,nl,0); e=e+1 } 101 let mq: i64=acc/N 102 return (mq*1000)/Q16 103} 104 105func main() -> i64 { 106 g_puts("nx_nofloat_quant gate (post-training INT8 + TERNARY quantization for efficient sovereign inference)\n" as *u8) 107 let V: i64=8; let P: i64=12; let dm: i64=24; let scale: i64=13377 108 let tape: *i64=sys_mmap(512*7*8) as *i64 109 let vals: *i64=sys_mmap(65536*8) as *i64 110 let grads: *i64=sys_mmap(65536*8) as *i64 111 let st: *i64=sys_mmap(2*8) as *i64 112 let nW: i64=6 113 let W: *i64=sys_mmap(nW*8) as *i64; let WN: *i64=sys_mmap(nW*8) as *i64 114 WN[0]=V*dm; WN[1]=dm*dm; WN[2]=dm*dm; WN[3]=dm*dm; WN[4]=dm*dm; WN[5]=dm*V 115 var wi: i64=0; while wi<nW { let a: *i64=sys_mmap(WN[wi]*8) as *i64; dini(a,WN[wi],wi+1); W[wi]=a as i64; wi=wi+1 } 116 // a parallel set of dequantized-weight arrays + its pointer table 117 let Wq: *i64=sys_mmap(nW*8) as *i64 118 wi=0; while wi<nW { Wq[wi]=(sys_mmap(WN[wi]*8) as *i64) as i64; wi=wi+1 } 119 // QAT shadow weights (fresh init, trained ternary-aware) 120 let W2: *i64=sys_mmap(nW*8) as *i64 121 wi=0; while wi<nW { let a: *i64=sys_mmap(WN[wi]*8) as *i64; dini(a,WN[wi],wi+1); W2[wi]=a as i64; wi=wi+1 } 122 let leaves: *i64=sys_mmap(8*8) as *i64; let gbuf: *i64=sys_mmap(4096*8) as *i64 123 let S: *i64=sys_mmap(P*8) as *i64; let tgt: *i64=sys_mmap(P*8) as *i64; let sdat: *i64=sys_mmap(8) as *i64 124 125 sdat[0]=12345 126 do_train(tape,vals,grads,st,W,WN,S,tgt,P,dm,V,scale,leaves,gbuf,30000,sdat) 127 128 sdat[0]=70707070 129 let full_ce: i64=eval_ce(tape,vals,st,W,S,tgt,P,dm,V,scale,leaves,200,sdat) 130 // quantize all weights to int8 -> Wq, eval 131 wi=0; while wi<nW { quant_int8(W[wi] as *i64, Wq[wi] as *i64, WN[wi]); wi=wi+1 } 132 sdat[0]=70707070 133 let int8_ce: i64=eval_ce(tape,vals,st,Wq,S,tgt,P,dm,V,scale,leaves,200,sdat) 134 // naive post-training ternary (expected to FAIL -- ternary needs quantization-AWARE training) 135 wi=0; while wi<nW { quant_ternary(W[wi] as *i64, Wq[wi] as *i64, WN[wi]); wi=wi+1 } 136 sdat[0]=70707070 137 let tern_ptq_ce: i64=eval_ce(tape,vals,st,Wq,S,tgt,P,dm,V,scale,leaves,200,sdat) 138 139 // ternary QAT: train the shadow W2 ternary-aware (STE), then eval its ternary-quantized weights 140 sdat[0]=12345 141 do_train_qat(tape,vals,grads,st,W2,Wq,WN,S,tgt,P,dm,V,scale,leaves,gbuf,30000,sdat) 142 wi=0; while wi<nW { quant_ternary(W2[wi] as *i64, Wq[wi] as *i64, WN[wi]); wi=wi+1 } 143 sdat[0]=70707070 144 let tern_qat_ce: i64=eval_ce(tape,vals,st,Wq,S,tgt,P,dm,V,scale,leaves,200,sdat) 145 146 g_puts(" [measure] held-out CE (milli-nats): full-Q16="); g_pn(full_ce); g_puts(" INT8-PTQ="); g_pn(int8_ce); g_puts(" TERNARY-PTQ="); g_pn(tern_ptq_ce); g_puts(" (naive, fails) TERNARY-QAT="); g_pn(tern_qat_ce); g_puts(" (uniform="); g_pn(UNIFORM_MNAT); g_puts(", floor="); g_pn(FLOOR_MNAT); g_puts(")\n") 147 148 var pass: i64=0; var total: i64=0 149 var t1: i64=0; if int8_ce <= full_ce+150 { t1=1 } 150 pass=pass+g_check("T1: INT8 post-training quant preserves quality (int8 CE ~= full-precision CE)" as *u8, t1); total=total+1 151 var t2: i64=0; if int8_ce*10 <= UNIFORM_MNAT*7 { t2=1 } 152 pass=pass+g_check("T2: INT8 stays near-OPTIMAL (<< uniform = efficient 8-bit sovereign inference works)" as *u8, t2); total=total+1 153 var t3: i64=0; if tern_qat_ce < UNIFORM_MNAT { if tern_qat_ce*2 < tern_ptq_ce { t3=1 } } 154 pass=pass+g_check("T3: ternary QAT >> naive PTQ (BitNet insight: ternary needs quant-AWARE training; QAT CE < uniform AND << PTQ)" as *u8, t3); total=total+1 155 156 var okall: i64=0; if pass==total { okall=1 } 157 if okall==1 { 158 let logf: i64=sys_openat_append("knowledge/status/nofloat_quant.log" as *u8, 420) 159 if logf>=0 { let x0: i64=sys_write(logf,"NOFLOATQUANT int8+ternary post-training quantization measured\n" as *u8,62); sys_close(logf) } 160 } 161 g_puts("---- quant gate: passed "); g_pn(pass); g_puts(" / "); g_pn(total); g_puts(" ----\n") 162 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check 163 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled 164 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify. 165 let ctr__dry: *i64 = gv_ctr() 166 ctr__dry[0] = pass 167 ctr__dry[1] = total 168 let rc__dry: i64 = gv_verdict("NOFLOAT-QUANT-GATE" as *u8, ctr__dry, "post-training INT8 inference preserves quality; ternary carries signal -- efficient sovereign inference)" as *u8) 169 sys_exit(rc__dry) 170 return rc__dry 171}