Deploy from Achraf-cyber/hackton-locallang@9a6624dfc5e7799c9920a85849625e3bcefd8a98

app/deps.py

@@ -9,9 +9,10 @@ class Settings(BaseSettings):
 
     ALLOWED_ORIGINS: list[str] = ["*"]
 
-    # ASR temporaire via l'API d'inference Hugging Face pendant que
-    # facebook/mms-1b-all finit de telecharger en local (voir asr.py).
-    ASR_BACKEND: Literal["local", "hf_api"] = "local"
+    # Voir app/services/asr.py pour le detail des backends.
+    ASR_BACKEND: Literal["local", "hf_api", "omnilingual", "omnilingual_ctc"] = "local"
+    TRANSLATION_BACKEND: Literal["nllb", "afrimt5"] = "nllb"
+    TTS_BACKEND_DYU: Literal["mms", "omnivoice"] = "mms"
     HF_TOKEN: str | None = None
 
 

app/services/asr.py

@@ -1,7 +1,7 @@
 """Reconnaissance vocale (speech-to-text) pour le Dioula, le Moore et le francais
 via facebook/mms-1b-all.
 
-Deux backends, choisis par Settings.ASR_BACKEND :
+Trois backends, choisis par Settings.ASR_BACKEND :
 - "local" (defaut) : Wav2Vec2ForCTC + AutoProcessor charges en local.
 - "hf_api" : pont temporaire vers l'API d'inference Hugging Face, utile tant
   que le modele local (~3.86 Go) n'est pas entierement telecharge.
@@ -10,7 +10,12 @@ Deux backends, choisis par Settings.ASR_BACKEND :
   utilise donc openai/whisper-large-v3 a la place, qui NE supporte PAS
   officiellement le Dioula ni le Moore (~99 langues entrainees, dyu/mos
   absentes) : fiable seulement pour lang="fra", best-effort pour dyu/mos.
-Le contrat de transcribe(audio_path, lang) est identique dans les deux cas.
+- "omnilingual" : Meta Omnilingual ASR (2025), couvre nativement dyu/mos
+  (verifie via lang_ids.py du modele). Necessite le paquet omnilingual-asr
+  (fairseq2 + fairseq2n), qui n'a AUCUN wheel Windows -- fonctionne
+  uniquement sous Linux/WSL. L'import est fait en lazy pour ne pas casser
+  les backends "local"/"hf_api" sur une machine Windows sans ce paquet.
+Le contrat de transcribe(audio_path, lang) est identique dans les trois cas.
 """
 
 import logging
@@ -34,6 +39,14 @@ MMS_LANG_CODES = {
     "fra": "fra",
 }
 
+OMNILINGUAL_MODEL_CARD = "omniASR_CTC_300M_v2"
+OMNILINGUAL_CTC_MODEL_CARD = "omniASR_CTC_1B"
+OMNILINGUAL_LANG_CODES = {
+    "dyu": "dyu_Latn",
+    "mos": "mos_Latn",
+    "fra": "fra_Latn",
+}
+
 TARGET_SAMPLE_RATE = 16_000
 WINDOW_SECONDS = 30
 OVERLAP_SECONDS = 2
@@ -50,6 +63,13 @@ class ASR:
             self._client = InferenceClient(model=HF_API_MODEL_NAME, token=settings.HF_TOKEN)
             return
 
+        if self.backend in ("omnilingual", "omnilingual_ctc"):
+            from omnilingual_asr.models.inference.pipeline import ASRInferencePipeline
+
+            model_card = OMNILINGUAL_CTC_MODEL_CARD if self.backend == "omnilingual_ctc" else OMNILINGUAL_MODEL_CARD
+            self._omni_pipeline = ASRInferencePipeline(model_card=model_card)
+            return
+
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
         self.processor = AutoProcessor.from_pretrained(MODEL_NAME)
         self.model = Wav2Vec2ForCTC.from_pretrained(MODEL_NAME).to(self.device)
@@ -101,10 +121,21 @@ class ASR:
         output = self._client.automatic_speech_recognition(audio_path)
         return output.text.strip()
 
