Un fichier MP3, au fond, c'est quoi ? Une longue, très longue liste de nombres. Ton oreille y entend une chanson ; un modèle d'IA, lui, n'y voit que des échantillons bruts, des milliers de valeurs par seconde, trop redondantes pour être apprises telles quelles. Le pont entre les deux s'appelle librosa : une bibliothèque Python qui transforme n'importe quel son en données propres — spectrogramme, coefficients MFCC, tempo, accords — exactement le genre de choses qu'un algorithme de machine learning sait digérer.
C'est la brique de base de tout le ML audio : classer un genre musical, reconnaître un morceau façon Shazam, détecter un rythme cardiaque ou trier une bibliothèque par humeur. Ici, on charge un son, on le visualise, puis on en extrait les features essentielles, avec du code que tu peux copier-coller et adapter à tes propres fichiers.
Pour suivre, il te faut Python 3, un fichier audio (mp3, wav, ogg, flac...) et trois bibliothèques. Pas de GPU, pas de clé API : tout tourne sur ton PC, en local.
On va procéder en six étapes courtes : installer, charger, afficher la forme d'onde, puis extraire le spectrogramme, les MFCC et le tempo. À la fin, tu sauras tirer d'un simple fichier audio les features que n'importe quel modèle attend. Chaque bloc de code est autonome : exécute-les au fil de l'eau.
1. Installer librosa
L'installation tient en une commande. On embarque aussi numpy pour les calculs et matplotlib pour les visualisations. librosa tire beaucoup de choses dans son sillage (scipy, numba...), alors laisse pip faire son travail sans t'impatienter.
pip install librosa numpy matplotlib2. Charger un son et le visualiser
librosa.load() lit le fichier et renvoie deux choses : y, le signal sous forme de tableau numpy, et sr, la fréquence d'échantillonnage, c'est-à-dire le nombre de mesures prises par seconde. Par défaut, librosa rééchantillonne tout en mono à 22 050 Hz, ce qui suffit largement pour analyser de la voix ou de la musique. Si ton fichier est en stéréo, le paramètre mono=True (activé par défaut) fait la moyenne des deux canaux : pour l'analyse, c'est presque toujours ce qu'on veut.
import librosa
import numpy as np
# Charge un fichier audio (mp3, wav, ogg, flac...)
y, sr = librosa.load("chanson.mp3", sr=22050)
# y : le signal (tableau numpy) ; sr : la fréquence d'échantillonnage
print("Durée :", round(len(y) / sr, 2), "secondes")
print("Fréquence d'échantillonnage :", sr, "Hz")Pas de fichier sous la main ? Fabrique un accord de trois secondes (Do, Mi, Sol) avec numpy, et remplace le chargement par ce signal synthétique :
# Pas de fichier ? Fabrique un accord (Do, Mi, Sol) de 3 secondes
sr = 22050
t = np.linspace(0, 3, sr * 3, endpoint=False)
y = 0.3 * (np.sin(2 * np.pi * 261.63 * t)
+ np.sin(2 * np.pi * 329.63 * t)
+ np.sin(2 * np.pi * 392.00 * t)).astype(np.float32)La forme d'onde, c'est la première chose à regarder : l'amplitude du son au fil du temps. Un battement de batterie y apparaît comme un pic, un passage calme comme une ligne presque plate. On l'affiche avec waveshow() :
import matplotlib.pyplot as plt
import librosa.display
plt.figure(figsize=(10, 3))
librosa.display.waveshow(y, sr=sr, alpha=0.6)
plt.title("Forme d'onde")
plt.xlabel("Temps (s)")
plt.ylabel("Amplitude")
plt.tight_layout()
plt.show()3. Le spectrogramme : voir les fréquences
La forme d'onde ne dit pas tout : deux notes différentes peuvent avoir exactement la même amplitude. Le spectrogramme de Mel découpe le son en courtes tranches de temps et mesure l'énergie dans chaque bande de fréquences. C'est la représentation que ton oreille, et donc les modèles, préfèrent : grave en bas, aigu en haut, volume en couleur. Concrètement, c'est l'image que tu donnerais à un réseau de neurones pour reconnaître un aboiement, un klaxon ou un genre musical.
# Spectrogramme de Mel : énergie selon la fréquence et le temps
S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128)
S_db = librosa.power_to_db(S, ref=np.max)
plt.figure(figsize=(10, 4))
librosa.display.specshow(S_db, sr=sr, x_axis="time", y_axis="mel")
plt.colorbar(format="%+2.0f dB")
plt.title("Spectrogramme de Mel")
plt.tight_layout()
plt.show()4. Les MFCC : la signature d'un timbre
Les MFCC (Mel-Frequency Cepstral Coefficients) condensent le spectrogramme en une poignée de nombres par tranche de temps, en imitant la façon dont l'oreille humaine perçoit le timbre. C'est la feature standard des classificateurs audio : la même voix ou le même instrument donnent des MFCC proches, même si le volume change. Chaque colonne de la matrice correspond à une tranche de temps, chaque ligne à un coefficient. Treize coefficients suffisent pour la plupart des tâches : c'est le chiffre que tu retrouveras dans la quasi-totalité des papiers sur la classification audio.
# MFCC : la signature timbrale qu'on donne aux modèles de classification
mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
plt.figure(figsize=(10, 4))
librosa.display.specshow(mfcc, sr=sr, x_axis="time")
plt.colorbar()
plt.title("13 coefficients MFCC")
plt.tight_layout()
plt.show()
# 13 lignes (coefficients), une colonne par tranche de temps
print("Forme de la matrice MFCC :", mfcc.shape)5. Le tempo et les battements
Détecter le rythme, c'est le métier de beat_track(). Il estime le tempo en battements par minute (BPM) et repère l'instant précis de chaque battement — la brique de base d'un synchroniseur de lumières, d'un outil de DJ ou d'un métronome intelligent. Attention : un accord continu n'a pas de battements à détecter, il faut du rythme. Pour tester sans chanson sous la main, on génère d'abord un clic de métronome à 120 BPM. Sur un vrai morceau, remplace y_clic par ton signal y et tu obtiendras son tempo réel.
# Fabrique un clic de métronome à 120 BPM pendant 4 secondes
bpm_cible = 120
moments = np.arange(0, 4.0, 60 / bpm_cible)
y_clic = librosa.clicks(times=moments, sr=sr, click_duration=0.05, length=int(sr * 4))
tempo, beat_frames = librosa.beat.beat_track(y=y_clic, sr=sr)
beat_times = librosa.frames_to_time(beat_frames, sr=sr)
# beat_track renvoie parfois un tableau, on en extrait la valeur
bpm = float(np.asarray(tempo).ravel()[0])
print("Tempo estimé :", round(bpm, 1), "BPM (cible :", bpm_cible, ")")
print("Battements détectés :", len(beat_times))
print("Premiers battements (s) :", np.round(beat_times[:8], 2))6. Bonus : la chroma pour repérer les accords
La chroma regroupe les fréquences en douze classes correspondant aux douze notes de la gamme (Do, Do#, Ré...). Joue le même accord une octave plus haut, la chroma reste identique : c'est l'outil idéal pour reconnaître une tonalité ou suivre une grille d'accords, comme le font les applications de tablature automatique.
# Chroma : la carte des 12 notes pour repérer les accords
chroma = librosa.feature.chroma_stft(y=y, sr=sr)
plt.figure(figsize=(10, 4))
librosa.display.specshow(chroma, sr=sr, x_axis="time", y_axis="chroma")
plt.colorbar()
plt.title("Chromagramme (12 classes de notes)")
plt.tight_layout()
plt.show()En vingt lignes de Python, tu viens de transformer un fichier audio brut en quatre jeux de données exploitables : la forme d'onde, le spectrogramme, les MFCC et la chroma. Branche ces features sur un modèle scikit-learn ou PyTorch, et tu tiens les fondations d'un classificateur de genre, d'un détecteur de tempo ou d'un mini-Shazam.
Le plus important reste de comprendre ce que raconte chaque feature. La prochaine fois que tu entraînes un modèle, tu sauras quels nombres lui donner — et pourquoi il entend de la musique là où toi tu ne vois qu'un tableau de float. Et si tu veux aller plus loin, enchaîne avec un classificateur : tes MFCC dans scikit-learn, et tu classes des genres musicaux en un après-midi.
