nx_nofloat_train.nx source

1// nx_nofloat_train.nx -- SOVEREIGN NO-FLOAT TRAINING CORE (ledger #1, the biggest gap). Integer Q16 fixed-point 2// gradient descent: forward (pred=w*x+b), loss (sum err^2), backprop (dw=err*x, db=err), SGD update -- 100% integer, 3// no float. Learning is DEMONSTRATED: loss drops + weights converge to the true params. The training analog of the 4// no-float inference moat. 5// EXCEED vs Unsloth (eff_unsloth.raw) / MLPerf (bt_mlperf.raw): training is DETERMINISTIC/bit-exact reproducible 6// (same weights every run, on any hardware) -- float/CUDA training is NOT (nondeterministic kernels, hardware drift). 7// SOVEREIGN (no CUDA/PyTorch/GPU), runs on any CPU. BEHIND: raw speed (no GPU kernels) + scale (tiny vs billions). 8// T1 loss DECREASED (learning happened). T2 weights CONVERGED to truth (w~2.0, b~1.0 in Q16). 9// T3 (EXCEED) DETERMINISM: two training runs -> BIT-IDENTICAL weights. T4 final loss is small. 10// expect_exit: 0 Sovereign: nx_syscalls. 11import "nx_syscalls.nx" 12import "nx_g_puts_lib.nx" 13 14func g_pn(v: i64) -> i64 { let b: *u8=sys_mmap(28); var x: i64=v; if x<0{b[0]=45;sys_write(1,b,1);x=0-x} if x==0{b[0]=48;sys_write(1,b,1);return 0} var d: i64=0; var y: i64=x; while y>0{d=d+1;y=y/10} var i: i64=d-1; y=x; while i>=0{b[i]=(48+(y%10)) as u8;y=y/10;i=i-1} sys_write(1,b,d); return 0 } 15func ck(name: *u8, c: i64) -> i64 { if c==1 { g_puts(" PASS " as *u8) } else { g_puts(" FAIL " as *u8) } g_puts(name); g_puts("\n" as *u8); return c } 16func have(path: *u8) -> i64 { let fd: i64=sys_openat_rd(path); if fd<0 { return 0 } sys_close(fd); return 1 } 17 18const Q: i64 = 16 19const ONE: i64 = 65536 20func fxmul(a: i64, b: i64) -> i64 { return (a*b)>>Q } // Q16 fixed-point multiply 21func iabs(v: i64) -> i64 { if v<0 { return 0-v } return v } 22 23// train a linear model y=w*x+b by integer SGD; returns final weights via wout[0]=w, wout[1]=b, wout[2]=loss0, wout[3]=lossF. 24func train(wout: *i64, epochs: i64, lr: i64) -> i64 { 25 let N: i64 = 8 26 let xs: *i64 = sys_mmap(N*8) as *i64; let ys: *i64 = sys_mmap(N*8) as *i64 27 let w_true: i64 = 2*ONE; let b_true: i64 = 1*ONE 28 var i: i64=0; while i<N { let x: i64 = ((i+1)*ONE)/N; xs[i]=x; ys[i]=fxmul(w_true,x)+b_true; i=i+1 } // x in (0,1], y=2x+1 29 var w: i64=0; var b: i64=0 30 var ep: i64=0; var loss0: i64=0 31 while ep<epochs { 32 var sdw: i64=0; var sdb: i64=0; var loss: i64=0 33 var k: i64=0 34 while k<N { let pred: i64=fxmul(w,xs[k])+b; let err: i64=pred-ys[k]; loss=loss+fxmul(err,err); sdw=sdw+fxmul(err,xs[k]); sdb=sdb+err; k=k+1 } 35 let adw: i64=sdw/N; let adb: i64=sdb/N 36 w = w - fxmul(lr, adw); b = b - fxmul(lr, adb) 37 if ep==0 { loss0=loss } 38 if ep==(epochs-1) { wout[3]=loss } 39 ep=ep+1 40 } 41 wout[0]=w; wout[1]=b; wout[2]=loss0 42 return 0 43} 44 45func main() -> i64 { 46 g_puts("nx_nofloat_train (SOVEREIGN no-float TRAINING: integer Q16 gradient descent; deterministic; vs Unsloth/MLPerf)\n" as *u8) 47 var pass: i64=0; var total: i64=0 48 let lr: i64 = ONE/4 // 0.25 in Q16 49 let EP: i64 = 400 50 let r1: *i64 = sys_mmap(8*8) as *i64; train(r1, EP, lr) 51 g_puts(" trained linear model y=w*x+b on y=2x+1, "); g_pn(EP); g_puts(" epochs (integer Q16 SGD)\n" as *u8) 52 g_puts(" loss[epoch0]="); g_pn(r1[2]); g_puts(" loss[final]="); g_pn(r1[3]); g_puts(" (Q16; lower = learned)\n" as *u8) 53 g_puts(" final w="); g_pn(r1[0]); g_puts(" (~"); g_pn(r1[0]/ONE); g_puts(". true=131072/2.0) final b="); g_pn(r1[1]); g_puts(" (true=65536/1.0)\n" as *u8) 54 55 var t1: i64=0; if r1[3]<r1[2] { t1=1 } 56 pass=pass+ck("T1: LOSS DECREASED epoch0 -> final (learning happened via integer gradient descent)" as *u8, t1); total=total+1 57 var t2: i64=0; if iabs(r1[0]-2*ONE)<(ONE/4) { if iabs(r1[1]-1*ONE)<(ONE/4) { t2=1 } } 58 pass=pass+ck("T2: weights CONVERGED to truth (w~2.0, b~1.0 within 0.25) -- the model actually learned the function" as *u8, t2); total=total+1 59 let r2: *i64 = sys_mmap(8*8) as *i64; train(r2, EP, lr) 60 g_puts(" determinism: run1 w="); g_pn(r1[0]); g_puts(" b="); g_pn(r1[1]); g_puts(" run2 w="); g_pn(r2[0]); g_puts(" b="); g_pn(r2[1]); g_puts("\n" as *u8) 61 var t3: i64=0; if r1[0]==r2[0] { if r1[1]==r2[1] { if r1[3]==r2[3] { t3=1 } } } 62 pass=pass+ck("T3 (EXCEED): DETERMINISTIC -- two training runs give BIT-IDENTICAL weights (Unsloth/CUDA training cannot)" as *u8, t3); total=total+1 63 var t4: i64=0; if r1[3]<(ONE/4) { t4=1 } 64 pass=pass+ck("T4: final loss is small (Q16 < 0.25) -- the fit is good, not just moving" as *u8, t4); total=total+1 65 66 g_puts(" -- vs Unsloth / MLPerf (cite the incumbent's own yardstick, per the research ledger) --\n" as *u8) 67 var grounded: i64=0; if have("knowledge/fetched/eff_unsloth.raw" as *u8)==1 { grounded=grounded+1 } if have("knowledge/fetched/bt_mlperf.raw" as *u8)==1 { grounded=grounded+1 } 68 g_puts(" [EXCEED] DETERMINISM/REPRODUCIBILITY -- bit-exact training (auditable/verifiable ML); Unsloth=float+GPU=nondeterministic (grounded sources="); g_pn(grounded); g_puts("/2)\n" as *u8) 69 g_puts(" [EXCEED] SOVEREIGN -- no CUDA/PyTorch/GPU; runs on any integer CPU (incl this laptop native, no-FPU)\n" as *u8) 70 g_puts(" [BEHIND] RAW SPEED -- Unsloth's optimized GPU kernels are far faster (MEASURE: tokens/s on MLPerf-style task)\n" as *u8) 71 g_puts(" [BEHIND] SCALE -- this is a linear model = the TRAINING CORE; LLM scale (MLP->transformer, billions of params) is the climb\n" as *u8) 72 g_puts(" *** ASTERISK: Unsloth/MLPerf win on speed+scale (the mainstream). Nishi wins reproducible+sovereign training. NOT a speed claim. ***\n" as *u8) 73 g_puts(" >> CLIMB: scale the integer core MLP -> attention -> transformer; add optimized integer kernels; MEASURE tokens/s vs Unsloth + accuracy vs MLPerf.\n" as *u8) 74 75 var okall: i64=0; if pass==total { okall=1 } 76 g_puts("---- nx_nofloat_train: passed "); g_pn(pass); g_puts(" / "); g_pn(total); g_puts(" ----\n" as *u8) 77 if okall==1 { 78 let logf: i64=sys_openat_append("knowledge/status/nofloat_train.log" as *u8, 420) 79 if logf>=0 { let z: i64=sys_write(logf,"NXNOFLOATTRAIN GREEN: integer Q16 SGD training -- loss decreased + weights converged + BIT-IDENTICAL across runs (deterministic, sovereign)\n" as *u8,135); sys_close(logf) } 80 g_puts("verdict=GREEN (sovereign no-float training core: integer SGD learns + converges + is bit-exact reproducible; EXCEED determinism/sovereignty vs Unsloth, honestly behind on speed/scale)\n" as *u8); sys_exit(0); return 0 81 } 82 g_puts("verdict=RED\n" as *u8); sys_exit(1); return 1 83}