proba par classes

.gitignore

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

src/model/feature_extractor.py

@@ -1,6 +1,6 @@
 import torch
 from transformers import Wav2Vec2Model, Wav2Vec2Processor
-from src.config import MODEL_NAME, DEVICE
+from config import MODEL_NAME, DEVICE
 
 processor = Wav2Vec2Processor.from_pretrained(MODEL_NAME)
 feature_extractor = Wav2Vec2Model.from_pretrained(MODEL_NAME).to(DEVICE)

src/predict.py

@@ -3,10 +3,9 @@ import os
 import torch
 import librosa
 import numpy as np
-from src.model.emotion_classifier import EmotionClassifier
-from src.utils.preprocessing import collate_fn
-from src.config import DEVICE, NUM_LABELS, BEST_MODEL_NAME
-import os
+from model.emotion_classifier import EmotionClassifier
+from utils.preprocessing import collate_fn
+from config import DEVICE, NUM_LABELS, BEST_MODEL_NAME
 
 # Charger le modèle entraîné
 feature_dim = 40  # Nombre de MFCCs utilisés
@@ -14,7 +13,10 @@ model = EmotionClassifier(feature_dim, NUM_LABELS).to(DEVICE)
 model.load_state_dict(torch.load(BEST_MODEL_NAME, map_location=DEVICE))
 model.eval()  # Mode évaluation
 
-# Fonction pour prédire l’émotion d’un fichier audio
+# Labels des émotions
+LABELS = {0: "colère", 1: "neutre", 2: "joie"}
+
+# Fonction pour prédire l’émotion d’un fichier audio avec probabilités
 def predict_emotion(audio_path, max_length=128):
     # Charger l’audio
     y, sr = librosa.load(audio_path, sr=16000)
@@ -35,17 +37,21 @@ def predict_emotion(audio_path, max_length=128):
     # Prédiction avec le modèle
     with torch.no_grad():
         logits = model(input_tensor)
+        probabilities = torch.nn.functional.softmax(logits, dim=-1).cpu().numpy().flatten()  # Convertir en probabilités
         predicted_class = torch.argmax(logits, dim=-1).item()
 
-    # Définition des labels
-    LABELS = {0: "colère", 1: "neutre", 2: "joie"}
-    return LABELS[predicted_class]
+    # Associer les probabilités aux labels
+    probabilities_dict = {LABELS[i]: float(probabilities[i]) for i in range(NUM_LABELS)}
+
+    return LABELS[predicted_class], probabilities_dict
 
-    
 
-#Exemple d'utilisation
+# 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}")
+
+    predicted_emotion, probabilities = predict_emotion(audio_file)
+
+    print(f"🎤 L'émotion prédite est : {predicted_emotion}")
+    print(f"📊 Probabilités par classe : {probabilities}")

src/test_speech.py

@@ -0,0 +1,49 @@
+import torch
+import torchaudio
+from transformers import Wav2Vec2Processor, Wav2Vec2ForSequenceClassification
+import os
+
+# 🔹 Paramètres
+MODEL_NAME = "./wav2vec2_emotion"  # Chemin du modèle sauvegardé
+LABELS = ["colere", "joie", "neutre"]  # Les classes
+
+# 🔹 Charger le processeur et le modèle
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+processor = Wav2Vec2Processor.from_pretrained(MODEL_NAME)
+model = Wav2Vec2ForSequenceClassification.from_pretrained(MODEL_NAME).to(device)
+model.eval()  # Mode évaluation
+
+
+def predict_emotion(audio_path):
+    # Charger l'audio
+    waveform, sample_rate = torchaudio.load(audio_path)
+
+    # Prétraitement du son
+    inputs = processor(
+        waveform.squeeze().numpy(),
+        sampling_rate=sample_rate,
+        return_tensors="pt",
+        padding=True,
+        truncation=True,
+        max_length=32000  # Ajuste selon la durée de tes fichiers
+    )
+
+    # Envoyer les données sur le bon device (CPU ou GPU)
+    input_values = inputs["input_values"].to(device)
+
+    # Prédiction
+    with torch.no_grad():
+        logits = model(input_values).logits
+
+    # Trouver l'émotion prédite
+    predicted_class = torch.argmax(logits, dim=-1).item()
+
+    return LABELS[predicted_class]  # Retourne le label correspondant
+
+base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "data"))
+audio_file = os.path.join(base_path, "colere", "c1ac.wav")
+predicted_emotion = predict_emotion(audio_file)
+print(f"🎙️ Émotion prédite : {predicted_emotion}")
+
+
+

src/train_speech.py

@@ -1,169 +1,88 @@
-import os
 import torch
-import torch.nn as nn
-import torch.optim as optim
-import soundfile as sf  
 import torchaudio
