Upload 3 files

app.py

@@ -0,0 +1,47 @@
+# ------
+# Simple Gradio app: paste Fon text, click SYNTH, hear audio.
+
+import gradio as gr
+from tts_infer import FonTTS
+import os
+
+MODEL_NAME = os.environ.get("FON_TTS_MODEL", "facebook/mms-tts-fon")
+
+# Create TTS backend (loaded once)
+backend = None
+
+def get_backend():
+    global backend
+    if backend is None:
+        backend = FonTTS(model_name=MODEL_NAME)
+    return backend
+
+
+def synthesize_text(text, seed=42):
+    if not text or text.strip() == "":
+        return None
+    tts = get_backend()
+    audio, sr = tts.synthesize(text, seed=int(seed))
+    out_path = "last_output.wav"
+    tts.save_wav(audio, sr, out_path)
+    return out_path
+
+
+def create_ui():
+    with gr.Blocks(title="Fon — Text to Speech (MMS-TTS)") as demo:
+        gr.Markdown("# Fon (Fongbé) — Text → Speech\nPaste Fon text (use standard orthography) and press Synthesize.")
+        with gr.Row():
+            txt = gr.Textbox(lines=4, label="Fon text", placeholder="e.g. e nɔ do fɔngbe ganji")
+            seed = gr.Number(value=42, label="Random seed (optional)")
+        synth_btn = gr.Button("Synthesize")
+        audio_out = gr.Audio(label="Output audio", type="filepath")
+        synth_btn.click(fn=synthesize_text, inputs=[txt, seed], outputs=audio_out)
+    return demo
+
+
+def main():
+    demo = create_ui()
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,9 @@
+# ----------------
+# Minimal Python dependencies
+
+transformers>=4.33.0
+accelerate
+scipy
+torch
+soundfile
+gradio

tts_infer.py

@@ -0,0 +1,46 @@
+# -------------
+# Small helper that loads the MMS VITS Fon model and exposes a function to synthesize text -> waveform
+
+from transformers import VitsModel, AutoTokenizer
+import torch
+import numpy as np
+import soundfile as sf
+
+class FonTTS:
+    def __init__(self, model_name="facebook/mms-tts-fon", device=None):
+        self.model_name = model_name
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Loading model {model_name} on {self.device}...")
+        self.model = VitsModel.from_pretrained(model_name).to(self.device)
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        # model.config.sampling_rate is expected; fallback to 16k if missing
+        self.sr = getattr(self.model.config, "sampling_rate", 16000)
+
+    def synthesize(self, text, seed: int | None = None):
+        # Tokenize
+        inputs = self.tokenizer(text, return_tensors="pt").to(self.device)
+        if seed is not None:
+            torch.manual_seed(seed)
+            np.random.seed(seed)
+        with torch.no_grad():
+            out = self.model(**inputs).waveform
+        # Output from model may be a tensor on device
+        if isinstance(out, torch.Tensor):
+            audio = out.cpu().numpy()
+        else:
+            audio = np.array(out)
+        # Ensure 1D
+        audio = audio.squeeze()
+        return audio, self.sr
+
+    def save_wav(self, audio, sr, path):
+        sf.write(path, audio, sr)
+
+
+if __name__ == "__main__":
+    # quick smoke test
+    tts = FonTTS()
+    txt = "e nɔ do fɔngbe ganji"
+    audio, sr = tts.synthesize(txt)
+    tts.save_wav(audio, sr, "out_fon.wav")
+    print("Saved out_fon.wav")