+    def _transcribe_omnilingual(self, audio_path: str, lang: str) -> str:
+        if lang not in OMNILINGUAL_LANG_CODES:
+            raise ValueError(f"Langue non supportee: {lang}")
+        result = self._omni_pipeline.transcribe(
+            [audio_path], lang=[OMNILINGUAL_LANG_CODES[lang]], batch_size=1
+        )
+        return result[0].strip()
+
     def transcribe(self, audio_path: str, lang: str) -> str:
         if self.backend == "hf_api":
             return self._transcribe_hf_api(audio_path, lang)
 
+        if self.backend in ("omnilingual", "omnilingual_ctc"):
+            return self._transcribe_omnilingual(audio_path, lang)
+
         self._set_lang(lang)
         samples = self._load_audio(audio_path)
 

app/services/translator.py

@@ -1,10 +1,13 @@
-"""Traduction entre le francais et le Dioula / Moore via facebook/nllb-200-distilled-600M."""
-
+import logging
 import re
 
 import torch
 from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
 
+from app.deps import get_settings
+
+logger = logging.getLogger("model-service.translator")
+
 MODEL_NAME = "facebook/nllb-200-distilled-600M"
 
 NLLB_LANG_CODES = {
@@ -21,9 +24,35 @@ class Translator:
 
     def __init__(self) -> None:
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-        self.model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME).to(self.device)
-        self.model.eval()
+        settings = get_settings()
+        self.backend = settings.TRANSLATION_BACKEND
+
+        # Lazy init for NLLB
+        self.nllb_tokenizer = None
+        self.nllb_model = None
+
+        # Lazy init for AfriMT5
+        self.afrimt5_models = {}
+        self.afrimt5_tokenizers = {}
+
+        if self.backend == "nllb":
+            self._init_nllb()
+
+    def _init_nllb(self) -> None:
+        if self.nllb_model is None:
+            self.nllb_tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+            self.nllb_model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME).to(self.device)
+            self.nllb_model.eval()
+
+    def _get_afrimt5_model(self, lang: str):
+        if lang not in self.afrimt5_models:
+            # masakhane/afrimt5_fr_bam_news pour dyu/bambara, masakhane/afrimt5_fr_mos_news pour mos
+            hf_repo = "masakhane/afrimt5_fr_bam_news" if lang == "dyu" else "masakhane/afrimt5_fr_mos_news"
+            self.afrimt5_tokenizers[lang] = AutoTokenizer.from_pretrained(hf_repo)
+            model = AutoModelForSeq2SeqLM.from_pretrained(hf_repo).to(self.device)
+            model.eval()
+            self.afrimt5_models[lang] = model
+        return self.afrimt5_models[lang], self.afrimt5_tokenizers[lang]
 
     @classmethod
     def get_instance(cls) -> "Translator":
@@ -36,25 +65,43 @@ class Translator:
         return sentences or [text.strip()]
 
     def _translate_batch(self, sentences: list[str], src: str, tgt: str) -> list[str]:
-        self.tokenizer.src_lang = NLLB_LANG_CODES[src]
-        inputs = self.tokenizer(sentences, return_tensors="pt", padding=True).to(self.device)
-        forced_bos_token_id = self.tokenizer.convert_tokens_to_ids(NLLB_LANG_CODES[tgt])
+        self._init_nllb()
+        self.nllb_tokenizer.src_lang = NLLB_LANG_CODES[src]
+        inputs = self.nllb_tokenizer(sentences, return_tensors="pt", padding=True).to(self.device)
+        forced_bos_token_id = self.nllb_tokenizer.convert_tokens_to_ids(NLLB_LANG_CODES[tgt])
         with torch.no_grad():
