Text-to-Speech
MLX
ONNX
Portuguese
tts
pt-br
brazilian-portuguese
small-model
quantized
apple-silicon
pingo
fargan
Instructions to use semfence/pingo-ptbr with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- MLX
How to use semfence/pingo-ptbr with MLX:
# Download the model from the Hub pip install huggingface_hub[hf_xet] hf download semfence/pingo-ptbr --local-dir pingo-ptbr
- Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- LM Studio
- Atomic Chat
Download training/train.py from semfence/pingo-ptbr: direct link, hf CLI and curl.
- Browser
- Download file 6.45 kB
-
https://huggingface.co/semfence/pingo-ptbr/resolve/main/training/train.py
- Command line
-
hf download hf://semfence/pingo-ptbr/training/train.py
-
curl -L -o train.py https://huggingface.co/semfence/pingo-ptbr/resolve/main/training/train.py
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() | |