"""Acoustic model training: smooth-L1 on the 20 (normalized) features + 0.1 x MSE on log1p(duration). Receita do PiVo: batch pequeno, lr 3e-4, 200 passos de aquecimento. Uso: python code/pingo_ptbr/train.py --prep data/prep --out runs/w64 --width 64 --steps 40000 --device cuda """ import argparse, json, math, random, sys, time from pathlib import Path import numpy as np import torch import torch.nn.functional as F sys.path.insert(0, str(Path(__file__).resolve().parent)) from model import Acoustic, Config # noqa: E402 EDGE = 5 # silence frames kept at BOS/EOS (PiVo keeps a margin of 3) def load_split(prep, split, limit=None): rows = [json.loads(l) for l in (Path(prep) / f"{split}.jsonl").read_text().splitlines()] if limit: rows = rows[:limit] items = [] for r in rows: d = np.load(Path(prep) / split / f"{r['id']}.npz") feats, dur = d["features"], d["durations"].astype(np.int64).copy() cut_a = max(0, dur[0] - EDGE); dur[0] -= cut_a cut_b = max(0, dur[-1] - EDGE); dur[-1] -= cut_b feats = feats[cut_a: len(feats) - cut_b] assert dur.sum() == len(feats) and dur.max() <= 200, (r["id"], dur.sum(), len(feats), dur.max()) items.append((d["tokens"].astype(np.int16), int(d["voice"]), dur.astype(np.int16), feats.astype(np.float16), d["stress"].astype(np.int8))) return items def batches(items, size, shuffle): idx = list(range(len(items))) if shuffle: random.shuffle(idx) chunks = [idx[i: i + size * 50] for i in range(0, len(idx), size * 50)] out = [] for ch in chunks: ch.sort(key=lambda i: len(items[i][3])) out += [ch[i: i + size] for i in range(0, len(ch), size)] if shuffle: random.shuffle(out) return out def collate(items, ids, device): L = max(len(items[i][0]) for i in ids); T = max(len(items[i][3]) for i in ids) tok = torch.zeros(len(ids), L, dtype=torch.long); dur = torch.zeros(len(ids), L, dtype=torch.long); st = torch.zeros(len(ids), L, dtype=torch.long) feat = torch.zeros(len(ids), T, 20); lens, voice = [], [] for k, i in enumerate(ids): t, v, d, f, sx = items[i] st[k, :len(t)] = torch.from_numpy(sx.astype(np.int64)); tok[k, :len(t)] = torch.from_numpy(t.astype(np.int64)); dur[k, :len(d)] = torch.from_numpy(d.astype(np.int64)) feat[k, :len(f)] = torch.from_numpy(f.astype(np.float32)); lens.append(len(t)); voice.append(v) return (tok.to(device), st.to(device), torch.tensor(voice, device=device), torch.tensor(lens, device=device), dur.to(device), feat.to(device)) def losses(model, batch): tok, st, voice, lens, dur, feat = batch z, log_dur, fmask = model(tok, st, voice, lens, dur) target = (feat[:, : z.shape[1]] - model.f_mean) / model.f_std m = fmask.unsqueeze(-1).float() l_feat = (F.smooth_l1_loss(z, target, reduction="none") * m).sum() / (m.sum() * z.shape[-1]) tmask = (torch.arange(tok.shape[1], device=tok.device)[None] < lens[:, None]).float() l_dur = (((log_dur - torch.log1p(dur.float())) ** 2) * tmask).sum() / tmask.sum() return l_feat, l_dur def main(): ap = argparse.ArgumentParser() ap.add_argument("--prep", default="data/prep"); ap.add_argument("--out", required=True) ap.add_argument("--width", type=int, default=96); ap.add_argument("--ff", type=int) ap.add_argument("--steps", type=int, default=60000); ap.add_argument("--batch", type=int, default=16) ap.add_argument("--lr", type=float, default=3e-4); ap.add_argument("--warmup", type=int, default=200) ap.add_argument("--eval-every", type=int, default=1000); ap.add_argument("--device", default="cpu") ap.add_argument("--train-split", default="train"); ap.add_argument("--limit", type=int) ap.add_argument("--seed", type=int, default=42) a = ap.parse_args() random.seed(a.seed); np.random.seed(a.seed); torch.manual_seed(a.seed) out = Path(a.out); out.mkdir(parents=True, exist_ok=True) train, val = load_split(a.prep, a.train_split, a.limit), load_split(a.prep, "validation", 200) allf = np.concatenate([it[3] for it in train]).astype(np.float32) cfg = Config(width=a.width, ff=a.ff or 2 * a.width, vocab=128) model = Acoustic(cfg).to(a.device) model.f_mean.copy_(torch.from_numpy(allf.mean(0))); model.f_std.copy_(torch.from_numpy(allf.std(0) + 1e-3)) n = sum(p.numel() for p in model.parameters()) print(f"{len(train)} train, {len(val)} validation, {n:,} parameters, {len(allf):,} frames", flush=True) opt = torch.optim.AdamW(model.parameters(), lr=a.lr, betas=(0.9, 0.98), weight_decay=0.01) sched = lambda s: min(1.0, (s + 1) / a.warmup) * (0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * min(1.0, s / a.steps)))) step, best, t0, run = 0, 1e9, time.time(), [0.0, 0.0, 0] while step < a.steps: for ids in batches(train, a.batch, True): for g in opt.param_groups: g["lr"] = a.lr * sched(step) model.train() lf, ld = losses(model, collate(train, ids, a.device)) (lf + 0.1 * ld).backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) opt.step(); opt.zero_grad(set_to_none=True) run[0] += lf.item(); run[1] += ld.item(); run[2] += 1; step += 1 if step % 100 == 0: print(f"passo {step} feat {run[0]/run[2]:.4f} dur {run[1]/run[2]:.4f} lr {a.lr*sched(step):.2e} " f"{step/(time.time()-t0):.1f} it/s", flush=True); run = [0.0, 0.0, 0] if step % a.eval_every == 0 or step == a.steps: model.eval(); tl = td = k = 0 with torch.no_grad(): for vids in batches(val, 16, False): lf, ld = losses(model, collate(val, vids, a.device)); tl += lf.item(); td += ld.item(); k += 1 v = tl / k + 0.1 * td / k print(f" validation step {step}: feat {tl/k:.4f} dur {td/k:.4f} total {v:.4f}", flush=True) torch.save({"model": model.state_dict(), "config": cfg.to_dict(), "step": step, "val": v}, out / "last.pt") if v < best: best = v; torch.save({"model": model.state_dict(), "config": cfg.to_dict(), "step": step, "val": v}, out / "best.pt") if step >= a.steps: break print("done, best validation", round(best, 4)) if __name__ == "__main__": main()