nx_nofloat_train_exceed.nx source

1// nx_nofloat_train_exceed.nx -- the MEASURED S-class exceed for no-float TRAINING. Extends the established 2// no-float exceed axis (nx_nofloat_exceed_gate proved it for an INFERENCE dot product) to the GRADIENT, which 3// is what every training step computes. The capability that DETECTS/GUARANTEES what mainstream float training 4// CANNOT: a training gradient is a SUM of many per-sample / per-reduction contributions; integer addition is 5// associative + exact, so the no-float gradient is BIT-IDENTICAL regardless of accumulation order, batch order, 6// thread count, or machine -- i.e. REPRODUCIBLE + AUDITABLE training. IEEE-754 float add is non-associative, so 7// the SAME gradient gives DIFFERENT bits by order (PyTorch/JAX/llama.cpp are non-deterministic by construction). 8// 9// This is a CAPABILITY exceed (best-at-job: verifiable reproducibility), NOT merely "we are sovereign": 10// PART 1 (the principle, refereed head-to-head, float = the competitor = teeth): representative wide-dynamic- 11// range per-sample gradient contributions [2^24,1,1,1,1] (true sum 2^24+4). Integer fwd==rev==exact; 12// float fwd!=rev AND float!=exact (it silently drops the small-gradient terms -> the vanishing-update bug). 13// PART 2 (tie to the REAL engine): run nx_nofloat_autograd's actual backward on a batch in two different SAMPLE 14// ORDERS -> the resulting integer gradient is BYTE-IDENTICAL. The real training engine is order-invariant. 15// HONEST scope: this is the reproducibility/exactness/auditability axis. It is NOT a claim to beat PyTorch on 16// model scale, breadth, or wall-clock -- those remain genuinely behind (tiny models, no GPU kernels). expect_exit: 0 17// Sovereign: imports nx_nofloat_autograd (the pure-integer engine) + nx_syscalls; the __f32 builtins appear ONLY 18// here to demonstrate the FLOAT competitor (the training engine itself stays float-free). license_tier: ORIGINAL 19import "nx_nofloat_autograd.nx" 20import "nx_syscalls.nx" 21const K_MAGIC_16777216: i64 = 16777216 22const K_MAGIC_16777220: i64 = 16777220 23const K_MAGIC_2048: i64 = 2048 24const K_MAGIC_65536: i64 = 65536 25const K_MAGIC_131072: i64 = 131072 26const K_MAGIC_32768: i64 = 32768 27const K_MAGIC_98304: i64 = 98304 28 29func te_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } 30func te_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 } 31func te_chk(name: *u8, cond: i64) -> i64 { if cond==1 { te_puts(" PASS " as *u8) } else { te_puts(" FAIL " as *u8) } te_puts(name); te_puts("\n" as *u8); return cond } 32 33// build a 1x2 linear regression batch via the REAL autograd, accumulating samples in the given ORDER, and 34// return the integer gradient dW[0],dW[1]. W starts at zero (so the gradient is a pure sum over samples). 35func te_dw(tape: *i64, vals: *i64, grads: *i64, st: *i64, order: *i64, X: *i64, Y: *i64, T: i64, dw: *i64) -> i64 { 36 let Wp: *i64 = sys_mmap(2*8) as *i64; Wp[0]=0; Wp[1]=0 37 st[0]=0; st[1]=0 38 let nW: i64 = nfa_leaf(tape,vals,st,1,2,Wp,0) 39 var root: i64 = 0 - 1 40 var k: i64 = 0 41 while k < T { 42 let t: i64 = order[k] 43 let nx: i64 = nfa_leaf(tape,vals,st,2,1,X,t*2) 44 let np: i64 = nfa_matvec(tape,vals,st,nW,nx) 45 let ny: i64 = nfa_leaf(tape,vals,st,1,1,Y,t) 46 let nm: i64 = nfa_mse(tape,vals,st,np,ny) 47 if root < 0 { root = nm } else { root = nfa_vadd(tape,vals,st,root,nm) } 48 k = k + 1 49 } 50 nfa_backward(tape,vals,grads,st[0],root) 51 dw[0] = nfa_grad(tape,grads,nW,0) 52 dw[1] = nfa_grad(tape,grads,nW,1) 53 return 0 54} 55 56func main() -> i64 { 57 te_puts("NO-FLOAT TRAINING EXCEED: the gradient is order-invariant + EXACT (reproducible training) where float is not\n\n" as *u8) 58 var pass: i64 = 0; var ttl: i64 = 0 59 60 // ---- PART 1: representative per-sample gradient contributions with wide dynamic range ---- 61 let K: i64 = 5 62 let c: *i64 = sys_mmap(K*8) as *i64 63 c[0]=K_MAGIC_16777216; c[1]=1; c[2]=1; c[3]=1; c[4]=1 // dL/dw contributions a batch accumulates 64 let exact: i64 = K_MAGIC_16777220 // 2^24 + 4 65 66 var ifwd: i64=0; var k: i64=0 67 while k<K { ifwd = ifwd + c[k]; k=k+1 } 68 var irev: i64=0; k=K-1 69 while k>=0 { irev = irev + c[k]; k=k-1 } 70 71 let cf: *i64 = sys_mmap(K*8) as *i64 72 k=0 73 while k<K { cf[k]=__f32_from_i64(c[k]); k=k+1 } 74 var ffwd: i64=__f32_from_i64(0) 75 k=0 76 while k<K { ffwd=__f32_add(ffwd, cf[k]); k=k+1 } 77 var frev: i64=__f32_from_i64(0) 78 k=K-1 79 while k>=0 { frev=__f32_add(frev, cf[k]); k=k-1 } 80 let ffwd_i: i64=__f32_to_i64(ffwd); let frev_i: i64=__f32_to_i64(frev) 81 82 te_puts(" gradient = sum of per-sample contributions [2^24,1,1,1,1] true value = " as *u8); te_num(exact); te_puts("\n" as *u8) 83 te_puts(" NO-FLOAT (integer): fwd=" as *u8); te_num(ifwd); te_puts(" rev=" as *u8); te_num(irev); te_puts(" -> identical + exact\n" as *u8) 84 te_puts(" FLOAT (f32): fwd=" as *u8); te_num(ffwd_i); te_puts(" rev=" as *u8); te_num(frev_i); te_puts(" -> DIFFER + the small-gradient terms VANISH\n\n" as *u8) 85 86 var t1: i64=0; if ifwd==irev { t1=1 } 87 var t2: i64=0; if ifwd==exact { t2=1 } 88 var t3: i64=0; if ffwd_i!=frev_i { t3=1 } 89 var t4: i64=0; if ffwd_i!=exact { t4=1 } 90 ttl=ttl+1; pass=pass+te_chk("T1 no-float gradient is ORDER-INVARIANT (integer fwd == rev)" as *u8, t1) 91 ttl=ttl+1; pass=pass+te_chk("T2 no-float gradient is EXACT (integer == true value)" as *u8, t2) 92 ttl=ttl+1; pass=pass+te_chk("T3 float gradient is ORDER-DEPENDENT (f32 fwd != rev) = irreproducible by construction" as *u8, t3) 93 ttl=ttl+1; pass=pass+te_chk("T4 float gradient is LOSSY (f32 != true value; small updates vanish)" as *u8, t4) 94 95 // ---- PART 2: the REAL nx_nofloat_autograd engine is order-invariant under batch reordering ---- 96 let tape: *i64 = sys_mmap(256*7*8) as *i64 97 let vals: *i64 = sys_mmap(K_MAGIC_2048*8) as *i64 98 let grads: *i64 = sys_mmap(K_MAGIC_2048*8) as *i64 99 let st: *i64 = sys_mmap(2*8) as *i64 100 let T: i64 = 4 101 let X: *i64 = sys_mmap(T*2*8) as *i64 102 X[0]=K_MAGIC_65536; X[1]=K_MAGIC_65536; X[2]=K_MAGIC_131072; X[3]=K_MAGIC_32768; X[4]=K_MAGIC_32768; X[5]=K_MAGIC_131072; X[6]=K_MAGIC_98304; X[7]=K_MAGIC_65536 103 let Wt: *i64 = sys_mmap(2*8) as *i64; Wt[0]=K_MAGIC_65536; Wt[1]=0-K_MAGIC_32768 104 let Y: *i64 = sys_mmap(T*8) as *i64 105 var t: i64=0 106 while t<T { Y[t]=(Wt[0]*X[t*2]+Wt[1]*X[t*2+1])>>16; t=t+1 } 107 let ordA: *i64 = sys_mmap(T*8) as *i64; ordA[0]=0; ordA[1]=1; ordA[2]=2; ordA[3]=3 108 let ordB: *i64 = sys_mmap(T*8) as *i64; ordB[0]=3; ordB[1]=2; ordB[2]=1; ordB[3]=0 109 let dwa: *i64 = sys_mmap(2*8) as *i64 110 let dwb: *i64 = sys_mmap(2*8) as *i64 111 te_dw(tape,vals,grads,st, ordA, X, Y, T, dwa) 112 te_dw(tape,vals,grads,st, ordB, X, Y, T, dwb) 113 te_puts(" real engine dW order[0,1,2,3]=[" as *u8); te_num(dwa[0]); te_puts("," as *u8); te_num(dwa[1]) 114 te_puts("] order[3,2,1,0]=[" as *u8); te_num(dwb[0]); te_puts("," as *u8); te_num(dwb[1]); te_puts("]\n" as *u8) 115 var same: i64 = 1 116 if dwa[0]!=dwb[0] { same=0 } 117 if dwa[1]!=dwb[1] { same=0 } 118 ttl=ttl+1; pass=pass+te_chk("T5 REAL nx_nofloat_autograd gradient is BYTE-IDENTICAL under batch reorder (reproducible training)" as *u8, same) 119 120 te_puts("\nNX-NOFLOAT-TRAIN-EXCEED passed " as *u8); te_num(pass); te_puts("/" as *u8); te_num(ttl); te_puts("\n" as *u8) 121 if pass==ttl { te_puts("verdict=GREEN (no-float training gradients are EXACT + ORDER-INVARIANT = reproducible/auditable -- the measured exceed float cannot match; honest BEHIND on scale/breadth/speed)\n" as *u8); sys_exit(0); return 0 } 122 te_puts("verdict=RED\n" as *u8); sys_exit(1); return 1 123}