Download code/tvq272c.py from Yakimask/PartLock-CMU: direct link, hf CLI and curl.
- Browser
- Download file 5.85 kB
-
https://huggingface.co/Yakimask/PartLock-CMU/resolve/main/code/tvq272c.py
- Command line
-
hf download hf://Yakimask/PartLock-CMU/code/tvq272c.py
-
curl -L -o tvq272c.py https://huggingface.co/Yakimask/PartLock-CMU/resolve/main/code/tvq272c.py
5.85 kB
| """ | |
| Stage 1: causal version of H (sees only current + past frames), for endless streaming. | |
| Same layers / same parameter count as tvq272.HierTok; only padding moves to the left. | |
| Compared against the already-measured H (runs/t272_v1.json) - H is NOT retrained. | |
| Pass rule (fixed before running): | |
| pos <= 61 mm, seam <= 12 mm, consistency <= 5.5 deg, | |
| causality check: changing frames >= t never changes outputs before the token boundary. | |
| """ | |
| import os, sys, json, time, argparse | |
| import numpy as np | |
| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) | |
| import vq_mix as V | |
| import tvq | |
| import tvq272 as B | |
| class CConv(nn.Module): | |
| """Conv1d with all padding on the left -> output i depends on inputs <= i*stride + (stride-1).""" | |
| def __init__(self, cin, cout, k, s=1, dil=1): | |
| super().__init__() | |
| self.pad = (k - 1) * dil - (s - 1) | |
| self.conv = nn.Conv1d(cin, cout, k, s, 0, dilation=dil) | |
| def forward(self, x): | |
| return self.conv(F.pad(x, (self.pad, 0))) | |
| class CRes(nn.Module): | |
| def __init__(self, ch, dil): | |
| super().__init__() | |
| self.c1 = CConv(ch, ch, 3, 1, dil) | |
| self.c2 = nn.Conv1d(ch, ch, 1) | |
| def forward(self, x): | |
| return x + self.c2(F.relu(self.c1(F.relu(x)))) | |
| def cenc(cin, ch, d): | |
| L = [CConv(cin, ch, 3), nn.ReLU()] | |
| for _ in range(2): | |
| L += [CConv(ch, ch, 4, 2), CRes(ch, 1), CRes(ch, 3)] | |
| L += [CConv(ch, d, 3)] | |
| return nn.Sequential(*L) | |
| def cdec(d, ch, cout): | |
| L = [CConv(d, ch, 3), nn.ReLU()] | |
| for _ in range(2): | |
| L += [CRes(ch, 3), CRes(ch, 1), nn.Upsample(scale_factor=2, mode="nearest"), CConv(ch, ch, 3)] | |
| L += [nn.ReLU(), CConv(ch, cout, 3)] | |
| return nn.Sequential(*L) | |
| class CHierTok(nn.Module): | |
| def __init__(self, kg=4096, kp=128, d=128, ch=128, gch=256): | |
| super().__init__() | |
| self.genc = cenc(272, gch, d) | |
| self.gvq = V.VQ(kg, d) | |
| self.enc = nn.ModuleList([cenc(len(c), ch, d) for c in B.PD]) | |
| self.vq = nn.ModuleList([V.VQ(kp, d) for _ in B.PD]) | |
| self.dec = nn.ModuleList([cdec(2 * d, ch, len(c)) for c in B.PD]) | |
| def forward(self, x): | |
| qg, cg, _ = tvq.vq_seq(self.gvq, self.genc(x.permute(0, 2, 1))) | |
| y = torch.empty_like(x) | |
| commit = cg | |
| for p, c in enumerate(B.PD): | |
| q, cm, _ = tvq.vq_seq(self.vq[p], self.enc[p](x[..., c].permute(0, 2, 1))) | |
| commit = commit + cm | |
| y[..., c] = self.dec[p](torch.cat([qg, q], 1)).permute(0, 2, 1) | |
| return y, commit / 7 | |
| def causality_check(m, Zva): | |
| """perturb frames from cut onward; outputs before the token block containing cut must not change.""" | |
| m.eval() | |
| x = Zva[:32].clone() | |
| y0 = m(x)[0] | |
| worst = 0.0 | |
| for cut in (8, 20, 33, 47, 60): | |
| x2 = x.clone() | |
| x2[:, cut:] = torch.randn_like(x2[:, cut:]) * 3 | |
| y2 = m(x2)[0] | |
| safe = (cut // 4) * 4 # frames of tokens fully before cut | |
| worst = max(worst, float((y2[:, :safe] - y0[:, :safe]).abs().max())) | |
| m.train() | |
| return worst | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--frames", type=int, default=500000) | |
| ap.add_argument("--steps", type=int, default=6000) | |
| ap.add_argument("--tag", default="t272_causal_v1") | |
| ap.add_argument("--check-only", action="store_true") | |
| a = ap.parse_args() | |
| dev = "cuda" | |
| t0 = time.time() | |
| mean = torch.from_numpy(np.load(os.path.join(B.ROOT, "mean_std", "Mean.npy")).astype(np.float32)).to(dev) | |
| std = torch.from_numpy(np.load(os.path.join(B.ROOT, "mean_std", "Std.npy")).astype(np.float32)).to(dev) | |
| Wtr, ntr = B.load_split("train", a.frames, 16) # same data / seed as t272_v1 | |
| Wva, nva = B.load_split("val", max(40000, a.frames // 10), B.T) | |
| Xtr = torch.from_numpy(Wtr).to(dev); Xva = torch.from_numpy(Wva).to(dev) | |
| print("train %d win val %d win load %.0fs" % (Xtr.shape[0], Xva.shape[0], time.time() - t0), flush=True) | |
| Ztr, Zva = (Xtr - mean) / std, (Xva - mean) / std | |
| mt = B.Metrics(mean, std, Xtr) | |
| del Xtr | |
| torch.manual_seed(0) | |
| m = CHierTok().to(dev) | |
| print("params causal H %d (non-causal H %d)" % (B.nparams(m), B.nparams(B.HierTok())), flush=True) | |
| print("causality (untrained) max diff %.2e" % causality_check(m, Zva), flush=True) | |
| if a.check_only: | |
| return | |
| secs = B.train(m, Ztr, Zva, a.steps, 256, 4e-4, 0.25, 1000, mt) | |
| r = B.evaluate(m, Zva, mt) | |
| r.update(params=B.nparams(m), train_seconds=round(secs, 1), causality_maxdiff=causality_check(m, Zva)) | |
| torch.save(m.state_dict(), os.path.join(B.CKPT_DIR, a.tag + "_H.pt")) | |
| ref = json.load(open(os.path.join(B.OUTDIR, "t272_v1.json"), encoding="utf-8"))["results"]["H"] | |
| r["pass"] = dict(pos=r["mpjpe_mm"] <= 61, seam=r["seam_bone_mm"] <= 12, | |
| consistency=r["consistency_deg"] <= 5.5, causal=r["causality_maxdiff"] == 0.0) | |
| json.dump(dict(causal_H=r, ref_H=ref), open(os.path.join(B.OUTDIR, a.tag + ".json"), "w", encoding="utf-8"), | |
| ensure_ascii=False, indent=2) | |
| print("causal H: pos %.2f (ref %.2f) | rot g %.2f (ref %.2f) | seam %.2f (ref %.2f) | consist %.2f (ref %.2f) | causal diff %.1e | %.0fs" | |
| % (r["mpjpe_mm"], ref["mpjpe_mm"], r["rot_global_deg"], ref["rot_global_deg"], r["seam_bone_mm"], | |
| ref["seam_bone_mm"], r["consistency_deg"], ref["consistency_deg"], r["causality_maxdiff"], secs), flush=True) | |
| for pn, v in r["per_part"].items(): | |
| print(" %-6s pos %7.2f rot %6.2f (ref %7.2f / %6.2f)" % (pn, v["pos_mm"], v["rot_global_deg"], | |
| ref["per_part"][pn]["pos_mm"], ref["per_part"][pn]["rot_global_deg"]), flush=True) | |
| print("PASS" if all(r["pass"].values()) else "FAIL", r["pass"]) | |
| if __name__ == "__main__": | |
| main() | |