Laptop-Konzert

Musik live coden mithilfe von Sprachmodellen

Mit ein paar Zeilen Code programmieren Sie im kostenlosen Sonic Pi einen coolen Elektro-Track. Dank umfangreicher Tutorials lernen insbesondere Schüler dabei spielend die Grundlagen von Musik und Informatik. Wir zeigen, wo ChatGPT bei aufwendigeren Songs helfen kann.

Von Hartmut Gieselmann

Seit nunmehr zwölf Jahren können Schüler, DJs und andere Musikbegeisterte in dem kostenlosen Open-Source-Programm Sonic Pi mit Klängen und Songs experimentieren. Nicht nur, dass sich das Programm kinderleicht auf Windows-Rechnern, Macs und sogar Raspberry Pis installieren lässt. Dank der eingebauten Tutorials und der Fähigkeit des integrierten Compilers, Änderungen am Code quasi in Echtzeit umzusetzen, kann man seine Musikstücke live verändern und den pumpenden Beats zuhören, während man eine neue Bassline bastelt. Das macht ungeheuren Spaß und lädt zum Experimentieren ein.

Diese Algorave genannte Musikrichtung hat in den vergangenen Jahren viele Freunde gewonnen (siehe Kasten). Um mitzumachen, bietet Sonic Pi den leichtesten Einstieg, denn die Programmierumgebung lässt sich mit ein paar Mausklicks installieren. Einsteiger nimmt Sonic Pi mit ausführlichen Tutorials in Deutsch und anderen Sprachen an die Hand. Man braucht tatsächlich null Vorkenntnisse: weder in Musiktheorie noch im Programmieren der Skriptsprache Ruby, die Sonic Pi verwendet.

