Clemylia / Musica2

🎼 Musica2 : Détection de Rythme Audio (Calé ou Décalé)

🌟 Présentation

Musica2 est un modèle d'apprentissage profond conçu pour analyser un clip audio (chanson) et déterminer s'il est dans le rythme (calé) ou hors rythme (décalé) . Ce modèle a été entraîné from scratch par Clemylia en utilisant la bibliothèque Keras et TensorFlow .

🎯 Tâche et Classes

⚙️ Architecture et Entraînement

Musica2 est un modèle Convolutionnel 2D (CNN) , adapté à l'analyse d'images de spectrogrammes Mel, qui représentent la distribution de l'énergie audio dans le temps et la fréquence.

• Framework d'Entraînement : Keras (TensorFlow)
• Données d'Entrée : Spectrogrammes Mel (représentation visuelle de l'audio).

📥 Comment Utiliser Musica2

Le modèle est disponible en téléchargement et chargement direct depuis Hugging Face Hub en utilisant huggingface_hub et tensorflow/keras .

💻 Dépendances

Assurez-vous d'avoir installé les bibliothèques nécessaires :

pip install tensorflow keras numpy librosa huggingface_hub

🐍 Code d'Inférence (Exemple)

Le code d'inférence fourni est la méthode stable pour utiliser Musica2. Il gère le téléchargement, le chargement, le prétraitement de l'audio et la prédiction.

Paramètres Clés

🛠️ Pipeline de Prétraitement

1. Chargement : L'audio est chargé.
2. Rééchantillonnage : L'audio est rééchantillonné à $16000\text{ Hz}$.
3. Tronquage/Padding : L'audio est tronqué ou complété pour atteindre exactement $10$ secondes.
4. Spectrogramme Mel : Le spectrogramme Mel à $128$ bandes est calculé.
5. Conversion Logarithmique : Conversion en décibels ( librosa.power_to_db ).
6. Normalisation Z-Score : Le spectrogramme est normalisé à $\mu=0$ et $\sigma=1$ pour l'entrée du modèle.

Note : Le modèle attend une entrée de forme $(1, \text{Hauteur}, \text{Largeur}, 1)$, correspondant à un spectrogramme Mel normalisé.

📊 Interprétation des Résultats

Le modèle effectue une prédiction binaire, retournant une probabilité $P$ entre $0.0$ et $1.0$ :

• Si $P < 0.5$, le verdict est Calé (Classe 0). La confiance est $1 - P$.
• Si $P \ge 0.5$, le verdict est Décalé (Classe 1). La confiance est $P$.

⚠️ Limitations et Avertissements

• Durée du Clip : Le modèle est optimisé pour des clips audio de 10 secondes . L'analyse d'un clip plus long ou plus court pourrait affecter la précision.
• Qualité Audio : La performance peut être affectée par une mauvaise qualité d'enregistrement ou un bruit excessif.
• Définition de Rythme : Le modèle a appris à partir d'un ensemble de données spécifique ; sa généralisation à des genres musicaux ou des définitions de "rythme" très éloignées peut varier.

🤝 Contribution et Contact

Pour toute question, suggestion ou collaboration, veuillez contacter Clemylia .

Exemple de code d'inférence fonctionnel

import tensorflow as tf
from tensorflow import keras
import numpy as np
import librosa
from huggingface_hub import hf_hub_download
import os
import warnings

warnings.filterwarnings('ignore', category=FutureWarning) 
warnings.filterwarnings('ignore', category=UserWarning)

# ----------------------------------------------------------------------------------
# PARTIE 1 : CONFIGURATION ET CHARGEMENT DU MODÈLE COMPLET
# ----------------------------------------------------------------------------------

# --- CONFIGURATION D'INFÉRENCE ---
SAMPLE_RATE = 16000     
MAX_CLIP_DURATION = 10
N_MELS = 128           

# >>> NOUVEAU NOM DE FICHIER DU MODÈLE COMPLET <<<
HF_REPO_ID = "Clemylia/Musica2"
FULL_MODEL_FILENAME = "musica2_complete_model.keras"

