Upload folder using huggingface_hub

LICENSE-rapido

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

app.py

@@ -20,6 +20,8 @@ WORKER_MOCK=1 permite subir a casca inteira num notebook para teste.
 """
 from __future__ import annotations
 
+import os
+
 import gradio as gr
 
 import nucleo
@@ -82,6 +84,44 @@ def _fazer_endpoint(tipo: str):
     return endpoint
 
 
+# A VOZ DO LIVE (13/10/2026): o Rápido TTS (Apache 2.0, pt-BR), na CPU deste
+# Space — FORA do @spaces.GPU, então não gasta quota de GPU nenhuma. Ele mora
+# aqui porque hospedar Gradio em CPU gratuita passou a exigir PRO no Hugging
+# Face, e este Space já existe. O código dele é clonado pelo `publicar.sh`.
+_RAPIDO = {"tts": None, "erro": ""}
+
+
+def _falar_live(segredo: str, texto: str):
+    recusa = nucleo.autenticar(segredo)
+    if recusa:
+        return {"erro": recusa}
+    texto = str(texto or "").strip()[:600]
+    if not texto:
+        return {"erro": "texto vazio"}
+    try:
+        if _RAPIDO["tts"] is None:
+            import torch
+            from rapido import Rapido
+            torch.set_num_threads(max(1, os.cpu_count() or 2))
+            _RAPIDO["tts"] = Rapido.from_pretrained(device="cpu")
+        import base64, io, time as _t, wave
+        import numpy as np
+        t0 = _t.time()
+        r = _RAPIDO["tts"].synthesize(texto)
+        audio, taxa = r.output["audio"], r.output["sample_rate"]
+        if taxa == 48000:
+            audio = audio[: len(audio) // 2 * 2].reshape(-1, 2).mean(axis=1)
+            taxa = 24000
+        pcm = (np.clip(audio, -1, 1) * 32767).astype(np.int16)
+        buf = io.BytesIO()
+        with wave.open(buf, "wb") as w:
+            w.setnchannels(1); w.setsampwidth(2); w.setframerate(taxa); w.writeframes(pcm.tobytes())
+        return {"audio_base64": base64.b64encode(buf.getvalue()).decode(), "mime": "audio/wav",
+                "segundos": round(_t.time() - t0, 2)}
+    except Exception as e:
+        return {"erro": f"{type(e).__name__}: {str(e)[:200]}"}
+
+
 def _saude(segredo: str):
     recusa = nucleo.autenticar(segredo)
     if recusa:
@@ -110,6 +150,12 @@ with gr.Blocks(title="Conecta Primo — GPU") as demo:
         _btn.click(_fazer_endpoint(_tipo), inputs=[segredo_in, params_in],
                    outputs=[saida], api_name=_nome)
 
+    # A VOZ TEM FILA PRÓPRIA (`concurrency_id`): na fila das gerações ela
+    # esperaria um vídeo de minutos terminar, e o Live ficaria mudo.
+    _btn_voz = gr.Button(visible=False)
+    _btn_voz.click(_falar_live, inputs=[segredo_in, params_in], outputs=[saida],
+                   api_name="falar_live", concurrency_limit=2, concurrency_id="voz")
+
     _btn_saude = gr.Button(visible=False)
     _btn_saude.click(_saude, inputs=[segredo_in], outputs=[saida],
                      api_name="saude")

modelos/wan22.py

@@ -163,9 +163,11 @@ def gerar(params: Dict, progresso: base.Progresso) -> base.Saida:
     # não terminam nisso. 3 s a 20 passos é um vídeo DE VERDADE que termina —
     # um de 5 s que aborta não entrega nada.
     curto = not base.gpu_dedicada()
-    segundos = max(2, min(int(params.get("duration") or (3 if curto else 5)),
-                          int(os.getenv("VIDEO_MAX_SEGUNDOS", "3" if curto else "8"))))
-    fps = 24
+    # 5 s a 16 fps são 81 quadros: o mesmo custo de ~3,4 s a 24 fps, e o clipe
+    # sai com mais de 3 segundos dentro do mesmo prazo de GPU.
+    segundos = max(2, min(int(params.get("duration") or 5),
+                          int(os.getenv("VIDEO_MAX_SEGUNDOS", "5" if curto else "8"))))
+    fps = 16 if curto else 24
     quadros = segundos * fps + 1
     passos = int(params.get("steps") or (20 if curto else 30))
 
@@ -214,8 +216,8 @@ def config_menor(params: Dict) -> Optional[Dict]:
         p["width"], p["height"] = menor
         return p
     dur = int(p.get("duration") or 5)
-    if dur > 3:
-        p["duration"] = 3
+    if dur > 4:
+        p["duration"] = 4
         return p
     return None
 

rapido/__init__.py

@@ -0,0 +1,5 @@
+"""Rápido: tiny, fast Brazilian Portuguese text-to-speech."""
+from .engine import Config, Rapido, Result
+
+__all__ = ["Rapido", "Config", "Result"]
+__version__ = "0.1.0"

rapido/__main__.py

@@ -0,0 +1,30 @@
+"""python -m rapido "Olá, tudo bem?" -o ola.wav"""
+import argparse
+
+from . import Config, Rapido
+
+
+def main():
+    ap = argparse.ArgumentParser(prog="rapido", description="Brazilian Portuguese text-to-speech")
+    ap.add_argument("text", nargs="?", help="text to speak (or use -f)")
+    ap.add_argument("-f", "--file", help="read text from a file")
+    ap.add_argument("-o", "--out", default="rapido.wav")
+    ap.add_argument("--model", default=Config.model)
+    ap.add_argument("--device", default="auto")
+    ap.add_argument("--steps", type=int, default=8)
+    ap.add_argument("--guidance", type=float, default=4.0)
+    ap.add_argument("--speed", type=float, default=1.0)
+    ap.add_argument("--seed", type=int, default=0)
+    a = ap.parse_args()
+    text = open(a.file, encoding="utf-8").read() if a.file else a.text
+    if not text:
+        ap.error("give text or -f FILE")
+    tts = Rapido(Config(model=a.model, device=a.device, steps=a.steps, guidance=a.guidance, speed=a.speed, seed=a.seed))
+    r = tts.synthesize(text)
+    r.save(a.out)
+    m = r.metrics
+    print(f"{a.out}: {m['audio_s']}s of audio in {m['total_s']}s ({m['x_realtime']}x realtime) on {tts.device}")
+
+
+if __name__ == "__main__":
+    main()

rapido/_dit.py

@@ -0,0 +1,248 @@
+# Modified from Apache-2.0 licensed source; see LICENSE.
+"""Rápido acoustic network: letters in, 64-dim latents at 25 Hz out.
+
+Both stages take padded batches with masks and return exactly what each item would get alone, so the
+plain path, the batched path and the recorded CUDA graphs all run these same functions.
+"""
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def rope(pos, dim):
+    inv = 1.0 / (10000.0 ** (torch.arange(dim // 2, device=pos.device).float() / (dim // 2)))
+    ang = pos[..., None].float() * inv
+    ang = torch.cat([ang, ang], -1)
+    return ang.cos(), ang.sin()
+
+
+def apply_rope(x, cos, sin):
+    a, b = x.chunk(2, -1)
+    return x * cos + torch.cat([-b, a], -1) * sin
+
+
+class SwiGLU(nn.Module):
+    def __init__(self, d, mult=4):
+        super().__init__()
+        hidden = int(d * mult * 2 / 3)
+        self.w1 = nn.Linear(d, hidden, bias=False)
+        self.w3 = nn.Linear(d, hidden, bias=False)
+        self.w2 = nn.Linear(hidden, d, bias=False)
+
+    def forward(self, x):
+        return self.w2(F.silu(self.w1(x)) * self.w3(x))
+
+
+class Attention(nn.Module):
+    def __init__(self, d, heads):
+        super().__init__()
+        self.h, self.dh = heads, d // heads
+        self.qkv = nn.Linear(d, 3 * d, bias=False)
+        self.proj = nn.Linear(d, d, bias=False)
+
+    def forward(self, x, cos, sin, mask):
+        B, T, D = x.shape
+        q, k, v = (t.view(B, T, self.h, self.dh).transpose(1, 2) for t in self.qkv(x).chunk(3, -1))
+        q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin)
+        x = F.scaled_dot_product_attention(q, k, v, attn_mask=mask[:, None, None, :])
+        return self.proj(x.transpose(1, 2).reshape(B, T, D))
+
+
+class ConvNeXtBlock(nn.Module):
+    def __init__(self, d):
+        super().__init__()
+        self.dw = nn.Conv1d(d, d, 7, padding=3, groups=d)
+        self.norm = nn.LayerNorm(d)
+        self.pw1 = nn.Linear(d, 2 * d)
+        self.pw2 = nn.Linear(2 * d, d)
+        self.gamma = nn.Parameter(torch.ones(d))
+
+    def forward(self, x, mask):
+        y = self.norm(self.dw((x * mask[..., None]).transpose(1, 2)).transpose(1, 2))  # padding reads as zeros
+        return x + self.gamma * self.pw2(F.gelu(self.pw1(y)))
+
+
+class TextBlock(nn.Module):
+    def __init__(self, d, heads):
+        super().__init__()
+        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
+        self.attn, self.ff = Attention(d, heads), SwiGLU(d)
+
+    def forward(self, x, cos, sin, mask):
+        x = x + self.attn(self.n1(x), cos, sin, mask)
+        return x + self.ff(self.n2(x))
+
+
+class TextEncoder(nn.Module):
+    def __init__(self, n_vocab, d, n_conv, n_attn, heads):
+        super().__init__()
+        self.dh = d // heads
+        self.emb = nn.Embedding(n_vocab, d, padding_idx=0)
+        self.conv = nn.ModuleList(ConvNeXtBlock(d) for _ in range(n_conv))
+        self.attn = nn.ModuleList(TextBlock(d, heads) for _ in range(n_attn))
+        self.norm = nn.LayerNorm(d)
+
+    def forward(self, ids, mask):
+        x = self.emb(ids)
+        for block in self.conv:
+            x = block(x, mask)
+        cos, sin = rope(torch.arange(ids.shape[1], device=ids.device), self.dh)
+        for block in self.attn:
+            x = block(x, cos, sin, mask)
+        return self.norm(x)
+
+
+def masked_group_norm(x, norm, m):
+    """GroupNorm(1, C) with statistics over real positions only."""
+    count = m.sum((1, 2), keepdim=True) * x.shape[1]
+    mean = (x * m).sum((1, 2), keepdim=True) / count
+    var = (((x - mean) * m) ** 2).sum((1, 2), keepdim=True) / count
+    return (x - mean) / torch.sqrt(var + norm.eps) * norm.weight[None, :, None] + norm.bias[None, :, None]
+
+
+class Duration(nn.Module):
+    def __init__(self, d, hidden):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv1d(d, hidden, 3, padding=1), nn.SiLU(), nn.GroupNorm(1, hidden), nn.Identity(),
+            nn.Conv1d(hidden, hidden, 3, padding=1), nn.SiLU(), nn.GroupNorm(1, hidden))
+        self.out = nn.Linear(hidden, 1)
+
+    def forward(self, h, mask):
+        m = mask[:, None].float()
+        x = masked_group_norm(F.silu(self.net[0](h.transpose(1, 2) * m)), self.net[2], m) * m
+        x = masked_group_norm(F.silu(self.net[4](x)), self.net[6], m)
+        log_d = self.out(x.transpose(1, 2)).squeeze(-1).masked_fill(~mask, 0.0)
+        return torch.expm1(log_d.clamp(max=6.0)).clamp(min=1e-3) * mask.float()
+
+
+class Aligner(nn.Module):
+    def __init__(self, d, heads, pos_scale, lookback, lookahead, letter_pos):
+        super().__init__()
+        self.h, self.dh = heads, d // heads
+        self.pos_scale, self.lookback, self.lookahead, self.letter_pos = pos_scale, lookback, lookahead, letter_pos
+        self.q, self.k, self.v, self.o = (nn.Linear(d, d, bias=False) for _ in range(4))
+        self.frame_q = nn.Parameter(torch.zeros(1, 1, d))
+        self.log_sigma = nn.Parameter(torch.zeros(heads))
+        self.bias_w = nn.Parameter(torch.zeros(heads))
+        self.log_temp = nn.Parameter(torch.zeros(()))
+
+    def forward(self, h, cw, cp, fw, fp, mask, n_words):
+        B, L, D = h.shape
+        T = fw.shape[1]
+        if self.letter_pos:
+            c, f = cw.clamp(min=0), fw.clamp(min=0)
+            wlen = torch.zeros(B, n_words, device=h.device).scatter_add_(1, c, (cw >= 0).float()).clamp(min=1.0)
+            woff = wlen.cumsum(-1) - wlen
+            cg = woff.gather(1, c) + cp.float() * wlen.gather(1, c)
+            fg = woff.gather(1, f) + fp.float() * wlen.gather(1, f)
+        else:
+            cg, fg = cw.clamp(min=0).float() + cp, fw.float() + fp
+        q = self.q(self.frame_q.expand(B, T, D)).view(B, T, self.h, self.dh).transpose(1, 2)
+        k = self.k(h).view(B, L, self.h, self.dh).transpose(1, 2)
+        v = self.v(h).view(B, L, self.h, self.dh).transpose(1, 2)
+        q = apply_rope(q, *(t[:, None] for t in rope(fg * self.pos_scale, self.dh)))
+        k = apply_rope(k, *(t[:, None] for t in rope(cg * self.pos_scale, self.dh)))
+        logits = (q @ k.transpose(-2, -1)) / math.sqrt(self.dh) * self.log_temp.exp()
+        sig2 = (self.log_sigma.exp() ** 2).view(1, self.h, 1, 1)
+        dist2 = ((fg[:, :, None] - cg[:, None, :]) ** 2)[:, None]
+        logits = logits - self.bias_w.view(1, self.h, 1, 1) * dist2 / (2 * sig2)
+        rel = cw[:, None, :] - fw[:, :, None]
+        allow = (rel >= -self.lookback) & (rel <= self.lookahead) & mask[:, None, :] & (cw[:, None, :] >= 0)
+        attn = logits.masked_fill(~allow[:, None], -1e4).softmax(-1) * allow[:, None]
+        return self.o((attn @ v).transpose(1, 2).reshape(B, T, D))
+
+
+class DiTBlock(nn.Module):
+    def __init__(self, d, heads, ff_mult, shared):
+        super().__init__()
+        self.n1 = nn.LayerNorm(d, elementwise_affine=False, eps=1e-6)
+        self.n2 = nn.LayerNorm(d, elementwise_affine=False, eps=1e-6)
+        self.attn, self.ff = Attention(d, heads), SwiGLU(d, ff_mult)
+        if shared:
+            self.ada_offset = nn.Parameter(torch.zeros(6, d))
+        else:
+            self.ada = nn.Sequential(nn.SiLU(), nn.Linear(d, 6 * d))
+
+    def forward(self, x, c, cos, sin, mask):
+        p = (c + self.ada_offset[None]).unbind(1) if hasattr(self, "ada_offset") else self.ada(c).chunk(6, -1)
+        sa, ga, aa, sf, gf, af = (t.unsqueeze(1) for t in p)
+        x = x + aa * self.attn(self.n1(x) * (1 + ga) + sa, cos, sin, mask)
+        return x + af * self.ff(self.n2(x) * (1 + gf) + sf)
+
+
+class TimestepEmbed(nn.Module):
+    def __init__(self, d, freq=256):
+        super().__init__()
+        self.freq = freq
+        self.mlp = nn.Sequential(nn.Linear(freq, d), nn.SiLU(), nn.Linear(d, d))
+
+    def forward(self, t):
+        half = self.freq // 2
+        a = t[:, None] * 1000.0 * torch.exp(-math.log(10000) * torch.arange(half, device=t.device) / half)[None]
+        return self.mlp(torch.cat([a.cos(), a.sin()], -1))
+
+
+class Acoustic(nn.Module):
+    def __init__(self, cfg, vocab, shared):
+        super().__init__()
+        d, heads = cfg["d"], cfg["n_heads"]
+        self.d, self.dh, self.latent_dim, self.shared = d, d // heads, cfg.get("latent_dim", 64), shared
+        self.vocab = list(vocab)
+        self.stoi = {ch: i for i, ch in enumerate(self.vocab)}
+        self.times = [float(t) for t in cfg["distilled"]["times"]]
+        self.text = TextEncoder(len(vocab), d, cfg.get("text_conv", 4), cfg.get("text_attn", 2), heads)
+        self.chardur = Duration(d, cfg.get("dur_hidden", 256))
+        self.aligner = Aligner(d, cfg.get("align_heads", 4), cfg.get("pos_scale", 24.0), cfg.get("lookback", 1),
+                               cfg.get("lookahead", 1), bool(cfg.get("letter_pos", False)))
+        self.in_proj = nn.Linear(self.latent_dim, d)
+        self.t_embed = TimestepEmbed(d)
+        if shared:
+            self.ada_shared = nn.Sequential(nn.SiLU(), nn.Linear(d, 6 * d))
+        self.blocks = nn.ModuleList(DiTBlock(d, heads, cfg.get("ff_mult", 4), shared) for _ in range(cfg["n_layers"]))
+        self.norm_out = nn.LayerNorm(d, elementwise_affine=False, eps=1e-6)
+        self.ada_out = nn.Sequential(nn.SiLU(), nn.Linear(d, 2 * d))
+        self.out_proj = nn.Linear(d, self.latent_dim)
+
+    def backbone(self, x, cond, t, mask, cos, sin):
+        c = self.t_embed(t)
+        bc = self.ada_shared(c).view(-1, 6, self.d) if self.shared else c
+        x = self.in_proj(x) + cond
+        for block in self.blocks:
+            x = block(x, bc, cos, sin, mask)
+        s, g = self.ada_out(c).chunk(2, -1)
+        return self.out_proj(self.norm_out(x) * (1 + g.unsqueeze(1)) + s.unsqueeze(1))
+
+    def text_stage(self, ids, mask):
+        """Letters to text features and per-letter durations in frames."""
+        h = self.text(ids, mask)
+        return h, self.chardur(h, mask)
+
+    def sound_stage(self, h, dur, mask, cw, wstart, fw, fp, fmask, noise):
+        """Text features and a frame timeline to latents, in len(self.times) steps from the given noise."""
+        c = dur.clamp(min=1e-4) * mask
+        done = c.cumsum(-1)
+        before = done - c
+        word = cw.clamp(min=0)
+        total = torch.zeros_like(c).scatter_add_(1, word, c).gather(1, word)
+        cp = ((done - before.gather(1, wstart) - 0.5 * c) / total.clamp(min=1e-8)).clamp(0.0, 1.0) * mask
+        cond = self.aligner(h, cw, cp, fw, fp, mask, cw.shape[1])
+        cos, sin = rope(torch.arange(fw.shape[1], device=h.device), self.dh)
+        x = noise[:, 0]
+        for k, t in enumerate(self.times):
+            step = torch.full((x.shape[0],), t, device=x.device)
+            x1 = x + (1 - t) * self.backbone(x, cond, step, fmask, cos, sin)
+            if k + 1 < len(self.times):
+                x = (1 - self.times[k + 1]) * noise[:, k + 1] + self.times[k + 1] * x1
+        return x1
+
+
+def load_acoustic(path, device):
+    ck = torch.load(path, map_location="cpu", weights_only=False)
+    sd = ck["ema"]
+    shared = bool(ck["cfg"].get("shared_ada", any(k.startswith("ada_shared") for k in sd)))
+    model = Acoustic(ck["cfg"], ck["vocab"], shared)
+    model.load_state_dict(sd)
+    return model.to(device).float().eval().requires_grad_(False)

rapido/_vae.py

@@ -0,0 +1,581 @@
+# From VoxCPM (https://github.com/OpenBMB/VoxCPM), Apache License 2.0. AudioVAE v2.
+import math
+from typing import List, Optional
+
+import numpy as np
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torch.nn.utils import weight_norm
+from pydantic import BaseModel
+
+
+def WNConv1d(*args, **kwargs):
+    return weight_norm(nn.Conv1d(*args, **kwargs))
+
+
+def WNConvTranspose1d(*args, **kwargs):
+    return weight_norm(nn.ConvTranspose1d(*args, **kwargs))
+
+
+class CausalConv1d(nn.Conv1d):
+    def __init__(self, *args, padding: int = 0, output_padding: int = 0, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.__padding = padding
+        self.__output_padding = output_padding
+
+    def forward(self, x):
+        x_pad = F.pad(x, (self.__padding * 2 - self.__output_padding, 0))
+        return super().forward(x_pad)
+
+
+class CausalTransposeConv1d(nn.ConvTranspose1d):
+    def __init__(self, *args, padding: int = 0, output_padding: int = 0, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.__padding = padding
+        self.__output_padding = output_padding
+
+    def forward(self, x):
+        return super().forward(x)[..., : -(self.__padding * 2 - self.__output_padding)]
+
+
+def WNCausalConv1d(*args, **kwargs):
+    return weight_norm(CausalConv1d(*args, **kwargs))
+
+
+def WNCausalTransposeConv1d(*args, **kwargs):
+    return weight_norm(CausalTransposeConv1d(*args, **kwargs))
+
+
+# Scripting this brings model speed up 1.4x
+@torch.jit.script
+def snake(x, alpha):
+    shape = x.shape
+    x = x.reshape(shape[0], shape[1], -1)
+    x = x + (alpha + 1e-9).reciprocal() * torch.sin(alpha * x).pow(2)
+    x = x.reshape(shape)
+    return x
+
+
+class Snake1d(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.alpha = nn.Parameter(torch.ones(1, channels, 1))
+
+    def forward(self, x):
+        return snake(x, self.alpha)
+
+
+def init_weights(m):
+    if isinstance(m, nn.Conv1d):
+        nn.init.trunc_normal_(m.weight, std=0.02)
+        if m.bias is not None:
+            nn.init.constant_(m.bias, 0)
+
+
+class CausalResidualUnit(nn.Module):
+    def __init__(self, dim: int = 16, dilation: int = 1, kernel: int = 7, groups: int = 1):
+        super().__init__()
+        pad = ((7 - 1) * dilation) // 2
+        self.block = nn.Sequential(
+            Snake1d(dim),
+            WNCausalConv1d(
+                dim,
+                dim,
+                kernel_size=kernel,
+                dilation=dilation,
+                padding=pad,
+                groups=groups,
+            ),
+            Snake1d(dim),
+            WNCausalConv1d(dim, dim, kernel_size=1),
+        )
+
+    def forward(self, x):
+        y = self.block(x)
+        pad = (x.shape[-1] - y.shape[-1]) // 2
+        assert pad == 0
+        if pad > 0:
+            x = x[..., pad:-pad]
+        return x + y
+
+
+class CausalEncoderBlock(nn.Module):
+    def __init__(self, output_dim: int = 16, input_dim=None, stride: int = 1, groups=1):
+        super().__init__()
+        input_dim = input_dim or output_dim // 2
+        self.block = nn.Sequential(
+            CausalResidualUnit(input_dim, dilation=1, groups=groups),
+            CausalResidualUnit(input_dim, dilation=3, groups=groups),
+            CausalResidualUnit(input_dim, dilation=9, groups=groups),
+            Snake1d(input_dim),
+            WNCausalConv1d(
+                input_dim,
+                output_dim,
+                kernel_size=2 * stride,
+                stride=stride,
+                padding=math.ceil(stride / 2),
+                output_padding=stride % 2,
+            ),
+        )
+
+    def forward(self, x):
+        return self.block(x)
+
+
+class CausalEncoder(nn.Module):
+    def __init__(
+        self,
+        d_model: int = 64,
+        latent_dim: int = 32,
+        strides: list = [2, 4, 8, 8],
+        depthwise: bool = False,
+    ):
+        super().__init__()
+        # Create first convolution
+        self.block = [WNCausalConv1d(1, d_model, kernel_size=7, padding=3)]
+
+        # Create EncoderBlocks that double channels as they downsample by `stride`
+        for stride in strides:
+            d_model *= 2
+            groups = d_model // 2 if depthwise else 1
+            self.block += [CausalEncoderBlock(output_dim=d_model, stride=stride, groups=groups)]
+
+        groups = d_model if depthwise else 1
+
+        # Create two convolution, for mu and logvar
+        self.fc_mu = WNCausalConv1d(d_model, latent_dim, kernel_size=3, padding=1)
+        self.fc_logvar = WNCausalConv1d(d_model, latent_dim, kernel_size=3, padding=1)
+
+        # Wrap black into nn.Sequential
+        self.block = nn.Sequential(*self.block)
+        self.enc_dim = d_model
+
+    def forward(self, x):
+        hidden_state = self.block(x)
+        return {
+            "hidden_state": hidden_state,
+            "mu": self.fc_mu(hidden_state),
+            "logvar": self.fc_logvar(hidden_state),
+        }
+
+
+class NoiseBlock(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.linear = WNCausalConv1d(dim, dim, kernel_size=1, bias=False)
+
+    def forward(self, x):
+        B, C, T = x.shape
+        noise = torch.randn((B, 1, T), device=x.device, dtype=x.dtype)
+        h = self.linear(x)
+        n = noise * h
+        x = x + n
+        return x
+
+
+class CausalDecoderBlock(nn.Module):
+    def __init__(
+        self,
+        input_dim: int = 16,
+        output_dim: int = 8,
+        stride: int = 1,
+        groups=1,
+        use_noise_block: bool = False,
+    ):
+        super().__init__()
+        layers = [
+            Snake1d(input_dim),
+            WNCausalTransposeConv1d(
+                input_dim,
+                output_dim,
+                kernel_size=2 * stride,
+                stride=stride,
+                padding=math.ceil(stride / 2),
+                output_padding=stride % 2,
+            ),
+        ]
+        if use_noise_block:
+            layers.append(NoiseBlock(output_dim))
+        layers.extend(
+            [
+                CausalResidualUnit(output_dim, dilation=1, groups=groups),
+                CausalResidualUnit(output_dim, dilation=3, groups=groups),
+                CausalResidualUnit(output_dim, dilation=9, groups=groups),
+            ]
+        )
+        self.block = nn.Sequential(*layers)
+        self.input_channels = input_dim
+
+    def forward(self, x):
+        return self.block(x)
+
+
+class TransposeLastTwoDim(torch.nn.Module):
+    def forward(self, x):
+        return torch.transpose(x, -1, -2)
+
+
+class SampleRateConditionLayer(nn.Module):
+    def __init__(
+        self,
+        input_dim: int,
+        sr_bin_buckets: int = None,
+        cond_type: str = "scale_bias",
+        cond_dim: int = 128,
+        out_layer: bool = False,
+    ):
+        super().__init__()
+
+        self.cond_type, out_layer_in_dim = cond_type, input_dim
+
+        if cond_type == "scale_bias":
+            self.scale_embed = nn.Embedding(sr_bin_buckets, input_dim)
+            self.bias_embed = nn.Embedding(sr_bin_buckets, input_dim)
+            nn.init.ones_(self.scale_embed.weight)
+            nn.init.zeros_(self.bias_embed.weight)
+        elif cond_type == "scale_bias_init":
+            self.scale_embed = nn.Embedding(sr_bin_buckets, input_dim)
+            self.bias_embed = nn.Embedding(sr_bin_buckets, input_dim)
+            nn.init.normal_(self.scale_embed.weight, mean=1)
+            nn.init.normal_(self.bias_embed.weight)
+        elif cond_type == "add":
+            self.cond_embed = nn.Embedding(sr_bin_buckets, input_dim)
+            nn.init.normal_(self.cond_embed.weight)
+        elif cond_type == "concat":
+            self.cond_embed = nn.Embedding(sr_bin_buckets, cond_dim)
+            assert out_layer, "out_layer must be True for concat cond_type"
+            out_layer_in_dim = input_dim + cond_dim
+        else:
+            raise ValueError(f"Invalid cond_type: {cond_type}")
+
+        if out_layer:
+            self.out_layer = nn.Sequential(
+                Snake1d(out_layer_in_dim),
+                WNCausalConv1d(out_layer_in_dim, input_dim, kernel_size=1),
+            )
+        else:
+            self.out_layer = nn.Identity()
+
+    def forward(self, x, sr_cond):
+        if self.cond_type == "scale_bias" or self.cond_type == "scale_bias_init":
+            x = x * self.scale_embed(sr_cond).unsqueeze(-1) + self.bias_embed(sr_cond).unsqueeze(-1)
+        elif self.cond_type == "add":
+            x = x + self.cond_embed(sr_cond).unsqueeze(-1)
+        elif self.cond_type == "concat":
+            x = torch.cat([x, self.cond_embed(sr_cond).unsqueeze(-1).repeat(1, 1, x.shape[-1])], dim=1)
+
+        return self.out_layer(x)
+
+
+class CausalDecoder(nn.Module):
+    def __init__(
+        self,
+        input_channel,
+        channels,
+        rates,
+        depthwise: bool = False,
+        d_out: int = 1,
+        use_noise_block: bool = False,
+        sr_bin_boundaries: List[int] = None,
+        cond_type: str = "scale_bias",
+        cond_dim: int = 128,
+        cond_out_layer: bool = False,
+    ):
+        super().__init__()
+
+        # Add first conv layer
+        if depthwise:
+            layers = [
+                WNCausalConv1d(input_channel, input_channel, kernel_size=7, padding=3, groups=input_channel),
+                WNCausalConv1d(input_channel, channels, kernel_size=1),
+            ]
+        else:
+            layers = [WNCausalConv1d(input_channel, channels, kernel_size=7, padding=3)]
+
+        # Add upsampling + MRF blocks
+        for i, stride in enumerate(rates):
+            input_dim = channels // 2**i
+            output_dim = channels // 2 ** (i + 1)
+            groups = output_dim if depthwise else 1
+            layers += [
+                CausalDecoderBlock(
+                    input_dim,
+                    output_dim,
+                    stride,
+                    groups=groups,
+                    use_noise_block=use_noise_block,
+                )
+            ]
+
+        # Add final conv layer
+        layers += [
+            Snake1d(output_dim),
+            WNCausalConv1d(output_dim, d_out, kernel_size=7, padding=3),
+            nn.Tanh(),
+        ]
+
+        if sr_bin_boundaries is None:
+            self.model = nn.Sequential(*layers)
+            self.sr_bin_boundaries = None
+        else:
+            self.model = nn.ModuleList(layers)
+
+            self.register_buffer("sr_bin_boundaries", torch.tensor(sr_bin_boundaries, dtype=torch.int32))
+            self.sr_bin_buckets = len(sr_bin_boundaries) + 1
+
+            cond_layers = []
+            for layer in self.model:
+                if layer.__class__.__name__ == "CausalDecoderBlock":
+                    cond_layers.append(
+                        SampleRateConditionLayer(
+                            input_dim=layer.input_channels,
+                            sr_bin_buckets=self.sr_bin_buckets,
+                            cond_type=cond_type,
+                            cond_dim=cond_dim,
+                            out_layer=cond_out_layer,
+                        )
+                    )
+                else:
+                    cond_layers.append(None)
+            self.sr_cond_model = nn.ModuleList(cond_layers)
+
+    def get_sr_idx(self, sr):
+        return torch.bucketize(sr, self.sr_bin_boundaries)
+
+    def forward(self, x, sr_cond=None):
+        if self.sr_bin_boundaries is not None:
+            # assert sr_cond is not None
+            sr_cond = self.get_sr_idx(sr_cond)
+
+            for layer, sr_cond_layer in zip(self.model, self.sr_cond_model):
+                if sr_cond_layer is not None:
+                    x = sr_cond_layer(x, sr_cond)
+                x = layer(x)
+            return x
+        else:
+            return self.model(x)
+
+
+class AudioVAEConfig(BaseModel):
+    encoder_dim: int = 128
+    encoder_rates: List[int] = [2, 5, 8, 8]
+    latent_dim: int = 64
+    decoder_dim: int = 2048
+    decoder_rates: List[int] = [8, 6, 5, 2, 2, 2]
+    depthwise: bool = True
+    sample_rate: int = 16000
+    out_sample_rate: int = 48000
+    use_noise_block: bool = False
+    sr_bin_boundaries: Optional[List[int]] = [20000, 30000, 40000]
+    cond_type: str = "scale_bias"
+    cond_dim: int = 128
+    cond_out_layer: bool = False
+
+
+class AudioVAE(nn.Module):
+    """
+    Args:
+    """
+
+    def __init__(
+        self,
+        config: AudioVAEConfig = None,
+    ):
+        # 如果没有传入config，使用默认配置
+        if config is None:
+            config = AudioVAEConfig()
+
+        super().__init__()
+
+        encoder_dim = config.encoder_dim
+        encoder_rates = config.encoder_rates
+        latent_dim = config.latent_dim
+        decoder_dim = config.decoder_dim
+        decoder_rates = config.decoder_rates
+        depthwise = config.depthwise
+        sample_rate = config.sample_rate
+        out_sample_rate = config.out_sample_rate
+        use_noise_block = config.use_noise_block
+        sr_bin_boundaries = config.sr_bin_boundaries
+        cond_type = config.cond_type
+        cond_dim = config.cond_dim
+        cond_out_layer = config.cond_out_layer
+
+        self.encoder_dim = encoder_dim
+        self.encoder_rates = encoder_rates
+        self.decoder_dim = decoder_dim
+        self.decoder_rates = decoder_rates
+        self.depthwise = depthwise
+
+        self.use_noise_block = use_noise_block
+
+        if latent_dim is None:
+            latent_dim = encoder_dim * (2 ** len(encoder_rates))
+
+        self.latent_dim = latent_dim
+        self.hop_length = np.prod(encoder_rates)
+        self.encoder = CausalEncoder(
+            encoder_dim,
+            latent_dim,
+            encoder_rates,
+            depthwise=depthwise,
+        )
+
+        self.decoder = CausalDecoder(
+            latent_dim,
+            decoder_dim,
+            decoder_rates,
+            depthwise=depthwise,
+            use_noise_block=use_noise_block,
+            sr_bin_boundaries=sr_bin_boundaries,
+            cond_type=cond_type,
+            cond_dim=cond_dim,
+            cond_out_layer=cond_out_layer,
+        )
+        self.sample_rate = sample_rate
+        self.out_sample_rate = out_sample_rate
+        self.sr_bin_boundaries = sr_bin_boundaries
+        self.chunk_size = math.prod(encoder_rates)
+        self.decode_chunk_size = math.prod(decoder_rates)
+
+    def preprocess(self, audio_data, sample_rate):
+        if sample_rate is None:
+            sample_rate = self.sample_rate
+        assert sample_rate == self.sample_rate
+        pad_to = self.hop_length
+        length = audio_data.shape[-1]
+        right_pad = math.ceil(length / pad_to) * pad_to - length
+        audio_data = nn.functional.pad(audio_data, (0, right_pad))
+
+        return audio_data
+
+    def decode(self, z: torch.Tensor, sr_cond: torch.Tensor = None):
+        """Decode given latent codes and return audio data
+
+        Parameters
+        ----------
+        z : Tensor[B x D x T]
+            Quantized continuous representation of input
+        length : int, optional
+            Number of samples in output audio, by default None
+
+        Returns
+        -------
+        dict
+            A dictionary with the following keys:
+            "audio" : Tensor[B x 1 x length]
+                Decoded audio data.
+        """
+        if self.sr_bin_boundaries is not None:
+            # use default output sample rate
+            if sr_cond is None:
+                sr_cond = torch.tensor([self.out_sample_rate], device=z.device, dtype=torch.int32)
+        return self.decoder(z, sr_cond)
+
+    def streaming_decode(self):
+        """Return a ``StreamingVAEDecoder`` context manager for stateful
+        chunk-by-chunk decoding.  Each call to ``decode_chunk`` processes only
+        the new latent patch and carries causal-conv state internally, avoiding
+        the redundant overlap decode used previously.
+
+        Usage::
+
+            with vae.streaming_decode() as dec:
+                for patch in patches:
+                    audio_chunk = dec.decode_chunk(patch)
+        """
+        return StreamingVAEDecoder(self)
+
+    def encode(self, audio_data: torch.Tensor, sample_rate: int):
+        """
+        Args:
+            audio_data: Tensor[B x 1 x T]
+            sample_rate: int
+        Returns:
+            z: Tensor[B x D x T]
+        """
+        if audio_data.ndim == 2:
+            audio_data = audio_data.unsqueeze(1)
+
+        audio_data = self.preprocess(audio_data, sample_rate)
+        return self.encoder(audio_data)["mu"]
+
+
+class StreamingVAEDecoder:
+    """Stateful streaming wrapper for :class:`AudioVAE`.
+
+    Carries causal-convolution padding buffers between calls so that each
+    ``decode_chunk`` processes only the new latent patch — no overlap needed.
+    """
+
+    def __init__(self, vae: AudioVAE):
+        self._vae = vae
+        self._states: dict = {}
+        self._originals: list = []
+
+    # -- context manager --------------------------------------------------
+    def __enter__(self):
+        self._states.clear()
+        self._install()
+        return self
+
+    def __exit__(self, *exc):
+        self._restore()
+        self._states.clear()
+
+    # -- public API --------------------------------------------------------
+    def decode_chunk(self, z_chunk: torch.Tensor) -> torch.Tensor:
+        """Decode a single latent chunk and return the audio waveform."""
+        return self._vae.decode(z_chunk)
+
+    # -- internals ---------------------------------------------------------
+    def _install(self):
+        for name, mod in self._vae.decoder.named_modules():
+            if isinstance(mod, CausalConv1d):
+                pad = mod._CausalConv1d__padding * 2 - mod._CausalConv1d__output_padding
+                if pad > 0:
+                    self._patch_causal_conv(mod, pad)
+            elif isinstance(mod, CausalTransposeConv1d):
+                trim = mod._CausalTransposeConv1d__padding * 2 - mod._CausalTransposeConv1d__output_padding
+                ctx = (mod.kernel_size[0] - 1) // mod.stride[0]
+                if ctx > 0:
+                    self._patch_transpose_conv(mod, ctx, trim)
+
+    def _patch_causal_conv(self, mod, pad_size):
+        states = self._states
+        key = id(mod)
+        orig = mod.forward
+
+        def fwd(x, _k=key, _p=pad_size, _m=mod):
+            x_pad = torch.cat([states[_k], x], dim=-1) if _k in states else F.pad(x, (_p, 0))
+            if x.shape[-1] >= _p:
+                states[_k] = x[:, :, -_p:].detach()
+            else:
+                prev = states.get(_k, torch.zeros(x.shape[0], x.shape[1], _p,
+                                                  device=x.device, dtype=x.dtype))
+                states[_k] = torch.cat([prev, x], dim=-1)[:, :, -_p:].detach()
+            return nn.Conv1d.forward(_m, x_pad)
+
+        mod.forward = fwd
+        self._originals.append((mod, orig))
+
+    def _patch_transpose_conv(self, mod, ctx, trim):
+        states = self._states
+        key = id(mod)
+        orig = mod.forward
+
+        def fwd(x, _k=key, _c=ctx, _t=trim, _m=mod):
+            x_full = torch.cat([states[_k], x], dim=-1) if _k in states else F.pad(x, (_c, 0))
+            states[_k] = x[:, :, -_c:].detach()
+            out = nn.ConvTranspose1d.forward(_m, x_full)
+            left = _c * _m.stride[0]
+            return out[..., left:-_t] if _t > 0 else out[..., left:]
+
+        mod.forward = fwd
+        self._originals.append((mod, orig))
+
+    def _restore(self):
+        for mod, orig in self._originals:
+            mod.forward = orig
+        self._originals.clear()

rapido/engine.py

@@ -0,0 +1,118 @@
+"""Rápido inference: Brazilian Portuguese text in, 48 kHz speech out."""
+import json
+import re
+import time
+from dataclasses import dataclass, field
+
+import numpy as np
+import torch
+from huggingface_hub import hf_hub_download
+
+from ._vae import AudioVAE, AudioVAEConfig
+from .frontend import VOCAB, encode, normalize
+from .model import RapidoModel
+
+DEFAULT_REPO = "edwixx/rapido-tts"
+DECODER_REPO = "openbmb/VoxCPM2"  # frozen AudioVAE decoder, Apache 2.0
+SAMPLE_RATE = 48000
+
+
+@dataclass
+class Config:
+    model: str = DEFAULT_REPO        # HF repo id or a local .pt path
+    device: str = "auto"             # "auto" | "cuda" | "cpu"
+    steps: int = 8                   # ODE steps (8 matches 16 in accuracy)
+    guidance: float = 4.0            # classifier-free guidance
+    speed: float = 1.0               # speaking rate
+    seed: int | None = 0             # None = random
+    cpu_threads: int | None = None
+
+
+@dataclass
+class Result:
+    output: dict                     # {"audio": np.float32 [N], "sample_rate": 48000, "text": spoken form}
+    metrics: dict = field(default_factory=dict)
+
+    def save(self, path):
+        import wave
+        pcm = (np.clip(self.output["audio"], -1, 1) * 32767).astype(np.int16)
+        with wave.open(str(path), "wb") as w:
+            w.setnchannels(1)
+            w.setsampwidth(2)
+            w.setframerate(self.output["sample_rate"])
+            w.writeframes(pcm.tobytes())
+        return path
+
+
+class Rapido:
+    def __init__(self, config: Config | None = None):
+        self.config = config or Config()
+        c = self.config
+        self.device = ("cuda" if torch.cuda.is_available() else "cpu") if c.device == "auto" else c.device
+        if c.cpu_threads:
+            torch.set_num_threads(c.cpu_threads)
+        path = c.model if c.model.endswith(".pt") else hf_hub_download(c.model, "rapido.pt")
+        ck = torch.load(path, map_location="cpu", weights_only=False)
+        self.model = RapidoModel(ck["cfg"], VOCAB, len(ck["spk_order"]))
+        self.model.load_state_dict({k: v.float() for k, v in ck["ema"].items()})
+        self.model.to(self.device).eval()
+        vae_cfg = json.load(open(hf_hub_download(DECODER_REPO, "config.json")))["audio_vae_config"]
+        self.vae = AudioVAE(AudioVAEConfig(**vae_cfg))
+        sd = torch.load(hf_hub_download(DECODER_REPO, "audiovae.pth"), map_location="cpu", weights_only=True)
+        self.vae.load_state_dict(sd.get("state_dict", sd))
+        self.vae.to(self.device).eval()
+
+    @classmethod
+    def from_pretrained(cls, model: str = DEFAULT_REPO, **kwargs):
+        return cls(Config(model=model, **kwargs))
+
+    def normalize(self, text: str) -> str:
+        """The exact spoken form the model reads (numbers, money, dates... expanded in pt-BR)."""
+        return normalize(text)
+
+    def synthesize(self, text: str, stream: bool = False, **settings):
+        """Text -> Result. With stream=True, yields one Result per sentence as soon as it is ready.
+        settings override Config: steps, guidance, speed, seed."""
+        gen = self._pieces(text, settings, max_chars=0 if stream else 220)
+        return gen if stream else self._join(list(gen))
+
+    @torch.inference_mode()
+    def _pieces(self, text, settings, max_chars=220):
+        c = self.config
+        steps, guidance = settings.get("steps", c.steps), settings.get("guidance", c.guidance)
+        speed, seed = settings.get("speed", c.speed), settings.get("seed", c.seed)
+        for k, piece in enumerate(_sentences(text, max_chars)):
+            spoken = normalize(piece)
+            if not spoken:
+                continue
+            t0 = time.time()
+            ids = torch.tensor(encode(spoken), device=self.device)
+            z = self.model.generate(ids, steps=steps, guidance=guidance, speed=speed,
+                                    seed=None if seed is None else seed + k)
+            audio = self.vae.decode(z.T[None]).float().reshape(-1).cpu().numpy()
+            dt = time.time() - t0
+            dur = len(audio) / SAMPLE_RATE
+            yield Result({"audio": audio, "sample_rate": SAMPLE_RATE, "text": spoken},
+                         {"audio_s": round(dur, 3), "total_s": round(dt, 3), "x_realtime": round(dur / dt, 2)})
+
+    @staticmethod
+    def _join(parts, pause=0.22):
+        if not parts:
+            raise ValueError("nothing to say after normalization")
+        gap = np.zeros(int(pause * SAMPLE_RATE), np.float32)
+        audio = np.concatenate([x for p in parts for x in (p.output["audio"], gap)][:-1])
+        total = sum(p.metrics["total_s"] for p in parts)
+        dur = len(audio) / SAMPLE_RATE
+        return Result({"audio": audio, "sample_rate": SAMPLE_RATE, "text": " ".join(p.output["text"] for p in parts)},
+                      {"audio_s": round(dur, 3), "total_s": round(total, 3), "x_realtime": round(dur / total, 2)})
+
+
+def _sentences(text, max_chars=220):
+    out, cur = [], ""
+    for p in re.split(r"(?<=[.!?…])\s+", text.strip()):
+        if cur and len(cur) + len(p) > max_chars:
+            out.append(cur)
+            cur = p
+        else:
+            cur = f"{cur} {p}".strip()
+    return [p for p in out + [cur] if p.strip()]

rapido/frontend.py

@@ -0,0 +1,266 @@
+"""Rápido text frontend: written Brazilian Portuguese in, text in the model's own alphabet out.
+
+Numbers, money, percentages, ordinals, times, dates and common abbreviations are read aloud in
+pt-BR. `modernize()` maps pre-1943 spellings found in the training audiobooks (elle, janella,
+pharmacia, inglez...) to modern ones; the reform changed spelling, not pronunciation. Nothing here
+raises on text.
+"""
+import re
+import unicodedata
+
+from num2words import num2words
+
+LETTERS = "abcdefghijklmnopqrstuvwxyzáàâãçéêíóôõúü"
+PUNCT = ".,?!;:-'"
+VOCAB = ["<pad>", "<unk>", " "] + list(LETTERS) + list(PUNCT)
+
+TYPOGRAPHY = str.maketrans({"’": "'", "‘": "'", "´": "'", "`": "'", "“": '"', "”": '"', "„": '"', "«": '"',
+                            "»": '"', "–": "-", "—": "-", "−": "-", "…": "...", " ": " "})
+MONTHS = ["janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro",
+          "novembro", "dezembro"]
+ABBREV = {
+    "sr.": "senhor", "sra.": "senhora", "srta.": "senhorita", "dr.": "doutor", "dra.": "doutora",
+    "prof.": "professor", "profa.": "professora", "sto.": "santo", "sta.": "santa", "av.": "avenida",
+    "r.": "rua", "etc.": "etcétera", "ex.": "exemplo", "obs.": "observação", "pág.": "página", "p.": "página",
+    "tel.": "telefone", "n.º": "número", "nº": "número", "no.": "número", "vs.": "versus", "aprox.": "aproximadamente",
+}
+UNITS = {"km": "quilômetros", "kg": "quilos", "g": "gramas", "m": "metros", "cm": "centímetros", "mm": "milímetros",
+         "l": "litros", "ml": "mililitros", "h": "horas", "min": "minutos", "s": "segundos", "km/h": "quilômetros por hora",
+         "°c": "graus celsius", "°": "graus", "gb": "gigabytes", "mb": "megabytes"}
+FEM = {"um": "uma", "dois": "duas"}
+
+
+def n2w(n, **kw):
+    try:
+        return num2words(n, lang="pt_BR", **kw).replace(",", "")
+    except Exception:
+        return " ".join(num2words(int(d), lang="pt_BR") for d in str(n) if d.isdigit())
+
+
+def fem(words):
+    """'um', 'dois', 'duzentos'... -> feminine, for horas, pessoas-style nouns."""
+    out = []
+    for w in words.split():
+        w = FEM.get(w, w)
+        w = re.sub(r"entos$", "entas", w) if w.endswith("entos") and w != "quinhentos" else w
+        out.append("quinhentas" if w == "quinhentos" else w)
+    return " ".join(out)
+
+
+def parse_num(s):
+    """'1.250.000' -> 1250000, '3,5' -> 3.5, '1.250,75' -> 1250.75"""
+    s = s.strip().rstrip(".,")
+    if re.fullmatch(r"\d{1,3}(\.\d{3})+(,\d+)?", s):
+        s = s.replace(".", "")
+    return float(s.replace(",", ".")) if "," in s else int(s)
+
+
+def money(m):
+    v = parse_num(m.group(1))
+    reais, cent = int(v), round((v - int(v)) * 100) if isinstance(v, float) else 0
+    out = []
+    if reais:
+        out.append(n2w(reais) + (" de" if reais >= 1_000_000 and reais % 1_000_000 == 0 else "") +
+                   (" real" if reais == 1 else " reais"))
+    if cent:
+        out.append(n2w(cent) + (" centavo" if cent == 1 else " centavos"))
+    return " " + (" e ".join(out) if out else "zero reais") + " "
+
+
+def time_(m):
+    h = int(m.group(1))
+    mi = int(m.group(2) or 0) if m.re.groups > 1 else 0
+    if h > 24 or mi > 59:
+        return m.group(0)
+    hs = fem(n2w(h)) + (" hora" if h == 1 else " horas")
+    return " " + hs + (f" e {fem(n2w(mi)) if mi in (1, 2) else n2w(mi)} minuto{'s' if mi != 1 else ''}" if mi else "") + " "
+
+
+def date(m):
+    d, mo, y = int(m.group(1)), int(m.group(2)), m.group(3)
+    if not (1 <= d <= 31 and 1 <= mo <= 12):
+        return m.group(0)
+    day = "primeiro" if d == 1 else n2w(d)
+    out = f" {day} de {MONTHS[mo - 1]}"
+    if y:
+        y = int(y) + (2000 if len(y) == 2 and int(y) < 50 else 1900 if len(y) == 2 else 0)
+        out += f" de {n2w(y)}"
+    return out + " "
+
+
+def number(m):
+    s = m.group(0)
+    if re.fullmatch(r"\d{10,}", s):  # phone numbers, codes: digit by digit
+        return " " + " ".join(n2w(int(c)) for c in s) + " "
+    v = parse_num(s)
+    if isinstance(v, float):
+        whole, frac = s.replace(".", "").split(",")
+        return f" {n2w(int(whole))} vírgula {' '.join(n2w(int(c)) for c in frac) if frac.startswith('0') else n2w(int(frac))} "
+    return f" {n2w(v)} "
+
+
+ROMAN = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
+ROMAN_CTX = r"(século|séculos|capítulo|capítulos|volume|tomo|parte|ato|livro|papa|rei|rainha|dom|dona|pio|joão|pedro|luís|henrique|elizabeth|guerra mundial|bienal|edição|congresso|fórum)"
+FEM_NOUNS = {"pessoa", "pessoas", "hora", "horas", "criança", "crianças", "vez", "vezes", "semana", "semanas",
+             "mulher", "mulheres", "cidade", "cidades", "casa", "casas", "vaga", "vagas", "família", "famílias",
+             "empresa", "empresas", "escola", "escolas", "página", "páginas", "moeda", "moedas", "unidade",
+             "unidades", "tonelada", "toneladas", "pessoa", "noite", "noites", "mãe", "mães", "filha", "filhas",
+             "aluna", "alunas", "garrafa", "garrafas", "xícara", "xícaras", "colher", "colheres", "fruta", "frutas",
+             "árvore", "árvores", "rua", "ruas", "vida", "vidas", "morte", "mortes", "parte", "partes", "linha",
+             "linhas", "palavra", "palavras", "questão", "questões", "região", "regiões", "nação", "nações",
+             "edição", "edições", "medalha", "medalhas", "gramas" }
+MASC_A = {"dia", "dias", "mapa", "mapas", "problema", "problemas", "sistema", "sistemas", "programa", "programas",
+          "tema", "temas", "clima", "planeta", "planetas", "idioma", "idiomas", "poema", "poemas", "telefonema",
+          "cinema", "cinemas", "atleta", "atletas", "jornalista", "artista", "artistas", "turista", "turistas"}
+
+
+def roman_to_int(r):
+    total, prev = 0, 0
+    for ch in reversed(r):
+        v = ROMAN[ch]
+        total = total - v if v < prev else total + v
+        prev = max(prev, v)
+    return total
+
+
+def romans(t):
+    """Roman numerals after context words (século XVIII, Dom Pedro II) and standalone II..XXXIX."""
+    def ctx(m):
+        n = roman_to_int(m.group(2))
+        word = m.group(1).lower()
+        if word in ("papa", "rei", "rainha", "dom", "dona", "pio", "joão", "pedro", "luís", "henrique", "elizabeth") and n <= 10:
+            return f"{m.group(1)} {n2w(n, to='ordinal')}"
+        return f"{m.group(1)} {n2w(n)}"
+    t = re.sub(r"(?i)\b" + ROMAN_CTX + r"\s+([IVXLCDM]{1,7})\b", ctx, t)
+    return t
+
+
+def is_fem(word):
+    w = word.lower().strip(".,;:!?")
+    if w in MASC_A:
+        return False
+    return w in FEM_NOUNS or (len(w) > 3 and (w.endswith("as") or w.endswith("a")) and not w.endswith("ma"))
+
+
+def agree(m):
+    """Cardinal + feminine noun: 'duas pessoas', 'duzentas horas', 'uma vez'."""
+    num, noun = m.group(1), m.group(2)
+    if "," in num:
+        return m.group(0)
+    v = parse_num(num)
+    words = n2w(v)
+    if is_fem(noun):
+        words = fem(words)
+    return f" {words} {noun}"
+
+
+def phones(t):
+    """(11) 98765-4321, 0800 721 3344 -> digits/pairs, not big cardinals."""
+    def rd(g):
+        g = re.sub(r"\D", "", g)
+        return " ".join(n2w(int(c)) for c in g)
+    t = re.sub(r"\((\d{2})\)\s*(\d{4,5})[-\s]?(\d{4})", lambda m: f" {rd(m.group(1))}, {rd(m.group(2))}, {rd(m.group(3))} ", t)
+    t = re.sub(r"\b(0800|0300|0500|0900)[\s-]?(\d{3})[\s-]?(\d{4})\b", lambda m: f" {rd(m.group(1))}, {rd(m.group(2))}, {rd(m.group(3))} ", t)
+    t = re.sub(r"\b(\d{4,5})-(\d{4})\b", lambda m: f" {rd(m.group(1))}, {rd(m.group(2))} ", t)
+    return t
+
+
+def spoken(text):
+    t = " " + text.translate(TYPOGRAPHY) + " "
+    t = phones(t)
+    t = romans(t)
+    t = re.sub(r"R\$\s*(\d{1,3}(?:\.\d{3})+(?:,\d+)?|\d+(?:,\d+)?)", money, t)
+    t = re.sub(r"(\d{1,3}(?:\.\d{3})+(?:,\d+)?|\d+(?:,\d+)?)\s*%", lambda m: f" {number(re.match(r'.+', m.group(1)))} por cento ", t)
+    t = re.sub(r"\b(\d{1,2})/(\d{1,2})(?:/(\d{2}|\d{4}))?\b", date, t)
+    t = re.sub(r"\b(\d{1,2})(?::|h)(\d{2})\b(?:min)?", time_, t)
+    t = re.sub(r"\b(\d{1,2})h\b", time_, t)
+    t = re.sub(r"(?i)(?<![\w.])(" + "|".join(re.escape(k) for k in sorted(ABBREV, key=len, reverse=True)) + r")(?=\s)",
+               lambda m: ABBREV[m.group(1).lower()], t)
+    t = re.sub(r"(\d{1,3}(?:\.\d{3})+(?:,\d+)?|\d+(?:,\d+)?)\s*(km/h|km|kg|mm|cm|ml|min|gb|mb|°\s*c|°|g|m|l|s|h)\b",
+               lambda m: m.group(1) + " " + unit_word(m.group(2)), t, flags=re.I)
+    t = re.sub(r"(\d+)\s*º", lambda m: f" {n2w(int(m.group(1)), to='ordinal')} ", t)
+    t = re.sub(r"(\d+)\s*ª", lambda m: f" {fem_ord(n2w(int(m.group(1)), to='ordinal'))} ", t)
+    t = re.sub(r"(?<![\d.,])(\d{1,3}(?:\.\d{3})+|\d+)\s+([A-Za-zÀ-ú]+)", agree, t)
+    t = re.sub(r"\d{1,3}(?:\.\d{3})+(?:,\d+)?|\d+(?:,\d+)?", number, t)
+    t = t.replace("&", " e ").replace("@", " arroba ").replace("+", " mais ").replace("=", " igual a ")
+    return t
+
+
+def unit_word(u):
+    return UNITS[re.sub(r"\s", "", u.lower())]
+
+
+def fem_ord(w):
+    return " ".join(x[:-1] + "a" if x.endswith("o") else x for x in w.split())
+
+
+ARCHAIC = [
+    (r"ph", "f"), (r"th", "t"), (r"(?<=[a-z])y(?=[a-z])", "i"),
+    (r"ll", "l"), (r"mm", "m"), (r"nn", "n"), (r"tt", "t"), (r"pp", "p"), (r"ff", "f"), (r"bb", "b"), (r"dd", "d"),
+    (r"gg", "g"), (r"cc(?=[aou])", "c"),
+]
+WORDS = {"hontem": "ontem", "emquanto": "enquanto", "emfim": "enfim", "sahir": "sair", "cahir": "cair",
+         "ás": "às", "á": "à", "sómente": "somente", "egreja": "igreja", "logar": "lugar", "comtudo": "contudo",
+         "emfim": "enfim", "inglez": "inglês", "portuguez": "português", "francez": "francês", "mez": "mês",
+         "vez": "vez", "pez": "pés", "fóra": "fora", "côr": "cor", "poz": "pôs", "poz-se": "pôs-se", "fez-se": "fez-se", "ella": "ela", "elle": "ele", "elles": "eles",
+         "ellas": "elas", "n'um": "num", "n'uma": "numa", "d'isto": "disto", "d'isso": "disso", "d'aqui": "daqui",
+         "d'ali": "dali", "d'elle": "dele", "d'ella": "dela", "d'esse": "desse", "d'essa": "dessa", "d'este": "deste",
+         "d'esta": "desta", "d'aquelle": "daquele", "d'aquella": "daquela"}
+
+
+def modernize(text):
+    """Pre-reform spellings -> modern pt-BR, word by word (training text only)."""
+    def fix(w):
+        lw = w.lower()
+        core = lw.strip(PUNCT + '"')
+        if core in WORDS:
+            return lw.replace(core, WORDS[core])
+        for a, b in ARCHAIC:
+            lw = re.sub(a, b, lw)
+        return lw
+    return " ".join(fix(w) for w in text.split())
+
+
+def alphabet(text):
+    text = unicodedata.normalize("NFC", text.lower())
+    out = []
+    for ch in text:
+        if ch in LETTERS or ch in PUNCT or ch == " ":
+            out.append(ch)
+        elif ch in "\"()[]{}":
+            out.append(" ")
+        else:
+            base = "".join(c for c in unicodedata.normalize("NFKD", ch) if not unicodedata.combining(c))
+            out.append(base if base and all(c in LETTERS for c in base) else " ")
+    t = re.sub(r"\s+", " ", "".join(out))
+    t = re.sub(r"\s+([.,?!;:])", r"\1", t)  # no space before punctuation
+    t = re.sub(r"([.,?!;:])\1+", r"\1", t).replace("..", ".")
+    return t.strip(" -'")
+
+
+def normalize(text, archaic=False):
+    try:
+        text = spoken(text)
+    except Exception:  # keep the words rather than lose the sentence
+        pass
+    if archaic:
+        text = modernize(text)
+    return alphabet(text)
+
+
+def encode(text):
+    stoi = {c: i for i, c in enumerate(VOCAB)}
+    return [stoi.get(c, 1) for c in text]
+
+
+if __name__ == "__main__":
+    tests = [
+        "Olá! O pedido custa R$ 1.250,50 e chega em 15/10/2026 às 14:30.",
+        "A inflação foi de 4,5% em 2025; o 1º lugar ficou com a 2ª colocada.",
+        "O Sr. Silva mora na Av. Paulista, nº 1000, a 12 km daqui.",
+        "Ligue para 11987654321 às 9h. Temperatura: 23°C.",
+        "Ella abriu a janella e poz-se a mirar o theatro emquanto sahia.",
+        "Você vem amanhã? Sim, chego às 2h com 3 amigos.",
+    ]
+    for t in tests:
+        print(t, "\n ->", normalize(t, archaic=True), "\n")

rapido/model.py

@@ -0,0 +1,87 @@
+"""Rápido acoustic model: Brazilian Portuguese letters in, 64-dim latents at 25 Hz out (flow matching)."""
+import torch
+import torch.nn as nn
+
+from ._dit import Acoustic, rope
+
+
+def word_layout(text):
+    """Letter -> word index and the first letter of that word (a word owns its trailing space)."""
+    starts = [i for i, ch in enumerate(text) if ch != " " and (i == 0 or text[i - 1] == " ")] or [0]
+    bounds = [0] + starts[1:] + [len(text)]
+    cw, wstart = [], []
+    for w, (a, b) in enumerate(zip(bounds[:-1], bounds[1:])):
+        cw += [w] * (b - a)
+        wstart += [a] * (b - a)
+    return cw, wstart
+
+
+def frame_layout(counts):
+    """Word frame counts -> each frame's word and its position inside that word."""
+    fw = torch.repeat_interleave(torch.arange(len(counts)), counts)
+    start = (counts.cumsum(0) - counts)[fw]
+    fp = ((torch.arange(len(fw)) - start).double() / counts[fw].double()).float()
+    return fw, fp
+
+
+class RapidoModel(nn.Module):
+    def __init__(self, cfg, vocab, n_spk):
+        super().__init__()
+        self.cfg = cfg
+        self.net = Acoustic(cfg, vocab, cfg.get("shared_ada", True))
+        self.spk = nn.Embedding(n_spk, cfg["d"])
+        self.register_buffer("lat_mean", torch.zeros(cfg["latent_dim"]))
+        self.register_buffer("lat_std", torch.ones(cfg["latent_dim"]))
+
+    def _condition(self, ids, mask, cw, wstart, fw, fp, spk):
+        h, dur = self.net.text_stage(ids, mask)
+        c = dur.clamp(min=1e-4) * mask
+        done = c.cumsum(-1)
+        word = cw.clamp(min=0)
+        total = torch.zeros_like(c).scatter_add_(1, word, c).gather(1, word)
+        cp = ((done - (done - c).gather(1, wstart) - 0.5 * c) / total.clamp(min=1e-8)).clamp(0.0, 1.0) * mask
+        return self.net.aligner(h, cw, cp, fw, fp, mask, cw.shape[1]) + self.spk(spk)[:, None]
+
+    def _velocity(self, x, cond, t, fmask):
+        cos, sin = rope(torch.arange(x.shape[1], device=x.device), self.net.dh)
+        return self.net.backbone(x, cond, t, fmask, cos, sin)
+
+    @torch.inference_mode()
+    def generate(self, ids, steps=8, guidance=4.0, speed=1.0, seed=None, speaker=0):
+        """ids: letter ids [L] -> latents [T, 64] (midpoint ODE + classifier-free guidance)."""
+        dev = ids.device
+        text_ids = ids[None]
+        cw, ws = word_layout_from_ids(text_ids, self.net.stoi)
+        mask = torch.ones_like(text_ids, dtype=torch.bool)
+        _, dur = self.net.text_stage(text_ids, mask)
+        dur = dur / speed
+        counts = torch.zeros(1, int(cw.max()) + 1, device=dev).scatter_add_(1, cw, dur).round().clamp(1, 250).long()[0]
+        fw, fp = frame_layout(counts.cpu())
+        fw, fp = fw[None].to(dev), fp[None].to(dev)
+        fmask = torch.ones_like(fw, dtype=torch.bool)
+        cond = self._condition(text_ids, mask, cw, ws, fw, fp, torch.tensor([speaker], device=dev))
+        g = torch.Generator(device=dev)
+        g.manual_seed(seed if seed is not None else torch.seed() % (2 ** 31))
+        x = torch.randn(1, fw.shape[1], self.cfg["latent_dim"], device=dev, generator=g)
+
+        def v(x, t):
+            tt = torch.full((1,), t, device=dev)
+            vc = self._velocity(x, cond, tt, fmask)
+            if guidance == 1.0:
+                return vc
+            vu = self._velocity(x, torch.zeros_like(cond), tt, fmask)
+            return vu + guidance * (vc - vu)
+
+        ts = torch.linspace(0, 1, steps + 1).tolist()
+        for a, b in zip(ts[:-1], ts[1:]):
+            x = x + (b - a) * v(x + (b - a) / 2 * v(x, a), (a + b) / 2)
+        return (x[0] * self.lat_std + self.lat_mean).float()
+
+
+def word_layout_from_ids(ids, stoi):
+    """Word layout from letter ids (the space id marks word ends)."""
+    space = stoi[" "]
+    row = ids[0].tolist()
+    text = "".join(" " if i == space else "x" for i in row)
+    cw, ws = word_layout(text)
+    return torch.tensor([cw], device=ids.device), torch.tensor([ws], device=ids.device)

requirements.txt

@@ -50,3 +50,7 @@ imageio-ffmpeg==0.6.0
 # dependência extra.
 boto3==1.35.90
 requests>=2.32
+
+# A voz do Live (Rápido TTS): números, datas e dinheiro por extenso em pt-BR.
+num2words
+pydantic