🤖 machine learning

Decomposer: Learning to Decompile Symbolic Music to Programs

Le document présente Decomposer, un cadre de post-entraînement en deux étapes qui utilise des données synthétiques et l'apprentissage par renforcement pour décompiler efficacement la musique MIDI symbolique en programmes Strudel lisibles et exécutables, surpassant les modèles existants tant en précision de reconstruction qu'en qualité du code.

Auteurs originaux : Yewon Kim, Apurva Gandhi, David Chung, Graham Neubig, Chris Donahue

Publié 2026-07-03

📖 4 min de lecture☕ Lecture pause café

CC BY 4.0

Auteurs originaux : Yewon Kim, Apurva Gandhi, David Chung, Graham Neubig, Chris Donahue

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous ayez l'enregistrement d'une belle chanson, mais que vous n'ayez qu'une liste géante et désordonnée de chaque note jouée, de chaque coup de batterie et de chaque seconde de silence. C'est comme avoir une recette écrite ainsi : « ajoutez un grain de riz, puis un autre, puis un autre... » au lieu de « cuisez 2 tasses de riz ». Vous entendez la chanson, mais il vous est impossible de changer facilement le tempo, de remplacer les instruments ou d'en comprendre la structure.

Ce document présente DECOMPOSER, un nouvel outil conçu pour rétro-concevoir cette liste désordonnée en un programme musical intelligent et éditable.

Voici comment cela fonctionne, décomposé en concepts simples :

Le gros problème : Le piège du « note par note »

Lorsque vous essayez de transformer une chanson en code, vous êtes confronté à deux obstacles principaux :

Le problème du « Robot » : Un simple script informatique peut transformer la chanson en code parfaitement, mais il l'écrit comme un robot comptant chaque étape individuelle. C'est précis, mais illisible et impossible à éditer pour un humain.
Le problème du « Rêveur » : Les modèles d'IA avancés (comme les chatbots les plus intelligents) peuvent écrire du code magnifique et lisible, mais ils ont tendance à « halluciner ». Ils peuvent écrire un programme qui sonne bien, mais qui ne correspond pas réellement à la chanson originale lorsqu'il est joué.

La solution : Un camp d'entraînement en deux étapes

Les auteurs ont entraîné leur IA, DECOMPOSER, en utilisant un « camp d'entraînement » en deux étapes pour résoudre ces deux problèmes à la fois.

Étape 1 : La phase du « Perroquet » (Affinage supervisé)
D'abord, ils ont créé une immense bibliothèque d'exemples faux mais parfaits appelée STRUDEL-SYNTH. Ils ont demandé à une IA super intelligente d'écrire des programmes musicaux sympas, puis ont exécuté ces programmes pour voir quelles chansons ils produisaient. Cela leur a donné des milliers de paires de « Chanson + Code Parfait ».
Ils ont appris à DECOMPOSER à imiter ces paires. Considérez cela comme un étudiant en musique copiant une partition du travail d'un maître enseignant. Désormais, l'IA sait à quoi ressemble un « bon » code Strudel (un langage pour faire de la musique).

Étape 2 : La phase du « Coach » (Apprentissage par renforcement)
Savoir à quoi ressemble le code ne suffit pas ; l'IA doit apprendre à créer un code qui sonne juste.

