"""RigNet v2: one PointNet-style network for six body plans. Reads a cloud of surface points, decides which body plan it is, then votes joint positions and predicts skin weights with that plan's head.""" import numpy as np, time, sys, json from tinygrad import T, Linear, Adam, cross_entropy, index FAMS = ["biped", "quadruped", "bird", "fish", "snake", "insect"] NJ = {"biped": 17, "quadruped": 19, "bird": 17, "fish": 8, "snake": 10, "insect": 21} OFF = {}; _o = 0 for f in FAMS: OFF[f] = (_o, _o + NJ[f]); _o += NJ[f] TOT = _o; NP = 512 class RigNet2: def __init__(s, seed=0): np.random.seed(seed) s.l1, s.l2, s.l3 = Linear(3, 64), Linear(64, 128), Linear(128, 256) s.ga, s.gb, s.l4 = Linear(128, 256), Linear(256, 256), Linear(256, 128) s.cls = Linear(256, len(FAMS)) s.hs, s.ha, s.ho = Linear(128, TOT), Linear(128, TOT), Linear(128, TOT * 3) for p in s.ho.params: p.data *= 0.1 s.mods = [s.l1, s.l2, s.l3, s.ga, s.gb, s.l4, s.cls, s.hs, s.ha, s.ho] s.params = [p for m in s.mods for p in m.params] def trunk(s, P): B, N, _ = P.shape x = T(P) f2 = s.l2(s.l1(x).relu()).relu() g = s.l3(f2).relu().max(1) h = s.l4((s.ga(f2) + s.gb(g).reshape(B, 1, 256)).relu()).relu() return g, h def save(s, f): np.savez(f, *[p.data for p in s.params]) def load(s, f): d = np.load(f) for i, p in enumerate(s.params): p.data = d[f"arr_{i}"] return s def predict(s, P, fam=None): g, h = s.trunk(P[None].astype(np.float32)) probs = np.exp(s.cls(g).data[0]); probs /= probs.sum() fam = fam or FAMS[int(probs.argmax())] a, b = OFF[fam]; N = P.shape[0] sk = s.hs(h).data[0][:, a:b]; at = s.ha(h).data[0][:, a:b]; of = s.ho(h).data[0].reshape(N, TOT, 3)[:, a:b] at = np.exp(at - at.max(0)); at /= at.sum(0) J = ((P[:, None, :] + of) * at[..., None]).sum(0) w = np.exp(sk - sk.max(1, keepdims=True)); w /= w.sum(1, keepdims=True) return fam, probs, J, w def load_data(): D = {} for f in FAMS: P = np.fromfile(f"data/{f}.P.bin", np.float32).reshape(-1, NP, 3) J = np.fromfile(f"data/{f}.J.bin", np.float32).reshape(len(P), NJ[f], 3) W = np.fromfile(f"data/{f}.W.bin", np.float32).reshape(len(P), NP, NJ[f]) D[f] = (P, J, W) return D def step_loss(m, batch): P = np.concatenate([b[0] for b in batch]); fam_ids = np.concatenate([[FAMS.index(b[3])] * len(b[0]) for b in batch]) B, N = P.shape[:2] g, h = m.trunk(P) lc = cross_entropy(m.cls(g), fam_ids) sk, at, of = m.hs(h), m.ha(h), m.ho(h).reshape(B, N, TOT, 3) total = lc; r0 = 0; stats = {} for (Pf, Jf, Wf, f) in batch: n = len(Pf); rows = np.arange(r0, r0 + n); r0 += n a, b = OFF[f] skf = index(sk, (rows[:, None, None], np.arange(N)[None, :, None], np.arange(a, b)[None, None, :])) atf = index(at, (rows[:, None, None], np.arange(N)[None, :, None], np.arange(a, b)[None, None, :])).softmax(1) off = index(of, (rows[:, None, None, None], np.arange(N)[None, :, None, None], np.arange(a, b)[None, None, :, None], np.arange(3)[None, None, None, :])) votes = off + T(Pf[:, :, None, :]) J = (votes * atf.reshape(n, N, b - a, 1)).sum(1) dj = J - T(Jf); dv = votes - T(Jf[:, None]) lf = (dj * dj).mean() * 100 + (dv * dv).mean() * 10 + cross_entropy(skf, Wf, soft=True) total = total + lf * (n / B) stats[f] = (J.data, skf.data) return total, stats, g def evaluate(m, D): res = {} for f in FAMS: P, J, W = D[f]; vi = np.arange(len(P) - 50, len(P)) _, st, g = step_loss(m, [(P[vi], J[vi], W[vi], f)]) Jp, sk = st[f] err = np.linalg.norm(Jp - J[vi], axis=-1).mean() acc = (sk.argmax(-1) == W[vi].argmax(-1)).mean() cl = (m.cls(g).data.argmax(-1) == FAMS.index(f)).mean() res[f] = (float(err), float(acc), float(cl)) return res def train(steps=4000): D = load_data(); m = RigNet2(); opt = Adam(m.params, lr=2e-3) rng = np.random.default_rng(0); log = []; t0 = time.time() for it in range(steps): batch = [] for f in FAMS: P, J, W = D[f]; idx = rng.integers(0, len(P) - 50, 3) p = P[idx] + rng.normal(0, 0.003, P[idx].shape).astype(np.float32) batch.append((p, J[idx], W[idx], f)) loss, _, _ = step_loss(m, batch); loss.backward() opt.step(2e-3 * 0.5 * (1 + np.cos(np.pi * it / steps)) + 1e-5) if it % 200 == 0 or it == steps - 1: ev = evaluate(m, D); log.append((it, float(loss.data), ev)) print(it, f"loss {loss.data:.3f}", " ".join(f"{f[:4]}:{e*100:.1f}%/{a*100:.0f}%/{c*100:.0f}%" for f, (e, a, c) in ev.items()), f"{time.time()-t0:.0f}s", flush=True) m.save("rig2.npz"); json.dump(log, open("rig2_log.json", "w")) m.save("rig2.npz"); json.dump(log, open("rig2_log.json", "w")) if __name__ == "__main__": train(int(sys.argv[1]) if len(sys.argv) > 1 else 4000)