🎼 KI-Komponist in Python: Musik von Grund auf neu erstellen

Wie wir einem neuronalen Netz beibringen, Musik zu verstehen, sie zu generieren und in einer Datei zu speichern, um sie anzuhören!

Du schaltest die Musik ein und hörst die Melodie. Und jetzt stell dir vor: Das neuronale Netzwerk „hört“ auch Musik, merkt sie sich – und komponiert dann seine eigene! 🤯

💡 Wir werden ein solches neuronales Netzwerk von Grund auf neu erstellen. Und wir beginnen mit dem ersten Schritt – wir bereiten die Musik in einem für das Training geeigneten Format vor, trainieren das Modell und generieren schließlich die erste Komposition!

🔧 Teil 1: Datenaufbereitung und Grundlagen

1. Installieren Sie das Tool für die Arbeit mit Musik

Öffne das Terminal (oder die Befehlszeile) und schreibe:

pip install music21

📦 Dies ist die Bibliothek music21. Sie ist wie ein Musikübersetzer:

• liest .mid Dateien (diese enthalten Musik),

• zieht Noten und Akkorde heraus,

• ermöglicht das Speichern und Erstellen neuer Melodien.

Dies ist unser Assistent, um Musik in Daten umzuwandeln, die für Python und das neuronale Netz verständlich sind.

2. Bereiten Sie die Musik vor

Damit die KI das Komponieren lernen kann, braucht sie Beispiele. Wie ein Kind: Zuerst hört es zu, wie die Erwachsenen singen, und erst dann fängt es an, selbst zu singen 🎵

🎼 Wir werden MIDI-файлы verwenden — das sind solche „musikalischen Entwürfe“, in denen aufgezeichnet ist, welche Noten in welcher Reihenfolge und wie lange gespielt werden.

🔍 Wo bekomme ich das?

1. Gehe auf die Website wie https://bitmidi.com

2. Lade ein paar Melodien herunter (z. B. Bach oder Beethoven)

3. Erstelle einen Ordner mit dem Namen midi_songs neben dem Code

4. Dateien mit der Erweiterung .mid dort ablegen

3. Lesen von Musik in Python

Jetzt der Code. Er liest alle MIDI-Dateien, extrahiert die Noten und fügt sie in eine Liste ein. Hier ist ein vollständiges Beispiel:

from music21 import converter, note, chord
import glob

notes = []

# Wir gehen alle Dateien im Ordner midi_songs durch
for file in glob.glob("midi_songs/*.mid"):
    # Wir laden die Datei als Musikstück hoch
    midi = converter.parse(file)

    # Wir bekommen alle Noten und Akkorde heraus, ohne die Instrumente zu beachten
    elements = midi.flat.notes

    for element in elements:
        if isinstance(element, note.Note):
            # Dies ist eine einzelne Note - zum Beispiel "C4" (bis zur 4. Oktave)
            notes.append(str(element.pitch))
        elif isinstance(element, chord.Chord):
            # Dieser Akkord ist zum Beispiel "60.64.67"
            # Wir nehmen die Nummern aller Noten im Akkord und verbinden sie zu einer Linie
            notes.append('.'.join(str(n) for n in element.normalOrder))

📌 Erklärung:

• glob.glob("midi_songs/*.mid") - sucht nach allen MIDI-Dateien im Ordner.

• converter.parse(file) — liest die Datei und wandelt sie in ein Objekt um, mit dem man arbeiten kann.

• midi.flat.notes — holt nur Noten (wir berühren noch nicht den Rhythmus, das Tempo und die Instrumente).

• note.Note - einzelne Noten (C, D, E usw.)

• chord.Chord - Akkorde (mehrere Noten gleichzeitig, wie in einem Gitarrenakkord).

🎵 Warum speichern wir Noten in Form von Zeilen?

Weil es einfacher ist, sie an das neuronale Netzwerk zu übergeben. Beispiel:

• "C4" - normale Note.

• "60.64.67" — ein Akkord aus drei Noten, wobei jede Ziffer die Nummer der Note in der Tonhöhe ist.

Was wir erreicht haben

👉 Die Variable notes enthält jetzt die gesamte Musik aus MIDI-Dateien — Note für Note, Akkord für Akkord.

Zum Beispiel:

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

Es ist, als ob du eine Melodie nach Gehör aufschreiben würdest — nur nicht mit den Ohren, sondern mit dem Code 🎧

✅ ERGEBNIS DES ERSTEN TEILS:

• Wir haben die richtige Bibliothek installiert

• Musik heruntergeladen

• Sie verwandelten sie in eine Notenliste

Dies ist das „Trainingsmaterial“ für die KI.

🔁 Teil 2: Training des neuronalen Netzes

