File size: 4,736 Bytes
0bf2a31 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 | # Одна группа = своя 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/g{G}"; os.makedirs(OUT, exist_ok=True)
MAX_MIN, TARGET, BATCH, LR = float(os.environ.get("MAX_MIN", 8)), 0.05, 20, 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/groups.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"{D}/txt_emb.npy")[tidx]).float().to(dev); msk = torch.from_numpy(np.load(f"{D}/txt_mask.npy")[tidx]).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.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(P):
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")
|