nx_mt_r1_gate.nx source

1// nx_mt_r1_gate.nx -- GATE for MT-R1: SEQUENCES. Proves, by RUNNING, that the sovereign MT core 2// (nx_mt_core) translates multi-token SEQUENCES with a SHARED, position-independent learned 3// word-map -- and that the map GENERALIZES to HELD-OUT sentences it was never trained on. This 4// is the seq2seq plumbing + the no-overfit test harness the rest of the arc rides on; R0 proved 5// the single-token atom, R2 will add cross-token CONTEXT (reordering) via fnet_mix. 6// 7// Dictionary (EN->ES), target indices are a PERMUTATION (not identity): tgt_map=[2,0,5,1,3,4]. 8// src EN: 0 hello 1 family 2 love 3 good 4 day 5 water 9// tgt ES: 0 familia 1 bueno 2 hola 3 dia 4 agua 5 amor 10// 11// TRAIN = 4 sentences x 3 tokens, arranged so EVERY word occurs EXACTLY TWICE (m=2) -> with 12// lr=1/8 the GD factor (1-2*lr*m)=0.5 is stable+monotone for all weights. HELD-OUT = 3 sentences 13// whose token TRIPLES never appear in training (novel combinations of the same vocab). 14// 15// FOUR GATES: 16// A LEARNS (train set): per-token acc == all-train-tokens, sum-loss < 1/1000, loss decreased. 17// B GENERALIZES (held-out): per-token acc == all-held-tokens on sentences NEVER trained -> 18// the shared map is compositional/position-independent, not a per-sentence memorization. 19// C BIT-EXACT: retrain from zero-init -> identical W bits. 20// D UNTRAINED FAILS (liar-kill): zero-epoch model scores < all-held-tokens on held-out. 21// 22// genealogy_id: rumelhart_1986_backprop (realized_in nx_autograd) 23// lineage_id: sovereign_neural_mt_r1_sequences_v1 24// license_tier: ORIGINAL 25import "nx_mt_core.nx" // mt_train / mt_argmax / mt_seq_acc (shared word-map model) 26import "nx_autograd.nx" // ag_constf + nx_f32 compares + AG_F32_* + nx_syscalls 27import "nx_syscalls.nx" 28 29const MR_LOG: *u8 = "knowledge/status/mt_r1.log" 30const MR_S: i64 = 6 31const MR_T: i64 = 6 32const MR_L: i64 = 3 // sequence length 33 34const EN0: *u8 = "hello" as *u8 35const EN1: *u8 = "family" as *u8 36const EN2: *u8 = "love" as *u8 37const EN3: *u8 = "good" as *u8 38const EN4: *u8 = "day" as *u8 39const EN5: *u8 = "water" as *u8 40const ES0: *u8 = "familia" as *u8 41const ES1: *u8 = "bueno" as *u8 42const ES2: *u8 = "hola" as *u8 43const ES3: *u8 = "dia" as *u8 44const ES4: *u8 = "agua" as *u8 45const ES5: *u8 = "amor" as *u8 46const ESQ: *u8 = "?" as *u8 47 48func mr_en(i: i64) -> *u8 { 49 if i == 0 { return EN0 } 50 if i == 1 { return EN1 } 51 if i == 2 { return EN2 } 52 if i == 3 { return EN3 } 53 if i == 4 { return EN4 } 54 if i == 5 { return EN5 } 55 return ESQ 56} 57func mr_es(j: i64) -> *u8 { 58 if j == 0 { return ES0 } 59 if j == 1 { return ES1 } 60 if j == 2 { return ES2 } 61 if j == 3 { return ES3 } 62 if j == 4 { return ES4 } 63 if j == 5 { return ES5 } 64 return ESQ 65} 66 67func mr_w(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 } 68func mr_wn(fd: i64, v: i64) -> i64 { 69 let bb: *u8 = sys_mmap(28); var m: i64 = v 70 if m < 0 { m = 0 - m; sys_write(fd, "-" as *u8, 1) } 71 let t: *u8 = sys_mmap(28); var k: i64 = 0 72 if m == 0 { t[0] = 48; k = 1 } 73 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 } 74 var i: i64 = 0 75 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 } 76 sys_write(fd, bb, k); return 0 77} 78func mr_f32_to_milli(v: i64) -> i64 { 79 var s: i64 = nx_f32_mul(v, nx_i32_to_f32(1000)) 80 var neg: i64 = 0 81 if nx_f32_lt(s, AG_F32_ZERO) == 1 { neg = 1; s = nx_f32_neg(s) } 82 let half: i64 = ag_constf(1, 2) 83 var m: i64 = 0 84 var go: i64 = 1 85 while go == 1 { 86 let mid: i64 = nx_f32_add(nx_i32_to_f32(m), half) 87 if nx_f32_lt(mid, s) == 1 { 88 m = m + 1 89 if m >= 100000 { go = 0 } 90 } else { go = 0 } 91 } 92 if neg == 1 { return 0 - m } 93 return m 94} 95 96// print each held-out token as en->es (predicted by the trained, frozen W). Honest demo. 97func mr_demo(fd: i64, W: *i64, held_src: *i64, n_held: i64) -> i64 { 98 mr_w(fd, "MT-R1 held-out (never trained):" as *u8) 99 var k: i64 = 0 100 let n: i64 = n_held * MR_L 101 while k < n { 102 let s: i64 = held_src[k] 103 let pj: i64 = mt_argmax(W, MR_S, MR_T, s) 104 mr_w(fd, " " as *u8); mr_w(fd, mr_en(s)); mr_w(fd, "->" as *u8); mr_w(fd, mr_es(pj)) 105 k = k + 1 106 } 107 mr_w(fd, "\n" as *u8) 108 return 0 109} 110 111func mr_emit(fd: i64, r: *i64) -> i64 { 112 mr_w(fd, "MTR1GATE authored=organ engine=scalar-tape-autograd-f32 task=sequence-translate-shared-wordmap" as *u8) 113 mr_w(fd, " | A_learns_pass=" as *u8); mr_wn(fd, r[0]) 114 mr_w(fd, " train_acc=" as *u8); mr_wn(fd, r[1]); mr_w(fd, "/" as *u8); mr_wn(fd, r[2]) 115 mr_w(fd, " loss_first_milli=" as *u8); mr_wn(fd, r[3]); mr_w(fd, " loss_last_milli=" as *u8); mr_wn(fd, r[4]) 116 mr_w(fd, " | B_generalizes_pass=" as *u8); mr_wn(fd, r[5]) 117 mr_w(fd, " heldout_acc=" as *u8); mr_wn(fd, r[6]); mr_w(fd, "/" as *u8); mr_wn(fd, r[7]) 118 mr_w(fd, " | C_bitexact_pass=" as *u8); mr_wn(fd, r[8]) 119 mr_w(fd, " | D_untrained_fails_pass=" as *u8); mr_wn(fd, r[9]); mr_w(fd, " untrained_heldout_acc=" as *u8); mr_wn(fd, r[10]) 120 if r[11] == 1 { mr_w(fd, " verdict=GREEN\n" as *u8) } else { mr_w(fd, " verdict=RED\n" as *u8) } 121 return 0 122} 123 124func main() -> i64 { 125 var ok: i64 = 1 126 let NW: i64 = MR_T * MR_S 127 128 // word-map (permutation) 129 let tmap: *i64 = (sys_mmap(MR_S * 8)) as *i64 130 tmap[0] = 2; tmap[1] = 0; tmap[2] = 5; tmap[3] = 1; tmap[4] = 3; tmap[5] = 4 131 132 // TRAIN: 4 sentences x 3, every word exactly twice 133 let n_train: i64 = 4 134 let ntr: i64 = n_train * MR_L 135 let tr_src: *i64 = (sys_mmap(ntr * 8)) as *i64 136 tr_src[0] = 0; tr_src[1] = 1; tr_src[2] = 2 137 tr_src[3] = 3; tr_src[4] = 4; tr_src[5] = 5 138 tr_src[6] = 2; tr_src[7] = 3; tr_src[8] = 0 139 tr_src[9] = 5; tr_src[10] = 1; tr_src[11] = 4 140 let tr_tgt: *i64 = (sys_mmap(ntr * 8)) as *i64 141 var k: i64 = 0 142 while k < ntr { tr_tgt[k] = tmap[tr_src[k]]; k = k + 1 } 143 144 // HELD-OUT: 3 sentences x 3, triples never appear in training 145 let n_held: i64 = 3 146 let nhd: i64 = n_held * MR_L 147 let hd_src: *i64 = (sys_mmap(nhd * 8)) as *i64 148 hd_src[0] = 1; hd_src[1] = 2; hd_src[2] = 3 149 hd_src[3] = 4; hd_src[4] = 5; hd_src[5] = 0 150 hd_src[6] = 3; hd_src[7] = 0; hd_src[8] = 5 151 let hd_tgt: *i64 = (sys_mmap(nhd * 8)) as *i64 152 k = 0 153 while k < nhd { hd_tgt[k] = tmap[hd_src[k]]; k = k + 1 } 154 155 let lr: i64 = ag_constf(1, 8) // m_max=2 -> factor (1-2*lr*m)=0.5, stable 156 157 // ---------- Gate A: LEARNS the training set ---------- 158 let W: *i64 = (sys_mmap(NW * 8)) as *i64 159 let lf: *i64 = (sys_mmap(8)) as *i64 160 let ll: *i64 = (sys_mmap(8)) as *i64 161 mt_train(W, MR_S, MR_T, tr_src, tr_tgt, n_train, MR_L, 300, lr, lf, ll) 162 let tr_acc: i64 = mt_seq_acc(W, MR_S, MR_T, tr_src, tr_tgt, n_train, MR_L) 163 var learns_pass: i64 = 1 164 if tr_acc != ntr { learns_pass = 0 } 165 if nx_f32_lt(*ll, ag_constf(1, 1000)) != 1 { learns_pass = 0 } 166 if nx_f32_lt(*ll, *lf) != 1 { learns_pass = 0 } 167 if learns_pass != 1 { ok = 0 } 168 169 // ---------- Gate B: GENERALIZES to held-out sentences ---------- 170 let hd_acc: i64 = mt_seq_acc(W, MR_S, MR_T, hd_src, hd_tgt, n_held, MR_L) 171 var gen_pass: i64 = 1 172 if hd_acc != nhd { gen_pass = 0 } 173 if gen_pass != 1 { ok = 0 } 174 175 // ---------- Gate C: bit-exact reproducible ---------- 176 let Wr: *i64 = (sys_mmap(NW * 8)) as *i64 177 let lfr: *i64 = (sys_mmap(8)) as *i64 178 let llr: *i64 = (sys_mmap(8)) as *i64 179 mt_train(Wr, MR_S, MR_T, tr_src, tr_tgt, n_train, MR_L, 300, lr, lfr, llr) 180 var bitexact_pass: i64 = 1 181 var c: i64 = 0 182 while c < NW { if Wr[c] != W[c] { bitexact_pass = 0 } c = c + 1 } 183 if bitexact_pass != 1 { ok = 0 } 184 185 // ---------- Gate D: untrained model FAILS held-out (liar-kill) ---------- 186 let W0: *i64 = (sys_mmap(NW * 8)) as *i64 187 let lf0: *i64 = (sys_mmap(8)) as *i64 188 let ll0: *i64 = (sys_mmap(8)) as *i64 189 mt_train(W0, MR_S, MR_T, tr_src, tr_tgt, n_train, MR_L, 0, lr, lf0, ll0) 190 let hd_acc0: i64 = mt_seq_acc(W0, MR_S, MR_T, hd_src, hd_tgt, n_held, MR_L) 191 var untrained_fails_pass: i64 = 1 192 if hd_acc0 >= nhd { untrained_fails_pass = 0 } 193 if untrained_fails_pass != 1 { ok = 0 } 194 195 // ---------- emit ---------- 196 let r: *i64 = (sys_mmap(12 * 8)) as *i64 197 r[0] = learns_pass; r[1] = tr_acc; r[2] = ntr 198 r[3] = mr_f32_to_milli(*lf); r[4] = mr_f32_to_milli(*ll) 199 r[5] = gen_pass; r[6] = hd_acc; r[7] = nhd 200 r[8] = bitexact_pass; r[9] = untrained_fails_pass; r[10] = hd_acc0 201 r[11] = ok 202 mr_emit(1, r) 203 mr_demo(1, W, hd_src, n_held) 204 let logf: i64 = sys_openat_append(MR_LOG, 420) 205 if logf >= 0 { mr_emit(logf, r); mr_demo(logf, W, hd_src, n_held); sys_close(logf) } 206 207 if ok == 1 { return 0 } 208 return 1 209}