🎼 Compositeur IA en Python : Créer de la musique à partir de zéro

Comment nous enseignons au réseau neuronal à comprendre la musique, à la générer et à l'enregistrer dans un fichier pour l'écouter !

Vous mettez de la musique et vous entendez une mélodie. Et maintenant imaginez : le réseau neuronal « entend » aussi la musique, la mémorise, puis compose la sienne ! 🤯

💡 Nous allons créer un tel réseau neuronal à partir de zéro. Et commençons par la toute première étape : préparons la musique dans un format pratique pour l'apprentissage, entraînons le modèle et, enfin, générons la première composition !

🔧 Partie 1 : Préparation des données et bases

1. Installez l'outil pour travailler avec la musique

Ouvrez le terminal (ou la ligne de commande) et écrivez :

pip install music21

📦 Ceci est la bibliothèque music21. Elle est comme un traducteur musical :

• lit les fichiers .mid (ils contiennent de la musique),

• tire des notes et des accords,

• permet de sauvegarder et de créer de nouvelles mélodies.

C'est notre assistant pour transformer la musique en données compréhensibles pour Python et les réseaux de neurones.

2. Préparons la musique

Pour que l'IA apprenne à composer, elle a besoin d'exemples. Comme un enfant : d'abord il écoute les adultes chanter, et ensuite seulement il commence à fredonner lui-même 🎵

🎼 MIDI-файлы nous conviendra, ce sont des « brouillons musicaux » où il est écrit quelles notes sont jouées, dans quel ordre et pendant combien de temps.

🔍 Où les trouver ?

1. Allez sur le site https://bitmidi.com

2. Téléchargez quelques mélodies (par exemple, Bach ou Beethoven)

3. Créez un dossier nommé midi_songs à côté du code

4. Placez-y les fichiers avec l'extension .mid

3. Lire de la musique en Python

Maintenant, le code. Il va lire tous les fichiers MIDI, extraire les notes et les ajouter à la liste. Voici un exemple complet :

from music21 import converter, note, chord
import glob

notes = []

# Parcourir tous les fichiers du dossier midi_songs
for file in glob.glob("midi_songs/*.mid"):
    # Télécharger le fichier en tant que morceau de musique
    midi = converter.parse(file)

    # On obtient toutes les notes et tous les accords, en ignorant les instruments
    elements = midi.flat.notes

    for element in elements:
        if isinstance(element, note.Note):
            # C'est une note unique - par exemple, "C4" (jusqu'à la 4ème octave)
            notes.append(str(element.pitch))
        elif isinstance(element, chord.Chord):
            # Cet accord - par exemple, "60.64.67"
            # Nous prenons les numéros de toutes les notes de l'accord et les connectons en une ligne
            notes.append('.'.join(str(n) for n in element.normalOrder))

📌 Explication :

• glob.glob("midi_songs/*.mid") - recherche tous les fichiers MIDI dans le dossier.

• converter.parse(file) - lit le fichier et le transforme en un objet avec lequel vous pouvez travailler.

• midi.flat.notes — ne prend que les notes (nous ne touchons pas encore au rythme, au tempo et aux instruments).

• note.Note - notes simples (do, ré, mi, etc.)

• chord.Chord — accords (plusieurs notes en même temps, comme dans un accord de guitare).

🎵 Pourquoi gardons-nous les notes sous forme de lignes ?

Parce qu'il est plus facile de les transmettre au réseau neuronal. Par exemple :

• "C4" - note ordinaire.

• "60.64.67" - un accord de trois notes, où chaque chiffre est le numéro de la note en hauteur.

Ce que nous avons réussi

👉 La variable notes contient désormais toute la musique des fichiers MIDI, note par note, accord par accord.

Par exemple :

notes[:10]
# ['E4', 'D4', 'C4', 'C4', 'D4', 'E4', 'E4', 'E4', 'D4', 'D4']

C'est comme si vous écriviez une mélodie à l'oreille, mais pas avec vos oreilles, avec du code 🎧

✅ RÉSULTAT DE LA PREMIÈRE PARTIE :

• Nous avons installé la bibliothèque nécessaire

• Musique téléchargée

• Ils l'ont transformé en une liste de notes

C'est le « matériel de formation » pour l'IA.

🔁 Partie 2 : Formation du réseau neuronal

La dernière fois, nous avons transformé la musique des fichiers .mid en une liste de notes. Maintenant, le plus intéressant est d'apprendre à l'IA à comprendre comment une mélodie est construite et à générer la sienne 🎶

Même si vous venez de commencer à apprendre Python, vous allez vous débrouiller ! Allons-y 🚀

