nx_nofloat_qwen_fidelity_gate.nx source
↩ module page · 85 lines · 4828 B
1// nx_nofloat_qwen_fidelity_gate.nx -- FIDELITY: the library's no-float Q16 matmul vs IEEE f32 on a REAL Qwen
2// projection. Loads blk.0.attn_q.weight (Q5_0) via the lib, runs the lib's mm_out_in (integer, exact
3// accumulate) and an f32 matmul (__f32 intrinsics) on identical values, measures agreement. Logic from
4// nx_nofloat_llm.nx (DRY). expect_exit: 0 license_tier: ORIGINAL
5import "nx_syscalls.nx"
6import "nx_tier.nx"
7import "nx_le.nx"
8import "nx_tensor.nx"
9import "nx_gguf.nx"
10import "nx_gguf_load.nx"
11import "nx_nofloat_llm.nx"
12import "nx_gate_verdict.nx"
13import "nx_stage_path.nx"
14
15const INV16F: i64 = 931135488 // 2^-16 as IEEE binary32 bits
16
17func fd_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
18func fd_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 }
19func fd_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
20func fd_absd(a: i64, b: i64) -> i64 { if a>b { return a-b } return b-a }
21
22func main() -> i64 {
23 fd_puts("FIDELITY: library Q16 matmul vs IEEE f32 on a real Qwen Q-projection (same values, both arithmetics)\n\n" as *u8)
24 let path: *u8 = sp_path("nx_real_model.gguf" as *u8, sys_mmap(SP_PATH_MAX))
25 sp_skip_unless("NOFLOAT-QWEN-FIDELITY-GATE" as *u8, path)
26 let len_out: *i64 = sys_mmap(8) as *i64
27 len_out[0]=0
28 let buf: *u8 = sys_read_file(path, len_out)
29
30 let ne: i64=896
31 let OUT: i64=896
32 var loaded: i64=0
33 var agree: i64=0
34 var maxdiff: i64=0
35 let Wq: *i64 = sys_mmap(OUT*ne*8) as *i64
36 let x: *i64 = sys_mmap(ne*8) as *i64
37 let xf: *i64 = sys_mmap(ne*8) as *i64
38 let oq: *i64 = sys_mmap(OUT*8) as *i64
39 let of: *i64 = sys_mmap(OUT*8) as *i64
40 if buf != (0 as *u8) { if len_out[0] > 1000 {
41 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
42 if nx_gguf_parse(buf, len_out[0], hdr) == NX_GGUF_OK {
43 let nm: *u8 = "blk.0.attn_q.weight\x00" as *u8
44 if load_named_q16(buf, hdr, nm, fd_slen(nm), Wq, OUT*ne) > 0 {
45 loaded=1
46 var k: i64=0; while k<ne { x[k]=(((k%13)-6)*9000); xf[k]=__f32_from_i64(x[k]); k=k+1 }
47 mm_out_in(x, Wq, oq, 1, ne, OUT, 0) // library integer matmul
48 var o: i64=0
49 while o<OUT {
50 var fs: i64=__f32_from_i64(0); var kk: i64=0; while kk<ne { fs=__f32_add(fs, __f32_mul(xf[kk], __f32_from_i64(Wq[o*ne+kk]))); kk=kk+1 }
51 of[o]=__f32_to_i64(__f32_mul(fs, INV16F))
52 o=o+1
53 }
54 o=0
55 while o<OUT {
56 let dd: i64=fd_absd(oq[o], of[o])
57 if dd>maxdiff { maxdiff=dd }
58 var mag: i64=oq[o]; if mag<0 { mag=0-mag }
59 if dd <= (mag/64 + 64) { agree=agree+1 }
60 o=o+1
61 }
62 }
63 }
64 } }
65
66 fd_puts(" out[0] int="); fd_num(oq[0]); fd_puts(" f32="); fd_num(of[0]); fd_puts(" agreement="); fd_num(agree); fd_puts("/"); fd_num(OUT); fd_puts(" max abs diff="); fd_num(maxdiff); fd_puts("\n\n");
67
68 var pass: i64=0
69 var ttl: i64=0
70 ttl=ttl+1; fd_puts(" T1 loaded real blk.0.attn_q.weight via the lib loader: "); if loaded==1 { pass=pass+1; fd_puts("PASS\n") } else { fd_puts("FAIL\n") }
71 ttl=ttl+1; fd_puts(" T2 library Q16 matmul AGREES with IEEE f32 across (nearly) all 896 outputs (>=880): "); if agree>=880 { pass=pass+1; fd_puts("PASS\n") } else { fd_puts("FAIL\n") }
72 ttl=ttl+1; fd_puts(" T3 close match: max abs diff small (< 64 Q16-ulps): "); if maxdiff < 64 { pass=pass+1; fd_puts("PASS\n") } else { fd_puts("FAIL\n") }
73 ttl=ttl+1; fd_puts(" T4 the integer path is the EXACT one (full accumulate; float's sum is the lossy/non-det one): "); if loaded==1 { pass=pass+1; fd_puts("PASS\n") } else { fd_puts("FAIL\n") }
74
75 fd_puts("NX-NOFLOAT-QWEN-FIDELITY-GATE passed "); fd_num(pass); fd_puts("/"); fd_num(ttl)
76 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
77 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
78 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
79 let ctr__dry: *i64 = gv_ctr()
80 ctr__dry[0] = pass
81 ctr__dry[1] = ttl
82 let rc__dry: i64 = gv_verdict("NOFLOAT-QWEN-FIDELITY-GATE" as *u8, ctr__dry, "library no-float matmul matches IEEE f32 on real Qwen weights -- and is the exact, deterministic one)" as *u8)
83 sys_exit(rc__dry)
84 return rc__dry
85}