-            generated = self.model.generate(
+            generated = self.nllb_model.generate(
                 **inputs,
                 forced_bos_token_id=forced_bos_token_id,
                 num_beams=4,
                 max_length=256,
             )
-        return self.tokenizer.batch_decode(generated, skip_special_tokens=True)
+        return self.nllb_tokenizer.batch_decode(generated, skip_special_tokens=True)
 
     def translate(self, text: str, src: str, tgt: str) -> str:
-        if src not in NLLB_LANG_CODES or tgt not in NLLB_LANG_CODES:
+        if src not in ["fr", "dyu", "mos"] or tgt not in ["fr", "dyu", "mos"]:
             raise ValueError(f"Langue non supportee: src={src}, tgt={tgt}")
+
+        # Traduction fr -> local avec AfriMT5 (si active et si le modele est dispo)
+        if self.backend == "afrimt5" and src == "fr":
+            lang = "dyu" if tgt == "dyu" else "mos"
+            try:
+                model, tokenizer = self._get_afrimt5_model(lang)
+                sentences = self._split_sentences(text)
+                translated = []
+                for sentence in sentences:
+                    inputs = tokenizer(sentence, return_tensors="pt").to(self.device)
+                    with torch.no_grad():
+                        generated = model.generate(**inputs, max_length=256)
+                    decoded = tokenizer.decode(generated[0], skip_special_tokens=True)
+                    translated.append(decoded.strip())
+                return " ".join(translated)
+            except Exception as e:
+                logger.warning("AfriMT5 non disponible pour %s, fallback sur NLLB: %s", lang, e)
+                # Fallback sur NLLB
+
+        # Traduction local -> fr (ou si afrimt5 non dispo/erreur) : toujours NLLB
         sentences = self._split_sentences(text)
-        # Un seul appel batch (au lieu d'une boucle par phrase) : sur CPU, le
-        # cout d'un forward/beam-search batche est tres inferieur a N appels
-        # sequentiels (amorti sur tout le batch au lieu d'etre paye N fois).
         translated = self._translate_batch(sentences, src, tgt)
         return " ".join(translated)
 

app/services/tts.py

@@ -1,6 +1,7 @@
 """Synthese vocale (text-to-speech) pour le Dioula et le Moore via les modeles
 VITS facebook/mms-tts-dyu et facebook/mms-tts-mos."""
 
+import logging
 import re
 
 import numpy as np
@@ -8,6 +9,10 @@ import soundfile as sf
 import torch
 from transformers import VitsModel, VitsTokenizer
 
+from app.deps import get_settings
+
+logger = logging.getLogger("model-service.tts")
+
 MMS_TTS_MODEL_NAMES = {
     "dyu": "facebook/mms-tts-dyu",
     "mos": "facebook/mms-tts-mos",
@@ -21,13 +26,6 @@ _SENTENCE_SPLIT_RE = re.compile(r"(?<=[.!?])\s+")
 _LETTERS_RE = re.compile(r"[^a-zA-ZÀ-ÖØ-öø-ÿ]")
 _SENTENCE_END_RE = re.compile(r"[.!?]+")
 
-# EXPERIMENTAL : NLLB laisse a raison les noms propres francais/anglais tels
-# quels (ex. "Jean Dupont", "Tetouan") -- mais le tokenizer VITS de
-# mms-tts-{dyu,mos} ne connait que l'alphabet phonetique de sa langue, et
-# SUPPRIME SILENCIEUSEMENT toute lettre absente de son vocabulaire (verifie
-# par inspection directe : "Achraf" -> "araf" en moore, "c" et "h" n'existant
-# pas dans le vocabulaire mos). On remplace donc chaque lettre absente par
-# l'approximation phonetique la plus proche plutot que de la perdre.
 _ACCENT_TRANSLATION = str.maketrans(
     {
         "é": "e", "è": "e", "ê": "e", "ë": "e",
@@ -51,6 +49,7 @@ class TTS:
         self._models: dict[str, VitsModel] = {}
         self._tokenizers: dict[str, VitsTokenizer] = {}
         self._allowed_chars: dict[str, set[str]] = {}
+        self._omnivoice_model = None
 
     @classmethod
     def get_instance(cls) -> "TTS":
@@ -174,7 +173,38 @@ class TTS:
             output = model(**inputs).waveform
         return output.squeeze().cpu().numpy()
 
+    def _get_omnivoice_model(self):
+        if self._omnivoice_model is None:
+            from omnivoice import OmniVoice
+            # on utilise cuda si disponible, sinon cpu
+            device = "cuda:0" if torch.cuda.is_available() else "cpu"
+            # CPU est plus stable avec float32 pour l'inference
+            dtype = torch.float32 if device == "cpu" else torch.float16
+            self._omnivoice_model = OmniVoice.from_pretrained(
+                "k2-fsa/OmniVoice",
+                device_map=device,
+                dtype=dtype
+            )
+        return self._omnivoice_model
+
     def speak(self, text: str, lang: str, output_path: str) -> str:
+        settings = get_settings()
+        if lang == "dyu" and settings.TTS_BACKEND_DYU == "omnivoice":
+            try:
+                model = self._get_omnivoice_model()
+                # Synthesiser l'audio avec Voice Design
+                audio = model.generate(
+                    text=text,
+                    instruct="female, young adult, clear speech, neutral accent"
+                )
+                # OmniVoice retourne du 24 kHz
+                sf.write(output_path, audio[0], 24000)
+                return output_path
+            except Exception as e:
+                logger.warning("OmniVoice non disponible pour dyu, fallback sur MMS-TTS: %s", e)
+                # Fallback sur MMS-TTS
+
+        # TTS MMS
         model, _ = self._get_model(lang)
         sample_rate = model.config.sampling_rate
 

download_models_wsl.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# Run from WSL (Ubuntu) to download NLLB + TTS-dyu + TTS-mos into the WSL
+# environment's own HF cache (separate from Windows' cache). The Omnilingual
+# ASR model is already cached from earlier setup; pre_download.py will skip
+# it if already present via HF's own resume/cache-check logic.
+#
+# Usage (from Windows, via PowerShell or Git Bash):
+#   wsl -d Ubuntu -- bash /mnt/c/Users/User/coding/hackaton/locallang/model-service/download_models_wsl.sh
+set -euo pipefail
+
+cd /mnt/c/Users/User/coding/hackaton/locallang
+/root/asr-bench/.venv/bin/python pre_download.py

requirements-omnilingual.txt

@@ -0,0 +1,19 @@
+# ASR_BACKEND=omnilingual : Meta Omnilingual ASR (2025), couvre nativement
+# dyu_Latn/mos_Latn/fra_Latn -- LINUX UNIQUEMENT (fairseq2n n'a aucun wheel
+# Windows, et exige une version de torch EXACTEMENT alignee avec un wheel
+# fairseq2 prebuild : 2.9.1 au moment de la redaction, pas la derniere).
+#
+# Installation (venv Linux/WSL/Docker deja actif) :
+#
+#   pip install torch==2.9.1 torchaudio==2.9.1 --index-url https://download.pytorch.org/whl/cpu
+#   pip install "fairseq2" --extra-index-url https://fair.pkg.atmeta.com/fairseq2/whl/pt2.9.1/cpu \
+#       --trusted-host fair.pkg.atmeta.com   # certificat de ce domaine expire au moment de la redaction
+#   pip install omnilingual-asr --no-deps    # --no-deps : evite de re-resoudre torch en variante CUDA
+#   pip install retrying xxhash              # dependances transitives manquantes du package
+#
+# Si un torch plus recent que 2.9.1 est deja installe (ex. le venv Windows
+# partage), le desinstaller/repointer d'abord : fairseq2 plante sinon
+# (incompatibilite ABI C++, cf. avertissement officiel de fairseq2).
+#
+# Verifie le 2026-07-04 : fairseq2==0.8.1 / fairseq2n==0.8.1+cpu sont les
+# versions resolues a cet index pour torch 2.9.1.

requirements.txt

@@ -15,3 +15,7 @@ pillow
 requests
 pytest
 httpx
+
+# ASR_BACKEND=omnilingual (voir app/services/asr.py) est OPTIONNEL et Linux
+# uniquement (fairseq2n n'a aucun wheel Windows) : voir requirements-omnilingual.txt
+# et pre_download.py pour l'installation (WSL/Docker/HF Spaces).

run_omnilingual_wsl.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Runs model-service from WSL with ASR_BACKEND=omnilingual, on port 8000.
+# WSL2 forwards localhost automatically, so the Next.js backend on Windows
+# (MODEL_SERVICE_URL=http://localhost:8000) keeps working unchanged.
+#
+# IMPORTANT: stop any Windows-hosted uvicorn on :8000 first (only one process
+# can bind that port). From PowerShell:
+#   Get-NetTCPConnection -LocalPort 8000 -State Listen | Select -Expand OwningProcess
+#   Stop-Process -Id <pid> -Force
+#
+# Usage (from Windows, via PowerShell or Git Bash):
+#   wsl -d Ubuntu -- bash /mnt/c/Users/User/coding/hackaton/locallang/model-service/run_omnilingual_wsl.sh
+set -euo pipefail
+
+cd /mnt/c/Users/User/coding/hackaton/locallang/model-service
+
+# Override .env's ASR_BACKEND=local for this run only (env var takes
+# priority over .env in pydantic-settings). Edit model-service/.env directly
+# instead if you want this to stick permanently.
+export ASR_BACKEND=omnilingual_ctc
+
+/root/asr-bench/.venv/bin/python -m uvicorn app.main:app --host 0.0.0.0 --port 8000

setup_wsl_env.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# Full from-scratch setup of the WSL environment for ASR_BACKEND=omnilingual.
+# Only needed once (or again if the WSL distro / venv gets wiped) -- the
+# environment already exists as of 2026-07-04, this documents how it was
+# built so it's reproducible on another machine or after a reset.
+#
+# Usage (from Windows, after `wsl --install -d Ubuntu --no-launch`):
+#   wsl -d Ubuntu -- bash /mnt/c/Users/User/coding/hackaton/locallang/model-service/setup_wsl_env.sh
+set -euo pipefail
+
+apt-get update -qq
+apt-get install -y -qq curl ca-certificates ffmpeg build-essential
+
+curl -LsSf https://astral.sh/uv/install.sh | sh
+UV=/root/.local/bin/uv
+
+$UV python install 3.11
+
+mkdir -p /root/asr-bench
+cd /root/asr-bench
+$UV venv --python 3.11 .venv
+PY=/root/asr-bench/.venv/bin/python
+
+# fairseq2 only has prebuilt wheels for specific torch versions (2.9.0/2.9.1
+# at the time of writing) -- must match EXACTLY or fairseq2n segfaults.
+$UV pip install --python "$PY" "torch==2.9.1" "torchaudio==2.9.1" \
+    --index-url https://download.pytorch.org/whl/cpu
+
+# fair.pkg.atmeta.com's TLS cert was expired at the time of writing (Meta's
+# own infra issue, not ours) -- --allow-insecure-host bypasses verification
+# for this specific host only. Remove once Meta fixes their cert.
+$UV pip install --python "$PY" "fairseq2" \
+    --extra-index-url https://fair.pkg.atmeta.com/fairseq2/whl/pt2.9.1/cpu \
+    --allow-insecure-host fair.pkg.atmeta.com \
+    --index-strategy unsafe-best-match
+
+# --no-deps: omnilingual-asr's declared torch dependency is unpinned and
+# would otherwise pull the CUDA build (~2GB) instead of reusing the CPU one
+# just installed above.
+$UV pip install --python "$PY" omnilingual-asr --no-deps
+
+# Transitive deps missing from omnilingual-asr's/fairseq2's own metadata.
+$UV pip install --python "$PY" retrying xxhash
+
+# Rest of model-service's own requirements (see requirements.txt).
+$UV pip install --python "$PY" \
+    fastapi "uvicorn[standard]" python-multipart accelerate sentencepiece \
+    pydantic-settings python-dotenv soundfile scipy pydub pillow requests \
+    huggingface_hub
+
+echo "✅ WSL environment ready at /root/asr-bench/.venv"