Update app.py

app.py

@@ -177,10 +177,12 @@ def synthesize_speech(text):
         print(f"Speech synthesis error: {str(e)}")
         return None
 
-# Fonction prédiction
+# ... (keep all previous imports and class definitions)
+
+# Updated predict_speaker function to return consistent values
 def predict_speaker(audio, model, processor):
     if audio is None:
-        return "Aucun audio détecté.", None, None
+        return "Aucun audio détecté.", {}, "Aucun texte reconnu", "Inconnu"  # Now returns 4 values
     
     try:
         audio_data, sr = sf.read(audio)
@@ -191,7 +193,7 @@ def predict_speaker(audio, model, processor):
         
         with torch.no_grad():
             output = model(input_tensor)
-            print(output)
+            print(output)  # Debug output
             probabilities = F.softmax(output, dim=1)
             confidence, predicted_class = torch.max(probabilities, 1)
         
@@ -203,28 +205,45 @@ def predict_speaker(audio, model, processor):
         probs_dict = {speakers[i]: float(probs) for i, probs in enumerate(probabilities[0].cpu().numpy())}
         
         # Recognize speech
-        recognized_text = recognize_speech(audio)
+        recognized_text = recognize_speech(audio) if speech_recognizer else "Modèle de reconnaissance vocale non disponible"
         
-        return result, probs_dict, recognized_text,predicted_speaker
+        return result, probs_dict, recognized_text, predicted_speaker  # Now returns 4 values
     
     except Exception as e:
-        return f"Erreur : {str(e)}", None, None
+        return f"Erreur : {str(e)}", {}, "Erreur de reconnaissance", "Inconnu"
 
-# Charger modèle
-def load_model(model_id="nareauow/my_speech_recognition", model_filename="model_3.pth"):
-    try:
-        model_path = hf_hub_download(repo_id=model_id, filename=model_filename)
-        model = modele_CNN(num_classes=7, dropout=0.)
-        model.load_state_dict(torch.load(model_path, map_location=device))
-        model.to(device)
-        model.eval()
-        print("Modèle chargé avec succès !")
-        return model
-    except Exception as e:
-        print(f"Erreur de chargement: {e}")
-        return None
+# Updated recognize function
+def recognize(audio, selected_model):
+    model = load_model(model_filename=selected_model)
+    if model is None:
+        return "Erreur: Modèle non chargé", None, "Erreur", None
+    
+    res, probs, text, speaker = predict_speaker(audio, model, processor)  # Now expects 4 values
+    
+    # Generate plot
+    fig = None
+    if probs:
+        fig, ax = plt.subplots(figsize=(10, 6))
+        ax.bar(probs.keys(), probs.values(), color='skyblue')
+        ax.set_ylim([0, 1])
+        ax.set_ylabel("Confiance")
+        ax.set_xlabel("Locuteurs")
+        ax.set_title("Probabilités de reconnaissance")
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+    
+    # Generate speech synthesis if text was recognized
+    synth_audio = None
+    if synthesizer is not None and text and "erreur" not in text.lower():
+        try:
+            synth_text = f"Le locuteur {speaker} a dit : {text}" if speaker else f"Le locuteur a dit : {text}"
+            synth_audio = synthesize_speech(synth_text)
+        except Exception as e:
+            print(f"Erreur de synthèse vocale: {e}")
+    
+    return res, fig, text, synth_audio if synth_audio else None
 
-# Gradio Interface
+# Updated interface creation
 def create_interface():
     processor = AudioProcessor()
     
@@ -239,49 +258,29 @@ def create_interface():
                     value="model_3.pth",
                     label="Choisissez le modèle"
                 )
-                audio_input = gr.Audio(sources=["microphone"], type="filepath", label="🎙️ Parlez ici")
+                
+                with gr.Tab("Microphone"):
+                    mic_input = gr.Audio(sources=["microphone"], type="filepath", label="🎙️ Enregistrer depuis le microphone")
+                
+                with gr.Tab("Upload Audio"):
+                    file_input = gr.Audio(sources=["upload"], type="filepath", label="📁 Télécharger un fichier audio")
+                
                 record_btn = gr.Button("Reconnaître")
+                
             with gr.Column():
                 result_text = gr.Textbox(label="Résultat")
                 plot_output = gr.Plot(label="Confiance par locuteur")
                 recognized_text = gr.Textbox(label="Texte reconnu")
-                audio_output = gr.Audio(label="Synthèse vocale", type="numpy")
-        
-        def recognize(audio, selected_model):
-            model = load_model(model_filename=selected_model)
-            res, probs, text,locuteur = predict_speaker(audio, model, processor)
-            
-            # Generate plot
-            fig = None
-            if probs:
-                fig, ax = plt.subplots()
-                ax.bar(probs.keys(), probs.values(), color='skyblue')
-                ax.set_ylim([0, 1])
-                ax.set_ylabel("Confiance")
-                ax.set_xlabel("Locuteurs")
-                plt.xticks(rotation=45)
-            
-            # Generate speech synthesis if text was recognized
-            synth_audio = None
-            if text and "error" not in text.lower():
-                synth_text = f"{locuteur} said  : {text}"
-                synth_audio = synthesize_speech(synth_text)
-            
-            return res, fig, text, synth_audio
-        
-        record_btn.click(fn=recognize, 
-                        inputs=[audio_input, model_selector], 
-                        outputs=[result_text, plot_output, recognized_text, audio_output])
+                audio_output = gr.Audio(label="Synthèse vocale", visible=False)
         
-        gr.Markdown("""### Comment utiliser ?
-        - Choisissez le modèle.
-        - Cliquez sur 🎙️ pour enregistrer votre voix.
-        - Cliquez sur **Reconnaître** pour obtenir la prédiction.
-        """)
+        record_btn.click(
+            fn=recognize,
+            inputs=[gr.inputs.Union([mic_input, file_input]), model_selector],
+            outputs=[result_text, plot_output, recognized_text, audio_output]
+        )
     
     return interface
 
-# Lancer
 if __name__ == "__main__":
     app = create_interface()
-    app.launch()
+    app.launch(share=True)