Download train_group2.py from LiberalMind/wm_groups: direct link, hf CLI and curl.
- Browser
- Download file 4.83 kB
-
https://huggingface.co/datasets/LiberalMind/wm_groups/resolve/main/train_group2.py
- Command line
-
hf download hf://datasets/LiberalMind/wm_groups/train_group2.py
-
curl -L -o train_group2.py https://huggingface.co/datasets/LiberalMind/wm_groups/resolve/main/train_group2.py
4.83 kB
| # Одна группа = своя world model ~50M на 10 промптах, на ОДНОМ чипе TPU | |
| import os, sys, time, copy, json, numpy as np, torch, av | |
| sys.path.insert(0, os.path.expanduser("~")) | |
| import torch_xla.core.xla_model as xm | |
| from wm import WorldDiT | |
| from vae import VAE | |
| G = int(os.environ["GROUP"]); R = os.path.expanduser("~"); D = f"{R}/wm_data"; OUT = f"{R}/wm_groups/v2/g{G}"; os.makedirs(OUT, exist_ok=True) | |
| MAX_MIN, TARGET, BATCH, LR = float(os.environ.get("MAX_MIN", 8)), float(os.environ.get("TARGET", 0.05)), 20, float(os.environ.get("LR", 4e-4)) | |
| LOG = open(f"{OUT}/log.txt", "w", buffering=1) | |
| def log(*a): print(*a, file=LOG) | |
| grp = json.load(open(f"{R}/wm_groups/v2/groups_v2.json"))[G]; sel = grp["clips"]; P = len(sel) | |
| dev = xm.xla_device() | |
| st = np.load(f"{R}/wm_run/lat_stats.npz"); mean, std = st["mean"], st["std"] | |
| lat = torch.from_numpy((np.load(f"{D}/latents.npy", mmap_mode="r")[sel].astype(np.float32) - mean) / std).to(dev) | |
| tidx = np.load(f"{D}/txt_idx.npy")[sel] | |
| emb = torch.from_numpy(np.load(f"{R}/wm_groups/v2/emb_g{G}.npy")).float().to(dev); msk = torch.from_numpy(np.load(f"{R}/wm_groups/v2/msk_g{G}.npy")).to(dev) | |
| model = WorldDiT(d=512, depth=10, heads=8).to(dev); ema = copy.deepcopy(model).eval().requires_grad_(False) | |
| log(f"group {G}: {grp['top_tasks']} | params {sum(p.numel() for p in model.parameters())/1e6:.1f}M | prompts {P}") | |
| opt = torch.optim.AdamW(model.parameters(), lr=LR, betas=(0.9, 0.95), weight_decay=0.0) | |
| sched = torch.optim.lr_scheduler.LambdaLR(opt, lambda s: min(1.0, (s + 1) / 150)) | |
| pm, pe = list(model.parameters()), list(ema.parameters()) | |
| if os.environ.get("RESUME"): | |
| _s = torch.load(f"{OUT}/wm_prev.pt", map_location="cpu")["ema"]; model.load_state_dict(_s); ema.load_state_dict(_s); model.to(dev); ema.to(dev); log("RESUMED from wm.pt") | |
| t0, step, hist = time.time(), 0, [] | |
| while time.time() - t0 < MAX_MIN * 60: | |
| ii = torch.randint(0, P, (BATCH,), device=dev); x0 = lat[ii] | |
| B, Fr = x0.shape[0], x0.shape[2] | |
| t = torch.sigmoid(torch.randn(B, Fr, device=dev)); same = torch.rand(B, 1, device=dev) < 0.5 | |
| t = torch.where(same, t[:, :1].expand(B, Fr), t) | |
| eps = torch.randn_like(x0); tt = t[:, None, :, None, None] | |
| with torch.autocast("xla", dtype=torch.bfloat16): | |
| pred = model((1 - tt) * x0 + tt * eps, t, emb[ii], msk[ii], torch.zeros(B, dtype=torch.bool, device=dev)) | |
| loss = ((pred.float() - (eps - x0)) ** 2).mean() | |
| opt.zero_grad(); loss.backward(); torch.nn.utils.clip_grad_norm_(pm, 1.0); opt.step(); sched.step() | |
| with torch.no_grad(): | |
| torch._foreach_mul_(pe, 0.99); torch._foreach_add_(pe, [p.detach() for p in pm], alpha=0.01) | |
| xm.mark_step(); step += 1 | |
| if step % 50 == 0: | |
| hist.append(loss.item()); avg = float(np.mean(hist[-6:])) | |
| log(f"step {step} loss {hist[-1]:.4f} avg300 {avg:.4f} {(time.time()-t0)/60:.1f} min") | |
| if step >= 600 and avg < TARGET: log(f"TARGET {TARGET} reached"); break | |
| torch.save({"ema": {k: v.cpu() for k, v in ema.state_dict().items()}, "clips": sel, "step": step, "cfg": dict(d=512, depth=10, heads=8)}, f"{OUT}/wm.pt") | |
| # --- проверка: 10 промптов -> 10 видео, ошибка латента против оригинала | |
| x = torch.randn(P, 128, 13, 8, 8, generator=torch.Generator().manual_seed(0)).to(dev); S_ = 40 | |
| with torch.no_grad(): | |
| for i in range(S_): | |
| t = torch.full((P, 13), 1 - i / S_).to(dev) | |
| with torch.autocast("xla", dtype=torch.bfloat16): | |
| v = ema(x, t, emb, msk, torch.zeros(P, dtype=torch.bool).to(dev)).float() | |
| x = x - v / S_; xm.mark_step() | |
| gen = x.cpu(); mse = (gen - lat.cpu()).pow(2).mean((1, 2, 3, 4)).numpy() | |
| for k in range(P): log(f"prompt {k}: mse {mse[k]:.4f} | {grp['prompts'][k]}") | |
| v_ = VAE(); v_.load_state_dict(torch.load(f"{R}/vae_run/last.pt", map_location="cpu")["model"]); dec = v_.dec.to(dev).eval(); del v_ | |
| mt, sd_ = torch.from_numpy(mean).float(), torch.from_numpy(std).float(); vids = [] | |
| with torch.no_grad(): | |
| for k in range(10): | |
| with torch.autocast("xla", dtype=torch.bfloat16): | |
| vids.append(dec((gen[k:k + 1] * sd_ + mt).to(dev)).float().clamp(-1, 1).cpu()[0]) | |
| V = torch.stack(vids) # (10,3,97,256,256) | |
| grid = torch.cat([torch.cat(list(V[r * 5:(r + 1) * 5]), 3) for r in range(2)], 2) # (3,97,512,1280) | |
| arr = ((grid.permute(1, 2, 3, 0) + 1) * 127.5).byte().numpy() | |
| with av.open(f"{OUT}/gen10.mp4", "w") as c: | |
| s = c.add_stream("libx264", rate=24); s.width, s.height = 1280, 512; s.pix_fmt = "yuv420p"; s.options = {"crf": "26"} | |
| for fr in arr: | |
| for pk in s.encode(av.VideoFrame.from_ndarray(fr, format="rgb24")): c.mux(pk) | |
| for pk in s.encode(): c.mux(pk) | |
| log(f"FINISHED step {step} | mean mse {mse.mean():.4f} | total {(time.time()-t0)/60:.1f} min") | |