Wer nach den ersten Experimenten, wie wir sie in unseren Einstiegsartikeln in [1], [2| und [3| erklärt haben, komplexere Stücke mit mehreren Song-Abschnitten und Instrumenten komponieren will, muss sich beispielsweise mit der Synchronisation der sogenannten Live-Loops auseinandersetzen und Notenwerte in Listen verwalten. Dabei kommen schnell weit über hundert Zeilen Code zusammen. Und genau hier kann ein generatives Sprachmodell wie ChatGPT helfen, den Überblick zu behalten und die einzelnen Programmteile zu verknüpfen. Dieser Artikel erklärt, wie man dabei grundsätzlich vorgeht, und stellt ein Template vor, das dabei hilft, komplexere Songs zu organisieren.

Wie musikalisch ist ChatGPT?

Bevor wir darauf eingehen, wie ein Sprachmodell beim Musizieren mit Sonic Pi helfen kann, müssen wir zunächst einmal klarstellen, was ein Sprachmodell nicht kann. Zuallererst kann es keine Musik hören und analysieren. Wenn man ChatGPT fragt: „Wie programmiere ich die Kickdrum-Sequenz aus dem Song Blue Monday von New Order?“, gibt der Chatbot zwar eine Kickdrum-Sequenz aus, den typischen Rhythmus des besagten Stücks hält diese aber nicht ein. Und auch bei Melodien oder Bass-Sequenzen ist es eher Zufall, wenn das ChatGPT-Ergebnis passende Töne trifft. Das Sprachmodell patzt auch oft, wenn es darum geht, Notenwerte und Takte zusammenzuzählen.

Befiehlt man ChatGPT, es solle einen Hit im Stil von Depeche Mode in Sonic Pi programmieren, stellt sich schnell Ernüchterung ein: Der Code produziert zwar einen lauffähigen Song, der aber einen lahmen Grundrhythmus hat und mit einer Synth-Stimme immer wieder die gleichen vier Töne als Melodie wiederholt – das langweilt bereits nach wenigen Sekunden.

Die Erklärung ist einfach: ChatGPT wurde zwar mit Millionen Webseiten und Codebeispielen trainiert, kann aber nicht zwischen einer guten und einer schlechten Komposition unterscheiden. Daher generiert es nur sehr einfache Abschnitte, die zwar von der Syntax her oft stimmen, aber niemanden auf die Tanzfläche locken.

Die musikalische Idee und das Rhythmusgefühl müssen also vom Musiker kommen, der seinen Track in Sonic Pi programmiert – egal ob mit KI oder ohne. Für welche Zwecke er die KI einspannt, hat gewaltige Auswirkungen darauf, wem der fertige Song schließlich gehört: An den Melodien aus Text-to-music-Generatoren wie Udio oder Suno, die Hit-Kopien auf einfache Textanweisungen hin fabrizieren, können allenfalls die Künstler, mit deren Material diese Generatoren trainiert wurden, eine Urheberschaft geltend machen – jedoch nicht der Nutzer, wenn er lediglich einen kurzen Prompt als Auftragsanweisung geschrieben hat [4]. Wenn sich die KI-Hilfe jedoch nur auf die technische Umsetzung einer Idee beschränkt, bleiben die Rechte am Song bei dem, der ihn mit Codezeilen komponiert hat.

Programmierhilfen

Wenn Sie die mitgelieferten Tutorials von Sonic Pi durchgearbeitet haben, kennen Sie zwar die wichtigsten Grundelemente. Sie wissen jedoch noch nicht, wie Sie daraus einen umfangreicheren Song bauen. Und genau hier kann ChatGPT helfen. Starten Sie mit einer eigenen kleinen Idee und schreiben Sie die ersten Codezeilen selbst. Sobald Sie nicht mehr weiterkommen, weil Sie die nötigen Befehle oder deren Syntax noch nicht kennen, formulieren Sie das, was Sie tun wollen, auf Deutsch und geben diese Beschreibung zusammen mit Ihrem Anfangscode an ChatGPT weiter.

Da ChatGPT auch beim Verfassen von Code zum Halluzinieren neigt, gehen Sie am besten Schritt für Schritt vor. Dann können Sie den Code nachvollziehen und eventuelle Fehler schneller finden.

Dazu ein Beispiel:

Unser Song soll das in Sonic Pi mitgelieferte Sample vom Amen-Break immer wieder zufällig neu zusammensetzen und so einen sich verändernden Drum-&-Bass-Rhythmus als Grundlage schaffen.

Das genannte Amen-Break können Sie leicht selbst einbauen:

live_loop :amen_brother do
  sample :loop_amen_full
  sleep 16
end

Wenn Sie das Amen-Break in voller Länge mitzählen, kommen Sie auf vier 4/4-Takte. Da eine Pause mit der Länge 1 genau eine Viertelnote lang ist, wartet der Befehl sleep 16 also 16 Schläge, bevor die live_loop wieder zum Anfang springt und das Sample erneut abspielt. Von Haus aus arbeitet Sonic Pi aber mit dem Tempo von 60 bpm (beats per minute, Schläge pro Minute); das ist deutlich langsamer, als das Amen-Break eingespielt wurde. Deshalb ist auch eine lange Pause zwischen den wiederkehrenden Sample-Wiedergaben zu hören.

bpm berechnen

Als Erstes sollte ChatGPT also zeigen, wie man die genaue Länge des Sample-Loops herausfindet und entsprechend das Tempo des Songs anpasst. Wenn wir ChatGPT bitten, genau dies zu tun, spuckt es nicht nur den erweiterten Code aus, sondern erklärt ihn auch Zeile für Zeile. Nach ein paar Iterationen, bei denen wir die Vorschläge ausprobierten und ChatGPT immer wieder mitteilten, was noch nicht funktionierte, hatten wir uns folgenden Code erarbeitet:

sample_loop = :loop_amen_full 
sample_takte = 4.0 
sample_beats = 4 * sample_takte
sample_length = sample_duration(sample_loop)
bpm = (sample_beats*60)/sample_length
use_bpm bpm

live_loop :sample_beat do
  sample sample_loop
  sleep sample_beats
end

Der Befehl sample_duration ermittelt die Länge des Samples in Sekunden. Zusätzlich geben wir an, wie viele Takte das Sample dauert (4.0), sodass das Skript die Anzahl der beats per minute (bpm) berechnet und als Tempo festlegt (140 bpm beim Amen-Break). In der live_loop wartet der sleep-Befehl dann immer die Anzahl der Viertelnotenschläge des Samples ab, bevor die Schleife von Neuem startet. Nach demselben Prinzip können Sie auch andere Samples als Drum-Loop einsetzen. Dazu müssen Sie nur den Namen von :loop_amen_full austauschen und dessen Taktlänge in sample_takte eintragen.

Als Nächstes soll ChatGPT den Code ergänzen. Es soll das Sample bei der Wiedergabe in Achtelnoten zerhacken und diese in zufälliger Reihenfolge wiedergeben. Eine Achtelnote dauert genau den halben Schlag einer Viertelnote. Die live_loop aus dem obigen Beispiel ändert sich dann folgendermaßen:

live_loop :sample_beat do
  divider = 2.0
  note_count = sample_beats * divider
  start_pos = rrand_i(0, note_count-1)
  sample sample_loop, start: start_pos / note_count.to_f, finish: (start_pos + 1) / note_count.to_f
  sleep 1 / divider
end

Als divider ist hier 2.0 eingetragen, um die Viertelnoten in Achtelnoten zu zerlegen. Anschließend berechnet das Skript die Anzahl der Achtelnoten des Samples und daraus eine zufällige Startposition. Der sample-Befehl spielt dann den Sample-Teil zwischen der zufälligen Startposition und der Endposition ab. Deren Werte werden durch den Teiler note_count.to_f auf Werte zwischen 0 und 1 normalisiert. Schließlich wartet der sleep-Befehl eine Achtelnote lang und springt wieder an den Anfang. Probieren Sie aus, was passiert, wenn Sie den divider auf 0.5, 1.0 oder 4.0 setzen.

Schließlich soll ChatGPT die Achtelnoten in zufälligen Geschwindigkeiten im Bereich von 0.7 bis 1.3 vorwärts oder rückwärts abspielen. Dazu berechnet ChatGPT eine zufällige Abspielrate, die entweder positiv oder negativ ausfällt, und ergänzt den Sample-Befehl um den Parameter rate:

abspielrate = rrand(0.7, 1.3) * (one_in(4) ? -1 : 1)
 sample sample_loop, start: start_pos / note_count.to_f, finish: (start_pos + 1) / note_count.to_f, rate: abspielrate

Die 4 in one_in(4) gibt an, dass nur jeder vierte Abschnitt mit einer negativen Rate, also rückwärts abgespielt werden soll. Sie können dort auch höhere Integer-Werte eintragen, um den Anteil der rückwärts abgespielten Abschnitte zu verringern.

Metronom für alle

Damit steht die live_loop mit dem rhythmischen Grundgerüst. Diese soll anschließend einen Basslauf bekommen, der synchron zu der Sample-Loop läuft. Sonic Pi kann zwar von sich aus mehrere Live-Loops starten. Da es aber unterschiedlich lange dauern kann, verschiedene Befehle abzuarbeiten, divergieren die Loops bald, wenn sie nicht von vornherein synchronisiert sind. Auf langsamen Systemen reduzieren Sie die Rechenlast etwas, indem Sie dem Skript den Befehl use_debug false voranstellen.

Zudem benötigen Sie eine live_loop, die ein Synchronisationssignal ausgibt. Das umgestellte Skript mit der Synchronisations-Loop sieht dann so aus:

use_debug false
sample_loop = :loop_amen_full
sample_takte = 4.0
sample_beats = 4 * sample_takte
sample_length = sample_duration(sample_loop)
bpm = (sample_beats * 60) / sample_length
use_bpm bpm
divider = 2.0
note_count = sample_beats * divider

live_loop :metronom do
  cue :tick
  sleep 1 / divider
end

live_loop :sample_beat do
  sync :tick
  start_pos = rrand_i(0, note_count-1)
  abspielrate = rrand(0.7, 1.3) * (one_in(4) ? -1 : 1)
sample sample_loop, start: start_pos / note_count.to_f, finish: (start_pos+1) / note_count.to_f, rate: abspielrate
end

Die :metronom-Loop gibt per cue einen :tick aus. Die :sample_beat-Loop wartet per sync auf diesen :tick, bevor es das Sample abspielt.

Nun kann man weitere Loops ergänzen, beispielsweise mit einem Basslauf. Für Drum & Bass eignet sich etwa der Sinus-Synth. Dazu gibt man die Noten an (etwa e2, g2, a2) und packt diese in eine Ring-Liste, damit man sie leicht austauschen kann. Schließlich sollen die Bassnoten nicht immer nur den Achtelnoten der Metronom-Schleife entsprechen. Deshalb definieren wir eine Liste für die Variable length, die die Länge der Noten in Viertelschlägen angibt. Bei jedem Aufruf von length wird ein zufälliger Eintrag aus 1.0, 2.0 und 4.0 ausgewählt. Die Bass-Loop kann man dann einfach hinter die Beat-Loop hängen:

live_loop :sine_bass do
  sync :tick
  use_synth :sine
  bass_notes = (ring :e2, :g2, :a2)
  length = [1.0, 2.0, 4.0].choose
  tick(:bass)
  if (look(:bass) % (divider*length)).zero?
play bass_notes.tick, sustain: length
  end
end

tick(:bass) lässt einen weiteren Tick in der Loop namens :bass hochzählen. Erst wenn der Rest aus der Division des aktuellen Ticks (abgefragt mit look(:bass)) und (divider*length) gleich Null ist, erklingt eine neue Note. Deren Tonhöhe schaut Sonic Pi in der Ring-Liste bass_notes nach, zählt mit jedem tick eine Stelle weiter und beginnt am Ende wieder von vorn.

Wer die Bassnoten zufallsgesteuert variieren will, kann die Noten ähnlich wie die Länge zufällig wählen lassen, zum Beispiel:

bass_notes = [:e2, :g2, :b2].choose

Die zugehörige play-Zeile lautet dann:

play bass_notes, sustain: length

Spielen Sie damit ein wenig herum. Probieren Sie andere Noten, Längen und Synthesizer abseits des :sine aus.

Weitere Intrumente

Nach dem Prinzip dieser Bass-Loop können Sie weitere Instrumente in neuen Loops hinzufügen. Fangen Sie dazu die Loop immer mit sync :tick an, definieren Sie dann den Synthesizer, listen die Töne in einer Liste auf und lassen die Noten spielen.

Wenn Sie mit einem Divider von 4.0 arbeiten, gibt die :metronom-Schleife das Tempo von Sechzehntelnoten aus. Dann können Sie in Listen beispielsweise Pattern aus 16 Noten notieren. Wenn Sie Pausen einbauen wollen, schreiben Sie in die Liste ein :r und ergänzen eine if-Bedingung bei der Wiedergabe, beispielsweise:

lead_notes = (ring :e4, :e4, :e4, :r, :g4, :g4, :g4, :r, :b4, :b4, :b4, :r, :c5, :c5, :c5, :r)
tick(:lead)
if lead_notes != :r
 play lead_notes.tick
end

Auch hier können Sie für lead_notes wie zuvor alternativ eine Liste mit Notenwerten in [ ] angeben, aus der Sonic Pi mit einem angehängten .choose einen zufälligen Wert wählt.

Mit wachsender Anzahl von Live-Loops wird der Code schnell unübersichtlich. Definieren Sie die Notenfolgen dann besser im vorderen Teil des Skripts. So können Sie diese bei einem Live-Konzert schneller ändern, ohne zu den jeweiligen Loops scrollen zu müssen. Um den Überblick zu behalten, sollten Sie darauf achten, dass die Variablen für die Notenlisten auf den Namen des Instruments hinweisen (etwa bass_notes, lead_notes und so weiter).

Song-Strukturen aufbauen

Etwas größer werden die Umbaumaßnahmen, wenn Sie die einzelnen Loops nicht manuell von Hand starten und stoppen sowie Noten austauschen wollen, sondern eine feste Song-Struktur mit Intro, Strophe, Refrain und Outro abspielen lassen. Dazu müssen Sie einige Variablen und Listen definieren.

Als Erstes eine Liste, in der Sie festlegen, welches Instrument in welchem Songabschnitt spielen soll:

sections = {
  intro: { drums: false, bass: true },
  verse: { drums: true, bass: true },
  outro: { drums: false, bass: true }
}

Dann legen Sie fest, wie viele Takte jeder Abschnitt dauern soll:

section_lengths = {
  intro: 4.0,
  verse: 8.0,
  outro: 4.0
}

Jetzt definieren Sie, mit welcher Sektion der Song starten soll:

current_section = :intro

Nach der :metronom-Loop bauen Sie eine Loop ein, die die Variable current_section von :intro auf :verse und schließlich auf :outro setzt, sobald die jeweiligen Sektionslängen durchlaufen wurden:

define :play_section do |section|
  current_section = section
  takte = section_lengths[section] * 4 * divider
  takte.times do
    sync :tick
  end
end

Den gesamten Songablauf legen Sie schließlich über einen Thread-Abschnitt fest. Dieser stoppt die :metronom-Loop, sobald das Outro durchgespielt wurde:

in_thread do
  play_section(:intro)
  play_section(:verse)
  play_section(:outro)
  live_loop :metronom do
    stop
  end
end

Damit jedes Instrument in seiner Live-Loop auf die richtigen Noten der aktuellen Song-Sektion zugreift, bauen Sie die live_loop-Routinen nach folgendem Muster auf (hier am Beispiel des Basses mit Sechzehntelnoten):

live_loop :bass_line do
  sync :tick
  use_synth :fm
  tick(:bass)
  if sections[current_section][:bass]
  note = bass_notes[current_section].tick
    if note != :r
     play note
    end
  end
end

Zunächst prüft die if-Bedingung, ob das Instrument in der aktuellen Sektion überhaupt spielen soll. Falls ja, dann übergibt sie der Variable note den aktuellen Wert aus der Ring-Liste bass_notes mit dem Namen der aktuellen Sektion. Schließlich prüft eine weitere if-Bedingung, ob nicht eine Pause (:r) gemacht werden soll, und gibt anderenfalls mit play die Note wieder.

Wir haben den gesamten Ablauf mit einigen Zusätzen in einem ausführlich kommentierten Beispiel-Template zusammengestellt, mit dem Sie Ihre Songs strukturieren können (siehe ct.de/ycp7). Betrachten Sie die dort eingesetzten Noten als Platzhalter und fangen Sie an zu experimentieren.

Jenseits der Sequencer

Diese Template-Struktur orientiert sich an typischen Sequencern, die Sechzehntel- oder Achtelnoten im festen 4/4-Takt abspulen. So arbeiten für gewöhnlich Digital Audio Workstations (DAW) oder auch MIDI-Tracker. Der Vorteil ist, dass man die Strukturen leicht nachvollziehen kann. Der Nachteil: Es entsteht ein sehr enges Korsett für den Rhythmus, die Melodien und die Song-Struktur. Das passt gut zu Dance-Tracks mit festen Beats, weniger aber zu Klangexperimenten, die solche Strukturen aufbrechen.

Deshalb sollten Sie sich nicht damit zufriedengeben, mit Sonic Pi einen Tracker oder eine DAW nachzuahmen. Dabei stoßen Sie nämlich schnell an die Grenzen der Entwicklungsumgebung. Nutzen Sie stattdessen die Vorteile und Besonderheiten der algorithmischen Generierung und Manipulation.

Dazu gibt es verschiedene Methoden. Sie können zum Beispiel die Länge der Ring-Listen von 16 Schritten auf weniger Schritte mit einer ungeraden Schrittanzahl verkürzen. Wenn beispielsweise eine Kick-Drum vier Schritte nutzt, die Hihat nur 3 und die Snare 5 Schritte, ergeben sich mit sehr kurzen Zeilen Code ungewöhnliche rhythmische Muster, die sich erst nach langer Zeit wiederholen.

Statt Melodien vorzugeben, können Sie Sonic Pi auch zufällige Töne aus einer Liste wählen lassen.

note = [:a2, :c2, :d2, :e2].choose

Da Sonic Pi mit Pseudo-Zufallszahlen arbeitet, sind die Ergebnisse reproduzierbar, die ungewöhnlichen Stücke klingen also bei jedem Neustart gleich.

Der Sonic-Pi Entwickler Sam Aaron hat dazu zahlreiche Beispiele verfasst, die Sie zusätzlich zum Tutorial in Sonic Pi finden. Erstaunlich ist etwa „Haunted“, das mit nur vier Zeilen Code eine endlose Reihe von Glockentönen erzeugt:

live_loop :haunted do
sample :perc_bell, rate: rrand(-1.5, 1.5)
  sleep rrand(0.1, 2)
end

Oder folgen Sie dem Komponisten Steve Reich, der zwei leicht voneinander abweichende Synchronisationsspuren kombiniert, um sich fortwährend ändernde Polyrhythmen zu erzeugen (Beispiel Reich Phase).

Sie können ChatGPT mit solchen Beispielen füttern und das Modell auffordern, diese zu variieren. Dabei unterlaufen dem Sprachmodell unweigerlich Fehler, aber auch glückliche Unfälle, die Sie auf neue musikalische Ideen bringen. So wandeln Sie den Nachteil, dass Sprachmodelle oft halluzinieren und Fehler machen, in einen kreativen Vorteil.

Fehler finden

Wenn ein vom Sprachmodell vorgeschlagener Code nicht läuft, können Sie den Fehler mit ein paar Hilfsmitteln einkreisen und korrigieren. Zunächst sollten Sie Ihren Code von einer kleinen Idee oder einem Motiv ausgehend immer schrittweise langsam erweitern. Nehmen Sie als Keimzelle ein paar Zeilen funktionierenden Code und bitten Sie ChatGPT um genau eine einzelne Erweiterung. Dann finden Sie mögliche Fehler schneller, als wenn das Sprachmodell gleich mehrere Ergänzungen auf einmal hinzuprogrammieren soll.

Wenn Sie bestimmte Codeblöcke nicht verstehen, bitten Sie ChatGPT, sie Ihnen Zeile für Zeile zu erklären. Zudem können Sie das aus Performancegründen deaktivierte Debugging mit use_debug true wieder einschalten. Dann zeigt Sonic Pi die Zeilen im Code an, in denen es klemmt, und gibt dazu eine Fehlermeldung aus.

Manchmal sitzt der eigentliche Fehler aber woanders. Oft enthalten beispielsweise Variablen andere Zahlen als gedacht. Die möglichen Zustände von Variablen können Sie mit dem Befehl puts variablenname ausgeben lassen, den Sie an beliebigen Stellen im Code einfügen.

Um die Fehlerquelle weiter einzugrenzen, empfiehlt es sich zudem, einzelne Code-Zeilen mit dem #-Zeichen auszukommentieren. Das sollten Sie aber mit Bedacht tun, denn dadurch können neue Fehler entstehen.

Während unserer Testphase reagierte Sonic Pi manchmal nicht mehr, obwohl der Code in Ordnung war. In solchen Fällen half ein simpler Neustart, und die Musik lief weiter.

Fazit

Sonic Pi ist ein wunderbarer Spielplatz, auf dem man nicht nur neue musikalische Ideen ausprobieren, sondern auch gefahrlos mit den Programmierfähigkeiten von Sprachmodellen experimentieren kann. Hier passiert viel Überraschendes, von der komplett missratenen Melodie bis hin zum coolen Zufallsrhythmus; dank Live-Coding fällt beides schnell auf, sodass man Fehler sofort ausbessern und schnell von Version zu Version iterieren kann.

Solche Experimente schulen nicht nur das musikalische Verständnis, sondern helfen auch, die Möglichkeiten und Grenzen von Sprachmodellen zu erkennen. Am besten kommt voran, wer dem Chatbot Schritt für Schritt genau vorgibt, was er tun soll. Die Sprach-KIs sind gut darin, die passende Syntax zu finden; die musikalischen Ideen müssen jedoch vom Anwender kommen.

Deshalb eignet sich Sonic Pi ideal für den Schulunterricht, um Musik und Informatik zusammenzubringen und Schüler spielerisch fürs Coden und für Musiktheorie zu begeistern. (hag@ct.de)

Template und Algorave-Quellen: ct.de/ycp7