README.md

---
license: mit
datasets:
- Clemylia/Tempo
language:
- fr
pipeline_tag: audio-classification
tags:
- music
- Rythme
- classification
- decalage
- problème de rythme
---

# 🩷🌸 Musica 🌸🩷

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

## 🦋 **c'est quoi** ? 

Musica est un projet de machine learning,
de type classification d'audio,
il a été conçu pour classifier les chansons au niveau de leur rythme (calé ou décalé),
C'est-à-dire de percevoir les décalages rythmiques dans les chansons.

## ❤️ Comment utiliser ? 

Pour utiliser Musica,
Qui a été crée from scratch sur la dataset Clemylia/Tempo,
Vous devez reconstruire le code d'inférence,
Voici un exemple de code d'utilisation :

```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchaudio
import numpy as np
from huggingface_hub import hf_hub_download
from datasets import load_dataset, Audio # On garde l'import au cas où

# =============================================================================
# PARTIE 1 : DÉFINITION DE L'ARCHITECTURE (inchangée)
# =============================================================================

NUM_CLASSES = 2
N_MELS = 128

class AudioClassifier(nn.Module):
    """Réseau de Neurones Convolutionnels (CNN) que nous avons entraîné."""
    def __init__(self):
        super(AudioClassifier, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=(5, 5), padding=2)
        self.bn1 = nn.BatchNorm2d(32)
        self.pool1 = nn.MaxPool2d(kernel_size=(2, 2))
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(3, 3), padding=1)
        self.bn2 = nn.BatchNorm2d(64)
        self.pool2 = nn.MaxPool2d(kernel_size=(2, 2))
        self.conv3 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=(3, 3), padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.pool3 = nn.MaxPool2d(kernel_size=(2, 2))
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc1 = nn.Linear(128 * 1 * 1, NUM_CLASSES)

    def forward(self, x):
        x = self.pool1(F.relu(self.bn1(self.conv1(x))))
        x = self.pool2(F.relu(self.bn2(self.conv2(x))))
        x = self.pool3(F.relu(self.bn3(self.conv3(x))))
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        return self.fc1(x)


# =============================================================================
# PARTIE 2 : FONCTIONS DE PRÉPARATION POUR L'INFÉRENCE (inchangée)
# =============================================================================

SAMPLING_RATE = 16000
N_FFT = 400
HOP_LENGTH = 160
MAX_TIME_STEPS = 300

def prepare_spectrogram(audio_path):
    """
    Charge un fichier audio, calcule le Log-Mel Spectrogramme, et le prépare
    pour le modèle.
    """
    # 1. Charger et Rééchantillonner
    waveform, sr = torchaudio.load(audio_path)
    if sr != SAMPLING_RATE:
        resampler = torchaudio.transforms.Resample(orig_freq=sr, new_freq=SAMPLING_RATE)
        waveform = resampler(waveform)

    if waveform.shape[0] > 1:
        waveform = torch.mean(waveform, dim=0, keepdim=True)

    # 2. Calculer le Log-Mel Spectrogramme
    mel_spectrogram_transform = torchaudio.transforms.MelSpectrogram(
        sample_rate=SAMPLING_RATE,
        n_fft=N_FFT,
        hop_length=HOP_LENGTH,
        n_mels=N_MELS,
    )
    mel_spectrogram = mel_spectrogram_transform(waveform.squeeze(0))
    log_mel_spectrogram = torchaudio.transforms.AmplitudeToDB()(mel_spectrogram)

    # 3. Tronquer
    if log_mel_spectrogram.shape[1] > MAX_TIME_STEPS:
        log_mel_spectrogram = log_mel_spectrogram[:, :MAX_TIME_STEPS]

    # 4. Ajouter les dimensions Batch et Channel : [1, 1, N_MELS, Time_Steps]
    input_tensor = log_mel_spectrogram.unsqueeze(0).unsqueeze(0)

    return input_tensor


def predict_audio(model, audio_tensor):
    """
    Effectue la prédiction et retourne l'étiquette.
    """
    model.eval()
    device = next(model.parameters()).device

    with torch.no_grad():
        audio_tensor = audio_tensor.to(device)
        outputs = model(audio_tensor)

        probabilities = F.softmax(outputs, dim=1)
        predicted_index = torch.argmax(probabilities, dim=1).item()

        # Décodeur des classes (assumant 0 = Calé, 1 = Décalé)
        class_labels = {0: "Calé (On Beat)", 1: "Décalé (Off Beat)"}

        return class_labels[predicted_index], probabilities[0].cpu().numpy()


# =============================================================================
# PARTIE 3 : CHARGEMENT DU MODÈLE ET EXÉCUTION DU TEST (CORRIGÉE)
# =============================================================================

# --- Configuration Hugging Face ---
REPO_ID = "Clemylia/Musica1"
MODEL_FILENAME = "pytorch_model.bin"

# 1. Télécharger les poids du modèle
print(f"1. Téléchargement des poids du modèle depuis {REPO_ID}...")
try:
    model_path = hf_hub_download(repo_id=REPO_ID, filename=MODEL_FILENAME)
except Exception as e:
    print(f"Erreur de téléchargement : {e}. Vérifiez le nom du dépôt et les permissions.")
    exit()

# 2. Charger le modèle
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = AudioClassifier()

try:
    model.load_state_dict(torch.load(model_path, map_location=device))
    model.to(device)
    print(f"2. Modèle chargé avec succès sur {device}.")
except Exception as e:
    print(f"Erreur lors du chargement des poids : {e}")
    exit()

# 3. Préparer une donnée de test

# *** CORRECTION MAJEURE ***
# Veuillez remplacer le chemin ci-dessous par un chemin valide sur votre système !
# Exemple : "C:/Users/Clemylia/Desktop/mes_sons/calé_test.wav" ou "./data/audio_test.mp3"
# ----------------------------------------------------------------------------------
AUDIO_TEST_FILE = input("Veuillez entrer le chemin complet d'un fichier audio (ex: /path/to/test.wav): ")
# ----------------------------------------------------------------------------------

print(f"\n3. Préparation d'un échantillon de test à partir de: {AUDIO_TEST_FILE}...")

try:
    input_tensor = prepare_spectrogram(AUDIO_TEST_FILE)
    audio_test_path = AUDIO_TEST_FILE # Pour l'affichage final

except Exception as e:
    print(f"Erreur lors de la préparation de l'échantillon de test (le fichier existe-t-il ? le format est-il pris en charge par torchaudio ?) : {e}")
    input_tensor = None


# 4. Exécuter la prédiction
if input_tensor is not None:
    print(f"\n4. Exécution de la prédiction sur l'échantillon...")

    prediction, probabilities = predict_audio(model, input_tensor)

    # Affichage des résultats
    print("\n-------------------------------------------")
    print(f"FICHIER TESTÉ: {audio_test_path}")
    print(f"PRÉDICTION: {prediction}")
    print(f"PROBABILITÉS: Calé={probabilities[0]:.4f}, Décalé={probabilities[1]:.4f}")
    print("-------------------------------------------")
else:
    print("Test annulé faute de pouvoir traiter le fichier audio.")
```
## ❤️🔥 Informations sur Musica

**nom** : Musica
**version** : 1 (entraînement sur un tout petit dataset)
**développeur** : Clemylia
**Tache** : détecter si une chanson est dans le rythme où pas 

❤️**amusez vous bien à détecter si vos chansons d'anniversaire, vos bruits de bouches, vos cover de chansons ou autre sont calé et si vous avez le rythme !**❤️