File size: 4,828 Bytes
b4dd1ed
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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/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")