nx_f32_llm_live_gen_test.nx source
↩ module page · 116 lines · 4375 B
1// nx_f32_llm_live_gen_test.nx -- LIVE-FIRE TEXT GENERATION from real
2// Qwen2.5-0.5B. Loads model + vocab + cache + runs greedy 5-token
3// generation from a fixed prompt. Writes output bytes to
4// /tmp/nx_qwen_gen.txt for inspection.
5//
6// This is the substrate's "text in, text out" proof on real
7// production weights.
8
9import "nx_syscalls.nx"
10import "nx_tier.nx"
11import "nx_bpe.nx"
12import "nx_gguf.nx"
13import "nx_gguf_load.nx"
14import "nx_gguf_meta.nx"
15import "nx_f32.nx"
16import "nx_f32_kv_cache.nx"
17import "nx_f32_lazy_weight.nx"
18import "nx_f32_llama_block.nx"
19import "nx_f32_llama_block_v4.nx"
20import "nx_f32_llama_stack_v4.nx"
21import "nx_f32_llama_layer_lazy_load.nx"
22import "nx_f32_llm.nx"
23import "nx_f32_llm_v4.nx"
24import "nx_f32_llm_read_dims.nx"
25import "nx_f32_bpe_load.nx"
26import "nx_f32_llm_special_tokens.nx"
27import "nx_f32_sampler.nx"
28import "nx_f32_llm_run_v2.nx"
29import "nx_f32_llm_run_v3.nx"
30
31func main() -> i64 {
32 let path: *u8 = sys_mmap(64)
33 path[0]=0x2F as u8; path[1]=0x74 as u8; path[2]=0x6D as u8; path[3]=0x70 as u8
34 path[4]=0x2F as u8; path[5]=0x6E as u8; path[6]=0x78 as u8; path[7]=0x5F as u8
35 path[8]=0x72 as u8; path[9]=0x65 as u8; path[10]=0x61 as u8; path[11]=0x6C as u8
36 path[12]=0x5F as u8; path[13]=0x6D as u8; path[14]=0x6F as u8; path[15]=0x64 as u8
37 path[16]=0x65 as u8; path[17]=0x6C as u8; path[18]=0x2E as u8
38 path[19]=0x67 as u8; path[20]=0x67 as u8; path[21]=0x75 as u8; path[22]=0x66 as u8
39 path[23]=0 as u8
40
41 let len_out: *i64 = sys_mmap(8) as *i64
42 let buf: *u8 = sys_read_file(path, len_out)
43 if buf == (0 as *u8) { return 10 }
44
45 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
46 if nx_gguf_parse(buf, len_out[0], hdr) != NX_GGUF_OK { return 20 }
47
48 let model: *NxF32LlamaModel = nx_f32_llama_model_alloc()
49 let out_err: *i64 = sys_mmap(8) as *i64
50 if nx_f32_llm_read_dims_from_gguf(buf, len_out[0], hdr, model, out_err) != NX_FLD_OK {
51 return 30
52 }
53 if nx_f32_llm_load_weights_v4_from_gguf(buf, hdr, model, out_err) != NX_FLV4_OK {
54 return 40
55 }
56
57 // Bump intern caps for Qwen2.5: vocab=151,936; merges ~150K;
58 // tokens can be multi-byte UTF-8. 64MB bytes, 256K ids, 512K merges.
59 let vocab: *NxBpeVocab = nx_bpe_vocab_new(67108864, 262144, 524288)
60 let nt: *i64 = sys_mmap(8) as *i64
61 let nm: *i64 = sys_mmap(8) as *i64
62 let bpe_v: nx_int = nx_f32_bpe_load_from_gguf(buf, len_out[0], hdr, vocab, nt, nm, out_err)
63 if bpe_v != NX_FBL_OK {
64 return (150 + bpe_v) as i64
65 }
66 // CHECKPOINT 1: BPE loaded OK. nt[0] = n_tokens loaded.
67 if nt[0] < 1000 { return 51 } // expect >100K tokens
68 if nt[0] > 200000 { return 52 } // sanity ceiling
69
70 let eos: nx_int = nx_f32_llm_read_eos(buf, len_out[0], hdr)
71
72 let cache: *NxF32KVCache = nx_f32_kv_cache_alloc(
73 model.n_layers, model.n_kv_heads, 64, model.head_dim)
74 if cache == (0 as *NxF32KVCache) { return 53 }
75
76 let cfg: *NxF32SamplerCfg = nx_f32_sampler_cfg_alloc()
77 // Greedy (top_k = top_p = 0 -> argmax) for reproducibility.
78
79 let prompt: *u8 = "Hi\x00" as *u8
80
81 let out_bytes: *u8 = sys_mmap(256)
82 let max_new: nx_int = 5
83
84 let prng: *i64 = sys_mmap(8) as *i64
85 prng[0] = 1
86
87 // Qwen2.5-0.5B published config:
88 // rms_norm_eps = 1e-6 -> f32 0x358637BD
89 // rope_freq_base = 1000000 -> log(1e6) = 13.8155 -> f32 0x415D0EAB
90 // head_dim = 64 -> 1/sqrt(64) = 0.125 -> f32 0x3E000000
91 let eps: i64 = 0x358637BD // 1e-6
92 let attn_scale: i64 = 0x3E000000 // 0.125
93 let rope_base: i64 = 0x415D0EAB // log(1000000)
94
95 let n_emit: nx_int = nx_f32_llm_run_v3(
96 model, vocab, cache, prompt, 2, max_new, cfg,
97 eps, attn_scale, rope_base, 1,
98 prng, eos, out_bytes, 256)
99 if n_emit < 0 {
100 // Encode the negative as 60 + |n_emit| (capped at 9).
101 var ne: nx_int = 0 - n_emit
102 if ne > 9 { ne = 9 }
103 return (60 + ne) as i64
104 }
105
106 // Write output to /tmp/nx_qwen_gen.txt
107 let out_path: *u8 = "/tmp/nx_qwen_gen.txt\x00" as *u8
108 let fd: i64 = sys_openat_wr(out_path, 0x1A4)
109 if fd < 0 { return 70 }
110 sys_write(fd, out_bytes, n_emit as i64)
111 sys_close(fd)
112
113 // Return n_emit so caller knows how many bytes were generated.
114 if n_emit > 250 { return 250 }
115 return n_emit as i64
116}