Letztes Mal haben wir Musik aus .mid-Dateien in eine Notenliste umgewandelt. Jetzt kommt der interessante Teil: Wir bringen der KI bei, zu verstehen, wie eine Melodie aufgebaut ist, und ihre eigene zu erzeugen 🎶

Auch wenn Sie gerade erst anfangen, Python zu lernen, werden Sie es verstehen! Los geht's 🚀

1. Teilen Sie die Musik in Stücke auf

Damit die KI das Komponieren lernen kann, braucht sie Beispiele: „Hier ist ein Stück Noten – rate mal, was als nächstes kommt.“ Als ob du ein bekanntes Lied hörst und errätst, was als nächstes kommt 🎧

# Wir erhalten eine Liste einzigartiger Noten
pitchnames = sorted(set(notes))

# Erstellen Sie ein Wörterbuch: Note -> Zahl
note_to_int = {note: number for number, note in enumerate(pitchnames)}

sequence_length = 50  # Stücklänge (50 Noten)
network_input = []
network_output = []

for i in range(len(notes) - sequence_length):
    # Wir nehmen 50 aufeinanderfolgende Noten
    sequence_in = notes[i:i + sequence_length]
    # Die nächste Note nach ihnen ist die "Antwort"se"
    sequence_out = notes[i + sequence_length]
    
    # Wir übersetzen Noten in Zahlen
    network_input.append([note_to_int[n] for n in sequence_in])
    network_output.append(note_to_int[sequence_out])

📌 Hier sind wir:

• Wir finden alle einzigartigen Noten (z. B. C4, D4, 60.64.67).

• Wir wandeln jede Note in eine Zahl um, weil das neuronale Netz den Text nicht versteht, sondern nur Zahlen.

🧠 In einfachen Worten:

• Wir nehmen ein Stück von 50 Noten als Kontext.

• Und wir bitten das neuronale Netzwerk, die 51. Note zu erraten.

• Wir werden Tausende solcher Beispiele haben, und das neuronale Netzwerk wird aus jedem lernen.

2. Bereiten Sie die Daten für das neuronale Netz vor

Das neuronale Netzwerk arbeitet mit Zahlen von 0 bis 1, nicht nur mit Notennummern. Normalisieren wir daher die Eingabedaten:

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

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

# Wir übersetzen in das gewünschte Format und teilen durch die Gesamtzahl der Noten
network_input = np.reshape(network_input, (n_patterns, sequence_length, 1))
network_input = network_input / float(n_vocab)

# Wir übersetzen die Ausgänge in der Kategorie (one-hot)
network_output = to_categorical(network_output)

🔍 Was ist hier los:

• Wir ändern das Anmeldeformular von der üblichen Liste in das 3D-Format (dies ist für die Arbeit des neuronalen Netzwerks erforderlich).

• Wir teilen jede Zahl durch die Gesamtzahl der Noten, um Werte von 0 bis 1 zu erhalten.

