Deploy from Achraf-cyber/hackton-locallang@0c3f105334ac28b550aa393ba64fcd8c3167851d

app/deps.py

@@ -14,6 +14,14 @@ class Settings(BaseSettings):
     TTS_BACKEND_DYU: Literal["mms", "omnivoice"] = "mms"
     HF_TOKEN: str | None = None
 
+    # Stack de modeles : "old" (facebook/nllb + mms) ou "goaicorp" (modeles
+    # GO AI Corporation, licence CC-BY-NC 4.0, usage non-commercial). Defaut
+    # "old" = aucun changement en prod tant que la variable n'est pas positionnee
+    # explicitement a "goaicorp" dans les secrets du Space HF.
+    # NB : pour le TTS dioula, GO AI n'a PAS de modele ; les deux stacks
+    # utilisent donc facebook/mms-tts-dyu pour le dioula (voir tts.py).
+    MODEL_STACK: Literal["old", "goaicorp"] = "old"
+
 
 @lru_cache
 def get_settings() -> Settings:

app/services/asr.py

@@ -1,7 +1,8 @@
 """Reconnaissance vocale (speech-to-text) pour le Dioula, le Moore et le francais
 via facebook/mms-1b-all.
 
-Trois backends, choisis par Settings.ASR_BACKEND :
+Quatre backends, choisis par Settings.ASR_BACKEND, et une stack GO AI distincte
+contrôlee par Settings.MODEL_STACK :
 - "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.
@@ -18,6 +19,14 @@ Trois backends, choisis par Settings.ASR_BACKEND :
   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.
+
+Quand Settings.MODEL_STACK == "goaicorp", tous les backends ci-dessus sont
+ignores au profit des modeles GO AI Corporation (licence CC-BY-NC 4.0) :
+  goaicorp/mos-asr  (Mooré)
+  goaicorp/dyu-asr  (Dioula)
+Charges via transformers pipeline("automatic-speech-recognition"), qui est
+agnostique de l'architecture (Whisper, Wav2Vec2, etc.) et s'adapte
+automatiquement au modele telecharge.
 Le contrat de transcribe(audio_path, lang) est identique dans tous les cas.
 """
 
@@ -36,6 +45,15 @@ logger = logging.getLogger("model-service.asr")
 MODEL_NAME = "facebook/mms-1b-all"
 HF_API_MODEL_NAME = "openai/whisper-large-v3"
 
+# Stack GO AI (MODEL_STACK=goaicorp) — modeles specialises par langue
+# Licence CC-BY-NC 4.0 (contact commercial : aristide@goaicorporation.org)
+GOAICORP_ASR_MODEL_NAMES = {
+    "mos": "goaicorp/mos-asr",
+    "dyu": "goaicorp/dyu-asr",
+    # Pas de modele GO AI pour le français : fallback sur Whisper (hf_api)
+    "fra": "openai/whisper-large-v3",
+}
+
 MMS_LANG_CODES = {
     "dyu": "dyu",
     "mos": "mos",
@@ -62,6 +80,15 @@ class ASR:
     def __init__(self) -> None:
         settings = get_settings()
         self.backend = settings.ASR_BACKEND
+        self._stack = settings.MODEL_STACK
+        self._hf_token = settings.HF_TOKEN
+
+        # La stack goaicorp remplace tous les backends ASR_BACKEND par les
+        # modeles GO AI, charges via pipeline() au premier appel (lazy).
+        if self._stack == "goaicorp":
+            self._goaicorp_pipelines: dict[str, object] = {}
+            logger.info("ASR: stack=goaicorp (CC-BY-NC 4.0, GO AI Corporation)")
+            return
 
         if self.backend == "hf_api":
             self._client = InferenceClient(model=HF_API_MODEL_NAME, token=settings.HF_TOKEN)
@@ -137,7 +164,38 @@ class ASR:
         )
         return result[0].strip()
 