-import numpy as np
-from datasets import Dataset
-from transformers import Wav2Vec2Model, Wav2Vec2Processor
-from dotenv import load_dotenv
-from sklearn.metrics import accuracy_score
-
-# Charger .env pour Hugging Face API Key
-load_dotenv()
-HF_API_KEY = os.getenv("HF_API_KEY")
-
-if not HF_API_KEY:
-    raise ValueError("Le token Hugging Face n'a pas été trouvé dans .env")
-
-# Définition des labels pour la classification des émotions
-LABELS = {"colere": 0, "neutre": 1, "joie": 2}
-NUM_LABELS = len(LABELS)
-
-# Charger le processeur et le modèle pour l'extraction de features
-model_name = "facebook/wav2vec2-large-xlsr-53-french"
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-processor = Wav2Vec2Processor.from_pretrained(model_name)
-feature_extractor = Wav2Vec2Model.from_pretrained(model_name).to(device)
-
-# Resampleur pour convertir en 16 kHz
-resampler = torchaudio.transforms.Resample(orig_freq=48_000, new_freq=16_000)
-
-# Définition du classifieur amélioré
-class EmotionClassifier(nn.Module):
-    def __init__(self, feature_dim, num_labels):
-        super(EmotionClassifier, self).__init__()
-        self.fc1 = nn.Linear(feature_dim, 512)
-        self.relu = nn.ReLU()
-        self.dropout = nn.Dropout(0.3)
-        self.fc2 = nn.Linear(512, num_labels)
-
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.relu(x)
-        x = self.dropout(x)
-        return self.fc2(x)
-
-# Instancier le classifieur
-classifier = EmotionClassifier(feature_extractor.config.hidden_size, NUM_LABELS).to(device)
-
-# Charger les fichiers audio et leurs labels
+import os
+from datasets import Dataset, DatasetDict
+from transformers import Wav2Vec2Processor, Wav2Vec2ForSequenceClassification, TrainingArguments, Trainer
+
+# 🔹 Paramètres
+MODEL_NAME = "facebook/wav2vec2-large-xlsr-53-french"
+NUM_LABELS = 3  # Nombre de classes émotionnelles
+BATCH_SIZE = 8
+EPOCHS = 10
+LEARNING_RATE = 1e-4
+MAX_LENGTH = 32000  # Ajuste selon la durée de tes fichiers audio
+
+# 🔹 Vérifier GPU dispo
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# 🔹 Charger le processeur et le modèle
+processor = Wav2Vec2Processor.from_pretrained(MODEL_NAME)
+model = Wav2Vec2ForSequenceClassification.from_pretrained(
+    MODEL_NAME,
+    num_labels=NUM_LABELS,
+    problem_type="single_label_classification"
+).to(device)
+
+# 🔹 Fonction pour charger les fichiers audio sans CSV
 def load_audio_data(data_dir):
-    data = []
-    for label_name, label_id in LABELS.items():
-        label_dir = os.path.join(data_dir, label_name)
-        for file in os.listdir(label_dir):
-            if file.endswith(".wav"):
-                file_path = os.path.join(label_dir, file)
-                data.append({"path": file_path, "label": label_id})
-    return Dataset.from_list(data)
-
-# Chargement du dataset
-data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "data"))
-ds = load_audio_data(data_dir)
-
-# Charger les fichiers audio avec SoundFile et rééchantillonner à 16 kHz
-def preprocess_audio(batch):
-    speech, sample_rate = sf.read(batch["path"], dtype="float32")
-
-    if sample_rate != 16000:
-        speech = torch.tensor(speech).unsqueeze(0)
-        speech = resampler(speech).squeeze(0).numpy()
-    
-    batch["speech"] = speech.tolist()  # Convertir en liste pour éviter les erreurs de PyArrow
-    batch["sampling_rate"] = 16000
-    return batch
-
-
-ds = ds.map(preprocess_audio)
-
-# Vérifier la distribution des longueurs des fichiers audio
-lengths = [len(sample["speech"]) for sample in ds]
-max_length = int(np.percentile(lengths, 95))
+    data = {"file_path": [], "label": []}
+    labels = ["colere", "joie", "neutre"]  # Ajuste selon tes classes
 
