README.md

---
license: mit
datasets:
- Clemylia/Rythme
language:
- fr
pipeline_tag: audio-classification
library_name: keras
tags:
- Rythme
- Décalage
- Calé ou décalé
- musique
- Audio classify
---

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

![Musica](http://www.image-heberg.fr/files/17631110924081649736.jpg)

## 🌟 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

| ID | Label | Description |
| :---: | :---: | :--- |
| **0** | **Calé** | L'audio est bien aligné sur le rythme. |
| **1** | **Décalé** | L'audio présente un désalignement ou un décalage rythmique. |

## ⚙️ 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 :

```bash
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

| Paramètre | Valeur | Description |
| :--- | :---: | :--- |
| `HF_REPO_ID` | `"Clemylia/Musica2"` | Identifiant du dépôt sur Hugging Face. |
| `FULL_MODEL_FILENAME` | `"musica2_complete_model.keras"` | Nom du fichier Keras complet. |
| `SAMPLE_RATE` | `16000` | Taux d'échantillonnage cible (Hz). |
| `MAX_CLIP_DURATION` | `10` | Durée maximale des clips audio traités (secondes). |
| `N_MELS` | `128` | Nombre de bandes Mel pour le spectrogramme. |

#### 🛠️ 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/