Update app.py

app.py

@@ -7,19 +7,19 @@ import numpy as np
 from contextlib import asynccontextmanager
 
 # --- CONFIGURATION ---
-# Utilisation de la V2 (Meilleure sur voix réelles/CommonVoice)
+# On garde uniquement la V2 car elle est meilleure sur les voix réelles
 MODEL_ID = "Cnam-LMSSC/wav2vec2-french-phonemizer-v2"
 
 ai_context = {}
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    print(f"🚀 Chargement du modèle {MODEL_ID}...")
+    print(f"🚀 Chargement du modèle stable {MODEL_ID}...")
     try:
         # Chargement du processeur et du modèle
         processor = Wav2Vec2Processor.from_pretrained(MODEL_ID)
         model = Wav2Vec2ForCTC.from_pretrained(MODEL_ID)
-        model.eval() # Mode lecture seule (plus rapide)
+        model.eval() # Mode lecture seule
         
         ai_context["processor"] = processor
         ai_context["model"] = model
@@ -27,9 +27,9 @@ async def lifespan(app: FastAPI):
         # On stocke le vocabulaire pour le masque
         ai_context["vocab"] = processor.tokenizer.get_vocab()
         
-        print("✅ Modèle chargé, VAD actif et vocabulaire indexé.")
+        print("✅ Modèle V2 chargé et prêt.")
     except Exception as e:
-        print(f"❌ Erreur critique au chargement : {e}")
+        print(f"❌ Erreur critique : {e}")
     yield
     ai_context.clear()
 
@@ -37,7 +37,7 @@ app = FastAPI(lifespan=lifespan)
 
 @app.get("/")
 def home():
-    return {"status": "API V2 running", "model": MODEL_ID}
+    return {"status": "API V2 Stable running", "model": MODEL_ID}
 
 @app.post("/transcribe")
 async def transcribe(
@@ -47,67 +47,50 @@ async def transcribe(
     if "model" not in ai_context:
         raise HTTPException(status_code=500, detail="Modèle non chargé")
 
-    # 1. Lecture Audio
+    # 1. Lecture Audio (Simple et robuste)
     try:
         content = await file.read()
+        # On lit juste le fichier, sans essayer de couper les silences (risque de bugs)
         audio_array, _ = librosa.load(io.BytesIO(content), sr=16000)
     except Exception as e:
-        raise HTTPException(status_code=400, detail=f"Erreur lecture audio: {str(e)}")
+        raise HTTPException(status_code=400, detail=f"Erreur audio: {str(e)}")
 
-    # 2. NETTOYAGE AUDIO (VAD / Trimming)
-    # On coupe le silence au début et à la fin.
-    # top_db=20 signifie qu'on coupe tout ce qui est 20dB sous le pic sonore (bruit de fond).
-    audio_trimmed, _ = librosa.effects.trim(audio_array, top_db=20)
-
-    # Sécurité : Si l'audio est vide après nettoyage (que du silence), on renvoie vide
-    if len(audio_trimmed) < 1000: # moins de 0.06 seconde
-        return {"ipa": "", "confidence": 0.0, "status": "empty_audio"}
-
-    # 3. Préparation Modèle
+    # 2. Préparation Modèle
     processor = ai_context["processor"]
     model = ai_context["model"]
     
-    inputs = processor(audio_trimmed, sampling_rate=16000, return_tensors="pt", padding=True)
+    inputs = processor(audio_array, sampling_rate=16000, return_tensors="pt", padding=True)
 
-    # 4. Calcul des Logits
+    # 3. Calcul des Logits
     with torch.no_grad():
         logits = model(inputs.input_values).logits
 
-    # --- 5. APPLICATION DU MASQUE BINAIRE ---
+    # --- 4. APPLICATION DU MASQUE BINAIRE ---
     
     requested_phones = [p.strip() for p in allowed_phones.split(',') if p.strip()]
     
     if requested_phones:
         vocab = ai_context["vocab"]
-        # Tokens techniques pour le modèle Cnam
+        # Tokens techniques indispensables
         technical_tokens = ["<pad>", "<s>", "</s>", "<unk>", "|", "[PAD]", "[UNK]"]
         full_allowed_set = set(requested_phones + technical_tokens)
         
+        # Mapping vers les ID du modèle
         allowed_indices = [vocab[t] for t in full_allowed_set if t in vocab]
         
         if allowed_indices:
-            # Masque d'interdiction totale (-Infini)
+            # On interdit tout (-Infini)
             mask = torch.full((logits.shape[-1],), float('-inf'))
-            # Ouverture des phonèmes autorisés
+            # On autorise la liste blanche (0.0)
             mask[allowed_indices] = 0.0
             # Application
             logits = logits + mask
 
-    # 6. CALCUL DU SCORE DE CONFIANCE
-    # On transforme les logits en probabilités (0% à 100%)
-    probs = torch.nn.functional.softmax(logits, dim=-1)
-    
-    # On prend la probabilité la plus haute pour chaque instant (frame)
-    max_probs, predicted_ids = torch.max(probs, dim=-1)
-    
-    # Le score de confiance est la moyenne de certitude sur toute la séquence
-    confidence_score = float(torch.mean(max_probs))
-
-    # 7. Décodage
+    # 5. Décodage (Le gagnant prend tout)
+    predicted_ids = torch.argmax(logits, dim=-1)
     transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
     
     return {
         "ipa": transcription,
-        "confidence": confidence_score, # ex: 0.95
         "allowed_used": allowed_phones
     }