+    def _get_goaicorp_pipeline(self, lang: str) -> object:
+        """Charge et met en cache le pipeline ASR GO AI pour la langue donnee.
+
+        pipeline("automatic-speech-recognition") est agnostique de
+        l'architecture : fonctionne pour Whisper, Wav2Vec2, Conformer, etc.
+        Le HF_TOKEN est necessaire pour les repos gated.
+        """
+        if lang not in self._goaicorp_pipelines:
+            repo_id = GOAICORP_ASR_MODEL_NAMES.get(lang)
+            if repo_id is None:
+                raise ValueError(f"Langue non supportee par la stack goaicorp ASR: {lang}")
+            from transformers import pipeline as hf_pipeline
+            logger.info("Chargement pipeline GO AI ASR %s (lang=%s)...", repo_id, lang)
+            device = 0 if torch.cuda.is_available() else -1
+            self._goaicorp_pipelines[lang] = hf_pipeline(
+                "automatic-speech-recognition",
+                model=repo_id,
+                token=self._hf_token,
+                device=device,
+            )
+            logger.info("Pipeline GO AI ASR %s charge.", repo_id)
+        return self._goaicorp_pipelines[lang]
+
+    def _transcribe_goaicorp(self, audio_path: str, lang: str) -> str:
+        pipe = self._get_goaicorp_pipeline(lang)
+        result = pipe(audio_path, return_timestamps=False)
+        return result["text"].strip() if isinstance(result, dict) else str(result).strip()
+
     def transcribe(self, audio_path: str, lang: str) -> str:
+        if self._stack == "goaicorp":
+            return self._transcribe_goaicorp(audio_path, lang)
+
         if self.backend == "hf_api":
             return self._transcribe_hf_api(audio_path, lang)
 

app/services/translator.py

@@ -1,10 +1,24 @@
+import logging
 import re
 
 import torch
 from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
 
+from app.deps import get_settings
+
+logger = logging.getLogger("model-service.translator")
+
+# Stack "old" : un seul modele NLLB-3.3B couvrant dyu ET mos.
 MODEL_NAME = "facebook/nllb-200-3.3B"
 
+# Stack "goaicorp" : deux modeles specialises CC-BY-NC 4.0
+# (Wendpanga Aristide Bandaogo, aristide@goaicorporation.org)
+# Architecture M2M100ForConditionalGeneration = NLLB, memes codes de langue.
+GOAICORP_MODEL_NAMES = {
+    "mos": "goaicorp/mos-translation",
+    "dyu": "goaicorp/dyu-translation",
+}
+
 NLLB_LANG_CODES = {
     "fr": "fra_Latn",
     "dyu": "dyu_Latn",
@@ -18,10 +32,29 @@ class Translator:
     _instance = None
 
     def __init__(self) -> None:
+        settings = get_settings()
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.nllb_tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-        self.nllb_model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME).to(self.device)
-        self.nllb_model.eval()
+        self._stack = settings.MODEL_STACK
+        self._hf_token = settings.HF_TOKEN
+
+        if self._stack == "goaicorp":
+            # Chargement paresseux par langue (voir _get_goaicorp_model) :
+            # on n'alloue pas la RAM pour les deux modeles si une seule
+            # direction est utilisee, et on ne bloque pas le demarrage du
+            # Space sur le premier modele si le second est encore en cours
+            # de telechargement.
+            self._goaicorp_models: dict[str, AutoModelForSeq2SeqLM] = {}
+            self._goaicorp_tokenizers: dict[str, AutoTokenizer] = {}
+            logger.info("Translator: stack=goaicorp (CC-BY-NC 4.0, GO AI Corporation)")
+        else:
+            self.nllb_tokenizer = AutoTokenizer.from_pretrained(
+                MODEL_NAME, token=self._hf_token
+            )
+            self.nllb_model = AutoModelForSeq2SeqLM.from_pretrained(
+                MODEL_NAME, token=self._hf_token
+            ).to(self.device)
+            self.nllb_model.eval()
+            logger.info("Translator: stack=old (facebook/nllb-200-3.3B)")
 
     @classmethod
     def get_instance(cls) -> "Translator":
@@ -29,29 +62,92 @@ class Translator:
             cls._instance = cls()
         return cls._instance
 
