Musica2

🎯 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)

site officiel : https://clem-beat.lovable.app/