L'IA essaie de transformer une chanson en code.
Elle exécute ce code pour entendre le résultat.
Le Coach (Système de récompense) : Un arbitre vérifie deux choses :
1. La Fidélité : Est-ce que la nouvelle chanson sonne exactement comme l'originale ?
2. La Lisibilité : Le code est-il court, ingénieux et facile à comprendre pour un humain ? (par exemple, utiliser « répéter ce motif » au lieu d'écrire la note 100 fois).
Si le code est trop désordonné ou sonne faux, l'IA reçoit une « pénalité ». Si le code est ingénieux et précis, elle reçoit une « récompense ». L'IA apprend de ce feedback pour s'améliorer de plus en plus.

Le résultat : Le meilleur des deux mondes

Le document montre que DECOMPOSER est une solution « Goldilocks » (ni trop, ni trop peu, mais juste ce qu'il faut) :

Il est plus précis que les modèles d'IA généralistes les plus intelligents (qui font souvent des erreurs de jugement).
Il est beaucoup plus lisible que les simples scripts informatiques (qui sont ennuyeux et longs).

Pourquoi cela compte (selon le document)

Les auteurs affirment que cela permet aux musiciens et aux codeurs de prendre une performance musicale brute et d'en faire un programme « vivant ». Au lieu d'avoir simplement un enregistrement, vous obtenez un ensemble d'instructions que vous pouvez modifier. Vous pourriez changer une progression d'accords ou accélérer un rythme en éditant le code, plutôt que de déplacer manuellement chaque note.

Le document note également que cela fonctionne mieux sur la musique avec des motifs clairs et répétitifs (comme la musique électronique de danse) et qu'il apprend encore à gérer parfaitement les styles très complexes ou irréguliers (comme le jazz ou le classique).

En bref : DECOMPOSER est un traducteur qui transforme un enregistrement musical « plat » en un plan musical « intelligent », rendant la musique facile à comprendre, à éditer et à remixer pour l'humain.

Résumé Technique : DECOMPOSER – Apprendre à décompiler la musique symbolique en programmes

Définition du Problème

Le document traite de la décompilation de musique symbolique, définie comme la tâche consistant à récupérer des programmes musicaux exécutables et éditables à partir d'entrées musicales symboliques (spécifiquement MIDI). Bien que la performance musicale implique l'exécution d'instructions de haut niveau, la récupération de ces instructions à partir de la performance résultante est un problème inverse complexe.

Les auteurs instaurent cette tâche sous la forme de la décompilation MIDI-vers-Strudel. Strudel est un langage de domaine spécifique (DSL) pour la composition algorithmique et le live coding avec une syntaxe JavaScript. Contrairement au MIDI, qui représente la musique sous forme de séquences de bas niveau d'événements de notes, Strudel représente la musique via des expressions de motifs de haut niveau, des opérateurs de répétition, de superposition et de structure temporelle.

Le défi central réside dans l'équilibre entre deux objectifs concurrents :

Fidélité (Faithfulness) : Le programme généré, lorsqu'il est exécuté, doit reproduire fidèlement le MIDI d'entrée.
Lisibilité (Readability) : Le programme généré doit être lisible par l'humain et éditable, exposant les structures musicales latentes (ex: progressions d'accords, motifs rythmiques) plutôt que d'offrir une translittération verbeuse note par note.

Les approches existantes échouent à équilibrer ces points : les convertisseurs heuristiques atteignent une haute fidélité mais produisent un code illisible, tandis que les LLM de pointe génèrent souvent un code lisible qui échoue à reconstruire fidèlement le MIDI d'entrée. De plus, la tâche souffre d'un manque de données ; les jeux de données appariés (MIDI, Strudel) sont quasi inexistants, et Strudel est un langage à faibles ressources.

Méthodologie

Les auteurs proposent DECOMPOSER, un cadre de post-entraînement en deux étapes conçu pour optimiser directement l'objectif de décompilation.

1. Construction de Données : STRUDEL-SYNTH

Pour remédier au manque de données d'entraînement appariées, les auteurs construisent STRUDEL-SYNTH, un corpus synthétique de 21 174 paires (programme Strudel, MIDI rendu).

Génération : Un LLM de pointe (Claude-Opus-4.6) est sollicité pour générer des programmes Strudel basés sur des germes musicaux (genre, ambiance, tonalité, etc.) et des germes de style de code (idiomes comme la mini-notation, l'empilement ou l'arrangement).
Nettoyage : Les programmes générés subissent un pipeline de nettoyage comprenant des réécritures par expressions régulières pour corriger les erreurs de syntaxe courantes et un processus d'élagage basé sur l'AST pour supprimer les "voix mortes" (couches qui compilent mais n'émettent aucun son).
Rendu : Les programmes nettoyés sont exécutés via un runtime Strudel sans interface graphique (headless) pour produire le MIDI correspondant.

2. Pipeline d'Entraînement en Deux Étapes

DECOMPOSER utilise une stratégie d'entraînement séquentielle utilisant des modèles à poids ouverts (Qwen3-4B et Qwen3-8B) :

Étape 1 : Fine-tuning Supervisé (SFT)
Le modèle est affiné sur le jeu de données apparié STRUDEL-SYNTH. Cette étape apprend au modèle à produire un code Strudel valide et idiomatique, fournissant un "démarrage à chaud" (warm start) qui empêche le modèle de s'effondrer vers des solutions dégénérées lors de l'apprentissage par renforcement ultérieur.
Étape 2 : Apprentissage par Renforcement (RL)
Le modèle est optimisé davantage via la Normalisation de Politique Découplée par Groupe de Récompense (GDPO - Group Reward-Decoupled Normalization Policy Optimization).
- Entrée : Données MIDI non appariées (aucune référence de code requise).
- Processus : Pour une entrée MIDI donnée, le modèle échantillonne un groupe de programmes candidats. Chaque candidat est exécuté via le runtime Strudel.
- Fonction de Récompense : Une récompense composite $R(\hat{y}, x)$ $R (\overset{y}{^}, x)$ est calculée selon :
  1. Fidélité ( $R_{faith}$ ) : Mesurée par le score F1 des déclenchements (onsets) multi-instruments entre le MIDI d'entrée et le MIDI rendu.
  2. Lisibilité ( $R_{read}$ ) : Mesurée par un juge LLM évaluant une liste de contrôle fixe de 12 critères binaires (rubrique) couvrant la qualité générale du code (formatage, commentaires) et les abstractions spécifiques à Strudel (utilisation d'opérateurs de motifs, symboles d'accords, réutilisation de variables).
- Optimisation : GDPO normalise les récompenses pour chaque composante indépendamment avant agrégation, permettant au modèle d'optimiser à la fois la fidélité et la lisibilité sans que l'une ne domine l'autre.

Contributions Clés

Formulation de la Tâche : L'introduction de la décompilation de musique symbolique comme une tâche distincte, se concentrant sur la récupération d'une structure programmatique de haut niveau et éditable à partir de musique symbolique de bas niveau.
Cadre (DECOMPOSER) : Un cadre de post-entraînement en deux étapes combinant le SFT sur données synthétiques avec le RL basé sur l'exécution sur des données non appariées. Cette approche permet au modèle d'apprendre à grande échelle sans nécessiter de code de référence pour l'étape de RL.
Jeu de Données (STRUDEL-SYNTH) : La publication d'un corpus synthétique à grande échelle de 21 174 paires (Strudel, MIDI), construit via la génération par LLM et l'exécution de runtime, ce qui est environ 30 fois plus grand que le code Strudel écrit par des humains disponible publiquement.
Résultats Empiriques : Démonstration qu'un modèle de 8B à poids ouverts entraîné avec ce pipeline surpasse substantiellement les LLM de pointe fermés en termes de fidélité de décompilation tout en maintenant une lisibilité comparable.

Résultats

Des expériences ont été menées sur des benchmarks MIDI synthétiques (STRUDEL-SYNTH) et réels (LMD, GigaMIDI, NES-MDB, Nottingham).

Fidélité : DECOMPOSER surpasse significativement les LLM de pointe (Claude-Opus-4.6, Gemini-3.5-Flash, GPT-5.5) dans la reconstruction du MIDI d'entrée. Sur le jeu de données LMD, le modèle DECOMPOSER (8B) améliore le score F1 des déclenchements de +0,32 par rapport au meilleur LLM de pointe.
Lisibilité : Contrairement aux convertisseurs heuristiques, qui atteignent une haute fidélité via des transcriptions verbeuses note par note (résultant en de faibles scores de lisibilité), DECOMPOSER produit du code avec des scores de lisibilité (Rubric) un ordre de grandeur plus élevés, comparables aux LLM de pointe.
Diversité : Le modèle évite l'effondrement de la diversité, produisant des structures de code variées plutôt que de s'effondrer sur un unique template de translittération.
Généralisation : Le modèle généralise bien aux jeux de données hors domaine (ex: chiptune, musique folk), bien que les performances varient selon la régularité rythmique et la complexité structurelle du genre d'entrée.

Signification et Revendications

Le papier affirme que DECOMPOSER parvient à combler le fossé entre la fidélité requise pour une reconstruction précise et la lisibilité nécessaire à l'utilité humaine. En récupérant la "structure musicale latente" que le MIDI aplatit en événements individuels, le système permet :

Édition Programmatique : Permettre aux utilisateurs d'éditer des structures musicales de haut niveau (accords, gammes, couches) via le code plutôt qu'en ajustant chaque note individuellement.
Compréhension Musicale : Fournir une représentation intermédiaire (code) qui est plus interprétable pour l'analyse musicale par LLM qu'une séquence brute de notes.
Pipeline Audio-vers-Code : Servir de composant critique pour les futurs systèmes de décompilation audio-vers-code lorsqu'ils sont combinés avec la transcription musicale automatique.

Les auteurs soulignent que l'équivalence fonctionnelle seule est insuffisante pour la décompilation ; le programme récupéré doit être lisible et éditable pour être utile. DECOMPOSER démontre que l'apprentissage par renforcement basé sur l'exécution peut efficacement optimiser ce compromis dans un contexte de langage spécifique à faibles ressources.