+    # ------------------------------------------------------------------
+    # Interne : chargement paresseux des modeles GO AI
+    # ------------------------------------------------------------------
+
+    def _get_goaicorp_model(
+        self, lang: str
+    ) -> tuple[AutoModelForSeq2SeqLM, AutoTokenizer]:
+        """Charge et met en cache le modele GO AI pour la langue donnee.
+
+        Les deux modeles (mos / dyu) ont la meme architecture NLLB/M2M100.
+        Le token HF est necessaire pour les repos gated -- il doit etre
+        configure dans les secrets du Space HF (variable HF_TOKEN).
+        """
+        if lang not in GOAICORP_MODEL_NAMES:
+            raise ValueError(f"Langue non supportee par la stack goaicorp: {lang}")
+        if lang not in self._goaicorp_models:
+            repo_id = GOAICORP_MODEL_NAMES[lang]
+            logger.info("Chargement du modele GO AI %s...", repo_id)
+            tok = AutoTokenizer.from_pretrained(repo_id, token=self._hf_token)
+            model = AutoModelForSeq2SeqLM.from_pretrained(
+                repo_id, token=self._hf_token
+            ).to(self.device)
+            model.eval()
+            self._goaicorp_tokenizers[lang] = tok
+            self._goaicorp_models[lang] = model
+            logger.info("Modele GO AI %s charge.", repo_id)
+        return self._goaicorp_models[lang], self._goaicorp_tokenizers[lang]
+
+    # ------------------------------------------------------------------
+    # Traduction
+    # ------------------------------------------------------------------
+
     def _split_sentences(self, text: str) -> list[str]:
         sentences = [s.strip() for s in _SENTENCE_SPLIT_RE.split(text.strip()) if s.strip()]
         return sentences or [text.strip()]
 
-    def _translate_batch(self, sentences: list[str], src: str, tgt: str) -> list[str]:
-        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])
+    def _translate_batch_nllb(
+        self,
+        sentences: list[str],
+        src: str,
+        tgt: str,
+        tokenizer: AutoTokenizer,
+        model: AutoModelForSeq2SeqLM,
+    ) -> list[str]:
+        tokenizer.src_lang = NLLB_LANG_CODES[src]
+        inputs = tokenizer(sentences, return_tensors="pt", padding=True).to(self.device)
+        forced_bos_token_id = tokenizer.convert_tokens_to_ids(NLLB_LANG_CODES[tgt])
         with torch.no_grad():
