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 :

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

L’attribut instruments contient la liste des instruments
fichier.instruments
Un instrument est composé de plusieurs attributs :
  • 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
 
Comme n’importe quelle liste en Python, il est possible d’accéder à chacun des instruments de la liste
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

Une note est composé de plusieurs attributs :
  • 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)
Tu peux trouver une liste d’instruments ici : https://soundprogramming.net/file-formats/general-midi-instrument-list/
 
 

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 :

  1. Créer une note ou la liste des notes complètes
  2. Créer un instrument
  3. Lui assigner la liste des notes ou ajouter les notes une par une avec la fonction append
  4. Créer l’objet Midi
  5. Ajouter l’instrument à la liste des instruments du fichier avec la fonction append
  6. 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
Exemple de code de la fonction :
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.

Retour en haut