code wiki / _hdl_build / nx_nofloat_transformer.nx
nx_nofloat_transformer.nx
buildroot/runtime/_hdl_build/nx_nofloat_transformer.nx
about
nx_nofloat_transformer.nx -- SOVEREIGN NO-FLOAT TRANSFORMER BLOCK (the AI culmination), pure integer Q16,
deterministic. Pre-norm block: h = x + SelfAttn(LayerNorm(x)); out = h + FFN(LayerNorm(h)). New primitive =
integer LayerNorm (mean/var + Newton integer sqrt for std). Self-attention reuses fixed-point exp/softmax.
FFN = matvec -> ReLU -> matvec. Everything integer => bit-exact deterministic (the moat vs float transformers).
T1 integer sqrt correct (sqrt_q16(4)=2, sqrt_q16(9)=3). T2 LayerNorm normalizes (output mean ~= 0).
T3 full block runs end-to-end (output transformed vs input, bounded). T4 (EXCEED) determinism bit-identical.
expect_exit: 0 Sovereign: nx_syscalls.
dependencies 2 imports · 0 importers
imports: nx_syscalls.nxnx_g_puts_lib.nx
imported by: nobody (leaf or entry point)
call flow from main pre-order; caps 40 nodes / depth 6 declared; ↻ = already shown
structs
| none |
consts
| 14 | const Q: i64 = 16 |
| 15 | const ONE: i64 = 65536 |
| 16 | const D: i64 = 4 |
| 17 | const T: i64 = 2 |
| 18 | const LOG2E: i64 = 94548 |
| 19 | const C1: i64 = 45426 |
| 20 | const C2: i64 = 15743 |
| 21 | const EPS: i64 = 65 // ~0.001 in Q16 (layernorm epsilon) |
functions
| 11 | func 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 } |
| 12 | func 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 } |
| 22 | func fxmul(a: i64, b: i64) -> i64 { return (a*b)>>Q } |
| 23 | func relu(x: i64) -> i64 { if x>0 { return x } return 0 } called by 1: block |
| 24 | func iabs(v: i64) -> i64 { if v<0 { return 0-v } return v } called by 1: main |
| 26 | func isqrt(n: i64) -> i64 { if n<2 { return n } var x: i64=n; var y: i64=(x+1)/2; while y<x { x=y; y=(x + n/x)/2 } return x } called by 1: sqrt_q16 |
| 27 | func sqrt_q16(y: i64) -> i64 { return isqrt(y*ONE) } // sqrt of a Q16 value, result in Q16 |
| 29 | func exp_fx(x: i64) -> i64 |
| 35 | func dotp(a: *i64, b: *i64, n: i64) -> i64 { var s: i64=0; var i: i64=0; while i<n { s=s+fxmul(a[i],b[i]); i=i+1 } return s } |
| 37 | func layernorm(x: *i64, out: *i64) -> i64 |
| 43 | func matvec(W: *i64, v: *i64, out: *i64) -> i64 { var i: i64=0; while i<D { var s: i64=0; var j: i64=0; while j<D { s=s+fxmul(W[i*D+j], v[j]); j=j+1 } out[i]=s; i=i+1 } return 0 } |
| 46 | func block(x: *i64, out: *i64, W1: *i64, W2: *i64) -> i64 |
| 76 | func main() -> i64 |