1. Diviser la musique en morceaux

Pour que l'IA apprenne à composer, elle a besoin d'exemples : « Voici un morceau de notes, devinez quelle sera la prochaine. » Comme si vous écoutiez une chanson familière et que vous deviniez ce qui allait se passer ensuite 🎧

# Nous obtenons une liste de notes uniques
pitchnames = sorted(set(notes))

# Créons un dictionnaire : note -> nombre
note_to_int = {note: number for number, note in enumerate(pitchnames)}

sequence_length = 50  # longueur du morceau (50 notes)
network_input = []
network_output = []

for i in range(len(notes) - sequence_length):
    # Prenons 50 notes consécutives
    sequence_in = notes[i:i + sequence_length]
    # La note suivante est la « réponse »se"
    sequence_out = notes[i + sequence_length]
    
    # Convertissons les notes en chiffres
    network_input.append([note_to_int[n] for n in sequence_in])
    network_output.append(note_to_int[sequence_out])

📌 Nous sommes ici :

• Nous trouvons toutes les notes uniques (par exemple, C4, D4, 60.64.67).

• Nous transformons chaque note en un nombre, car le réseau de neurones ne comprend pas le texte, seulement les chiffres.

🧠 En termes simples :

• Nous prenons un morceau de 50 notes comme contexte.

• Et nous demandons au réseau neuronal de deviner la 51e note.

• Nous aurons des milliers d'exemples de ce type et le réseau de neurones apprendra de chacun d'eux.

2. Préparons les données pour le réseau neuronal

Le réseau neuronal fonctionne avec des nombres de 0 à 1, et pas seulement avec des nombres de notes. Par conséquent, nous normalisons les données d'entrée :

import numpy as np
from tensorflow.keras.utils import to_categorical

n_patterns = len(network_input)
n_vocab = len(pitchnames)

# Convertissez au format requis et divisez par le nombre total de notes
network_input = np.reshape(network_input, (n_patterns, sequence_length, 1))
network_input = network_input / float(n_vocab)

# Nous traduisons les sorties dans la catégorie (one-hot)
network_output = to_categorical(network_output)

🔍 Que se passe-t-il ici :

• Nous changeons la forme d'entrée de la liste habituelle au format 3D (nécessaire pour le fonctionnement du réseau neuronal).

• Divisez chaque nombre par le nombre total de notes pour obtenir des valeurs de 0 à 1.