id_to_label = {0: "calé", 1: "décalé"} 
model = None # Initialisation

print(f"⏳ Téléchargement et chargement du modèle complet depuis {HF_REPO_ID}...")

downloaded_model_path = None

try:
    # 1. Télécharger le fichier .keras complet
    downloaded_model_path = hf_hub_download(
        repo_id=HF_REPO_ID, 
        filename=FULL_MODEL_FILENAME,
        force_download=True
    )
    
    # 2. CHARGEMENT DU MODÈLE : Keras gère le fichier .keras complet en une seule fois
    model = keras.models.load_model(downloaded_model_path)
    
    print("✅ Modèle Musica2 chargé et prêt pour l'inférence.")

except Exception as e:
    print(f"❌ ERREUR FATALE DE CHARGEMENT DU MODÈLE COMPLET : {e}")
    print("Veuillez vérifier l'URL du dépôt ou le nom du fichier du modèle complet sur Hugging Face.")
    model = None

# ----------------------------------------------------------------------------------
# PARTIE 2 : FONCTION DE PRÉTRAITEMENT
# ----------------------------------------------------------------------------------

def preprocess_audio_for_inference(audio_path):
    """
    Pipeline de prétraitement pour l'audio.
    """
    if not os.path.exists(audio_path):
        raise FileNotFoundError(f"Fichier audio non trouvé à : {audio_path}")
        
    print(f"   -> Prétraitement de l'audio à : {audio_path}")
    
    audio_data, current_sr = librosa.load(audio_path, sr=None)
    
    if current_sr != SAMPLE_RATE:
        audio_data = librosa.resample(audio_data, orig_sr=current_sr, target_sr=SAMPLE_RATE)

    target_length = SAMPLE_RATE * MAX_CLIP_DURATION
    if len(audio_data) > target_length:
        audio_data = audio_data[:target_length]
    elif len(audio_data) < target_length:
        padding = target_length - len(audio_data)
        audio_data = np.pad(audio_data, (0, padding), 'constant')

    S = librosa.feature.melspectrogram(y=audio_data, sr=SAMPLE_RATE, n_mels=N_MELS)
    S_dB = librosa.power_to_db(S, ref=np.max)
    
    S_norm = (S_dB - np.mean(S_dB)) / np.std(S_dB)
    
    S_final = S_norm[np.newaxis, ..., np.newaxis].astype(np.float32)

    return S_final

# ----------------------------------------------------------------------------------
# PARTIE 3 : FONCTION DE PRÉDICTION ET EXÉCUTION
# ----------------------------------------------------------------------------------

def predict_rhythm(model, audio_file_path):
    """
    Effectue la prédiction et affiche le résultat.
    """
    if model is None:
        print("\n❌ Impossible de prédire : Le modèle n'a pas été chargé.")
        return None, None
        
    try:
        input_features = preprocess_audio_for_inference(audio_file_path)
    except FileNotFoundError as e:
        print(f"\n⚠️ {e}")
        return None, None
        
    print(f"\n🔬 Début de l'analyse pour le fichier : {audio_file_path}")
    
    # Prédiction
    probability = model.predict(input_features, verbose=0)[0][0]
    
    # Verdict
    predicted_id = int(probability >= 0.5) 
    predicted_label = id_to_label[predicted_id]
    
    # Confiance
    confidence = probability if predicted_id == 1 else (1.0 - probability)
    
    # Affichage
    print("\n--- Résultat de la Prédiction ---")
    print(f"Probabilité de 'Décalé' (Classe 1) : **{probability:.4f}**")
    print(f"Verdict : La musique est **{predicted_label.upper()}**")
    print(f"Confiance : {confidence:.2f}")
    
    return predicted_label, probability

## --- EXÉCUTION DU TEST ---

TEST_AUDIO_PATH = "cale-1.mp3"

predict_rhythm(model, TEST_AUDIO_PATH)