predict file rebased

.gitignore

@@ -183,4 +183,4 @@ data/*
 
 # Mac
 .DS_Store
-*.pth
+.idea

requirements.txt

@@ -15,4 +15,5 @@ scikit-learn
 huggingface
 huggingface_hub
 pyaudio
-streamlit_audiorec
+streamlit_audiorec
+dotenv

src/model/predict.py

@@ -1,56 +0,0 @@
-import os
-import torch
-from transformers import Wav2Vec2Processor
-from src.model.emotion_classifier import Wav2Vec2EmotionClassifier
-import librosa
-import streamlit as st
-
-if "model_loaded" not in st.session_state:
-    st.session_state.model_loaded = None
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-# Charger le modèle et le processeur
-if st.session_state.model_loaded is None:
-    st.session_state.processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-large-xlsr-53-french")
-    st.session_state.model = Wav2Vec2EmotionClassifier()
-    st.session_state.model.load_state_dict(torch.load(os.path.join("src","model","wav2vec2_emotion.pth"), map_location=torch.device('cpu')), strict=False)
-    st.session_state.model_loaded = True
-
-if st.session_state.model_loaded:
-    processor = st.session_state.processor
-    model = st.session_state.model
-    model.to(device)
-    model.eval()
-
-emotion_labels = ["joie", "colère", "neutre"]
-
-def predict_emotion(audio_path, output_probs=False, sampling_rate=16000):
-    # waveform, _ = librosa.load(audio_path, sr=sampling_rate)
-    input_values = processor(audio_path, return_tensors="pt", sampling_rate=sampling_rate).input_values
-    input_values = input_values.to(device)
-    
-    with torch.no_grad():
-        outputs = model(input_values)
-    
-    if output_probs:        
-        # Appliquer softmax pour obtenir des probabilités
-        probabilities = torch.nn.functional.softmax(outputs, dim=-1)
-        
-        # Convertir en numpy array et prendre le premier (et seul) élément
-        probabilities = probabilities[0].detach().cpu().numpy()
-        
-        # Créer un dictionnaire associant chaque émotion à sa probabilité
-        emotion_probabilities = {emotion: prob for emotion, prob in zip(emotion_labels, probabilities)}
-        # emotion_probabilities = {"emotions": [emotion for emotion in emotion_labels],
-        #                          "probabilities": [prob for prob in probabilities]}
-        return emotion_probabilities
-    else:
-        # Obtenir l'émotion la plus probable (i.e. la prédiction)
-        predicted_label = torch.argmax(outputs, dim=1).item()
-        return emotion_labels[predicted_label]
-
-
-# Exemple d'utilisation
-# audio_test = "data/n1ac.wav"
-# emotion = predict_emotion(audio_test)
-# print(f"Émotion détectée : {emotion}")

src/predict.py

@@ -0,0 +1,47 @@
+import torch
+import torchaudio
+import soundfile as sf
+import numpy as np
+from model.emotion_classifier import EmotionClassifier
+from model.feature_extrator import feature_extractor, processor
+from utils.preprocessing import resampler
+from config import DEVICE, LABELS
+import os
+
+
+# Charger le modèle sauvegardé
+classifier = EmotionClassifier(feature_extractor.config.hidden_size, len(LABELS)).to(DEVICE)
+classifier.load_state_dict(torch.load(os.path.join("best_emotion_model.pth"), map_location=torch.device(DEVICE)))
+classifier.eval()
+
+
+# Fonction de prédiction
+def predict_emotion(audio_path):
+    # Charger l'audio
+    speech, sample_rate = sf.read(audio_path, dtype="float32")
+
+    # Rééchantillonnage si nécessaire
+    if sample_rate != 16000:
+        speech = torch.tensor(speech).unsqueeze(0)
+        speech = resampler(speech).squeeze(0).numpy()
+
+    # Extraire les features
+    inputs = processor(speech, sampling_rate=16000, return_tensors="pt", padding=True)
+    input_values = inputs.input_values.to(DEVICE)
+
+    with torch.no_grad():
+        features = feature_extractor(input_values).last_hidden_state.mean(dim=1)
+        logits = classifier(features)
+
+    # Obtenir la prédiction
+    predicted_label = torch.argmax(logits, dim=-1).item()
+    emotion = list(LABELS.keys())[predicted_label]
+
+    return emotion
+
+# Exemple d'utilisation
+if __name__ == "__main__":
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "data"))
+    audio_file = os.path.join(base_path, "colere", "c1ac.wav")
+    emotion = predict_emotion(audio_file)
+    print(f"🎤 L'émotion prédite est : {emotion}")

views/application.py

@@ -6,7 +6,7 @@ import os
 import matplotlib.pyplot as plt
 import librosa
 from src.model.transcriber import transcribe_audio
-from src.model.predict import predict_emotion
+from predict import predict_emotion
 
 
 DIRECTORY = "audios"

views/real_time.py

@@ -10,7 +10,7 @@ from transformers import Wav2Vec2ForSequenceClassification, Wav2Vec2Processor
 import matplotlib.pyplot as plt
 import numpy as np
 import time
-from src.model.predict import predict_emotion
+from predict import predict_emotion
 
 # Charger le modèle Wav2Vec2 pour la classification des émotions
 model_name = "superb/wav2vec2-base-superb-er"  # Exemple de modèle pour la reconnaissance des émotions