Documentation Midi
Sur cette page tu trouveras comment installer le logiciel fluidsynth et la librairie Prettymidi pour manipuler des fichiers sons avec google colab
Installation et lecteur audio
Installation de Fluidsynth et PrettyMidi
Nous allons installer le logiciel fluidsynth, un synthétiseur que l’on peut contrôler avec une librairie python, capable de lire des fichiers midi sur la machine virtuelle de colab, ainsi que la librairie PrettyMidi qui permet de manipuler facilement des fichiers Midi
Étape 1 : Installation du logiciel Fluidsynth
La machine virtuelle de google colab fonctionne sur un noyau linux on peut donc installer certains logiciels comme on le ferait sur un terminal linux. La seule différence est que tu vas pouvoir l’écrire directement dans le code.
La commande suivante permet de faire cette installation. Attention ça peut prendre un petit peu de temps.
!sudo apt install -y fluidsynth
Étape 2 : Installation des librairies fluidsynth et prettymidi
On va maintenant installer les librairies à l’aide de pip
Exécute les commandes suivantes.
Le –upgrade, permet de forcer les mises à jours de la librairie, au cas où une version précédente aurait été installé avec le logiciel.
!pip install --upgrade pyfluidsynth
!pip install pretty_midi
Lecteur de fichier audio
Google Colab ne sait pas lire les fichiers midi, afin de ne pas avoir à télécharger les résultats à chaque fois, on va convertir les fichiers en .wav avec fluidsynth et les lire directement dans notre console, grâce au lecteur Audio intégré dans la librairie.
Voici le code d’une petite fonction qui permet de lire un fichier midi.
Elle prend en paramètres :
- obligatoire : le fichier midi (déjà ouvert avec PrettyMidi)
- optionnel : le taux d’échantillonnage (rate) de lecture
from IPython.display import Audio
def display_audio(fichier_midi, rate = 16000):
musique = fichier_midi.fluidsynth(rate)
return Audio(musique, rate=rate)
Ouvrir et écouter le fichier midi
import pretty_midi
chemin_fichier = "/content/Animaniac.mid"
midi = pretty_midi.PrettyMIDI(chemin_fichier)
display_audio(midi)
Bibliothèques de fichiers midi
Si tu as besoin de trouver des fichiers midi pour tester ton lecteur, voici quelques sites où tu pourras trouver des fichiers midi :
- https://bitmidi.com/ site généraliste
- https://www.vgmusic.com/archives de musiques d’anciens jeux vidéo triés par consoles
- http://www.pandatooth.com site qui recense surtout des films, des séries, et des jeux vidéos
Lire et écrire un fichier midi
Voici le lien vers la documentation de la librairie Pretty_Midi
En résumé, un fichier midi est une liste d’instruments avec leurs partitions pour chaque instrument. Tu vas pouvoir accéder à chaque instrument et chaque ensemble de notes.
Lister les instruments
fichier.instruments
- program : le numéro de l’instrument de référence
- is_drum : est-ce que l’instrument est une percussion (les percussions ne jouent pas les mêmes notes)
- name : le nom commun de l’instrument
- notes : la liste des notes jouées par l’instrument
fichier.instruments[0]
La fonction program_to_instrument_name() permet de récupérer le nom complet de l’instrument à partir de son programme.
pretty_midi.program_to_instrument_name(instrument.program)
Afficher les notes d’un instrument
Pour lire les notes d’un instrument, il suffi d’accéder à l’attribut notes :
notes = instrument.notes
1ere_note = instrument.notes[0]
Lire une note
- start : le temps ou débute la note (en secondes)
- end : le temps ou s’arrête la note (en secondes)
- pitch : la hauteur de la note ( est-ce que c’est un Do ou un Fa)
- velocity : la force avec laquelle la note est jouée
- duration : la durée de la note
On peut transformer le pitch d’une note en son nom (en écriture anglaise) avec la fonction note_number_to_name
pretty_midi.note_number_to_name(note.pitch)
Voici un schéma qui illustre les différentes représentation d’une note
Pour lire plusieurs notes, sers toi de la liste python. Ajoute deux points : devant l’index pour lui dire de lire « jusqu’à X »
note_cinq = instrument.notes[:5]
Créer un instrument
Pour créer un instrument on utilise le constructeur Instrument et le numéro du programme :
instrument = pretty_midi.Instrument(19)
Créer une note
Pour créer une note on utilise le constructeur Note et ses différents attributs : start, end, pitch, velocity :
note = pretty_midi.Note(velocity=70,pitch=60,start=0.5,end=1.7)
Créer le fichier Midi
Pour créer un nouveau fichier midi il suffit de :
- Créer une note ou la liste des notes complètes
- Créer un instrument
- Lui assigner la liste des notes ou ajouter les notes une par une avec la fonction append
- Créer l’objet Midi
- Ajouter l’instrument à la liste des instruments du fichier avec la fonction append
- Utiliser la fonction write pour écrire le fichier en spécifiant son nom
mon_do = pretty_midi.Note(start=1.5, end=5.5, pitch=48, velocity=40) mon_orgue = pretty_midi.Instrument(26) mon_orgue.notes.append(mon_do) mon_midi = pretty_midi.PrettyMIDI() mon_midi.instruments.append(mon_orgue) mon_midi.write('do.midi') display_audio(mon_midi)
Midi et pandas
Transformation du morceau en un tableau pandas
Pour manipuler ton fichier MIDI et le transformer en tableau pandas, tu devras :
Importer pandas
import pandas as pd
Créer une fonction récupérant les instruments et les notes
def midi2pandas(midi): instrument = midi.instruments[0] df_notes = {'start':[], 'end':[], 'pitch':[], 'velocity':[], 'duration':[]}
Boucler pour ajouter toutes les valeurs
for note in instrument.notes: df_notes['duration'].append(note.duration) df_notes['start'].append(note.start) df_notes['end'].append(note.end) df_notes['pitch'].append(note.pitch) df_notes['velocity'].append(note.velocity)
return pd.DataFrame(df_notes)
Créer un graphe sous forme de rouleau de piano
Pour afficher un rouleau de piano tu auras besoin des librairies matplotlib et numpy
from matplotlib import pyplot as plt import numpy as np
Créer une fonction récupérant les données des notes de ton morceau musical. Dans celle-ci on va :
- Définir la taille du graphe
- Créer nos paires de valeurs e X et Y pour définir la durée sur un axe, et les notes sur l’autre
- Créer la courbe à tracer
- Donner une légende aux axes
def rouleau_piano(data, compteur=None): plt.figure(figsize=(20,4)) x = np.stack([data['start'],data['end']]) y = np.stack([data['pitch'],data['pitch']]) plt.plot(x,y,color="b",marker=".") plt.xlabel('Durée') plt.ylabel('Pitch') rouleau_piano(df_trie)
Ajouter un compteur :
Tu peux ajouter un compteur pour avoir uniquement les xxx premières notes sur ton graphe.
Pour ce faire, ajoute le compteur dans la courbe de ton tracer
plt.plot(x[:compteur,:compteur],y[:compteur,:compteur],color="b",marker=".")
Et appelle ta fonction en notant le nombre de notes que tu veux afficher
rouleau_piano(df_trie,50)
Tu peux également ajouter un titre à ton graphe qui affiche le compteur pour légender ton graphe.
En utilisant une condition, cela te permet de laisser ta fonction avec un compteur sur None, et choisir si tu souhaites avoir le morceau entier ou qu’une partie, lors des appels de ta fonction.
if compteur :
titre = f"les {compteur} premières notes"
else : titre = « le morceau entier » compteur = len(data[‘pitch’])
Glossaire
Duration
Dans la bibliothèque PrettyMIDI, l’argument duration est utilisé pour spécifier la durée d’une note MIDI. Cet argument est présent dans la classe Note() de la bibliothèque, et permet de déterminer pendant combien de temps une note sera jouée dans une séquence MIDI.
End
L’argument end fait référence au moment où une note MIDI se termine dans une séquence MIDI. C’est un paramètre utilisé pour spécifier la fin d’une note. Cet argument est utilisé dans la classe Note() pour déterminer la durée pendant laquelle la note est jouée.
Pitch
Dans la bibliothèque PrettyMIDI, le terme « pitch » fait référence à la hauteur d’une note MIDI. En musique, la hauteur d’une note est généralement associée à sa fréquence fondamentale, et dans le contexte MIDI, cette hauteur est représentée par un nombre entier compris entre 0 et 127.
Dans PrettyMIDI, l’attribut pitch est un paramètre utilisé pour spécifier la hauteur d’une note. Il s’agit d’un nombre entier représentant le numéro de note MIDI correspondant à la hauteur souhaitée.
Start
L’argument start est associé à la classe Note() dans PrettyMIDI. Il se réfère au moment où cette note commence dans la séquence MIDI.
Step
Le step est utilisé pour calculer l’écart entre le moment de début (start) de chaque note et le moment de début de la note suivante. Cette différence permet d’avoir une donnée supplémentaire pour laisser notre IA générer des notes capables de se chevaucher et améliorer le rendu mélodique du résultat obtenu.
Taux d’échantillonnage (rate)
Il s’agit du nombre d’échantillons audio prélevés par seconde lors de la numérisation d’un signal audio analogique. C’est une mesure technique liée à la représentation numérique d’un signal audio. Le taux d’échantillonnage est mesuré en hertz (Hz) et indique la fréquence à laquelle les points de mesure sont pris par seconde.
Tempo
Le tempo, se rapporte à la vitesse ou à la cadence d’une composition musicale. C’est le nombre de battements par minute (BPM) et indique la rapidité ou la lenteur perçue de la musique. Le tempo est une caractéristique musicale expressive qui influence la sensation rythmique d’une partition.
Velocity
L’argument velocity est utilisé pour spécifier la vélocité d’une note MIDI. La vélocité représente la force ou l’intensité avec laquelle une note est jouée. Elle est souvent associée à la force physique avec laquelle une touche est enfoncée sur un clavier ou à la pression exercée sur un pad de batterie électronique.