nx_nofloat_qwen_diag_gate.nx source
↩ module page · 130 lines · 12100 B
1// nx_nofloat_qwen_diag_gate.nx -- FAITHFULNESS LOCALIZER (memory-safe: ONE no-float forward, lazy per-layer load).
2// The config is verified correct (RoPE ln(1e6), QKV bias, scale 0.125) and the matmul agrees with f32 (<64 ulps),
3// yet the composed 24-layer forward predicts garbage. This instruments the SAME forward `run_stack` does (inlined,
4// calling the canonical attn_sublayer/ffn_sublayer per layer) and prints per-layer max|hidden| (blow-up / vanish
5// check) + the final top-5 logits with decoded tokens. Light footprint = single forward, no f32 stack, no OOM.
6// - per-layer max|hidden| trend: stable => systematic bug; growing/vanishing => Q16 precision/overflow compounding
7// - top-5 logits: a sharp WRONG peak => systematic; near-uniform => signal washed out (precision)
8// No hw writes (Rule 26). expect_exit: 0 license_tier: ORIGINAL
9import "nx_syscalls.nx"
10import "nx_tier.nx"
11import "nx_le.nx"
12import "nx_tensor.nx"
13import "nx_gguf.nx"
14import "nx_gguf_load.nx"
15import "nx_gguf_meta.nx"
16import "nx_nofloat_llm.nx"
17import "nx_nofloat_tok.nx"
18
19func dg_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
20func dg_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 }
21func dg_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
22func maxabs(a: *i64, n: i64) -> i64 { var mx: i64=0; var i: i64=0; while i<n { var v: i64=a[i]; if v<0 { v=0-v } if v>mx { mx=v } i=i+1 } return mx }
23
24func main() -> i64 {
25 dg_puts("FAITHFULNESS DIAG: one no-float forward of 'The capital of France is', per-layer + top-5 logits\n\n" as *u8)
26 let path: *u8 = "/home/elderwesto/nx_stage/nx_real_model.gguf\x00" as *u8
27 let len_out: *i64 = sys_mmap(8) as *i64; len_out[0]=0
28 let buf: *u8 = sys_read_file(path, len_out)
29 if buf == (0 as *u8) { dg_puts("MODEL ABSENT\n" as *u8); return 1 }
30 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
31 if nx_gguf_parse(buf, len_out[0], hdr) != NX_GGUF_OK { dg_puts("PARSE FAIL\n" as *u8); return 1 }
32
33 let ne: i64=896; let qd: i64=896; let kvd: i64=128; let fd: i64=4864; let MAXT: i64=16
34 let voff: *i64=sys_mmap(8) as *i64; let vty: *i64=sys_mmap(8) as *i64
35 var mfirst: i64=0; var nm_c: i64=0; var vfirst: i64=0; var vocab: i64=0
36 let km: *u8="tokenizer.ggml.merges\x00" as *u8; let kt: *u8="tokenizer.ggml.tokens\x00" as *u8
37 if nx_gguf_meta_find(buf, len_out[0], hdr, km, dg_slen(km), voff, vty)==NX_GMETA_OK { nm_c=nx_gguf_meta_array_count(buf, voff[0]); mfirst=nx_gguf_meta_array_first_elt_off(buf, voff[0]) }
38 if nx_gguf_meta_find(buf, len_out[0], hdr, kt, dg_slen(kt), voff, vty)==NX_GMETA_OK { vocab=nx_gguf_meta_array_count(buf, voff[0]); vfirst=nx_gguf_meta_array_first_elt_off(buf, voff[0]) }
39 let nt: *u8="token_embd.weight\x00" as *u8; let no: *u8="output.weight\x00" as *u8; let nn: *u8="output_norm.weight\x00" as *u8
40 let ie: nx_int=nx_gguf_find_tensor(hdr, nt, 17); let io: nx_int=nx_gguf_find_tensor(hdr, no, 13); let inn: nx_int=nx_gguf_find_tensor(hdr, nn, 18)
41 if ie<0 { return 1 } if io<0 { return 1 } if inn<0 { return 1 }
42 let te: *NxGgufTensorInfo=nx_gguf_tensor_at(hdr, ie); let te_base: i64=hdr.data_off+te.offset; let te_ty: i64=te.ggml_type
43 let oh: *NxGgufTensorInfo=nx_gguf_tensor_at(hdr, io); let oh_base: i64=hdr.data_off+oh.offset; let oh_ty: i64=oh.ggml_type
44 let gout: *i64=sys_mmap(ne*8) as *i64; load_named_q16(buf, hdr, nn, 18, gout, ne)
45
46 let wb: *i64=sys_mmap(12*8) as *i64
47 wb[0]=sys_mmap(ne*8) as i64; wb[1]=sys_mmap(qd*ne*8) as i64; wb[2]=sys_mmap(kvd*ne*8) as i64; wb[3]=sys_mmap(kvd*ne*8) as i64; wb[4]=sys_mmap(ne*qd*8) as i64
48 wb[5]=sys_mmap(ne*8) as i64; wb[6]=sys_mmap(ne*fd*8) as i64; wb[7]=sys_mmap(ne*fd*8) as i64; wb[8]=sys_mmap(fd*ne*8) as i64
49 wb[9]=sys_mmap(qd*8) as i64; wb[10]=sys_mmap(kvd*8) as i64; wb[11]=sys_mmap(kvd*8) as i64
50 let sb: *i64=sys_mmap(14*8) as *i64
51 sb[0]=sys_mmap(MAXT*ne*8) as i64; sb[1]=sys_mmap(MAXT*qd*8) as i64; sb[2]=sys_mmap(MAXT*kvd*8) as i64; sb[3]=sys_mmap(MAXT*kvd*8) as i64; sb[4]=sys_mmap(MAXT*qd*8) as i64
52 sb[5]=sys_mmap(MAXT*8) as i64; sb[6]=sys_mmap(MAXT*8) as i64; sb[7]=sys_mmap(MAXT*ne*8) as i64; sb[8]=sys_mmap(MAXT*fd*8) as i64; sb[9]=sys_mmap(MAXT*fd*8) as i64
53 sb[10]=sys_mmap(MAXT*fd*8) as i64; sb[11]=sys_mmap(MAXT*ne*8) as i64; sb[12]=sys_mmap(MAXT*ne*8) as i64; sb[13]=sys_mmap(MAXT*ne*8) as i64
54 let nmbuf: *u8=sys_mmap(64); let freqs: *i64=sys_mmap(32*8) as *i64; rope_freqs(freqs, 64)
55 let tmp: *i64=sys_mmap(64*256*8) as *i64
56 let x: *i64=sys_mmap(MAXT*ne*8) as *i64
57 let cfgA: *i64=sys_mmap(8*8) as *i64; cfgA[1]=ne; cfgA[2]=14; cfgA[3]=2; cfgA[4]=64; cfgA[5]=qd; cfgA[6]=kvd; cfgA[7]=8192
58 let cfgF: *i64=sys_mmap(4*8) as *i64; cfgF[1]=ne; cfgF[2]=fd
59
60 let input: *u8="The capital of France is\x00" as *u8; let ilen: i64=dg_slen(input)
61 let ids: *i64=sys_mmap(MAXT*8) as *i64; let tokp: *i64=sys_mmap(MAXT*8) as *i64; let tokl: *i64=sys_mmap(MAXT*8) as *i64
62 let ntok: i64=tk_bpe_encode(buf, mfirst, nm_c, vfirst, vocab, input, ilen, tokp, tokl, ids)
63 let T: i64=ntok; cfgA[0]=T; cfgF[0]=T
64 var ei: i64=0; while ei<T { dequant_row(buf, te_base, te_ty, ids[ei], ne, ((x as i64)+ei*ne*8) as *i64, tmp); ei=ei+1 }
65 dg_puts("encoded "); dg_num(ntok); dg_puts(" tokens; embed max|x|="); dg_num(maxabs(x, T*ne)); dg_puts("\n")
66 dg_puts("NF embed[0..7] Q16: "); var de: i64=0; while de<8 { dg_num(x[de]); dg_puts(" "); de=de+1 } dg_puts("\n\n")
67
68 // ---- inlined run_stack with per-layer instrumentation ----
69 let gA: *i64=wb[0] as *i64; let Wq: *i64=wb[1] as *i64; let Wk: *i64=wb[2] as *i64; let Wv: *i64=wb[3] as *i64; let Wo: *i64=wb[4] as *i64
70 let gF: *i64=wb[5] as *i64; let Wg: *i64=wb[6] as *i64; let Wu: *i64=wb[7] as *i64; let Wd: *i64=wb[8] as *i64
71 let bq: *i64=wb[9] as *i64; let bk: *i64=wb[10] as *i64; let bv: *i64=wb[11] as *i64
72 let xn: *i64=sb[0] as *i64; let Q: *i64=sb[1] as *i64; let K: *i64=sb[2] as *i64; let V: *i64=sb[3] as *i64; let concat: *i64=sb[4] as *i64
73 let scb: *i64=sb[5] as *i64; let at: *i64=sb[6] as *i64; let proj: *i64=sb[7] as *i64; let gate: *i64=sb[8] as *i64; let up: *i64=sb[9] as *i64
74 let hbuf: *i64=sb[10] as *i64; let hmid: *i64=sb[11] as *i64; let cur: *i64=sb[12] as *i64; let cur2: *i64=sb[13] as *i64
75 cpy(cur, x, T*ne)
76 dg_puts("per-layer max|hidden| (stable=systematic bug; growing/vanishing=precision):\n" as *u8)
77 var L: i64=0
78 while L<24 {
79 load_blk(buf, hdr, nmbuf, L, ".attn_norm.weight\x00" as *u8, gA, ne)
80 load_blk(buf, hdr, nmbuf, L, ".attn_q.weight\x00" as *u8, Wq, qd*ne)
81 load_blk(buf, hdr, nmbuf, L, ".attn_k.weight\x00" as *u8, Wk, kvd*ne)
82 load_blk(buf, hdr, nmbuf, L, ".attn_v.weight\x00" as *u8, Wv, kvd*ne)
83 load_blk(buf, hdr, nmbuf, L, ".attn_output.weight\x00" as *u8, Wo, ne*qd)
84 load_blk(buf, hdr, nmbuf, L, ".attn_q.bias\x00" as *u8, bq, qd)
85 load_blk(buf, hdr, nmbuf, L, ".attn_k.bias\x00" as *u8, bk, kvd)
86 load_blk(buf, hdr, nmbuf, L, ".attn_v.bias\x00" as *u8, bv, kvd)
87 load_blk(buf, hdr, nmbuf, L, ".ffn_norm.weight\x00" as *u8, gF, ne)
88 load_blk(buf, hdr, nmbuf, L, ".ffn_gate.weight\x00" as *u8, Wg, ne*fd)
89 load_blk(buf, hdr, nmbuf, L, ".ffn_up.weight\x00" as *u8, Wu, ne*fd)
90 load_blk(buf, hdr, nmbuf, L, ".ffn_down.weight\x00" as *u8, Wd, fd*ne)
91 attn_sublayer(cur, gA, Wq, Wk, Wv, Wo, bq, bk, bv, freqs, xn, Q, K, V, concat, scb, at, proj, hmid, cfgA, 0)
92 ffn_sublayer(hmid, gF, Wg, Wu, Wd, xn, gate, up, hbuf, proj, cur2, cfgF, 0)
93 cpy(cur, cur2, T*ne)
94 if L==0 { dg_puts("NF L0 tok4 x_mid[0..7]: "); var dh: i64=0; while dh<8 { dg_num(hmid[(T-1)*ne+dh]); dg_puts(" "); dh=dh+1 } dg_puts(" out: "); dh=0; while dh<8 { dg_num(cur2[(T-1)*ne+dh]); dg_puts(" "); dh=dh+1 } dg_puts("\n") }
95 dg_puts(" L"); dg_num(L); dg_puts(" postattn="); dg_num(maxabs(hmid, T*ne)); dg_puts(" postffn="); dg_num(maxabs(cur2, T*ne)); dg_puts("\n")
96 if L==0 { dg_puts(" L0 FFN intermediates (Q16): max|gate|="); dg_num(maxabs(gate, T*4864)); dg_puts(" max|up|="); dg_num(maxabs(up, T*4864)); dg_puts(" max|hbuf(silu*up)|="); dg_num(maxabs(hbuf, T*4864)); dg_puts("\n")
97 var gmd: i64=0; var gmv: i64=0; var gg: i64=0; while gg<4864 { var vv: i64=gate[gg]; if vv<0 { vv=0-vv } if vv>gmv { gmv=vv; gmd=gg } gg=gg+1 }
98 var umd: i64=0; var umv: i64=0; gg=0; while gg<4864 { var vv: i64=up[gg]; if vv<0 { vv=0-vv } if vv>umv { umv=vv; umd=gg } gg=gg+1 }
99 dg_puts(" L0 tok0 gate argmaxdim="); dg_num(gmd); dg_puts(" val="); dg_num(gate[gmd]); dg_puts(" up argmaxdim="); dg_num(umd); dg_puts(" val="); dg_num(up[umd]); dg_puts("\n")
100 dg_puts(" L0 gate[2370]="); dg_num(gate[2370]); dg_puts(" up[3369]="); dg_num(up[3369]); dg_puts(" hbuf[298]="); dg_num(hbuf[298]); dg_puts("\n")
101 dg_puts(" L0 DOWN: max|Wd|="); dg_num(maxabs(Wd, 4358144)); dg_puts(" max|proj|="); dg_num(maxabs(proj, T*ne)); dg_puts(" proj[0..3]="); dg_num(proj[0]); dg_puts(" "); dg_num(proj[1]); dg_puts(" "); dg_num(proj[2]); dg_puts(" "); dg_num(proj[3]); dg_puts("\n")
102 let ndn: *u8 = "blk.0.ffn_down.weight\x00" as *u8; let idn: nx_int = nx_gguf_find_tensor(hdr, ndn, 21)
103 if idn>=0 { let tdn: *NxGgufTensorInfo=nx_gguf_tensor_at(hdr, idn); dg_puts(" ffn_down: type="); dg_num(tdn.ggml_type); dg_puts(" ndims="); dg_num(tdn.n_dims); dg_puts(" d0="); dg_num(tdn.dim_0); dg_puts(" d1="); dg_num(tdn.dim_1); dg_puts(" nv="); dg_num(nx_gguf_tensor_n_values(tdn)); dg_puts("\n") }
104 var nzrows: i64=0; var rr: i64=0; while rr<896 { if Wd[rr*4864]!=0 { nzrows=nzrows+1 } rr=rr+1 } dg_puts(" nonzero rows(check Wd[r*4864])="); dg_num(nzrows); dg_puts("/896\n")
105 dg_puts(" L0 Wd row0[0..3]="); dg_num(Wd[0]); dg_puts(" "); dg_num(Wd[1]); dg_puts(" "); dg_num(Wd[2]); dg_puts(" "); dg_num(Wd[3]); dg_puts(" Wd row1[0..3]="); dg_num(Wd[4864]); dg_puts(" "); dg_num(Wd[4865]); dg_puts(" "); dg_num(Wd[4866]); dg_puts(" "); dg_num(Wd[4867]); dg_puts(" nz(row0 first256)="); var nz: i64=0; var wq: i64=0; while wq<256 { if Wd[wq]!=0 { nz=nz+1 } wq=wq+1 } dg_num(nz); dg_puts(" nz(row1 first256)="); nz=0; wq=0; while wq<256 { if Wd[4864+wq]!=0 { nz=nz+1 } wq=wq+1 } dg_num(nz); dg_puts("\n")
106 dg_puts(" NF L0 ffn_in[0..7] Q16: "); var dd3: i64=0; while dd3<8 { dg_num(xn[dd3]); dg_puts(" "); dd3=dd3+1 } dg_puts("\n") }
107 L=L+1
108 }
109
110 let normed: *i64=sys_mmap(ne*8) as *i64; rmsnorm_gamma_row_q24(cur, gout, (T-1)*ne, ne, normed, 0)
111 let row: *i64=sys_mmap(ne*8) as *i64; let logits: *i64=sys_mmap(vocab*8) as *i64
112 var v: i64=0
113 while v<vocab { dequant_row(buf, oh_base, oh_ty, v, ne, row, tmp); var s: i64=0; var k: i64=0; while k<ne { s=s+(normed[k]*row[k]); k=k+1 } logits[v]=s>>24; v=v+1 }
114 var prank: i64=0; let pv2: i64=logits[12095]; var pvi: i64=0; while pvi<vocab { if logits[pvi]>pv2 { prank=prank+1 } pvi=pvi+1 }
115 dg_puts("\nĠParis(12095) logit="); dg_num(pv2); dg_puts(" rank(0=top)="); dg_num(prank); dg_puts("\n")
116 dg_puts("top-5 logits (sharp peak=systematic; flat=washed out):\n" as *u8)
117 var r: i64=0
118 while r<5 {
119 var bi: i64=0; var bvv: i64=logits[0]; var i: i64=1
120 while i<vocab { if logits[i]>bvv { bvv=logits[i]; bi=i } i=i+1 }
121 let off: i64=tk_decode_off(buf, vfirst, bi); let pl: i64=nx_gguf_meta_read_string_len(buf, off)
122 dg_puts(" #"); dg_num(r); dg_puts(" id="); dg_num(bi); dg_puts(" logit="); dg_num(bvv); dg_puts(" tok='")
123 if pl>0 { sys_write(1, nx_gguf_meta_read_string_ptr(buf, off), pl) }
124 dg_puts("'\n")
125 logits[bi]=0-9223372036854775807
126 r=r+1
127 }
128 dg_puts("\nNX-NOFLOAT-QWEN-DIAG done (inspect the trend + top-5 to localize the divergence)\n" as *u8)
129 return 0
130}