-# Transformer l'audio en features utilisables par le modèle
-def prepare_features(batch):
-    features = processor(
-        batch["speech"], 
-        sampling_rate=16000,  
+    for label in labels:
+        folder_path = os.path.join(data_dir, label)
+        for file in os.listdir(folder_path):
+            if file.endswith(".wav"):
+                data["file_path"].append(os.path.join(folder_path, file))
+                data["label"].append(labels.index(label))
+
+    dataset = Dataset.from_dict(data)
+    train_test_split = dataset.train_test_split(test_size=0.2)  # 80% train, 20% test
+    return DatasetDict({"train": train_test_split["train"], "test": train_test_split["test"]})
+
+# 🔹 Prétraitement de l'audio
+def preprocess_audio(file_path):
+    waveform, sample_rate = torchaudio.load(file_path)
+    inputs = processor(
+        waveform.squeeze().numpy(),
+        sampling_rate=sample_rate,
+        return_tensors="pt",
         padding=True,
         truncation=True,
-        max_length=max_length,  
-        return_tensors="pt"
+        max_length=MAX_LENGTH  # ✅ Correction de l'erreur
     )
-    batch["input_values"] = features.input_values.squeeze(0)
-    batch["label"] = torch.tensor(batch["label"], dtype=torch.long)
-    return batch
-
-ds = ds.map(prepare_features)
-
-# Diviser les données en train et test
-ds = ds.train_test_split(test_size=0.2)
-train_ds = ds["train"]
-test_ds = ds["test"]
-
-# Fonction d'entraînement avec sauvegarde du meilleur modèle
-def train_classifier(feature_extractor, classifier, train_ds, test_ds, epochs=20, batch_size=8):
-    optimizer = optim.AdamW(classifier.parameters(), lr=2e-5, weight_decay=0.01)
-    loss_fn = nn.CrossEntropyLoss()
-
-    best_accuracy = 0.0  # Variable pour stocker la meilleure accuracy
-
-    for epoch in range(epochs):
-        classifier.train()
-        total_loss, correct = 0, 0
-        batch_count = 0
-
-        for i in range(0, len(train_ds), batch_size):
-            batch = train_ds[i: i + batch_size]
-            optimizer.zero_grad()
-
-            input_values = processor(
-                batch["speech"], 
-                sampling_rate=16000,  
-                return_tensors="pt", 
-                padding=True, 
-                truncation=True, 
-                max_length=max_length  
-            ).input_values.to(device)
-
-            with torch.no_grad():
-                features = feature_extractor(input_values).last_hidden_state.mean(dim=1)
-
-            logits = classifier(features)
-            labels = torch.tensor(batch["label"], dtype=torch.long, device=device)
+    return inputs["input_values"][0]  # Récupère les valeurs audio prétraitées
 
-            if labels.numel() == 0:
-                continue
-
-            loss = loss_fn(logits, labels)
-
-            loss.backward()
-            optimizer.step()
-
-            total_loss += loss.item()
-            correct += (logits.argmax(dim=-1) == labels).sum().item()
-            batch_count += 1
-
-        train_acc = correct / len(train_ds)
-
-        # Sauvegarde du modèle seulement si la précision s'améliore
-        if train_acc > best_accuracy:
-            best_accuracy = train_acc
-            torch.save({
-                "classifier_state_dict": classifier.state_dict(),
-                "feature_extractor_state_dict": feature_extractor.state_dict(),
-                "processor": processor
-            }, "acc_model.pth")
-            print(f"✅ Nouveau meilleur modèle sauvegardé ! Accuracy: {best_accuracy:.4f}")
-
-        print(f"Epoch {epoch+1}/{epochs} - Loss: {total_loss/batch_count:.4f} - Accuracy: {train_acc:.4f}")
-
-    return classifier
+# 🔹 Charger et prétraiter le dataset
+data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "data"))
+ds = load_audio_data(data_dir)
 
-# Entraînement
-trained_classifier = train_classifier(feature_extractor, classifier, train_ds, test_ds, epochs=20, batch_size=8)
+def preprocess_batch(batch):
+    batch["input_values"] = preprocess_audio(batch["file_path"])
+    return batch
 
-print("✅ Entraînement terminé, le meilleur modèle a été sauvegardé !")
+ds = ds.map(preprocess_batch, remove_columns=["file_path"])
+
+# 🔹 Définir les arguments d'entraînement
+training_args = TrainingArguments(
+    output_dir="./wav2vec2_emotion",
+    evaluation_strategy="epoch",
+    save_strategy="epoch",
+    learning_rate=LEARNING_RATE,
+    per_device_train_batch_size=BATCH_SIZE,
+    per_device_eval_batch_size=BATCH_SIZE,
+    num_train_epochs=EPOCHS,
+    save_total_limit=2,
+    logging_dir="./logs",
+    logging_steps=10,
+)
+
+# 🔹 Définir le trainer
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=ds["train"],
+    eval_dataset=ds["test"],
+)
+
+# 🚀 Lancer l'entraînement
+trainer.train()

src/utils/preprocessing.py

@@ -3,8 +3,8 @@ import soundfile as sf
 import torch
 import torchaudio
 import numpy as np
-from src.model.feature_extractor import processor  # type: ignore
-from src.config import DEVICE
+from model.feature_extractor import processor  # type: ignore
+from config import DEVICE
 
 # Resampler pour convertir en 16kHz
 resampler = torchaudio.transforms.Resample(orig_freq=48_000, new_freq=16_000)