base code

requirements.txt

@@ -1,3 +1,10 @@
-transformers 
-torch 
+transformers
+datasets
+torchaudio
+torch
 librosa
+soundfile
+numpy
+pandas
+matplotlib
+scikit-learn

src/model/emotion_classifier.py

@@ -0,0 +1,17 @@
+import torch
+import torch.nn as nn
+from transformers import Wav2Vec2Model
+
+class Wav2Vec2EmotionClassifier(nn.Module):
+
+    def __init__(self, model_name="facebook/wav2vec2-large-xlsr-53-french", num_labels=3):
+        super(Wav2Vec2EmotionClassifier, self).__init__()
+        self.wav2vec2 = Wav2Vec2Model.from_pretrained(model_name)
+        self.fc = nn.Linear(self.wav2vec2.config.hidden_size, num_labels)
+        self.softmax = nn.Softmax(dim=1)
+
+    def forward(self, input_values):
+        outputs = self.wav2vec2(input_values).last_hidden_state
+        pooled_output = torch.mean(outputs, dim=1)  
+        logits = self.fc(pooled_output)
+        return self.softmax(logits)

src/model/emotion_dataset.py

@@ -0,0 +1,22 @@
+import librosa
+import torch
+import pandas as pd
+from torch.utils.data import Dataset
+
+class EmotionDataset(Dataset):
+    def __init__(self, csv_file, processor):
+        self.data = pd.read_csv(csv_file)
+        self.processor = processor
+        self.emotion_labels = {"joie": 0, "colère": 1, "neutre": 2}
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        audio_path = self.data.iloc[idx, 0]
+        label = self.emotion_labels[self.data.iloc[idx, 1]]
+
+        waveform, _ = librosa.load(audio_path, sr=16000)
+        input_values = self.processor(waveform, return_tensors="pt", sampling_rate=16000).input_values
+
+        return input_values.squeeze(0), torch.tensor(label, dtype=torch.long)

src/model/predict.py

@@ -0,0 +1,30 @@
+import torch
+from transformers import Wav2Vec2Processor
+from model import Wav2Vec2EmotionClassifier
+import librosa
+
+# Charger le modèle et le processeur
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-large-xlsr-53")
+model = Wav2Vec2EmotionClassifier()
+model.load_state_dict(torch.load("wav2vec2_emotion.pth"))
+model.to(device)
+model.eval()
+
+emotion_labels = ["joie", "colère", "neutre"]
+
+def predict_emotion(audio_path):
+    waveform, _ = librosa.load(audio_path, sr=16000)
+    input_values = processor(waveform, return_tensors="pt", sampling_rate=16000).input_values
+    input_values = input_values.to(device)
+
+    with torch.no_grad():
+        outputs = model(input_values)
+    
+    predicted_label = torch.argmax(outputs, dim=1).item()
+    return emotion_labels[predicted_label]
+
+# Exemple d'utilisation
+audio_test = "data/audio1.wav"
+emotion = predict_emotion(audio_test)
+print(f"Émotion détectée : {emotion}")

src/model/test.py

@@ -1,51 +0,0 @@
-import torchaudio
-from datasets import load_dataset
-from evaluate import load as load_metric
-from transformers import (
-    Wav2Vec2ForCTC,
-    Wav2Vec2Processor,
-)
-import torch
-import re
-import sys
-
-model_name = "facebook/wav2vec2-large-xlsr-53-french"
-device = "cpu"
-
-chars_to_ignore_regex = '[\,\?\.\!\-\;\:\"]'  
-
-model = Wav2Vec2ForCTC.from_pretrained(model_name).to(device)
-processor = Wav2Vec2Processor.from_pretrained(model_name)
-
-ds = load_dataset("facebook/voxpopuli", "fr", trust_remote_code=True)
-
-resampler = torchaudio.transforms.Resample(orig_freq=48_000, new_freq=16_000)
-
-def map_to_array(batch):
-    speech, _ = torchaudio.load(batch["path"])
-    batch["speech"] = resampler.forward(speech.squeeze(0)).numpy()
-    batch["sampling_rate"] = resampler.new_freq
-    batch["sentence"] = re.sub(chars_to_ignore_regex, '', batch["sentence"]).lower().replace("’", "'")
-    return batch
-    
-ds = ds.map(map_to_array)
-
-def map_to_pred(batch):
-    features = processor(batch["speech"], sampling_rate=batch["sampling_rate"][0], padding=True, return_tensors="pt")
-    input_values = features.input_values.to(device)
-    attention_mask = features.attention_mask.to(device)
-    with torch.no_grad():
-        logits = model(input_values, attention_mask=attention_mask).logits
-    pred_ids = torch.argmax(logits, dim=-1)
-    batch["predicted"] = processor.batch_decode(pred_ids)
-    batch["target"] = batch["sentence"]
-    return batch
-    
-result = ds.map(map_to_pred, batched=True, batch_size=16, remove_columns=list(ds.features.keys()))
-
-wer = load_metric("wer")
-wer_score = wer.compute(predictions=result["predicted"], references=result["target"])
-print(f"WER: {wer_score}")
-
-
-# print(wer.compute(predictions=result["predicted"], references=result["target"]))

src/model/test_wav2vec.py

