pingo-ptbr / training /train.py
itxtoledo's picture
Add pingo-ptbr: 0.87 MB pt-BR TTS (MLX + ONNX + web demo)
27d8618 verified
Raw History Blame Contribute Delete
6.45 kB
"""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()