new model

src/model/emotion_classifier.py

@@ -1,5 +1,4 @@
-import torch
-import torch.nn as nn
+
 
 # Prédit 33% environ partout (dans le cas 3 classes)
 
@@ -19,17 +18,37 @@ import torch.nn as nn
     
 
 
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Attention(nn.Module):
+    """Mécanisme d’attention permettant de pondérer l’importance des caractéristiques audio"""
+    def __init__(self, hidden_dim):
+        super(Attention, self).__init__()
+        self.attention_weights = nn.Linear(hidden_dim, 1)
+
+    def forward(self, lstm_output):
+        # lstm_output: (batch_size, sequence_length, hidden_dim)
+        attention_scores = self.attention_weights(lstm_output)  # (batch_size, sequence_length, 1)
+        attention_weights = torch.softmax(attention_scores, dim=1)  # Normalisation softmax
+        weighted_output = lstm_output * attention_weights  # Pondération des features
+        return weighted_output.sum(dim=1)  # Somme pondérée sur la séquence
+
 class EmotionClassifier(nn.Module):
-    def __init__(self, feature_dim, num_labels=3):
+    """Modèle de classification des émotions basé sur BiLSTM et attention"""
+    def __init__(self, feature_dim, num_labels, hidden_dim=128):
         super(EmotionClassifier, self).__init__()
-        self.fc = nn.Linear(feature_dim, num_labels)
-        self.dropout = nn.Dropout(0.3)  # Evite l'overfitting
+        self.lstm = nn.LSTM(feature_dim, hidden_dim, batch_first=True, bidirectional=True)
+        self.attention = Attention(hidden_dim * 2)  # Bidirectionnel → hidden_dim * 2
+        self.fc = nn.Linear(hidden_dim * 2, num_labels)  # Couche de classification finale
 
     def forward(self, x):
-        pooled_output = torch.mean(x, dim=1)  # Moyenne des features audio
-        pooled_output = self.dropout(pooled_output)  # Dropout avant classification
-        logits = self.fc(pooled_output)
-        return logits  
+        lstm_out, _ = self.lstm(x)  # (batch_size, sequence_length, hidden_dim*2)
+        attention_out = self.attention(lstm_out)  # (batch_size, hidden_dim*2)
+        logits = self.fc(attention_out)  # (batch_size, num_labels)
+        return logits
+
 
 
 

src/model/feature_extractor.py

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

src/predict.py

@@ -4,8 +4,8 @@ import torch
 import librosa
 import numpy as np
 from model.emotion_classifier import EmotionClassifier
-from utils.preprocessing import collate_fn
-from config import DEVICE, NUM_LABELS, BEST_MODEL_NAME
+from src.utils.preprocessing import collate_fn
+from src.config import DEVICE, NUM_LABELS, BEST_MODEL_NAME
 
 # Charger le modèle entraîné
 feature_dim = 40  # Nombre de MFCCs utilisés

src/test_speech.py

@@ -1,49 +0,0 @@
-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,88 +0,0 @@
-import torch
-import torchaudio
-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 = {"file_path": [], "label": []}
-    labels = ["colere", "joie", "neutre"]  # Ajuste selon tes classes
-
-    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  # ✅ Correction de l'erreur
-    )
-    return inputs["input_values"][0]  # Récupère les valeurs audio prétraitées
-
-# 🔹 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)
-
-def preprocess_batch(batch):
-    batch["input_values"] = preprocess_audio(batch["file_path"])
-    return batch
-
-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/dataset.py

@@ -1,13 +1,8 @@
 import os
 from datasets import Dataset
-from config import LABELS
+from src.config import LABELS
 import pandas as pd
 
-import os
-from datasets import Dataset, DatasetDict
-import pandas as pd
-from src.config import LABELS  
-
 def load_audio_data(data_dir):
     data = []
     for label_name, label_id in LABELS.items():

src/utils/preprocessing.py

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