• Ausgänge (richtige Antworten) werden in eine spezielle Ansicht umgewandelt, in der jede Note ein separater „Ausgang“ des Netzwerks ist.

  3. Bauen Sie ein einfaches neuronales Netzwerk

  Jetzt die 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'))

  📌 Erklärung:

  • LSTM ist eine spezielle Art von neuronalem Netzwerk, das sich Sequenzen (z. B. Musik) gut merkt.

  • Dropout — damit das Modell nicht „auswendig lernt“, sondern wirklich lernt.

  • Dense(n_vocab, activation='softmax') — am Ausgang sagt das Netzwerk: „Ich denke, dass mit einer Wahrscheinlichkeit von 80% die nächste Note C4 ist, 10% — D4…“

  4. Wir trainieren das neuronale Netzwerk

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

  💡 Die Schulung wird einige Zeit in Anspruch nehmen. Das Wesentliche ist:

  • Das Netzwerk betrachtet 50 Noten.

  • Versucht, die 51. zu erraten.

  • Findet heraus, ob sie sich geirrt hat oder nicht.

  • Und passt seine "Logik" an, um das nächste Mal genauer zu erraten.

  So - tausendmal hintereinander. Und jedes Mal wird es immer besser. Wie ein Kind, das lernt, Melodien nach Gehör zu komponieren 🎶

  🔥 Das war's! Jetzt haben wir ein trainiertes Modell, das die nächste Note in einer Melodie vorhersagen kann.

  ---

  🎼 Teil 3: Musik generieren und speichern

  Du hast bereits Daten gesammelt, das neuronale Netz trainiert - und jetzt kommt der magische Moment: 👉 Die KI wird selbst Musik komponieren! Und du kannst dir das Ergebnis anhören.

  1. Beginnen Sie mit einer kleinen Melodie

  Wir haben das Netzwerk gelehrt: „Hier sind 50 Noten — errate die 51.“ Jetzt machen wir das Gegenteil: Wir geben ihr 50 Noten, sie sagt die nächste voraus, dann immer wieder...

  import random
  import numpy as np
  
  # Wörterbuch: von der Zahl — zur Note
  int_to_note = {number: note for number, note in enumerate(pitchnames)}
  
  # Wir wählen eine zufällige Startsequenz (50 Noten)
  start = random.randint(0, len(network_input) - 1)
  pattern = network_input[start]

  💡 Wir nehmen ein zufälliges Stück (das gleiche Format, das während des Trainings serviert wurde) - dies wird der "Startschuss" sein, der Beginn einer neuen Melodie.

  2. Wir generieren die Fortsetzung der Melodie

  Dann werden wir das Modell 300 Mal hintereinander fragen: „Welche Note möchtest du als nächstes spielen?“

  prediction_output = []
  
  for i in range(300):  # Wir wollen 300 neue Noten
      # Wir bereiten den Eingang vor: Umformen + Normalisieren (von 0 bis 1)
      prediction_input = pattern.reshape(1, len(pattern), 1)
      prediction_input = prediction_input / float(n_vocab)
  
      # Wir sagen die nächste Note voraus
      prediction = model.predict(prediction_input, verbose=0)
  
      # Wir nehmen den Index der wahrscheinlichsten Note
      index = np.argmax(prediction)
  
      # Wir wandeln die Zahl wieder in den Namen der Note um
      result = int_to_note[index]
      prediction_output.append(result)
  
      # Wir aktualisieren die Sequenz: Wir entfernen die 1., fügen eine neue hinzu
      pattern = np.append(pattern[1:], [[index]], axis=0)

  🔍 Was hier wichtig ist:

  • .reshape(...) - Konvertieren der Daten in das gewünschte Format (1 Melodie, 50 Noten, 1 Wert pro Note).

  • / float(n_vocab) - Normalisieren Sie die Werte, damit das Netzwerk ordnungsgemäß funktioniert.

  • model.predict(...) — das Netzwerk sagt die Wahrscheinlichkeiten für alle Noten voraus.

  • np.argmax(...) - Wählen Sie diejenige aus, die die höchste Wahrscheinlichkeit hat.

  • append(..., [[index]], ...) — Melodie einen Schritt weiterspielen.

  📌 Schritt für Schritt komponiert die KI eine neue Melodie: zuerst die 51. Note, dann die 52. und so weiter bis zur 300.

  3. Noten wieder in Musik verwandeln

  Jetzt haben wir eine Liste von Noten in Form von Zeilen: ['E4', 'F4', 'G4', '60.64.67', ...]

  Dies ist die zukünftige Melodie, aber um sie zu hören, müssen Sie daraus eine .mid Datei erstellen — dies ist wie ein Entwurf für ein Musikprogramm.

  from music21 import stream, note, chord, instrument
  
  output_notes = []
  
  for pattern in prediction_output:
      if '.' in pattern or pattern.isdigit():
          # Das ist ein Akkord
          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:
          # Dies ist eine einzelne Note, wie "C4"
          new_note = note.Note(pattern)
          new_note.storedInstrument = instrument.Piano()
          output_notes.append(new_note)

  📌 Erklärung:

  • Wenn die Zeile Punkte oder nur Zahlen enthält, ist dies ein Akkord (mehrere Noten).

  • Wenn es sich um eine normale Note handelt, machen wir note.Note(...) - und fügen sie als separaten Klang hinzu.

  • Alle Noten/Akkorde werden in output_notes zusammengefasst.

  4. Speichern Sie die Musik in einer Datei

  Jetzt erstellen wir einen Musik-Stream und speichern ihn in einer Datei:

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

  🎉 Das war's! Jetzt hast du die Datei generated_music.mid — öffne sie in:

  • 🎼 https://musescore.org/ - kostenloser Noten-Editor und -Player

  • 🧠 Auch im Browser: https://onlinesequencer.net/

  Klicke auf Play und höre dir an, was dein KI-Komponist komponiert hat 🤖🎵

  ---

  ✅ Was hast du getan:

  • Verwandelte Musik in Daten

  • Ich habe dem neuronalen Netzwerk beigebracht, Melodien fortzusetzen

  • Ich habe meine erste generierte Komposition erhalten

  🧑‍🎼 Das ist nicht mehr nur Python-Code. Das ist dein KI-Co-Autor!

  🎁 Möchten Sie hinzufügen:

  • Komposition für einen bestimmten Stil?

  • Rhythmus- und Dauerunterstützung?

  • Musikgenerierung auf Knopfdruck in der Webanwendung?

  Wenn es cool ist, teile es auf Telegram oder lade es auf TikTok hoch — KI-Musiker sind jetzt im Trend 😎

Quellcode

Den vollständigen Quellcode des Projekts finden Sie auf GitHub:

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