code wiki / _hdl_build / nx_train_r1_gate.nx
`nx_train_r1_gate.nx` source

↩ module page · 227 lines · 10115 B
1// nx_train_r1_gate.nx -- GATE for TRAIN-R1: the scalar-tape autograd keystone. Proves, by RUNNING, that the
2// team can TRAIN a model sovereignly. Three exact gates (spec 2026-06-09-tutoring-training-substrate-rung1.md):
3//
4//   A  GRADCHECK (oracle = mathematics): loss = (relu(w1*x+b1)*w2 + b2)^2 at params off the relu kink
5//      (w1=2/3, b1=1/4, w2=3/2, b2=1/4, x=3/4). For each param: analytic grad (reverse-mode backward) vs
6//      central finite difference (f(p+h)-f(p-h))/2h, h=1/128; relative error < 1/32 (floor 1/64). Catches
7//      every sign/chain-rule defect a wrong autograd could ship.
8//   B  A MODEL PROVABLY LEARNS: fit y = 1.5x - 0.5 (8 points x=i/4, targets in-f32) by full-batch gradient
9//      descent, lr=1/20, 500 epochs, MSE via the tape. Assert final loss < 1/1000 AND |w-1.5| < 1/16 AND
10//      |b+0.5| < 1/16 AND final loss < first loss. The smallest EXACT statement of "we can train a model".
11//   C  BIT-EXACT REPRODUCIBLE: run the whole training twice from zero-init; assert the final (w,b) f32 BITS
12//      are identical. GPU training is non-deterministic by default; the bits-up f32 substrate makes
13//      byte-identical training a GATE -- the determinism exceed-axis carried into ML.
14//
15// Evidence -> knowledge/status/train_r1.log (TRAINR1GATE authored=organ ... verdict=GREEN). license_tier: ORIGINAL
16import "nx_autograd.nx"     // ag_* tape + transitively nx_f32 / nx_f32_div / nx_f32_cvt / nx_syscalls
17import "nx_syscalls.nx"
18
19const TR_LOG: *u8 = "knowledge/status/train_r1.log"
20
21func tr_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 }
22func tr_wn(fd: i64, v: i64) -> i64 {
  let bb: *u8 = sys_mmap(28); var m: i64 = v
  if m < 0 { m = 0 - m; sys_write(fd, "-" as *u8, 1) }
  let t: *u8 = sys_mmap(28); var k: i64 = 0
  if m == 0 { t[0] = 48; 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 { bb[i] = t[k - 1 - i]; i = i + 1 }
  sys_write(fd, bb, k); return 0
31}
32
33// f32 -> round(v*1000) as a signed int, for readable logging (no f32->int converter exists yet; nearest by
34// linear advance over the i32->f32 ladder; our values are O(1) so this is a few thousand cheap compares).
35func tr_f32_to_milli(v: i64) -> i64 {
  var s: i64 = nx_f32_mul(v, nx_i32_to_f32(1000))
  var neg: i64 = 0
  if nx_f32_lt(s, AG_F32_ZERO) == 1 { neg = 1; s = nx_f32_neg(s) }
  let half: i64 = ag_constf(1, 2)
  var m: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let mid: i64 = nx_f32_add(nx_i32_to_f32(m), half)
      if nx_f32_lt(mid, s) == 1 {
          m = m + 1
          if m >= 100000 { go = 0 }
      } else { go = 0 }
  }
  if neg == 1 { return 0 - m }
  return m
51}
52
53// build the gradcheck loss graph on `tape`; write leaf indices [w1,b1,w2,b2] into leaves; return loss node.
54func tr_build_loss(tape: *i64, np: *i64, w1: i64, b1: i64, w2: i64, b2: i64, x: i64, leaves: *i64) -> i64 {
  *np = 0
  let nw1: i64 = ag_leaf(tape, np, w1)
  let nb1: i64 = ag_leaf(tape, np, b1)
  let nw2: i64 = ag_leaf(tape, np, w2)
  let nb2: i64 = ag_leaf(tape, np, b2)
  let nx:  i64 = ag_leaf(tape, np, x)
  let h1: i64 = ag_add(tape, np, ag_mul(tape, np, nw1, nx), nb1)
  let rr: i64 = ag_relu(tape, np, h1)
  let h2: i64 = ag_add(tape, np, ag_mul(tape, np, rr, nw2), nb2)
  let loss: i64 = ag_mul(tape, np, h2, h2)
  leaves[0] = nw1; leaves[1] = nb1; leaves[2] = nw2; leaves[3] = nb2
  return loss
67}
68
69func tr_loss_val(w1: i64, b1: i64, w2: i64, b2: i64, x: i64) -> i64 {
  let tape: *i64 = (sys_mmap(64 * 5 * 8)) as *i64
  let np: *i64 = (sys_mmap(8)) as *i64
  let lv: *i64 = (sys_mmap(4 * 8)) as *i64
  let loss: i64 = tr_build_loss(tape, np, w1, b1, w2, b2, x, lv)
  return ag_val(tape, loss)
75}
76
77func tr_analytic_grads(w1: i64, b1: i64, w2: i64, b2: i64, x: i64, gout: *i64) -> i64 {
  let tape: *i64 = (sys_mmap(64 * 5 * 8)) as *i64
  let np: *i64 = (sys_mmap(8)) as *i64
  let lv: *i64 = (sys_mmap(4 * 8)) as *i64
  let loss: i64 = tr_build_loss(tape, np, w1, b1, w2, b2, x, lv)
  ag_backward(tape, *np, loss)
  gout[0] = ag_grad(tape, lv[0]); gout[1] = ag_grad(tape, lv[1])
  gout[2] = ag_grad(tape, lv[2]); gout[3] = ag_grad(tape, lv[3])
  return 0
86}
87
88// central finite-difference grad of the loss w.r.t. param index pi (0..3), step h.
89func tr_fd_grad(p: *i64, pi: i64, h: i64) -> i64 {
  let pp: *i64 = (sys_mmap(5 * 8)) as *i64
  let pm: *i64 = (sys_mmap(5 * 8)) as *i64
  var i: i64 = 0
  while i < 5 { pp[i] = p[i]; pm[i] = p[i]; i = i + 1 }
  pp[pi] = nx_f32_add(p[pi], h)
  pm[pi] = nx_f32_sub(p[pi], h)
  let lp: i64 = tr_loss_val(pp[0], pp[1], pp[2], pp[3], pp[4])
  let lm: i64 = tr_loss_val(pm[0], pm[1], pm[2], pm[3], pm[4])
  return nx_f32_div(nx_f32_sub(lp, lm), nx_f32_add(h, h))
99}
100
101// full-batch GD training of y = w*x + b on y = 1.5x - 0.5. Writes final w,b + first/last loss.
102func tr_train(epochs: i64, wout: *i64, bout: *i64, lfirst: *i64, llast: *i64) -> i64 {
  var w: i64 = AG_F32_ZERO
  var b: i64 = AG_F32_ZERO
  let lr:   i64 = ag_constf(1, 20)
  let inv8: i64 = ag_constf(1, 8)
  let f15:  i64 = ag_constf(3, 2)
  let f05:  i64 = ag_constf(1, 2)
  let xs: *i64 = (sys_mmap(8 * 8)) as *i64
  let ys: *i64 = (sys_mmap(8 * 8)) as *i64
  var i: i64 = 0
  while i < 8 {
      let xi: i64 = ag_constf(i, 4)
      xs[i] = xi
      ys[i] = nx_f32_sub(nx_f32_mul(f15, xi), f05)
      i = i + 1
  }
  let tape: *i64 = (sys_mmap(2048 * 5 * 8)) as *i64
  let np: *i64 = (sys_mmap(8)) as *i64
  var ep: i64 = 0
  while ep < epochs {
      *np = 0
      let nw: i64 = ag_leaf(tape, np, w)
      let nb: i64 = ag_leaf(tape, np, b)
      var nsum: i64 = ag_leaf(tape, np, AG_F32_ZERO)
      i = 0
      while i < 8 {
          let nxi: i64 = ag_leaf(tape, np, xs[i])
          let nyi: i64 = ag_leaf(tape, np, ys[i])
          let pred: i64 = ag_add(tape, np, ag_mul(tape, np, nw, nxi), nb)
          let res:  i64 = ag_sub(tape, np, pred, nyi)
          let sq:   i64 = ag_mul(tape, np, res, res)
          nsum = ag_add(tape, np, nsum, sq)
          i = i + 1
      }
      let ninv:  i64 = ag_leaf(tape, np, inv8)
      let nloss: i64 = ag_mul(tape, np, nsum, ninv)
      ag_backward(tape, *np, nloss)
      if ep == 0 { *lfirst = ag_val(tape, nloss) }
      *llast = ag_val(tape, nloss)
      w = nx_f32_sub(w, nx_f32_mul(lr, ag_grad(tape, nw)))
      b = nx_f32_sub(b, nx_f32_mul(lr, ag_grad(tape, nb)))
      ep = ep + 1
  }
  *wout = w; *bout = b
  return 0
147}
148
149func tr_emit(fd: i64, r: *i64) -> i64 {
  tr_w(fd, "TRAINR1GATE authored=organ engine=scalar-tape-autograd-f32" as *u8)
  tr_w(fd, " | A_gradcheck_pass=" as *u8); tr_wn(fd, r[0])
  tr_w(fd, " worst_|fd-analytic|_milli=" as *u8); tr_wn(fd, r[1])
  tr_w(fd, " | B_learns_pass=" as *u8); tr_wn(fd, r[2])
  tr_w(fd, " w_milli=" as *u8); tr_wn(fd, r[3]); tr_w(fd, " b_milli=" as *u8); tr_wn(fd, r[4])
  tr_w(fd, " loss_first_milli=" as *u8); tr_wn(fd, r[5]); tr_w(fd, " loss_last_milli=" as *u8); tr_wn(fd, r[6])
  tr_w(fd, " | C_bitexact_repro_pass=" as *u8); tr_wn(fd, r[7])
  if r[8] == 1 { tr_w(fd, " verdict=GREEN\n" as *u8) } else { tr_w(fd, " verdict=RED\n" as *u8) }
  return 0
159}
160
161func main() -> i64 {
  var ok: i64 = 1
163
  // ---------- Gate A: gradcheck ----------
  let p: *i64 = (sys_mmap(5 * 8)) as *i64
  p[0] = ag_constf(2, 3); p[1] = ag_constf(1, 4); p[2] = ag_constf(3, 2); p[3] = ag_constf(1, 4); p[4] = ag_constf(3, 4)
  let grads: *i64 = (sys_mmap(4 * 8)) as *i64
  tr_analytic_grads(p[0], p[1], p[2], p[3], p[4], grads)
  let h: i64 = ag_constf(1, 128)
  let flo: i64 = ag_constf(1, 64)
  let tol: i64 = ag_constf(1, 32)
  var gradcheck_pass: i64 = 1
  var worst_milli: i64 = 0
  var pi: i64 = 0
  while pi < 4 {
      let ana: i64 = grads[pi]
      let fd:  i64 = tr_fd_grad(p, pi, h)
      let num: i64 = nx_f32_abs(nx_f32_sub(fd, ana))
      var den: i64 = nx_f32_abs(ana)
      if nx_f32_lt(den, flo) == 1 { den = flo }
      let thresh: i64 = nx_f32_mul(tol, den)
      if nx_f32_lt(num, thresh) != 1 { gradcheck_pass = 0 }
      let nm: i64 = tr_f32_to_milli(num)
      if nm > worst_milli { worst_milli = nm }
      pi = pi + 1
  }
  if gradcheck_pass != 1 { ok = 0 }
188
  // ---------- Gate B: a model provably learns ----------
  let wbox: *i64 = (sys_mmap(8)) as *i64
  let bbox: *i64 = (sys_mmap(8)) as *i64
  let lf: *i64 = (sys_mmap(8)) as *i64
  let ll: *i64 = (sys_mmap(8)) as *i64
  tr_train(500, wbox, bbox, lf, ll)
  let w: i64 = *wbox
  let b: i64 = *bbox
  var learns_pass: i64 = 1
  if nx_f32_lt(*ll, ag_constf(1, 1000)) != 1 { learns_pass = 0 }                              // loss < 1/1000
  if nx_f32_lt(nx_f32_abs(nx_f32_sub(w, ag_constf(3, 2))), ag_constf(1, 16)) != 1 { learns_pass = 0 }  // |w-1.5|<1/16
  if nx_f32_lt(nx_f32_abs(nx_f32_add(b, ag_constf(1, 2))), ag_constf(1, 16)) != 1 { learns_pass = 0 }  // |b+0.5|<1/16
  if nx_f32_lt(*ll, *lf) != 1 { learns_pass = 0 }                                             // loss decreased
  if learns_pass != 1 { ok = 0 }
203
  // ---------- Gate C: bit-exact reproducible ----------
  let wbox2: *i64 = (sys_mmap(8)) as *i64
  let bbox2: *i64 = (sys_mmap(8)) as *i64
  let lf2: *i64 = (sys_mmap(8)) as *i64
  let ll2: *i64 = (sys_mmap(8)) as *i64
  tr_train(500, wbox2, bbox2, lf2, ll2)
  var repro_pass: i64 = 1
  if *wbox2 != w { repro_pass = 0 }
  if *bbox2 != b { repro_pass = 0 }
  if repro_pass != 1 { ok = 0 }
214
  // ---------- emit ----------
  let r: *i64 = (sys_mmap(9 * 8)) as *i64
  r[0] = gradcheck_pass; r[1] = worst_milli; r[2] = learns_pass
  r[3] = tr_f32_to_milli(w); r[4] = tr_f32_to_milli(b)
  r[5] = tr_f32_to_milli(*lf); r[6] = tr_f32_to_milli(*ll)
  r[7] = repro_pass; r[8] = ok
  tr_emit(1, r)
  let logf: i64 = sys_openat_append(TR_LOG, 420)
  if logf >= 0 { tr_emit(logf, r); sys_close(logf) }
224
  if ok == 1 { return 0 }
  return 1
227}
nx_train_r1_gate.nx source

`nx_train_r1_gate.nx` source