-            generated = self.nllb_model.generate(
+            generated = model.generate(
                 **inputs,
                 forced_bos_token_id=forced_bos_token_id,
                 num_beams=4,
                 max_length=256,
             )
-        return self.nllb_tokenizer.batch_decode(generated, skip_special_tokens=True)
+        return tokenizer.batch_decode(generated, skip_special_tokens=True)
 
     def translate(self, text: str, src: str, tgt: str) -> str:
         if src not in ["fr", "dyu", "mos"] or tgt not in ["fr", "dyu", "mos"]:
             raise ValueError(f"Langue non supportee: src={src}, tgt={tgt}")
 
         sentences = self._split_sentences(text)
-        translated = self._translate_batch(sentences, src, tgt)
+
+        if self._stack == "goaicorp":
+            # Les modeles GO AI sont par paire (mos-translation, dyu-translation).
+            # Pour fr->mos on utilise le modele mos ; pour fr->dyu le modele dyu ;
+            # pour mos->dyu ou dyu->mos on passe par le français comme pivot :
+            # mos->fr avec mos-translation, puis fr->dyu avec dyu-translation.
+            if src == "fr":
+                # Traduction directe fr -> langue locale
+                model, tok = self._get_goaicorp_model(tgt)
+                translated = self._translate_batch_nllb(sentences, src, tgt, tok, model)
+            elif tgt == "fr":
+                # Traduction directe langue locale -> fr
+                model, tok = self._get_goaicorp_model(src)
+                translated = self._translate_batch_nllb(sentences, src, tgt, tok, model)
+            else:
+                # Pivot fr : src->fr puis fr->tgt
+                src_model, src_tok = self._get_goaicorp_model(src)
+                fr_sentences = self._translate_batch_nllb(sentences, src, "fr", src_tok, src_model)
+                tgt_model, tgt_tok = self._get_goaicorp_model(tgt)
+                translated = self._translate_batch_nllb(fr_sentences, "fr", tgt, tgt_tok, tgt_model)
+        else:
+            translated = self._translate_batch_nllb(
+                sentences, src, tgt, self.nllb_tokenizer, self.nllb_model
+            )
+
         return " ".join(translated)
 
 

app/services/tts.py

@@ -1,5 +1,13 @@
 """Synthese vocale (text-to-speech) pour le Dioula et le Moore via les modeles
-VITS facebook/mms-tts-dyu et facebook/mms-tts-mos."""
+VITS facebook/mms-tts-dyu et facebook/mms-tts-mos.
+
+Quand Settings.MODEL_STACK == "goaicorp", le TTS Mooré utilise
+goaicorp/mos-tts (CC-BY-NC 4.0, GO AI Corporation) à la place de
+facebook/mms-tts-mos. L'architecture est identique (VITS/MMS-TTS) : le
+code de synthese est donc entierement reutilise, seul le repo_id change.
+
+LE TTS DIOULA NE CHANGE PAS : GO AI n'a pas de modele TTS pour le dioula.
+facebook/mms-tts-dyu est utilise dans les deux stacks."""
 
 import io
 import logging
@@ -20,6 +28,13 @@ MMS_TTS_MODEL_NAMES = {
     "mos": "facebook/mms-tts-mos",
 }
 
+# Stack GO AI pour le TTS Mooré uniquement (CC-BY-NC 4.0).
+# Le dioula utilise TOUJOURS facebook/mms-tts-dyu (pas de modele GO AI dyu).
+GOAICORP_TTS_MODEL_NAMES = {
+    "mos": "goaicorp/mos-tts",
+    "dyu": "facebook/mms-tts-dyu",  # inchangé : GO AI n'a pas de modèle dyu TTS
+}
+
 MAX_CHARS_BEFORE_SPLIT = 500
 SILENCE_SECONDS = 0.3
 MIN_SEGMENT_LETTERS = 4
@@ -65,6 +80,19 @@ class TTS:
         self._tokenizers: dict[str, VitsTokenizer] = {}
         self._allowed_chars: dict[str, set[str]] = {}
         self._omnivoice_model = None
+        # MODEL_STACK determine quel repo_id utiliser pour le TTS Mooré.
+        # Le TTS dioula est toujours sur facebook/mms-tts-dyu (GO AI n'a
+        # pas de modele dyu TTS).
+        from app.deps import get_settings as _gs
+        _s = _gs()
+        self._tts_model_names = (
+            GOAICORP_TTS_MODEL_NAMES if _s.MODEL_STACK == "goaicorp"
+            else MMS_TTS_MODEL_NAMES
+        )
+        if _s.MODEL_STACK == "goaicorp":
+            logger.info("TTS: stack=goaicorp pour Mooré (goaicorp/mos-tts, CC-BY-NC 4.0) ; "
+                        "Dioula inchangé (facebook/mms-tts-dyu)")
+        self._hf_token = _s.HF_TOKEN
 
     @classmethod
     def get_instance(cls) -> "TTS":
@@ -73,12 +101,16 @@ class TTS:
         return cls._instance
 
     def _get_model(self, lang: str) -> tuple[VitsModel, VitsTokenizer]:
-        if lang not in MMS_TTS_MODEL_NAMES:
+        if lang not in self._tts_model_names:
             raise ValueError(f"Langue non supportee: {lang}")
         if lang not in self._models:
-            model_name = MMS_TTS_MODEL_NAMES[lang]
-            self._tokenizers[lang] = VitsTokenizer.from_pretrained(model_name)
-            model = VitsModel.from_pretrained(model_name).to(self.device)
+            model_name = self._tts_model_names[lang]
+            self._tokenizers[lang] = VitsTokenizer.from_pretrained(
+                model_name, token=self._hf_token
+            )
+            model = VitsModel.from_pretrained(
+                model_name, token=self._hf_token
+            ).to(self.device)
             model.eval()
             self._models[lang] = model
         return self._models[lang], self._tokenizers[lang]