modele rapide

app.py

@@ -3,6 +3,11 @@ from streamlit_option_menu import option_menu
 from views.studio import studio
 from views.emotion_analysis import emotion_analysis
 from views.about import about
+import os
+import sys
+
+sys.path.append(os.path.abspath("src"))
+sys.path.append(os.path.abspath(".")) 
 
 if "model_loaded" not in st.session_state:
     st.session_state.model_loaded = None

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

@@ -1,9 +1,11 @@
+import sys
+import os
 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
+from src.model.emotion_classifier import EmotionClassifier
+from src.utils.preprocessing import collate_fn
+from src.config import DEVICE, NUM_LABELS
 import os
 
 # Charger le modèle entraîné

src/train.py

@@ -2,37 +2,31 @@ import torch
 import torch.optim as optim
 import torch.nn as nn
 from torch.utils.data import DataLoader
-import numpy as np
 from sklearn.metrics import accuracy_score
 from utils.dataset import load_audio_data
 from utils.preprocessing import preprocess_audio, prepare_features, collate_fn
 from model.emotion_classifier import EmotionClassifier
-from config import DEVICE, NUM_LABELS
+from src.config import DEVICE, NUM_LABELS
 import os
 
-# 🔹 Charger les données
+# Charger les données et les séparer en train / test
 data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "data"))
 ds = load_audio_data(data_dir)
 
-# 🔹 Prétraitement des données
-ds = ds.map(preprocess_audio)
-ds = ds.map(lambda batch: prepare_features(batch, max_length=128))
+# Prétraitement
+ds["train"] = ds["train"].map(preprocess_audio).map(lambda batch: prepare_features(batch, max_length=128))
+ds["test"] = ds["test"].map(preprocess_audio).map(lambda batch: prepare_features(batch, max_length=128))
 
-# 🔹 Séparation en train et test
-ds = ds.train_test_split(test_size=0.2)
-train_ds, test_ds = ds["train"], ds["test"]
+# DataLoader
+train_loader = DataLoader(ds["train"], batch_size=8, shuffle=True, collate_fn=collate_fn)
+test_loader = DataLoader(ds["test"], batch_size=8, shuffle=False, collate_fn=collate_fn)
 
-# 🔹 Création des DataLoaders avec `collate_fn`
-train_loader = DataLoader(train_ds, batch_size=8, shuffle=True, collate_fn=collate_fn)
-test_loader = DataLoader(test_ds, batch_size=8, shuffle=False, collate_fn=collate_fn)
+# Instancier le modèle
+classifier = EmotionClassifier(feature_dim=40, num_labels=NUM_LABELS).to(DEVICE)
 
-# 🔹 Instancier le modèle
-feature_dim = 40  # Nombre de MFCCs
-classifier = EmotionClassifier(feature_dim, NUM_LABELS).to(DEVICE)
-
-# 🔹 Fonction d'entraînement
-def train_classifier(classifier, train_loader, test_loader, epochs=20, lr=2e-4):
-    optimizer = optim.AdamW(classifier.parameters(), lr=lr, weight_decay=0.01)
+# Fonction d'entraînement
+def train_classifier(classifier, train_loader, test_loader, epochs=20):
+    optimizer = optim.AdamW(classifier.parameters(), lr=2e-5, weight_decay=0.01)
     loss_fn = nn.CrossEntropyLoss()
     best_accuracy = 0.0
 
@@ -55,17 +49,16 @@ def train_classifier(classifier, train_loader, test_loader, epochs=20, lr=2e-4):
 
         train_acc = correct / len(train_loader.dataset)
 
-        # 🔹 Sauvegarde du meilleur modèle
         if train_acc > best_accuracy:
             best_accuracy = train_acc
-            torch.save(classifier.state_dict(), "acc_model.pth")
-            print(f"✅ Nouveau meilleur modèle sauvegardé ! Accuracy: {best_accuracy:.4f}")
+            torch.save(classifier.state_dict(), "best_model.pth")
+            print(f"✔️ Nouveau meilleur modèle sauvegardé ! Accuracy: {best_accuracy:.4f}")
 
-        print(f"📊 Epoch {epoch+1}/{epochs} - Loss: {total_loss/len(train_loader):.4f} - Accuracy: {train_acc:.4f}")
+        print(f"📢 Epoch {epoch+1}/{epochs} - Loss: {total_loss:.4f} - Accuracy: {train_acc:.4f}")
 
     return classifier
 
-# 🔹 Fonction d'évaluation
+# Évaluer le modèle
 def evaluate(model, test_loader):
     model.eval()
     all_preds, all_labels = [], []
@@ -73,6 +66,7 @@ def evaluate(model, test_loader):
     with torch.no_grad():
         for inputs, labels in test_loader:
             inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
+
             logits = model(inputs)
             preds = torch.argmax(logits, dim=-1).cpu().numpy()
             all_preds.extend(preds)
@@ -80,7 +74,7 @@ def evaluate(model, test_loader):
 
     return accuracy_score(all_labels, all_preds)
 
-# 🔹 Lancer l'entraînement
-trained_classifier = train_classifier(classifier, train_loader, test_loader, epochs=20, lr=2e-4)
+# Lancer l'entraînement
+trained_classifier = train_classifier(classifier, train_loader, test_loader, epochs=20)
 
 print("✅ Entraînement terminé, le meilleur modèle a été sauvegardé !")

src/utils/dataset.py

@@ -3,6 +3,11 @@ from datasets import Dataset
 from config import LABELS
 import pandas as pd
 
+import os
+from datasets import Dataset, DatasetDict
+import pandas as pd
+from config import LABELS  
+
 def load_audio_data(data_dir):
     data = []
     for label_name, label_id in LABELS.items():
@@ -11,7 +16,15 @@ def load_audio_data(data_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)
+
+    # Convertir en dataset Hugging Face
+    ds = Dataset.from_list(data)
+
+    # Séparer en 80% train / 20% test
+    ds = ds.train_test_split(test_size=0.2)
+    return ds  # Contient ds["train"] et ds["test"]
+
+
 
 
 # def load_audio_data_from_csv(csv_path, data_dir):

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)
@@ -43,7 +43,7 @@ def prepare_features(batch, max_length):
     mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=40)
 
     # Debugging: afficher la forme des MFCCs
-    print(f"MFCC original shape: {mfcc.shape}")
+    # print(f"MFCC original shape: {mfcc.shape}")
 
     # Ajuster la longueur des MFCCs
     if mfcc.shape[1] > max_length:
@@ -52,7 +52,7 @@ def prepare_features(batch, max_length):
         pad_width = max_length - mfcc.shape[1]
         mfcc = np.pad(mfcc, pad_width=((0, 0), (0, pad_width)), mode='constant')  # Padding si trop court
 
-    print(f"MFCC padded shape: {mfcc.shape}")
+    # print(f"MFCC padded shape: {mfcc.shape}")
 
     # Convertir en tensor PyTorch et stocker
     batch["input_values"] = torch.tensor(mfcc.T, dtype=torch.float32)  # Transposer pour obtenir (max_length, 40)