• Les sorties (réponses correctes) sont transformées en une vue spéciale, où chaque note est une « sortie » distincte du réseau.

  3. Construire un réseau de neurones simple

  Maintenant, la magie :

  from tensorflow.keras.models import Sequential
  from tensorflow.keras.layers import LSTM, Dropout, Dense
  
  model = Sequential()
  model.add(LSTM(256, input_shape=(sequence_length, 1)))
  model.add(Dropout(0.3))
  model.add(Dense(n_vocab, activation='softmax'))

  📌 Explication :

  • LSTM est un type spécial de réseau neuronal qui mémorise bien les séquences (par exemple, la musique).

  • Dropout — pour que le modèle n'apprenne pas par cœur, mais apprenne vraiment.

  • Dense(n_vocab, activation='softmax') - à la sortie, le réseau dira : « Je pense qu'il y a 80 % de chances que la prochaine note soit C4, 10 % de chances que ce soit D4... »

  4. Nous formons le réseau neuronal

  model.compile(loss='categorical_crossentropy', optimizer='adam')
  model.fit(network_input, network_output, epochs=50, batch_size=64)

  💡 La formation prendra un peu de temps. Voici l'idée :

  • Le réseau regarde 50 notes.

  • Essaie de deviner la 51ème.

  • Il reconnaît, s'il s'est trompé ou non.

  • Et il ajuste sa « logique » pour deviner plus précisément la prochaine fois.

  Alors, des milliers de fois de suite. Et à chaque fois, elle s'améliore. Comme un enfant qui apprend à composer des mélodies à l'oreille 🎶

  🔥 C'est tout ! Maintenant, nous avons un modèle formé qui peut prédire la prochaine note de la mélodie.

  ---

  🎼 Partie 3 : Générer et enregistrer de la musique

  Vous avez déjà collecté des données, formé le réseau neuronal, et maintenant vient le moment magique : 👉 l'IA composera elle-même de la musique ! Et tu pourras entendre le résultat.

  1. Commençons par une petite mélodie

  Nous avons appris le réseau : « Voici 50 notes, devinez la 51e. » Maintenant, nous faisons l'inverse : On lui donne 50 notes, elle prédit la suivante, puis encore et encore…

  import random
  import numpy as np
  
  # Dictionnaire : du nombre à la note
  int_to_note = {number: note for number, note in enumerate(pitchnames)}
  
  # Choisissez une séquence de départ aléatoire (50 notes)
  start = random.randint(0, len(network_input) - 1)
  pattern = network_input[start]

  💡 Nous prenons un morceau aléatoire (le même format que celui utilisé lors de la formation) - ce sera « l'amorce », le début d'une nouvelle mélodie.

  2. Générer la suite de la mélodie

  Ensuite, nous demanderons au modèle 300 fois de suite : « Quelle note veux-tu mettre ensuite ? »

  prediction_output = []
  
  for i in range(300):  # nous voulons 300 nouvelles notes
      # Préparer l'entrée : reshape + normalisation (de 0 à 1)
      prediction_input = pattern.reshape(1, len(pattern), 1)
      prediction_input = prediction_input / float(n_vocab)
  
      # Prédire la note suivante
      prediction = model.predict(prediction_input, verbose=0)
  
      # Nous prenons l'index de la note la plus probable
      index = np.argmax(prediction)
  
      # Nous transformons le nombre en nom de note
      result = int_to_note[index]
      prediction_output.append(result)
  
      # Mise à jour de la séquence : supprimer la 1ère, ajouter une nouvelle
      pattern = np.append(pattern[1:], [[index]], axis=0)

  🔍 Ce qui est important ici :

  • .reshape(...) - convertissons les données au format requis (1 mélodie, 50 notes, 1 valeur par note).

  • / float(n_vocab) - normalisez les valeurs pour que le réseau puisse fonctionner correctement.

  • model.predict(...) - le réseau prédit les probabilités pour toutes les notes.

  • np.argmax(...) — choisissez celle qui a la plus grande probabilité.

  • append(..., [[index]], ...) - faire défiler la mélodie d'un pas.

  📌 Ainsi, pas à pas, l'IA compose une nouvelle mélodie : d'abord la 51e note, puis la 52e, et ainsi de suite jusqu'à la 300e.

  3. Nous transformons les notes en musique

  Nous avons maintenant une liste de notes sous forme de lignes : ['E4', 'F4', 'G4', '60.64.67', ...]

  C'est la future mélodie, mais pour l'entendre, il faut en extraire un fichier .mid — c'est comme un brouillon pour un programme musical.

  from music21 import stream, note, chord, instrument
  
  output_notes = []
  
  for pattern in prediction_output:
      if '.' in pattern or pattern.isdigit():
          # C'est un accord
          notes_in_chord = pattern.split('.')
          chord_notes = [note.Note(int(n)) for n in notes_in_chord]
          new_chord = chord.Chord(chord_notes)
          output_notes.append(new_chord)
      else:
          # C'est une note unique, de type "C4"
          new_note = note.Note(pattern)
          new_note.storedInstrument = instrument.Piano()
          output_notes.append(new_note)

  📌 Explication :

  • Si la ligne contient des points ou seulement des chiffres, c'est un accord (plusieurs notes).

  • Si la note est régulière, nous faisons note.Note(...) et l'ajoutons comme un son séparé.

  • Toutes les notes/accords sont ajoutés à output_notes.

  4. Enregistrer la musique dans un fichier

  Maintenant, nous créons un flux musical et l'enregistrons dans un fichier :

  midi_stream = stream.Stream(output_notes)
  midi_stream.write('midi', fp='generated_music.mid')

  🎉 C'est tout ! Vous avez maintenant le fichier generated_music.mid — ouvrez-le dans :

  • 🎼 https://musescore.org/ - éditeur de notes et lecteur gratuit

  • 🧠 Même dans le navigateur : https://onlinesequencer.net/

  Appuie sur Play et écoute ce que ton compositeur IA a composé 🤖🎵

  ---

  ✅ Ce que tu as fait :

  • Il a transformé la musique en données

  • J'ai appris au réseau neuronal à continuer les mélodies

  • J'ai reçu ma première composition générée

  🧑‍🎼 Ce n'est plus seulement du code Python. C'est votre co-auteur IA !

  🎁 Voulez-vous ajouter :

  • Une rédaction dans un style particulier ?

  • Le soutien du rythme et de la durée ?

  • Génération de musique en appuyant sur un bouton dans l'application Web ?

  Si le résultat est cool, partage-le sur Telegram ou télécharge-le sur TikTok : les musiciens IA sont à la mode en ce moment 😎

Code source

Vous pouvez trouver le code source complet du projet sur GitHub :

https://github.com/Coursme/ai-composer-python