@@ -0,0 +1,62 @@
+from transformers import Wav2Vec2Processor, Wav2Vec2ForCTC
+import torch
+import librosa
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Charger le modèle et le processeur Wav2Vec 2.0
+model_name = "facebook/wav2vec2-large-xlsr-53-french"
+processor = Wav2Vec2Processor.from_pretrained(model_name)
+model = Wav2Vec2ForCTC.from_pretrained(model_name)
+
+# Charger l'audio
+audio_file = "C:\\Users\\fkpamegan\\Downloads\\datasets_oreau2_m_sessp_07a01Pa.wav"
+y, sr = librosa.load(audio_file, sr=16000) 
+
+# Prétraiter l'audio avec le processeur Wav2Vec 2.0
+input_values = processor(y, return_tensors="pt").input_values
+
+# Obtenir la prédiction (logits)
+with torch.no_grad():
+    logits = model(input_values).logitsa
+
+# Obtenir les IDs des tokens prédits (transcription)
+predicted_ids = torch.argmax(logits, dim=-1)
+
+# Décoder les IDs pour obtenir le texte transcrit
+transcription = processor.decode(predicted_ids[0])
+
+print("Transcription:", transcription)
+
+
+# Extraire le pitch (hauteur tonale) et l'intensité
+pitch, magnitudes = librosa.core.piptrack(y=y, sr=sr)
+intensity = librosa.feature.rms(y=y)  # Intensité (volume)
+
+# Calculer le tempo (vitesse de parole)
+tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
+
+# Affichage du pitch
+plt.figure(figsize=(10, 6))
+librosa.display.specshow(pitch, x_axis='time', y_axis='log')
+plt.colorbar()
+plt.title("Pitch (Hauteur Tonale)")
+plt.show()
+
+# Affichage de l'intensité
+plt.figure(figsize=(10, 6))
+librosa.display.specshow(intensity, x_axis='time')
+plt.colorbar()
+plt.title("Intensité")
+plt.show()
+
+# Fusionner la transcription avec les caractéristiques prosodiques (pitch, intensité, tempo)
+features = np.hstack([
+    np.mean(intensity, axis=1),  # Moyenne de l'intensité
+    np.mean(pitch, axis=1),  # Moyenne du pitch
+    tempo  # Tempo
+])
+
+# Afficher les caractéristiques extraites
+print("Caractéristiques combinées :")
+print(features)

src/model/train.py

@@ -1,62 +1,43 @@
-from transformers import Wav2Vec2Processor, Wav2Vec2ForCTC
 import torch
-import librosa
-import numpy as np
-import matplotlib.pyplot as plt
-
-# Charger le modèle et le processeur Wav2Vec 2.0
-model_name = "facebook/wav2vec2-large-960h"
-processor = Wav2Vec2Processor.from_pretrained(model_name)
-model = Wav2Vec2ForCTC.from_pretrained(model_name)
-
-# Charger l'audio
-audio_file = "path_to_audio_file.wav"
-y, sr = librosa.load(audio_file, sr=16000)  # Assurez-vous que le sample rate est 16kHz
-
-# Prétraiter l'audio avec le processeur Wav2Vec 2.0
-input_values = processor(y, return_tensors="pt").input_values
-
-# Obtenir la prédiction (logits)
-with torch.no_grad():
-    logits = model(input_values).logits
-
-# Obtenir les IDs des tokens prédits (transcription)
-predicted_ids = torch.argmax(logits, dim=-1)
-
-# Décoder les IDs pour obtenir le texte transcrit
-transcription = processor.decode(predicted_ids[0])
-
-print("Transcription:", transcription)
-
-
-# Extraire le pitch (hauteur tonale) et l'intensité
-pitch, magnitudes = librosa.core.piptrack(y=y, sr=sr)
-intensity = librosa.feature.rms(y=y)  # Intensité (volume)
-
-# Calculer le tempo (vitesse de parole)
-tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
-
-# Affichage du pitch
-plt.figure(figsize=(10, 6))
-librosa.display.specshow(pitch, x_axis='time', y_axis='log')
-plt.colorbar()
-plt.title("Pitch (Hauteur Tonale)")
-plt.show()
-
-# Affichage de l'intensité
-plt.figure(figsize=(10, 6))
-librosa.display.specshow(intensity, x_axis='time')
-plt.colorbar()
-plt.title("Intensité")
-plt.show()
-
-# Fusionner la transcription avec les caractéristiques prosodiques (pitch, intensité, tempo)
-features = np.hstack([
-    np.mean(intensity, axis=1),  # Moyenne de l'intensité
-    np.mean(pitch, axis=1),  # Moyenne du pitch
-    tempo  # Tempo
-])
-
-# Afficher les caractéristiques extraites
-print("Caractéristiques combinées :")
-print(features)
+import torch.optim as optim
+import torch.nn as nn
+from torch.utils.data import DataLoader
+from transformers import Wav2Vec2Processor
+from emotion_dataset import EmotionDataset
+from model import Wav2Vec2EmotionClassifier
+
+# Charger le processeur et le dataset
+processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-large-xlsr-53")
+dataset = EmotionDataset("data/dataset.csv", processor)
+dataloader = DataLoader(dataset, batch_size=4, shuffle=True)
+
+# Initialiser le modèle
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = Wav2Vec2EmotionClassifier().to(device)
+
+# Définir la fonction de perte et l'optimiseur
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.AdamW(model.parameters(), lr=5e-5)
+
+# Entraînement du modèle
+num_epochs = 10
+for epoch in range(num_epochs):
+    model.train()
+    total_loss = 0
+
+    for inputs, labels in dataloader:
+        inputs, labels = inputs.to(device), labels.to(device)
+
+        optimizer.zero_grad()
+        outputs = model(inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        total_loss += loss.item()
+
+    print(f"Epoch {epoch+1}, Loss: {total_loss:.4f}")
+
+# Sauvegarde du modèle
+torch.save(model.state_dict(), "wav2vec2_emotion.pth")
+print("Modèle sauvegardé !")