Rapport de Stage ATIAM - Adrien Ycart

Quantification rythmique dans OpenMusic
Adrien Ycart
To cite this version:

Adrien Ycart. Quantification rythmique dans OpenMusic. Automatique. 2015. <hal-
01202257>
HAL Id: hal-01202257

https://hal.inria.fr/hal-01202257
Submitted on 19 Sep 2015
HAL is a multi-disciplinary open access Larchive ouverte pluridisciplinaire HAL, est

archive for the deposit and dissemination of sci- destinee au depot et a la diffusion de documents
entific research documents, whether they are pub- scientifiques de niveau recherche, publies ou non,
lished or not. The documents may come from emanant des etablissements denseignement et de
teaching and research institutions in France or recherche francais ou etrangers, des laboratoires
abroad, or from public or private research centers. publics ou prives.
Quantification rythmique dans OpenMusic
Rfrents :
Auteur :
Jean Bresson
Adrien Ycart
Florent Jacquemard
Stage de master ATIAM

ralis lIrcam
du 16 fvrier au 14 aot 2015
31 juillet 2015
Rsum
La quantification rythmique est laction de transformer un flux temporel, par exemple une
squence de notes, en une partition, connaissant le tempo. Cette squence de notes peut provenir
de la captation du jeu dun musicien ou tre gnre par un processus compositionnel : cest ce
deuxime cas qui nous intressera. Ltape de transcription faisant partie du processus cratif,
nous cherchons dvelopper un outil permettant aux compositeurs de transcrire comme ils le
souhaitent leurs oeuvres en partitions. Pour cela, nous avons interrog des compositeurs et nous
avons dvelopp un algorithme proposant un ensemble de transcriptions possibles dune squence
de notes, classes selon un critre prenant en compte la prcision de la notation ( quel point la
sortie est fidle lentre) et sa complexit ( quel point la notation est lisible). Nous prsentons
des rsultats de cet algorithme et les comparons ceux de loutil actuel de quantification de
lenvironnement de composition assiste par ordinateur OpenMusic. Nous proposons diffrentes
pistes damlioration pour des travaux futurs.
Abstract
Rhythm quantization is the act of transforming a temporal stream, for example a sequence
of notes, into a music sheet, given the tempo. This sequence of notes can be taken from the
performance of a musician, or generated with computer-assisted composition tools : we will consider
the latter case in this work. Transcription is a part of the creation process, thus we aim to develop
a tool allowing the composers to transcribe their works into music sheets the way they want. To
do so, we interviewed composers and we developed an algorithm that returns a set of possible
transcriptions of a sequence of notes, ranked according to a criterion that takes into account
the precision of the notation (how close the output is from the input) and its complexity (how
readable it is). We present some results of this algorithm and compare them to those returned by
the quantization tool currently used in the computer-assisted composition environment OpenMusic.
We suggest various possible improvements for future work.
Remerciements
Je remercie mes deux encadrants, Jean Bresson et Florent Jacquemard
pour leur aide prcieuse tout au long de ce stage, depuis la dfinition des
thmatiques de recherche jusqu la rdaction de ce rapport. Que ce soit
par leur aide dans la comprhension des concepts manipuls, dans limpl-
mentation des algorithmes dvelopps, ou dans la restitution des travaux
effectus, leur recul et leur soutien mont t indispensables pour mener
bien ce travail de recherche, et je leur en suis extrmement reconnaissant.
Je remercie tous les compositeurs et utilisateurs dOpenMusic que jai

interrogs pendant ce stage pour leur disponibilit et leurs ides. Leur
contact ma normment appris la fois sur leurs mthodes de travail, sur
leurs visions respectives de la composition et sur leurs attentes, qui ont
permi dorienter ce stage et de guider mes recherches.
Je remercie Karim Haddad, pour le temps quil a eu la gentillesse de

consacrer mexpliquer sa vision du rythme et des outils de quantification,
qui maura permi de bien cerner le problme.
Enfin, je remercie mes camarades et collgues pour leurs discussions tou-

jours stimulantes, ainsi que lensemble du personnel de lIrcam pour leur
accueil chaleureux.
Table des matires
1 La quantification rythmique 1
1.1 Description du problme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.1 Explication pralable sur le rythme . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.2 Le problme de la quantification rythmique . . . . . . . . . . . . . . . . . . 2
1.1.3 Deux approches pour la quantification . . . . . . . . . . . . . . . . . . . . . 3
1.2 Reprsentation du rythme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.1 Arbres de rythme dOpenMusic . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2 Arbres de rythme symboliques . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Etat de lart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Entretiens avec les utilisateurs dOpenMusic 8

2.1 Utilisateur 1 : AR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.1 Description de ses travaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.2 Mthode de travail actuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.3 Problmatiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.4 Pistes damlioration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.4.1 Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.4.2 Modes de quantification . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.4.3 Silences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Utilisateur 2 : OM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2.2 Mthode de travail actuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Utilisateur 3 : EP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3.2 Mthode de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4 Utilisateur 4 : GH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4.2 Algorithmes gntiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4.3 Choix de la reprsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.4 Utilisation des algorithmes gntiques pour la quantification . . . . . . . . . 14
2.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3 Automates darbres et quantification 16

3.1 Fondements thoriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.1.1 Automates darbres et grammaires hors-contexte . . . . . . . . . . . . . . . 16
3.1.2 Schma de subdivision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.1.3 Automates darbres pondrs . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.1.4 Arbre de poids minimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1
3.2 Principe de lalgorithme dnumration des meilleures solutions : lalgorithme k-best 19
3.2.1 Entres et sorties de lalgorithme . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.2 Construction de lautomate . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.2.1 Reprsentation interne des arbres . . . . . . . . . . . . . . . . . . 20
3.2.2.2 Format de lautomate . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2.3 Droulement de lalgorithme . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2.3.1 Une tape de lalgorithme . . . . . . . . . . . . . . . . . . . . . . . 21
3.2.3.2 Ajout des candidats suivants la liste des candidats . . . . . . . . 22
3.2.4 Un exemple simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3 Choix des mesures de poids . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4 Dveloppements, valuation et rsultats 27

4.1 Bibliothque k-best . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.1.1 Implmentation modulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.1.2 Mise en forme de lentre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.1.3 Post-traitement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.1.3.1 Construction de larbre de rythme . . . . . . . . . . . . . . . . . . 28
4.1.3.2 Format des rsultats . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.1.4 Grace notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2 Dveloppements pour OMrewrite . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.3 Analyse de complexit de lalgorithme k-best . . . . . . . . . . . . . . . . . . . . . 31
4.3.1 Mise en forme de lentre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.3.2 Construction de lautomate . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.3.3 Obtention des k meilleurs arbres . . . . . . . . . . . . . . . . . . . . . . . . 32
4.3.3.1 Meilleur arbre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.3.3.2 Construction des k-1 arbres suivants . . . . . . . . . . . . . . . . . 32
4.3.4 Construction de larbre de sortie . . . . . . . . . . . . . . . . . . . . . . . . 33
4.3.5 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.4 Rsultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.4.1 Exemples de rsultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.4.2 Comparaisons avec omquantify . . . . . . . . . . . . . . . . . . . . . . . . . 39
5 Bilan et perspectives 44
5.1 Bilan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.2 Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.2.1 Critres de choix des arbres . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.2.1.1 Choix des mesures de distance . . . . . . . . . . . . . . . . . . . . 45
5.2.1.2 Choix des mesures de complexit . . . . . . . . . . . . . . . . . . . 45
5.2.1.3 Choix de la fonction de poids . . . . . . . . . . . . . . . . . . . . . 46
5.2.2 Sur les automates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.2.2.1 Stockage en mmoire des automates . . . . . . . . . . . . . . . . . 46
5.2.2.2 Choisir un autre automate . . . . . . . . . . . . . . . . . . . . . . 46
5.2.3 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.2.3.1 Prciser les paramtres significatifs . . . . . . . . . . . . . . . . . . 47
5.2.3.2 Editeur de schmas de subdivision . . . . . . . . . . . . . . . . . . 48
5.2.4 Apprentissage des prfrences de lutilisateur . . . . . . . . . . . . . . . . . 48
Chapitre 1
La quantification rythmique
La quantification est laction de convertir des donnes valeurs continues (ou discrtes ap-
partenant un grand ensemble de valeurs) en donnes valeurs discrtes appartenant un petit
ensemble de valeurs. Ce problme se pose en particulier lorsque lon souhaite numriser des donnes
analogiques, telles que par exemple un signal acoustique en un fichier audio, ou un signal lumineux
en une image numrique, ou encore lorsque lon souhaite compresser des donnes. Cela se fait
le plus souvent au prix dapproximations, que lon souhaite les moins sensibles possible. Dans le
domaine de la musique, on se confronte au problme de la quantification lors de la transcription
dune performance, dun enregistrement, ou de donnes musicales non quantifies, en partition.
On doit dune part quantifier les hauteurs, cest dire obtenir partir de la donne physique de
la frquence fondamentale la notes de la gamme laquelle elle correspond, dautre part, on doit
quantifier les dures, cest dire transformer la suite des instants de dbut et de fin des notes en
rythmes crits en notation occidentale. Ce stage porte sur ce deuxime problme.
Dans cette section, nous poserons le problme de la quantification, puis nous dcrirons quelques
formalismes darbres de rythme, et enfin, nous ferons un tat de lart des mthodes de transcription
rythmique existantes.
1.1 Description du problme

1.1.1 Explication pralable sur le rythme
Avant de dcrire les principales difficults du problme de la quantification rythmique ainsi que
langle sous lequel nous laborderons, il convient dexpliquer ce quest le rythme et comment il est
dfini dans le systme de notation occidental.
Le rythme caractrise tout ce qui touche lorganisation temporelle de la musique. Il correspond
au flux temporel des dures des notes et accords dune pice de musique.
Dans la musique occidentale, le rythme est dfini par rapport la pulsation. La pulsation, aussi
appele tactus, est la priodicit ressentie lorsque lon coute de la musique, celle naturellement
battue par un auditeur qui lon demanderait de taper des mains en rythme [20]. Le tempo dfinit
la dure de cette pulsation : il donne le nombre dunits rythmiques de base, en gnral, la noire,
quil y a dans une minute. Un tempo de 60 la noire correspond donc 60 noires par minutes,
cest--dire quune noire dure une seconde.
Une fois le tempo fix, les diffrentes dures sont dfinies par division successives de lunit de
temps, comme indiqu Figure 1.1 : une ronde se divise en deux blanches, une blanche se divise
en deux noires, une noire se divise en deux croches, une croche se divise en deux doubles croches,
et ainsi de suite. Le nombre de divisions dune unit de temps peut ne pas tre gal deux, par
exemple, dans le cas dun rythme binaire, une noire est divise en deux croches, mais dans le
1
cas dun rythme ternaire, elle est divise en trois. Dautres divisions moins courantes, appeles
irrationnelles, existent galement. Le rythme est ensuite donn par lassemblage de ces figures de
notes. Les rythmes sont ensuite regroups en mesures, dont la dure est donne par la signature
rythmique, afin dtre manipuls plus facilement en units cohrentes.
Figure 1.1 Division successive des dures : une ronde vaut deux blanches, une blanche vaut deux
noires...
1.1.2 Le problme de la quantification rythmique

De lexplication prcdente, on peut dduire quil y a une triple dpendance entre les dures,
exprimes en secondes, le tempo, exprim en unit par minute, et les figures de notes, qui ap-
partiennent un petit ensemble de fractions de lunit. Dterminer un de ces lments partir
des deux autres dfinit trois problmes : linterprtation, linfrence de tempo, et la quantification
rythmique, comme indiqu en Figure 1.2. Une difficult du problme de la transcription rythmique
rside dans le fait que lon ne connait que les dures, et on souhaite obtenir la fois le tempo et les
figures de notes. Or, ces trois paramtres sont trs fortement interdpendants : pour en estimer un,
on doit connatre les deux autres. Par exemple, on a besoin du tempo pour dterminer la notation
rythmique, mais lestimation du tempo se repose sur une certaine exactitude des instants de dbut
et de fin des notes. En particulier, un tempo ou une signature mal adapts peuvent donner des
transcriptions inutilement compliqus, comme on peut le voir Figure 1.3.
Dures
Quantification Infrence de
rythmique tempo
Figures de
Tempo
Interprtation notes
Figure 1.2 Une reprsentation de la triple dpendance entre dures, tempo et figures de notes, et des
trois problmes quelle dfinit.
2
Figure 1.3 On quantifie deux fois la suite de notes en haut, au milieu sans prciser de tempo ni de
signature, en bas en prcisant les changements de tempo et la signature. On obtient dans le deuxime cas
une notation beaucoup plus intelligible.
Dans ce stage, nous nous intresserons uniquement au problme de la quantification rythmique.

Nous supposerons donc que le tempo est connu, quil soit donn par lutilisateur ou dtect laide
de mthodes algorithmiques.
Le problme de la quantification rythmique est donc celui de lobtention, partir de dures
valeurs relles et dune valeur de tempo, de dures exprimes comme des divisions entires de
la pulsation : il faudra donc approximer ces dures. Il y a alors un compromis trouver entre la
prcision de la notation (cest--dire quel point la partition est fidle lentre) et la complexit
de la notation ( quel point elle est lisible). En effet, il ne faut pas que la partition dnature ce qui
est cens tre jou, mais il faut aussi quelle soit facilement lisible par un musicien et produise un
sens musical. Un exemple est montr Figure 1.4.
a)
b)
c)
Figure 1.4 Figure extraite de [8] : a) Squence quantifier. b) Une notation prcise, mais complexe de
la squence. c) Une autre notation de la mme squence, moins prcise mais moins complexe.
1.1.3 Deux approches pour la quantification

On peut distinguer deux approches du problme :
Approche MIR 1 Les donnes temporelles sont extraites dun enregistrement audio dune
performance par des mthodes de traitement du signal, ou dune captation directe du jeu
1. MIR = Music Information Retrieval
3
dun musicien (enregistrement MIDI), et on veut en retrouver la notation rythmique.
Approche CAO 2 Les donnes temporelles ont t gnres par un processus compositionnel
ou bien dictes par le compositeur sur un clavier, et on veut en faire une partition destine
tre joue par des interprtes.
La posture adopter est lgrement diffrente dans les deux cas. En effet, dans le premier
cas, on peut supposer quil existe une partition de rfrence, laquelle comparer le rsultat de la
quantification. Dans le deuxime cas, il ny a pas une seule bonne partition que lalgorithme doit
donner. En effet, de mme quune ide peut tre crite de diffrentes faons, un mme rythme peut
avoir de nombreuses notations diffrentes, chacune induisant un sens particulier, une interprtation
particulire. Choisir celle qui correspond ce que le compositeur souhaite transmettre est une
tape importante du processus de composition, puisquelle conditionne la faon dont les interprtes
joueront loeuvre et donc le rendu final. Lobjectif ici nest donc pas de trouver la meilleure notation,
mais plutt de fournir au compositeur des outils pour lui permettre dobtenir la partition quil
souhaite, parmi un ensemble de partitions possibles choisies selon des paramtres porteurs de sens
musical.
1.2 Reprsentation du rythme

Le rythme peut tre considr comme une succession de dures, une srie temporelle. De nom-
breuses mthodes de transcription rythmique sen tiennent cette vision linaire du rythme. Nous
explorerons dautres formalismes pour reprsenter le rythme, en particulier les arbres de rythme.
La dfinition mme du rythme repose sur des divisions successives des dures. Cette struc-
ture hirarchique voque donc naturellement les structures arborescentes (cf Figure 1.1). De fait,
la reprsentation arborescente des rythmes est une ide bien tablie, utilise depuis longtemps
[16] et dans diffrents domaines. Diffrents formalismes ont t proposs, chacun pour une utilisa-
tion particulire. Lune des reprsentations les plus utilises est le formalisme darbre de rythme
dabord utilis dans lenvironnement de composition assiste par ordinateur PATCHWORK [15],
puis dans OpenMusic [3], o les arbres de rythme sont utiliss principalement pour la reprsenta-
tion graphique [2]. Parmi les autres exemples, on peut citer les arbres de rythme symboliques [13]
utiliss pour la rcriture de termes, et des reprsentations qui incluent des lments mlodiques
et rythmiques [22] pour la comparaison doeuvres musicales partir de donnes symboliques.
Dans ce stage, nous nous concentrerons particulirement sur les arbres de rythme dOpenMusic
et les arbres symboliques.
1.2.1 Arbres de rythme dOpenMusic

Les arbres de rythme dOpenMusic [3] sont tiquets par des valeurs numriques. On dfinit
une dure de base, puis chaque arbre est crit selon le mme modle :
(D(Subdivisions))
D correspond la dure du noeud, et (Subdivisions) est une liste, ventuellement vide lorsque
le noeud est une feuille, contenant des sous-arbres. La dure D dun noeud est dfinie en proportions
par rapport aux dures de ses cousins. Ainsi, larbre de rythme (1 (1 2 1)) est quivalent (1 (2 4 2)),
et donne le rythme si la dure de base choisie vaut une blanche. Lorsquune dure est ngative,
elle correspond un silence, et lorsquil sagit dun flottant et non dun entier, sa valeur est lie
la prcdente.
2. CAO = Composition Assiste par Ordinateur
4
1.2.2 Arbres de rythme symboliques
Les arbres de rythme symboliques [13], contrairement aux arbres dOpenMusic, ne contiennent
aucune valeur numrique. Les noeuds internes nont pas dtiquettes (ou ventuellement une ti-
quette correspondant larit du noeud, et donc redondante avec la structure de larbre). Les
feuilles sont tiquetes avec 4 symboles. Une feuille tiquete avec le symbole n correspondra une
note, le symbole r donne un silence, le symbole s lie la note avec la prcdente, et le symbole 1+
permet de sommer des dures. La dure de chaque feuille est dfinies par sa position dans larbre :
la dure dun noeud est gale celle de son parent divise par larit du parent, laquelle on ajoute
la dure du cousin de gauche si ce dernier est tiquet avec le symbole 1+.
La figure 1.5 montre la notation dun mme rythme avec chacun des deux formalismes.
Partition rythmique
Arbre symbolique Arbre de rythme d'OpenMusic
Figure 1.5 Un rythme et ses quivalents dans les deux formalismes darbres de rythme dcrits
1.3 Etat de lart

Le problme de la quantification est ancien et complexe. La multiplicit des notations possibles
pour une mme srie de dures en fait un problme dintelligence artificielle difficile. Dans cette
section, nous dcrirons les outils qui ont t dvelopps par le pass pour la transcription ryth-
mique, en nous attardant sur deux outils dvelopps lIrcam : loutil de quantification actuel
dOpenMusic, omquantify, et loutil de quantification par rcriture.
De nombreux quantificateurs existent sur le march, intgrs dans les diteurs de partitions ou
les squenceurs, mais dans limmense majorit des cas, les rsultats sont peu satisfaisants lorsque
les dviations par rapport au rythme original sont trop grandes, ou lorsque les rythmes jous
sont trop complexes. Dautres solutions ont t dveloppes, mais aucune nutilise la structure
arborescente du rythme. Certains systmes se basent sur les rapports entre les dures successives,
qui doivent tre un rapport dentiers les plus petits possibles, en particulier celui dcrit dans [19].
Cet approche est intressante, mais lalgorithme dcrit fait des hypothses assez restrictives : le
rapport de deux intervalles conscutifs est approxim par un quotient de deux entiers dont un
doit tre une puissance de 2. Si cette hypothse est trs souvent vrifie dans le cas de la musique
polyphonique, cest moins systmatique quand on considre une seule voix. Ali Cemgil a propos un
modle baysien pour la transcription rythmique [6], dans lequel il utilise un modle de performance
o lerreur entre lentre et le rythme idal est un bruit gaussien. Le modle de performance le
fait plutt rentrer dans la catgorie des approches MIR prcdemment voques, mais le fait que
le bruit soit gaussien et non li des considrations sur linterprtation dun musicien rend son
utilisation possible dans tous les contexte. Cet approche offre des possibilits intrssantes, comme
par exemple celle de pouvoir prciser les divisions successives du temps que lon autorise, mais
lalgorithme est trs long donner des rsultats, et ne donne quune seule transcription possible
la fois, il ne propose pas plusieurs possibilits. Dans les deux cas, le systme se base sur une vision
linaire du rythme, sans profiter de sa structure hirarchique.
5
Le principe de fonctionnement de lalgorithme de quantification actuel dOpenMusic, omquantify
[18], est dcrit dans [1]. Il se base sur un dcoupage en sous tches de la squence quantifier.
La squence est dabord dcoupe en archi-mesures, puis en mesures, qui correspondent des
segments sur lesquels le tempo est suppos constant. Le tempo peut tre dtermin sur chaque
segment comme tant un pgcd approxim des dures lintrieur du segment. Chaque temps est
divis en n parties gales, avec n allant du nombre de notes dans le temps 32, et les instants de
dbut des notes sont recals sur la subdivision la plus proche. Le rythme choisi est celui obtenu
laide de la valeur de n, cest dire de la grille de quantification offrant le meilleur compromis
entre la prcision (caractrise par la distance entre le rythme original et le rythme quantifi) et la
complexit (les subdivisions du temps sont classes de la moins complexe la plus complexe : 1,
2, 4, 3, 6, 5, 8, 7...). La fonction renvoie une structure rythmique, reprsente sous la forme dun
arbre de rythme OpenMusic.
Cet outil fonctionne, il est trs utilis par lensemble des utilisateurs dOpenMusic, mais il a
plusieurs dfauts. Tout dabord, la grille de quantification est uniforme sur chaque temps, ce qui
signifie quon ne peut pas quantifier plus finement certaines parties du temps plus denses en notes
que dautres parties de temps qui en contiennent moins. Dautre part, lorsque des contraintes ne
peuvent pas tre rsolues, cest dire lorsque deux notes sont recales sur le mme point de la
grille, lune des deux est limine, ce qui nest videmment pas souhaitable. Il serait prfrable
dadopter la notation de grace note (appogiature), cest dire considrer lune des deux comme
un ornement de lautre. Enfin, les silences, ne sont pas grs par lalgorithme, qui prend en entre
une suite de dures et considre que toutes les notes sont conscutives. Pour pouvoir quantifier des
silences, il faut les noter explicitement dans la suite des dures dentre. Des entretiens avec les
utilisateurs de cet outil ont t raliss au cours de ce stage, dont un compte rendu est donn au
chapitre 2, et ont permi de mettre en vidences certains problmes rencontrs par les utilisateurs
de cet outil.
Une autre approche pour la quantification base sur les arbres de rythme a t propose [9] et
implmente dans OpenMusic sous forme dune bibliothque appele OMrewrite, sappuyant sur
la notion de rgles de rcriture [13], cest--dire des transformations darbres dfinies par filtrage
par motif (pattern matching). Ces rgles permettent dobtenir diffrentes notations quivalentes
dun mme rythme (cest--dire de la mme suite de dures), par exemple pour laisser le choix
lutilisateur entre diffrentes notations. Certaines sont conservatives (les dures ne sont pas modi-
fies), et dautres non. A partir dun ensemble de rgles de rcriture, on peut proposer un systme
de quantification, qui commence par gnrer un arbre de profondeur maximale correspondant
lentre, puis applique ces rgles pour le simplifier, comme prsent Figure 1.6.
Figure 1.6 Des rgles de rcriture sont appliques larbre complet gnr partir des dures (arbre
de gauche). On obtient finalement le rythme croche demi-soupir.
Ici, la structure arborescente du rythme est bien exploite, mais le succs de la quantification
dpend grandement des rgles de rcriture utilises et de leur application. En effet, le choix de
lordre dans lequel on applique ces rgles nest pas anodin et peut tre dterminant (en dautres
6
termes, la proprit de confluence nest pas forcment vrifie). Pour avoir un systme efficace, il
faut choisir une stratgie de rcriture, par exemple de la racine vers les feuilles ou linverse. De
nombreuses stratgies de rcriture de termes existent [4], la recherche et limplantation de rgles
et de stratgies de rcriture pertinentes est un problme de recherche compliqu, qui dpasse le
cadre de ce stage. De plus, la structure de larbre de profondeur maximale est dterminante pour le
rsultat final, et elle est fige, on ne peut pas en essayer plusieurs moins de relancer lalgorithme
avec dautres paramtres.
7
Chapitre 2
Entretiens avec les utilisateurs

dOpenMusic
Dans le cadre de ce stage, nous avons rencontr quatre utilisateurs de lenvironnement Open-
Music. Nous les avons interrogs sur leurs travaux, ainsi que la place quy prennent les outils de
quantification et de manipulation de rythmes. Nous avons galement discut des problmes quils
ont rencontrs, et des perspectives damlioration qui pourraient rendre ces outils plus efficaces
la fois pour les utilisateurs interrogs et, dans un cadre plus gnral, pour lensemble de la commu-
naut OpenMusic. Nous ne nommerons pas les utilisateurs, nous les dsignerons simplement par
leurs initiales.
2.1 Utilisateur 1 : AR
2.1.1 Description de ses travaux
AR est un compositeur italien qui travaille sur il canto in ottava rima, une forme de chant
traditionnel italien. Il sagit de chants improviss sur des textes potiques. Les performances sar-
ticulaient sous forme de joutes verbales codifies, avec des changes, de appels, auxquels corres-
pondaient certaines formules mlodiques et rythmiques. Il souhaiterait obtenir des partitions de
ces chants, qui font partie de la tradition orale italienne et nont donc jamais t crites, afin dy
puiser des ides et enrichir son propre vocabulaire musical.
2.1.2 Mthode de travail actuelle

Son processus de travail est le suivant :
Conversion du fichier audio en MIDI : Pour cela, il utilise les logiciels Audiosculpt et Me-
lodyne. Melodyne donne un fichier MIDI plus liss, o par exemple les trilles et vibrati sont
considrs comme une seule note, tandis quAudioSculpt donne un fichier plus proche de
lanalyse audio, mais qui peut comporter des artefacts ou considrer un vibrato comme
une suite de notes diffrentes. AR garde les deux approches, car selon lui, mme les arte-
facts obtenus sont intressants tudier et constituent un matriau pour son processus de
cration.
Ajustement du tempo : Le but est dobtenir un fichier MIDI tempo constant. Il sagit
dun tape de pr-quantification, qui est ralise avec le logiciel Cubase. Cette tape se
dcompose en plusieurs actions :
On choisit un premier tempo approximatif partir des premires mesures du morceau.
8
On fixe les dures en secondes des vnements MIDI, et on dcale la souris les pulsations
pour les faire concider avec des dbuts de notes MIDI. Dans cette tape, on ne recale
que les notes qui correspondent des temps forts. Par exemple, pour une longue phrase,
on ne recalera que le dbut et la fin de la phrase, le milieu sera laiss tel quel. On obtient
ainsi une piste avec des notes de dures inchanges, mais avec un tempo variable.
On fixe ensuite les dures des notes non plus par rapport au temps physique 1 , mais par
rapport la mesure, puis on rend le tempo constant. Cette tape conserve les conci-
dences entre les notes et la pulsation, mais modifie les dures en secondes des notes. On
obtient ainsi un fichier MIDI tempo constant, o les temps forts de la musique sont
recals sur les pulsations.
La Figure 2.2 dtaille cette tape.
Quantification dans OpenMusic : AR charge le fichier MIDI ajust dans OpenMusic, puis
il place ventuellement les sparateurs juste avant les temps forts de la musique (cette tape
nest pas forcment obligatoire, puisque ces temps forts sont en gnral dj recals sur des
dbuts de mesure. Il quantifie ensuite les segments laide domquantify, en prenant comme
tempo celui utilis lors du rajustement du fichier MIDI. Les autres paramtres sont ajusts
la main, en visualisant le rsultat des diffrentes modifications.
Les diffrentes tapes de ce processus sont rsumes dans le diagramme Figure 2.1
Barres de
Tempo mesure
Conversion en Fichier MIDI Ajustement du Fichier MIDI Partition

Fichier audio Quantication
chier MIDI brut tempo ajust
AudioSculpt / Melodyne Cubase omquantify
Figure 2.1 Processus de travail dAR
a) b) c)
Piano roll Piano roll Piano roll
Tempo track Tempo track Tempo track
Figure 2.2 Etape dajustement du tempo. a) Dures non ajustes, tempo constant. Les barres verticales
correspondent aux pulsations. b) Les dures ne sont pas modifies, le tempo nest plus constant. Les barres
rouges correspondent aux pulsations dcales manuellement. c) On rend le tempo constant. Les dures sont
modifies, les coincidences entre les notes et la pulsation sont conserves.
1. On distingue le temps absolu, physique, qui correspond des dures en secondes, et le temps relatif, musical,
qui est li la pulsation et dpend du tempo.
9
2.1.3 Problmatiques
On voit que diffrents moments, le compositeur est amen faire des choix dans le processus
de quantification (par exemple pour choisir quels sont les notes recaler sur des pulsations, quelles
notes laisser libres, comment regrouper les notes en mesures). Ces choix ne sont pas anodins, il
sagit de gestes cratifs forts, qui donnent un sens particulier la musique qui est crite. Une
phrase musicale naura pas le mme sens, ne sera pas interprte de la mme faon en fonction
de la position des temps forts, dfinis par le compositeur lors de lcriture de la partition. Mme
si on pourrait imaginer des algorithmes permettant de rpondre certaines de ces question, par
exemple des algorithmes permettant de maximiser les concidences entre la grille et les notes, ce
nest pas souhaitable, car cest au compositeur quil revient de prendre ces dcisions.
Dautre part, les diffrents choix faits ont tous une importance sur la partition finale, et ils sont
pour la plupart lis entre eux. Le tempo que lon choisit dans Cubase sera conserv pour tout le
reste de la quantification, et le choix de ce tempo se base sur un certain nombre dhypothses faites
sur la quantification du morceau (en particulier, que les temps forts sont jous sans imprcision).
De plus, il ny a pas une unique solution pour chaque problme, le compositeur peut vouloir essayer
plusieurs valeurs de paramtres, et choisir la solution qui lui convient le mieux. On voit quavec
ce genre de processus de travail, linaire, on peut difficilement jouer indpendamment sur chaque
paramtre : on ne peut pas en faire varier un et obtenir le rsultat sans repasser par toutes les
tapes du processus.
Enfin, il arrive que lon veuille transcrire des phrases musicales complexes, de dures diffrentes,
o les temps forts ne sont pas forcment uniformment espacs. Dans ce cas, la transcription peut
se faire selon plusieurs paradigmes : soit on prfre faire varier le tempo, soit on fait au contraire
varier la signature rythmique. Par exemple, en 4/4, pour noter une mesure constitue de cinq
notes de longueur gales, on pourra soit conserver la mesure 4/4, et noter un quintolet, soit utiliser
exceptionnellement une mesure 5/4. Dans le premier cas, il faudra que le tempo soit plus lent que
dans le deuxime pour obtenir un rsultat quivalent. Ces deux notations ont des sens diffrents,
et peuvent donner lieu des interprtations diffrentes (par exemple, le quintolet pourra tre
interprt plus librement rythmiquement que les cinq noires, o il sera plus important que les 5
notes aient des longueur gales car elles sont directement lies la pulsation), et un compositeur
peut vouloir choisir entre les deux.
2.1.4 Pistes damlioration

2.1.4.1 Interface
On se rend compte que dans la mthode de travail dAR, de nombreux lments sont ajusts
la main, en fonction du rsultats, de la partition quils produisent. Un point important serait de
pouvoir facilement modifier chacun des paramtres et des choix qui ont t faits dans une interface
unifie. On viterait ainsi de nombreux allers retours entre les diffrents logiciels (en particulier
entre Cubase et OpenMusic), et on pourrait voir rapidement linfluence quont les changements
effectus sur la partition (par exemple, si on dcide daligner les notes sur le temps diffremment,
il est pnible davoir reprendre tout le processus avant de voir comment ces changements se
traduisent sur la partition).
Un exemple prcis : Pour ajuster le fichier MIDI, AR peut vouloir essayer diffrents ajustements,
en cherchant par exemple faire concider au mieux, entre deux notes fixes sur des temps, les
notes et les temps du mtronome. Pour faire a, il est oblig deffectuer ses modifications dans
Cubase, exporter le fichier MIDI, et quantifier dans OpenMusic. Si il pouvait faire directement
cette opration dans OpenMusic, il trouverait plus facilement le meilleur ajustement.
10
2.1.4.2 Modes de quantification
Pouvoir choisir quel paramtre on prfre fixer, et quel paramtre on veut faire varier pourrait
tre un contrle important pour la quantification, comme nous lavons expliqu dans la partie
prcdente. Pour noter un rythme complexe, avec des mesures de dures diffrentes, on peut :
Fixer le tempo et la signature rythmique. On obtient une notation souvent complexe, difficile
dchiffrer, qui ne reflte pas forcment le sens musical de la phrase
Fixer la signature rythmique, et faire varier le tempo dune phrase lautre. Cette notation
peut donner lieu des rythmes complexes mais a lavantage de dcouper en units cohrentes
la musique
Fixer le tempo, et faire varier la signature rythmique. Si on arrive trouver un diviseur
commun, ou au moins approxim, toutes les dures de lensemble des phrases quantifier,
on peut vouloir utiliser cette unit comme base commune pour la transcription, crire les
rythmes par rapport cette base et faire varier la signature en fonction de la longueur de
chaque phrase. Ce choix va en gnral donner lieu des rythmes plus simples dchiffrer,
mais des mesures aux signatures plutt complexes et changeantes.
Un exemple est montr Figure 2.3
Tactus constant Signature constante
=60 =100
10 6 4
8 8 4
Figure 2.3 Deux grilles diffrentes pour quantifier des phrases de dures diffrentes
2.1.4.3 Silences
Au cours de ces travaux, AR a remarqu que souvent, la dure des silences, des respirations,
ntait pas quelconque, elle faisait partie de la musique. Ces respirations ont un sens smantique,
qui nest pas vraiment analys dans ltat actuel, car seules les dures des notes sont prises en
compte, et on les suppose toutes conscutives. Il ny a pas donc de quantification des silences
proprement parler si lon utilise loutil omquantify tel quel. Il existe nanmoins un moyen de
quantifier des silences. On peut appliquer au pralable la fonction true-durations lentre
quantifier. true-durations est une fonction qui prend en entre un objet chord-seq, cest dire
une squence de notes ou daccords, et renvoie une liste de dure. Cette liste de dures est telle que
les silences qui taient prsents dans lobjet chord-seq sont rendus explicites (ils sont nots avec
des dures ngatives) et lorsque deux notes conscutives se superposent dans lobjet chord-seq, la
premire est raccourcie jusquau dbut de la deuxime. On peut ainsi quantifier correctement une
partition monophonique contenant des silences, puisque les dures des silences sont explicites, et
seront quantifies comme les autres dures, mais cette fonction est mconnue des utilisateurs.
2.2 Utilisateur 2 : OM
OM tudie dans le cadre de sa thse en musicologie le chant non mlodique francophone dans
le rap, le ragga et le punk. Il essaie en particulier de dfinir ces styles, trouver des diffrences et des
points communs entre ces courants, et mettre en vidence leurs singularits. Pour cela, il tudie
en particulier le placement rythmique de la voix dans ces styles (temps forts, dbuts et fins de
phrases), et cette fin, utilise des outils de quantification rythmique.
11
2.2.2 Mthode de travail actuelle
Son processus de travail est le suivant :
Extraction de syllabes : Pour cela, il utilise AudioSculpt. Il extrait automatiquement les
phonmes et recale la main leurs instants de dbut pour les faire correspondre linstant
de dbut peru. Il obtient ainsi une liste dinstants de dbuts de phonmes, ainsi que diverses
autres annotations qui ninterviennent pas dans le processus de quantification.
Extraction de beats : Toujours dans AudioSculpt, OM utilise Ircam Beats pour dtecter le
tempo, ainsi que les mesures et les premiers temps dans ses morceaux. Il obtient ainsi une
liste dinstants correspondant aux pulsations, regroupes par quatre (par mesure).
Quantification : Pour quantifier, il rcupre les premiers temps de chaque mesure et utilise ces
marqueurs pour dcouper le fichier dentre en mesures. Il quantifie ensuite avec omquantify
sur chaque mesure. Il obtient ainsi une partition par mesure, puis les concatne pour obtenir
la partition finale. Les rythmes obtenus peuvent parfois tre inutilement compliqus, il
interdit donc les subdivisions par 5 et par 7, et obtient des rsultats satisfaisants.
Son processus de travail est rsum sur le diagramme Figure 2.4
Extraction de Premiers temps

mesure
Ircam Beats
Extraction de Liste d'instants Dcoupage en Liste d'instants

Fichier audio Quantication Partition
phonmes mesures par mesure
AudioSculpt + recalage omquantify
Figure 2.4 Processus de travail dOM

Dans ltat actuel, la quantification est satisfaisante pour OM. Les rythmes obtenus sont la fois
fidles ceux qui ont t chants, et ne donnent pas lieu des notations inutilement compliques.
Le processus de travail est ralis par un patch OpenMusic qui fonctionne bien et dont les diffrents
paramtres sont facilement accessibles et modifiables.
Le seul inconvnient est que les sparateurs utiliss pour dcouper le fichier dentre en mesure
doivent tre forcment lis une note. Or il ny a pas forcment une note chante sur le premier
temps de la mesure. Dans ce cas, le sparateur nest pas pris en compte. Ce cas se produit rarement,
donc on na jamais plus de deux ou trois mesures regroupes en un segment Kant, cela ne pose
donc pas trop de problmes pour cette application prcise. Il pourrait cependant tre utile dans
dautres cas de ne pas tre contraint de lier un sparateur ncessairement un segment, mais de
pouvoir le placer nimporte o, y compris lorsquil ne sagit pas dun dbut de notes (silence, note
tenue).
On voit aussi que ici, la quantification est faite indpendamment pour chaque mesure (les
paramtres utiliss sont les mmes pour toutes les mesures, mais lalgorithme de quantification
na aucune connaissance sur le morceau au del de la mesure considre). Ici, les rsultats sont
satisfaisants, et les rythmes sont assez simples. Cependant, avoir une approche plus globale, en
prenant en compte les choix de quantification faits dans les autres mesures pourrait donner de
meilleurs rsultats dans le cas gnral.
12
2.3 Utilisateur 3 : EP
EP est un compositeur italien. Il souhaite composer une oeuvre en prenant comme base la
dcomposition harmonique dun son de clarinette.
2.3.2 Mthode de travail

Pour obtenir sa partition, EP commence par analyser le son de clarinette sous AudioSculpt,
et en dduit les frquences de chaque harmonique. Il cre ensuite plusieurs voix, chacune jouant
en boucle une note correspondant un harmonique. La priode de rptition de chaque note est
une fonction de sa hauteur : plus une note est grave, plus la priode sera grande. Il obtient ainsi
une partition polyrythmique. Il retravaille ensuite ce matriau en supprimant des groupes de notes
pour obtenir la partition quil dsire.
Cette oeuvre a une structure par dfinition assez lacunaire, constitue principalement de notes
tenues et de silences. Comme par dfaut, omquantify considre que toutes les notes sont lies les
unes aux autres, il utilise ensuite le quantificateur de bach (bibliothque de CAO pour MaxMSP
[24]) pour obtenir une partition de son oeuvre.

Le point le plus vident qui ressort de cet entretien est la diffictult de la gestion des silences.
On ne peut pas ici quantifier quavec les dures, en considrant que toutes les notes sont lies sans
corrompre lessence mme de loeuvre. Il faut que les silences soient pris en compte au mme titre
que les notes, car ils sont, comme ces dernires, des lments indispensables de la musique. En
particulier, lorsque la partition commence par un silence, il ne faudrait pas quil soit limin, car
on risquerait de dcaler les voix entre elles, compromettant le bon rendu de la pice. Ce problme
peut tre rsolu laide de la fonction true-durations dj voque. Or cette fonction est souvent
inconnue des compositeurs, alors mme quelle rpond exactement leurs besoins. Il pourrait tre
utile de la rendre plus facilement visible, ou de lintgrer mieux aux outils dj existants.
Un autre point qui a t soulev est la prise en compte ou non de variations linaires de tempo
(accelerando, rallentando). Pouvoir prciser au quantificateur les sections sur lesquelles on veut que
le tempo reste constant, et celles sur lesquelles le tempo peut varier linairement simplifierait les
notations dans le cas o cette variation de tempo est dcide lavance (cela vite en particulier
de dfinir un nouveau tempo chaque mesure avec un faible incrment de pulsations par minutes).
2.4 Utilisateur 4 : GH
GH est un compositeur canadien. Il ne travaille pas directement sur omquantify, mais plutt
autour de la reprsentation du rythme dans OpenMusic. Il travaille sur la gnration de phrases
musicales laide dalgorithmes gntiques, et cherche en particulier trouver une bonne repr-
sentation pour pouvoir gnrer des rythmes avec de tels algorithmes.
2.4.2 Algorithmes gntiques

Les algorithmes gntiques visent modliser une volution similaire a slection naturelle. Le
principe gnral de tels algorithmes est le suivant :
13
On a une population de dpart, qui correspond des solutions possibles dun certain pro-
blme (dans notre cas, par exemple, des squences de notes). Elle peut tre soit initialise
alatoirement, soit choisie par lutilisateur.
On effectue des croisements entre les individus de cette population. Cela revient crer de
nouveaux individus, mlangeant des caractristiques dindividus existants.
On applique des mutations sur certains de ces individus. Cela correspond effectuer de
petites modifications sur les individus.
On slectionne selon un certain critre les meilleurs individus de la population. On applique
nouveau lalgorithme sur cette population rduite, et on rpte cette squence dtapes
jusqu ce que le rsultat soit satisfaisant.
A partir de cet algorithme gnral, il faut rpondre 4 questions pour obtenir un algorithme
appliquable la gnration de rythmes :
Comment effectuer les croisements entre individus ?
Comment faire les mutations ? La question sous-jacente est celle de la dtermination du sens
quon donne "petite modification".
Comment choisir les meilleurs individus ?
Quelle reprsentation des rythmes choisir pour effectuer ces modifications ?
2.4.3 Choix de la reprsentation

Le problme du choix de la reprsentation est la fois central et dlicat, car il est trs li la
dfinition des croisements et mutations.
La premire option consiste rutiliser le formalisme des arbres de rythme dj utilis dans
OpenMusic. Cette reprsentation est bonne car elle tient compte de la structure intrinsquement
arborescente du rythme. Cependant, un problme de continuit entre la reprsentation et le rsultat
musical se pose : une petite modification de la structure de larbre peut entraner une notation, et
donc un rsultat musical trs loign (si on touche par exemple un noeud interne de larbre), et
de mme, une petite modification du rsultat musical peut donner un arbre compltement diffrent
(si par exemple on retarde un peu une note joue sur un temps, il faudra reprsenter un rythme
avec une granularit beaucoup plus fine, et donc beaucoup augmenter la profondeur de larbre).
Par contre, avec ce formalisme, il est assez facile dimaginer des croisements entre arbres. On peut
par exemple imaginer pour cela quon intervertit deux sous-arbres ayant leurs racines au mme
niveau dans larbre, et en prenant tout jusquaux feuilles.
La deuxime option consiste saffranchir de cette structure arborescente, et de ne considrer
que le rsultat musical. Ici, il est plus facile de dfinir une mutation (par exemple, un petit d-
placement dun onset ou dun offset). Cependant, on perd la structure arborescente, et on risque
dobtenir des rsultats peu musicaux. Cest la solution envisage jusqu prsent par GH. Dans son
formalisme, un rythme est reprsent par :
Un nombre donnant la granularit de la grille
Un nombre binaire de longueur gale au nombre prcdent, o un 1 signifie quune note est
joue, un 0 correspond un silence.
Par exemple, (4 1101) correspond au rythme "noire noire soupir noire". Dans ce cas, les croi-
sements peuvent poser des problmes. Si par exemple notre squence est compose de plusieurs
couples (granularit ;nombre binaire), on ne pourra pas intervertir nimporte quel couple de sous-
squences car on risquerait de corrompre le format de la squence.
2.4.4 Utilisation des algorithmes gntiques pour la quantification

Les algorithmes gntiques permettent de rsoudre de nombreux problmes, en fonction des
choix de fonctions de slection, de mutation et de croisement. Si lon veut les appliquer au problme
de la quantification, il faudra prendre des prcautions quant ces fonctions. La fonction de slection
14
devra tre une fonction valuant une distance par rapport la squence non quantifie, pondre
par la complexit du rythme quantifi. Les fonctions de mutation et de croisement devront en
particulier garantir que le nombre de notes nest pas modifi. Cela implique que la mutation ne
devra pas rajouter ni enlever de notes (cest dire de feuilles). On pourra donc par exemple
modifier la dure dun noeud de larbre (ce qui change la dure relative de la section descendant de
ce noeud), ou encore modifier la structure de larbre sans changer le nombre de feuille (par exemple
en supprimant un noeud interne et en faisant remonter tous ses fils). La fonction de croisement
devra faire en sorte de nchanger que des motifs (cest dire des sous-arbres) contenant le mme
nombre de notes.
Les algorithmes gntiques peuvent proposer une alternative omquantify, comme nous lavons
vu plus haut, quelques restrictions prs (notamment sur le nombre de notes dans la squence).
Avec des fonctions de mutation et de slection bien penses, on pourrait peut-tre trouver plus
facilement une bonne notation pour une entre particulire, fidle, simple, et potentiellement assez
diffrente de celle obtenue avec omquantify (la structure de larbre dpendra de ses diffrentes mu-
tations, et non dun schma de subdivision prdfini). Cependant, il nest pas forcment judicieux
dutiliser ces algorithmes dans ce but. En effet, les algorithmes gntiques sont assez lourds en cal-
cul, et convergent en gnral au bout dun temps assez long. Or, nous lavons vu, les compositeurs
ne recherchent pas forcment loutil qui leur renverra la meilleure partition pour leur oeuvre, ils
recherchent plutt un outil permettant de tester les diffrents paramtres et visualiser des rsultats
correspondants facilement et rapidement. Cela peut donc tre une alternative, mais cela ne semble
pas tre la direction prconise par les compositeurs rencontrs.
2.5 Conclusion
Les principales conclusions que nous pouvons dgager de ces entretiens sont :
Contrle du compositeur : Le choix dune notation nest pas anodin, et fait partie du pro-
cessus de composition. De plus, les diffrentes tapes de la production dune partition ont
toutes une grande importance sur le rsultat final. Il est donc important que les outils fournis
facilitent le contrle du compositeur sur la partition finale, par exemple en lui permettant de
visualiser facilement le rsultat des diffrentes modifications ou en lui proposant de choisir
parmi plusieurs solutions possibles au lieu de donner une seule solution.
Gestion des silences et des grace notes : Ces aspects de la quantification sont assez mal
exploits par les utilisateurs. omquantify ne gre pour linstant pas directement les silences
dans les suites de notes, puisque seuls les onsets sont pris en compte. Nanmoins, il existe
des fonctions permettant de quantifier les silences, mais elles ne sont en gnral pas connues
des utilisateurs. De mme, certaines mthodes existent pour quantifier les grace notes,
mais le formalisme des arbres de rythme ne le prend pas en compte.
Fixer les temps forts : Il nexiste pas de mthode simple permettant de dfinir quelles notes
sont censes tomber sur des temps, o doivent tre les barres de mesure, ainsi que dautres
paramtres importants du point de vue smantique (quil revient au compositeur de dfinir
et non un algorithme).
Tactus, signature, tempo : Lorsque lon veut quantifier des phrases de dures (en seconde)
diffrentes, on peut soit garder un tempo constant et faire varier la signature rythmique, soit
faire varier le tempo en gardant une signature constante. Un schma reprsentant ces deux
modes de quantification est donn Figure 2.3. On peut aussi prfrer noter des variations
linaires du tempo (accelerando, decelerando), plutt que de faire appel des rythmes ou
des notations plus complexes. Les compositeurs sont demandeurs doutils permettant de
naviguer entre ces diffrentes notations.
15
Chapitre 3
Automates darbres et quantification
Suite aux entretiens raliss, nous avons essay de dvelopper un outil plus performant vis vis
des problmes voqus. Notre systme prend en compte les silences et les grace notes. Nous avons
galement propos une solution au problme du contrle du musicien en dveloppant un algorithme
permettant au compositeur de choisir entre plusieurs quantifications possibles pour une srie de
dures donne, et ce avec peu de calculs. Cette solution a t dveloppe en se basant sur la classe
dalgorithmes, appels algorithmes k-best, dcrite dans [12]. Ils permettent, laide de techniques
de programmation dynamique, de renvoyer, parmi une classe darbres prdfinie, les arbres de poids
les plus faibles selon une certaine mesure. Les poids sont valus de faon paresseuse, ce qui rend
ces algorithmes efficaces dun point de vue computationnel. De plus, ces algorithmes permettent
une structuration du rythme plus complexe que la division de la pulsation en partie de dures
gales propose par omquantify.
Dans cette partie, nous commencerons par voquer les points thoriques sur lesquels notre algo-
rithme se repose, puis nous dcrirons notre version de lalgorithme k-best ainsi que les modifications
que nous lui avons apportes pour ladapter la quantification rythmique.
3.1 Fondements thoriques

Les arbres de rythme dans OpenMusic peuvent tre vus comme des arbres de drivation de
grammaires hors-contexte. Le fait de les considrer comme tels ouvre la voie lutilisation des
automates darbres et tous les outils qui ont t dvelopps autour de ce formalisme [7].
3.1.1 Automates darbres et grammaires hors-contexte

Les automates darbres sont un type de machines tats finis. Ils sont trs similaires aux
automates standards, qui oprent sur les mots [11], ceci prs que les transitions ne se font pas
dun tat un autre tat, mais dun tat un ensemble dtats. De mme quun automate permet
de reconnaitre ou de gnrer les mots qui appartiennent un langage rgulier, un automate darbres
permet de reconnaitre ou de gnrer les arbres qui appartiennent un langage rgulier darbres ou,
de manire quivalente, reconnaitre lensemble des arbres de drivation des mots gnrs par une
grammaire hors-contexte. Nous utiliserons donc les automates darbres pour gnrer des arbres de
drivation dune grammaire hors-contexte. Chaque noeud de larbre est associ, lors du calcul de
lautomate, un tat de lautomate, qui correspond un symbole de la grammaire hors-contexte.
Cette grammaire est dfinie par un schma de subdivision, qui dcrit les subdivisions successives
possibles des units de temps. Un exemple explicitant le lien entre rythme et grammaires hors-
contexte est donn Figure 3.1 : la grammaire hors contexte est donne gauche, le mot gnr
16
par la grammaire est la suite des dures donne par les feuilles de larbre, et larbre de rythme de
sortie est larbre de drivation de cette grammaire qui permet dobtenir les dures considres.
Figure 3.1 [16] Un rythme et larbre de drivation correspondant selon la grammaire hors-contexte
dcrite gauche : la structure de larbre de drivation est comparable aux arbres de rythme utiliss dans
ce stage.
3.1.2 Schma de subdivision

Le schma de subdivision dcrit les subdivisions possible du segment temporel dentre. En ce
sens, il dcrit un grammaire hors contexte. A chaque niveau, plusieurs subdivisions peuvent tre
autorises. Pour dcrire cela, le schma est donn sous forme de listes imbriques. Un schma est
dfini rcursivement comme suit :
Schema = AndList
AndList = liste de OrList
OrList = valeur ou liste de AndList
Les lments dune AndList correspondent des divisions successives, et les lments dune
OrList correspondent diffrents choix de subdivisions une profondeur donne. Les deux types
de listes sont reprsents par des listes simples, mais pour en faciliter la lecture, nous sparerons
les lments des OrList par des barres verticales : | . Plusieurs exemples de schmas sont donns,
ainsi que les subdivisions possibles auxquels ils correspondent :
(3 2 2) : On divise le segment en 3, puis on redcoupe chaque subdivision en 2, puis nouveau
en 2.
((2|3) 2 2) : On a le choix entre les schmas (2 2 2) et (3 2 2)
((2|3) ((2 3) | ((3|5) 2))) : Pour la premire division, on peut diviser soit en 2, soit en 3. En-
suite, on peut soit diviser en deux puis en 3, soit diviser en 3 ou en 5, puis en 2. Cela revient
avoir le choix entre les schmas (2 2 3), (2 3 2), (2 5 2), (3 2 3), (3 3 2) et (3 5 2).
Ainsi, lexemple de la Figure 3.1 correspond un schma de subdivision gal (2 2 2 2).
On a la proprit suivante :
Lensemble des arbres de rythme compatibles avec un schma de subdivision est un langage
dautomate darbre
En effet, partir dun schma, on peut construire une grammaire hors contexte. Par exemple,
le schma ((2|3) ((2 3)((3|5) 2))) permet de gnrer la grammaire hors contexte suivante :
17
racine 21 | 31 |
21 22 | 32 | 52 |
31 22 | 32 | 52 |
22 33 |
32 23 |
52 23 |
23
33
Ici, le symbole signifie quon ne resubdivise pas, cest le seul symbole terminal.
3.1.3 Automates darbres pondrs

On peut galement attribuer des poids aux arbres, et dfinir ainsi un automate darbres pondr
[10]. Un automate darbre standard est une application associant un arbre une valeur boolenne :
vrai si larbre est reconnu, cest dire si larbre appartient au langage darbres considr, faux
sinon. Un automate darbre pondr est une application qui associe un arbre une valeur de poids
dans un semi-anneau. La proprit de compositionnalit, qui dit qu partir de deux automates
darbres, on peut construire un automate reconnaissant lintersection des deux langages, stend
au cas pondr de la faon suivante :
A partir de deux automates darbres pondrs, on peut construire un automate retournant
pour un arbre le produit des poids retourns par les deux automates.
Pour attribuer ces poids, on sinspire du principe de dcision baysien dcrit dans [6] :
P (rythme|entree) P (entree|rythme)P (rythme)

Cette quation peut sinterprter de la faon suivante :
P oids d0 un arbre (distance entre l0 entree et le rythme)(complexite du rythme)
Le poids dun arbre est donc vu comme le produit dune mesure de distance et dune mesure
de complexit. Le choix de ces mesures est dterminant, nous y reviendrons la partie 3.3. Une
fois ces mesures dfinies, le problme de la transcription revient trouver larbre de poids minimal
que lon peut gnrer avec la grammaire dfinie au pralable.
3.1.4 Arbre de poids minimal

Trouver larbre de poids minimal est un problme facile conceptuellement, mais difficile calcu-
latoirement, car lensemble des arbres possibles devient vite trop grand pour tre parcouru enti-
rement lorsque le schma de subdivision, et donc lautomate, deviennent grands. Cependant, des
algorithmes ont t dvelopps, laide de techniques de programmation dynamique, pour valuer
de faon paresseuse les poids des arbres et retourner celui de poids le plus faible sans parcourir
tout lespace des arbres possibles. Nous dcrirons en dtail dans la partie 3.2 un algorithme, bas
sur le fonctionnement des algorithmes dcrits dans [12], adapt des automates gnrs par des
schmas de subdivision. Il permet dnumrer les k arbres de poids les plus faibles que lon peut
obtenir laide dun automate pondr. Cest un algorithme rcursif qui calcule le poids dun arbre
18
partir de ceux de ses fils. Lhypothse qui permet de commencer lnumration sans avoir explor
lensemble des solutions est celle de la monotonie :
Soit un noeud a, ayant k fils nots a1 , a2 , ... , ak , et w la fonction qui associe un noeud
son poids. Alors
i [1..k], w(a0i ) > w(ai ) w(a0 ) > w(a)

o a0 est le noeud ayant pour fils a1 , a2 , ... , ai1 , a0i , ai+1 , ... , ak
Autrement dit, augmenter le poids dun des fils fera augmenter le poids du pre. Ainsi, on sait
que larbre de poids minimum sera obtenu en choisissant chaque noeud les fils de poids minimum.
3.2 Principe de lalgorithme dnumration des meilleures so-

lutions : lalgorithme k-best
Lalgorithme k-best que nous avons dvelopp permet dnumrer les meilleures transcriptions
des dures dentre, au sens des mesures voques la partie 3.1.3. Il se droule en deux tapes
principales. Dabord, on construit lautomate pondr, qui est dcrit par une table de hachage
indexe par les tats, et ensuite, on calcule les k meilleures solutions pour cet automate. Une
fois lautomate construit, on peut facilement, et sans grand cot computationnel, obtenir dautres
solutions. Dans cette partie nous dtaillerons le fonctionnement de cet algorithme.
3.2.1 Entres et sorties de lalgorithme

Divers paramtres sont donns lalgorithme en entre :
Une srie dinstants, correspondant aux instants de dbut des vnements (notes ou silences).
Cette srie est normalise de sorte que le premier vnement commence 0 et le dernier
finit 1. On a donc un segment lintrieur duquel se trouvent des instants quantifier. Le
dernier lment ne sera pas pris en compte, il ne sert qu indiquer la fin du segment.
Une liste, de mme longueur que la srie dinstants, indiquant si chaque instant correspond
une note (n) ou si il correspond un silence (s). Cette liste nintervient pas dans lalgorithme
en lui-mme, elle ne sera utile que pour la reconstruction de larbre de rythme la fin de
lalgorithme.
Un schma de subdivision, donnant les subdivisions successives de lentre possible. Le
format de ce schma est donn la partie 3.1.2.
La construction de larbre revient ensuite dcouper rcursivement ce segment, et aligner les
instants dentre la borne de la subdivision la plus proche, cette borne tant dpendante du
schma de subdivision et du nombre de divisions successives.
Une srie dinstants correspond une unit musicale, typiquement une mesure. Cela implique
quun prtraitement a t effectu pour dcouper le flux dentre en pulsations et en mesures. Nous
reviendrons sur ces points la partie 4.1.2.
En sortie, on renvoie k arbres, ordonns par poids, le poids tant une mesure de qualit des
solutions proposes. La dfinition de ce poids sera discute la section 3.3.
On peut donc poser le problme de la faon suivante : en entre, on a n instants, nots
x1 , x2 , ..., xn , et en sortie, on renvoie k arbres de rythmes nots t1 , t2 , ..., tk , auxquels correspondent
k sries dinstants quantifis, notes y11 , y12 , ..., y1n , y21 , y22 , ..., y2n , yk1 , yk2 , ..., ykn .
3.2.2 Construction de lautomate

Lautomate est dcrit par une table de hachage indexe par les tats, cest--dire les noeuds de
larbre. Les noeuds sont reprsents par le chemin pour y arriver depuis la racine. Un chemin a la
19

Figure 3.2 Le noeud rouge est rfrenc par le chemin (3 1)(2 2)
forme suivante : path = (a1 d1 )(a2 d2 )...(an dn ) , o les a correspondent aux arits des noeuds, et
les d indiquent la branche choisie pour arriver au noeud considr. Un exemple est donn Figure 3.2.
A chaque chemin correspond une portion du segment dentre : le chemin (3 1)(2 2) correspond
ainsi la deuxime moiti du premier tiers du segment.
3.2.2.1 Reprsentation interne des arbres

A aucun moment dans lalgorithme on ne manipule des arbres explicitement. Ils sont toujours
donns implicitement par rcursion : on connait les fils de chaque noeud, mais pas larbre global
(qui sera reconstruit uniquement la fin, pour renvoyer un rsultat). Les donnes manipules sont
appeles des run, auxquels sont associs des poids. Il sagit dune liste dentiers, de longueur gale
larit du noeud, et dont les lments sont des indices dans la liste des k meilleurs rsultats pour
chaque tat fils, cest dire la liste des k runs de poids les plus faibles de chaque tat fils. Par
exemple, pour un tat dcrit par un chemin p, un run valant (3 1 2) signifie que le sous-arbre
considr est obtenu en allant chercher le 3me meilleur run de ltat p(3 1), le meilleur run de ltat
p(3 2) et le 2me meilleur run de ltat p(3 3). Un run gal la liste vide signifie quon ne subdivise
pas plus loin. Ainsi, en parcourant successivement les runs et les listes des meilleurs runs, on peut
reconstituer larbre complet.
3.2.2.2 Format de lautomate

Chaque entre de la table, qui est indexe par les tats, contient :
La liste des k meilleurs runs
La liste des candidats parmi lesquels on va choisir le k + 1me meilleur run
Dautre lments stocks ici pour des raisons defficacit
A laide du schma de subdivision, on construit les diffrents tats, donc les diffrents chemins
possibles. Par exemple, pour le schma ((2|3) 2), on va construire les tats rassembls dans le
tableau Figure 3.3.
Pour amliorer les performances de lalgorithme, on effectue quelques optimisations lors de la
construction de lautomate. En effet, si le segment correspondant un chemin ne contient aucune
entre, il est inutile de subdiviser plus finement, car il ny a rien aligner dans ce segment. On
va alors se dispenser de crer les tats fils de ce chemin, ce qui conomisera des calculs la fois
la cration de lautomate et pendant la construction de larbre, puisquil y aura moins dtats
explorer.
Une fois lautomate cr, on initialise la liste des candidats. Pour cela, on place dans la table
de hachage les premiers candidats ainsi que leurs poids. Ces premiers candidats sont :
Le cas o on ne subdivise pas plus loin, on aligne directement les entres qui se trouvent
lintrieur du segment correspondant ltat considr aux bornes les plus proches. On
place alors dans la liste des candidats un run vide et le poids, calcul partir des distances
entre les entres et la borne la plus proche.
On redcoupe en le nombre de subdivisions autorises par le schma. On place alors pour
chaque subdivision possible le meilleur candidat qui est, daprs la proprit de monotonie,
20
Niveau 0 Niveau 1 Niveau 2
liste vide (racine) (3 1) (3 1), (2 1)
(3 1), (2 2)
(3 2) (3 2), (2 1)
(3 2), (2 2)
(3 3) (3 3), (2 1)
(3 3), (2 2)
(2 1) (2 1), (2 1)
(2 1), (2 2)
(2 2) (2 2), (2 1)
(2 2), (2 2)
Figure 3.3 Tableau recensant les tats construits pour un schma de subdivision ((2|3) 2). Les
tats sont classs par profondeur.
le run (1 1...1), o le nombre de 1 est gal larit de la subdivision.

En reprenant lexemple prcdent, aprs linitialisation, la liste des candidats de lentre de la
table de hachage correspondant la racine contiendra donc :
Un run vide, et son poids initialis avec la distance de chaque input la borne du segment
la plus proche (0 ou 1)
Un run (1 1) et son poids qui na pas encore t calcul
Un run (1 1 1) et son poids qui na pas non plus t calcul.
3.2.3 Droulement de lalgorithme

Une fois lautomate cr, on peut drouler lalgorithme. Il sagit dun algorithme rcursif : on
demande chercher le k me arbre de poids le plus faible en partant de la racine, et la fonction sera
appele rcursivement sur tous les sous-arbres pour valuer leurs poids. On note best la fonction
rcursive qui renvoie pour un certain tat son k me arbre de poids le plus faible. On va donc appeler
best(k, racine), qui retourne un arbre et son poids.
3.2.3.1 Une tape de lalgorithme

Supposons que lon veuille retourner le k me arbre (ou sous-arbre) de poids le plus faible, plu-
sieurs cas sont possibles :
Cet arbre a dj t valu : Il suffit de le chercher dans la liste des meilleurs runs stocke
dans la table de hachage la ligne correspondant au chemin, et retourner son poids et le
run correspondant.
Cet arbre na pas encore t valu : On va chercher le run de poids le plus faible dans
la liste des candidats pour la ligne correspondant au chemin :
Si des poids nont pas t dfinis dans la liste des candidats, on applique rcursivement
lalgorithme pour les calculer. Par exemple, pour tat p et un run (3 1 2), on appelle
lalgorithme pour obtenir le poids du 3me meilleur run pour le 1er fils (best(3, p(3 1))),
celui du meilleur run pour le 2me fils (best(1, p(3 2))) et celui du 2me meilleur run pour
le 3me fils (best(2, p(3 3))), puis on en dduit le poids du run (3 1 2).
21
1) 1 2 3 4 2) 1 2 3 4 3) 1 2 3 4
1 C 1 1 C 1 1 C
2 2 C 2 2 C
3 3 3 C
4 4 4
4) 1 2 3 4 5) 1 2 3 4 6) 1 2 3 4
1 1 3 C 1 1 3 C 1 1 3 C
2 2 C 2 2 C 2 2 5 C
3 C 3 4 C 3 4 C
4 4 C 4 C
Figure 3.4 Exemple dordre dajout des candidats pour un noeud darit 2 : La ligne donne le rang
du run fils pour la branche de gauche, la colonne, celui de la branche de droite, C veut dire que le run est
ajout la liste des candidats, les numros donnent lordre dajout la liste des candidats dans la liste des
meilleurs runs.
Si tous les poids des candidats ont t dfinis, on choisit celui de poids le plus faible, on
le retire de la liste des candidats et on le place dans la liste des k meilleurs. On ajoute
la liste des candidats les prochains potentiels candidats, comme expliqu plus loin.
Si la liste des candidats est vide, par exemple dans le cas dune feuille, o il ny a quun
candidat possible, ou dans le cas dun noeud interne dont tous les candidats ont dj t
valus et classs dans la liste des k meilleurs, on renvoie un valeur spciale de poids (+).
Ainsi, on vite de continuer chercher lorsque toutes les possibilits ont dj t numres.
Ainsi on va lancer lalgorithme la racine, qui appellera rcursivement lalgorithmes sur chaque
sous-arbre, et ce jusquaux feuilles. Une fois arriv aux feuilles, on peut commencer valuer les
poids, et on value ainsi le poids de chaque sous arbre partir du poids de ses fils.
3.2.3.2 Ajout des candidats suivants la liste des candidats

Une fois quon a plac un candidat dans la liste des candidats, il faut dterminer qui peuvent
tre les suivants. La rgle dajout est la suivante :
Soit un run (i1 i2 ... in ). On ajoute n nouveaux candidats de la forme :
((i1 + 1) i2 ... in ), (i1 (i2 + 1) ... in ), ..., (i1 i2 ... (in + 1))
Cette rgle dcoule de la proprit de monotonie. En effet, si par exemple on considre le

meilleur run (1 1 ... 1), le deuxime meilleur run sera forcment parmi les suivants : (2 1 ... 1),
(1 2 ... 1), ... , (1 1 ... 2) ( moins quune autre subdivision, dj prsente dans la liste des candidats,
ne soit plus avantageuse). Un exemple de parcours des candidats possibles pour un noeud darit
2 est donn Figure 3.4. Les doublons ne sont pas pris en compte.
3.2.4 Un exemple simple

Nous allons drouler lalgorithme dans un cas trs simple pour en expliciter le fonctionnement.
On prend comme fonction de poids une fonction nave, dfinie pour une feuille par le produit
de la somme des distances entre les entres et la borne de la subdivision la plus proche et de la
profondeur de larbre, et pour un noeud, par la somme des poids des fils.
Nous prenons comme entre la srie normalise (0, 0.45, 1), la liste (n n s) indiquant que les
deux premiers instants correspondent des dbuts de notes, et le schma (2 2). Les entres et les
22
subdivisions possibles sont reprsentes Figure 3.5. On peut dores et dj supposer quune bonne
quantification de ces dures serait le rythme .
0 0.45 1
Figure 3.5 Lentre est reprsente en rouge, les subdivisions possibles sont reprsentes en noir.
Lautomate construit a donc les tats suivants :
liste vide (racine)

(2 1)
(2 2)
(2 1)(2 1)
(2 1)(2 2)
(2 2)(2 1)
(2 2)(2 2)
Les listes de candidats et des meilleurs runs, stocks dans la table sous la forme de couples
(run, poids) sont initialises comme suit :
Etat Liste de candidats Liste des meilleurs runs

liste vide (racine) (nil, 0.45 1) ((1 1), undef )
(2 1) (nil, 0.05 2) ((1 1), undef )
(2 2) (nil, 0 2) ((1 1), undef )
(2 1)(2 1) (nil, 0 3)
(2 1)(2 2) (nil, 0.05 3)
(2 2)(2 1) (nil, 0 3)
(2 2)(2 2) (nil, 0 3)
On cherche obtenir best(1, racine). La liste des meilleurs runs est vide pour linstant, on
cherche donc dans la liste des candidats le meilleur. Un candidat dans la liste a un poids indfini,
on cherche donc lvaluer. Pour cela, comme le run non valu vaut (1 1), on cherche best(1, (2 1))
et best(1, (2 2)).
Commenons par le fils de gauche. A nouveau, la liste des meilleurs runs est vide et le poids
dun des candidat nest pas dfini, on cherche donc lvaluer.
Comme le run non valu vaut (1 1), on appelle best(1, (2 1)(2 1)) et best(1, (2 2)(2 2)). Pour
ltat (2 1)(2 1), tous les candidats ont t valus, celui de poids le plus faible est (nil, 0) : on le
retire de la liste des candidats et on le place dans la liste des meilleurs runs. Dsormais, lorsque lon
cherchera le meilleur run pour ltat (2 1)(2 1), il suffira daller le chercher dans la liste des meilleurs
runs. Comme aucune subdivision nest possible pour cet tat, on ne rajoute pas de candidats, la
liste des candidats reste vide. On fait de mme pour ltat (2 1)(2 2).
A ce stade, la table de hachage est la suivante :
23
liste vide (racine) (nil, 0.45) ((1 1), undef )
(2 1) (nil, 0.1) ((1 1), undef )
(2 2) (nil, 0) ((1 1), undef )
(2 1)(2 1) (nil, 0)
(2 1)(2 2) (nil, 0.15)
(2 2)(2 1) (nil, 0)
(2 2)(2 2) (nil, 0)
On peut maintenant valuer le run (1 1) de ltat (2 1) : son poids vaut 0 + 0.15 = 0.15. Tous les
candidats de cet tat sont maintenant valus, celui de poids le plus faible est le run correspondant
au cas o on ne subdivise pas : on le retire de la liste des candidats et on le place dans la liste
des meilleurs runs. Comme aucune subdivision nest possible pour cet tat, on ne rajoute pas de
candidats.
De la mme faon que pour ltat (2 1), on calcule le poids du run (1 1) de ltat (2 2) : son
poids vaut 0 + 0 = 0.
La table de hachage contient maintenant :

liste vide (racine) (nil, 0.45) ((1 1), undef )
(2 1) ((1 1), 0.15) (nil, 0.1)
(2 2) ((1 1), 0) (nil, 0)
(2 1)(2 1) (nil, 0)
(2 1)(2 2) (nil, 0.15)
(2 2)(2 1) (nil, 0)
(2 2)(2 2) (nil, 0)
On peut maintenant valuer le run (1 1) de ltat racine. Son poids vaut 0.1 + 0 = 0.1. A
nouveau, on peut maintenant retirer le run de poids le plus faible de la liste des candidats de la
racine, qui est le run (1 1). On le retire de la liste des candidats et on le place dans la liste des
meilleurs runs, mais cette fois, on rajoute deux candidats pour cet tat : (2 1) et (1 2).
A la fin de lalgorithme, la table de hachage contient :

liste vide (racine) (nil, 0.45) ((2 1), undef ) ((1 2), undef ) ((1 1), 0.1 )
(2 1) ((1 1), 0.15) (nil, 0.1)
(2 2) ((1 1), 0) (nil, 0)
(2 1)(2 1) (nil, 0)
(2 1)(2 2) (nil, 0.15)
(2 2)(2 1) (nil, 0)
(2 2)(2 2) (nil, 0)
24
Le rsultat renvoy est le meilleur run pour la racine : il sagit du run (1 1) (sans surprises),
avec le poids 0.1. Une fois larbre reconstitu, il correspond au rythme , ce qui correspond bien
ce quon aurait voulu obtenir qualitativement.
Si on souhaite ensuite calculer le 2me meilleur run, il suffit de relancer lalgorithme avec la
mme table de hachage.
3.3 Choix des mesures de poids

Lalgorithme prsent prcdemment est trs gnrique : on aligne des instants sur une grille de
pas variable, mais ces instants pourraient correspondre nimporte quoi. Mme au del des instants,
si on avait initialis les feuilles avec dautres valeurs de poids, pas forcment lies des distances
entre des instants, cet algorithme aurait pu tre exploit pour rsoudre dautres problmes : les
algorithmes dcrits dans [12] ont dailleurs t proposs pour le traitement du langage naturel.
Le choix des mesures de poids en fait un algorithme spcifiquement destin la quantification
rythmique.
Pour dterminer le poids dun arbre, lalgorithme se base sur trois lments : une mesure de
prcision, une mesure de complexit, et une fonction permettant de renvoyer un poids partir de
ces deux objets.
La mesure de prcision est obtenue partir dun vecteur de dimension gale au nombre dins-
tants dentre. Le ime lment de ce vecteur est gal la diffrence entre le ime instant dentre et
le point de la grille sur lequel il est align. Autrement dit, en reprenant les notations de la section
3.2.1, le ime lment de ce vecteur est gal |xi yi |. Pour un noeud interne de larbre, certains
lments de ce vecteur nauront pas de valeur. En effet, nous avons vu la partie 3.2.2 qu chaque
noeud de larbre correspond une portion du segment dentre. Les xi contenus dans cette portion
seront aligns la borne de la portion la plus proche, et on na aucune information sur les autres
portions. La distance |xi yi | nest donc connue que pour les xi contenus dans cette portion.
La mesure de complexit est obtenue partir de 3 valeurs :
Un vecteur contenant le nombre doccurences de chaque arit pour le sous-arbre considr.
Cette valeur permet de pnaliser les arits inhabituelles comme 5 ou 7.
La profondeur du sous-arbre. Cette valeur permet dviter les subdivisions trop fines, qui
donnent lieu des rythmes peu lisibles
Le nombre de notes alignes sur le mme point de la grille. Cette valeur vise viter davoir
dans larbre de sortie des grace notes.
Reste dterminer la fonction de poids combinant ces deux notions de prcision et de com-
plexit. Or, nous lavons vu, la condition indispensable au bon droulement de lalgorithme est
celle de la monotonie de la fonction de poids : si on augmente le poids de lun des fils, le poids du
pre doit aussi augmenter.
Pour dterminer le poids dun arbre partir de ses fils, on combine les prcisions des fils
dune part et leurs complexits dautre part pour obtenir la prcision et la complexit du pre,
et on applique la fonction de poids ces deux lments pour obtenir le poids du pre. Trouver
une fonction de combinaison monotone simplement par rapport la prcision ou par rapport
la complexit est une tche facile, trouver une fonction qui garantisse que si la combinaison de
la prcision et de la complexit dun des fils augmente, la combinaison de la prcision et de la
complexit du pre augmente aussi est beaucoup moins trivial.
On pose le problme de la faon suivante, dans le cas particulier dun arbre ayant deux fils (il
est facile de gnraliser n fils) :
Soient p1 , p2 , les prcisions des fils (respectivement gauche et droit), c1 , c2 leurs complexits
respectives, p la prcision du pre et c sa complexit. Soient w : c, p 7 w(c, p) la fonction qui
combine la prcision et la complexit pour donner le poids, f : c1 , c2 7 f (c1 , c2 ) la fonction qui
25
donne la complexit du pre partir de celle des fils et g : p1 , p2 7 g(p1 , p2 ) la fonction qui donne
la prcision du pre partir de celle des fils. On veut que w, f et g vrifient :
Si w(c01 , p01 ) > w(c1 , p1 ), alors w(c0 , p0 ) > w(c, p)

Autrement dit :
Si w(c01 , p01 ) > w(c1 , p1 ), alors w(f (c01 , c2 ), g(p01 , p2 )) > w(f (c1 , c2 ), g(p1 , p2 ))
Nous avons choisi comme fonction de complexit une combinaison linaire de tous les lments
voqus plus haut : les distances point--point entre lentre et la grille (notes d1 , d2 ...dn ), les
nombres doccurence des arits (nots ca1 , ca2 ...cam , les pj correpondent des pnalits qui t-
pendent de la complexit de larit considre), la profondeur de larbre (note cd) et le nombre de
notes alignes sur un mme point de la grille (not cg). On nutilise que 4 coefficients pour cette
combinaison linaire :
X X
poids = a1 ( di ) + a2 ( (pj caj )) + a3 cd + a4 cg
Ces 4 coefficients sont dtermins exprimentalement pour linstant. Chaque coefficient d-
termine linfluence de chaque paramtre dans le rsultat final, et donc si on privilgie plutt les
distances faible, les arits simples, les arbres peu profonds ou labsence de grace notes. Ces co-
efficients ont une grande influence sur les solutions obtenues, il faut donc envisager de les rendre
rglables par lutilisateur dans une certaine mesure.
26
Chapitre 4
Dveloppements, valuation et
rsultats
Nous avons prsent le travail formel et algorithmique ralis pour la quantification rythmique.
Nous allons dans cette partie prsenter le travail technique dimplmentation qui a t ralis et
intgr dans OpenMusic et discuter les performances de lalgorithme, tant en termes de complexit
algorithmique que de qualit de la quantification.
4.1 Bibliothque k-best

4.1.1 Implmentation modulaire
Nous avons implment lalgorithme prsent la partie prcdente. Limplmentation a t
faite en Lisp, et les diffrents fichiers ont t regroups dans une bibliothque OpenMusic. Diff-
rentes structures de donnes ont galement t dfinies pour faciliter son implmentation et surtout,
son amlioration. En effet, lalgorithme a t implment de faon modulaire, avec des donnes en-
capsules dans des structures de donnes plus ou moins complexes et un nombre restreint de
fonctions partages. En particulier, le coeur de lalgorithme est indpendant de la faon dont les
diffrentes mesures de prcision, de complexit et le poids sont calcules, et mme de la faon dont
on compare les poids. Seules des fonctions comme weight-compare, qui permet de comparer deux
poids, ou weight-addall, qui permet dobtenir le poids dun arbre partir de ces sous-arbres sont
appeles. Le coeur de lalgorithme est indpendant de la dfinition de ces fonctions. Cela permet
en particulier de pouvoir amliorer ces diffrentes fonctions sans avoir modifier tout lalgorithme.
4.1.2 Mise en forme de lentre

Nous avons vu que lalgorithme prend en entre seulement une suite dinstants. Pour mieux
lintgrer lenvironnement OpenMusic, nous avons dvelopp des fonctions permettant de crer
une entre utilisable par lalgorithme partir de suites de notes regroupes en chordseq.
Ces fonctions prennent en entre les instants de dbut et les dures des notes du chordseq ainsi
que le tempo et la signature (ventuellement une liste de tempos et de signature si ils varient).
Prcisons que lalgorithme dvelopp est un algorithme de quantification, le tempo et la signature
sont donc supposs connus. On dcoupe ensuite lentre en mesures, puisque lon connait la dure
dune mesure partir des tempos et des signatures. Lorsquune barre de mesure coupe une note,
on la divise en deux, et on stocke dans une liste un boolen indiquant que la premire note de la
deuxime mesure doit tre lie la dernire note de la premire mesure. Cette liste de boolens
sera utilise lors de la reconstruction de larbre de sortie : elle permettra dindiquer, lorsque lon
27
recollera les mesures aprs quantification, quil faut lier la dernire note de la mesure prcdente
la premire de la suivante. Un exemple est donn en Figure 4.1. On obtient ainsi des units
facilement manipulables par lalgorithme.
instants de dbut : ((0 1.5) (2))

dures : ((1 0.5) (1))
0 1 2 3 4
temps
(en secondes)
liaisons : ( 1 0 )
Figure 4.1 Lentre gauche correspond une liste dinstants valant (0 1.5) et une liste de dures
valant (1 1.5). Lentre est dcoupe en deux mesures de deux temps, avec un tempo de 60. Le 1 dans la
liste "liaisons" indique que la dernire note de la premire mesure doit tre lie la premire note de la
deuxime.
A partir de chaque mesure, on convertit la liste dinstants de dbuts et la liste de dures en

une suite dinstants, correspondant aux dbuts et fins des notes, et une liste de mme longueur
indiquant si chaque instant correspond un dbut de note ou un dbut de silence. Ainsi, lorsque
deux notes ne sont pas directement conscutives, on place dans la liste dentres 4 instants :
linstant de dbut de la premire, linstant de fin de la premire, linstant de dbut de la deuxime,
et linstant de fin de la deuxime, en prcisant que linstant de fin de la premire correspond un
dbut de silence. Lorsque deux notes se superposent, on place dans la liste linstant de dbut de la
premire et linstant de dbut de la deuxime, en prcisant que ces deux instants correspondent
des dbuts de notes. La Figure 4.2 donne des exemples de mise en forme de lentre. Les instants
sont normaliss de sorte que le premier instant vaut 0 et le dernier, qui correspond la fin du
segment, vaut 1.
(0 0.4 0.6 1)
0 2 3 4
temps
(en secondes)
(n s n s)
(0 0.4 1)
0 2 3 4 temps (n n s)
(en secondes)
Figure 4.2 Deux mesures diffrentes et leurs mises en formes. Dans les deux cas, le tempo vaut 60, et
la signature est 5/4. n veut dire note, s veut dire silence. Les instants sont normaliss entre 0 et 1 pour
tre indpendants du tempo.
Une fois les mesures mises en forme, on les quantifie une par une laide de lalgorithme
prcdemment dcrit, et on les concatne ensuite, en liant les notes qui avaient t coupes lors du
dcoupage en mesures.
4.1.3 Post-traitement
4.1.3.1 Construction de larbre de rythme
Comme nous lavons voqu la partie 3.2.2.1, lalgorithme ne renvoie pas explicitement des
arbres. Les arbres de rythme doivent tre reconstruits rcursivement partir de la table de hachage,
en partant de la racine et en allant jusquaux feuilles.
On nomme la fonction qui permet de reconstruire le k me meilleur arbre pour un tat : build(k, etat).
Pour reconstruire le k me arbre, on appelle donc build(k, racine).
28
1
1 1
Figure 4.3 Arbre reconstruit par lalgorithme avec lexemple de la partie 3.2.4
Si il nest pas vide, cest quon subdivise encore, auquel cas on appelle rcursivement la fonction
de reconstruction pour chacun des fils afin dobtenir les sous-arbres indiqus par les runs.
Si il est vide, cest quon ne resubdivise plus. On aligne donc les entres contenues dans le
segment la borne du segment la plus proche. De nombreux sous-cas se posent alors, que nous ne
dtaillerons pas. Lide gnrale est la suivante :
Les entres alignes gauche sont prises en compte dans la subdivision courante. Si il y en
a plusieurs, on ajoute donc des grace notes la subdivision courante.
Les entres alignes droite seront prises en compte la subdivision suivante : elles seront
places en tant que grace notes dans la subdivision suivante.
Si le segment correspondant ltat courant ne contient aucune entre, cela correspond
une liaison avec la section prcdente (ou un silence si la section prcdente se terminait sur
un silence).
Pour illustrer, nous reprendrons lexemple de la partie 3.2.4. On appelle build(1, racine). Le
meilleur run est (1 1), on appelle donc build(1, (2 1)) puis build(1, (2 2)) (ici, lordre dappel est
important, puisque des entres de la subdivision (2 1) peuvent tre dplacs dans la subdivision
(2 2) si elles sont alignes droite du segment).
Le meilleur run de ltat (2 1) est vide, on ne subdivise pas plus loin. Le segment contient deux
entres : la premire et la deuxime. La premire est recale gauche du segment, la deuxime
droite. On place donc une note dans la subdivision, et on retient dune part que la deuxime entre
est recale droite pour pouvoir la prendre en compte dans le segment suivant, dautre part que
la dernire entre de la subdivision correspond une note et non un silence pour savoir si il faut
faure une liaison ou non avec la subdivision suivante dans le cas o elle ne contient aucune entre.
Le meilleur run de ltat (2 2) est vide aussi, on ne subdivise pas plus loin. Le segment contient
une seule entre : la dernire, qui nest pas prise en compte, elle ne sert qu indiquer la fin du
segment quantifier. Le segment ne contient donc aucune entre recaler. Comme le segment
prcdent avait une entre aligne droite, on place cette note dans la subdivision.
Lappel build(1, (2 1)) renvoie une note, et lappel build(1, (2 2)) galement. build(1, racine)
retourne donc larbre de la Figure 4.3, ce qui correspond avec la notation OpenMusic larbre
(1 (1 1)). On ajoute ensuite la signature pour obtenir le rsultat voulu.
4.1.3.2 Format des rsultats

Les rsultats sont prsents sous la forme dune liste ordonne darbres de rythme correspondant
aux k meilleures transcriptions possibles. La premire transcription est obtenue en concatnant
les meilleurs arbres de toutes les mesures, la deuxime, en concatnant les deuximes meilleurs
rsultats de toutes les mesures, et ainsi de suite. Lutilisateur peut ensuite visualiser chacune de
ces transcriptions dans un objet voice, ou bien toutes la fois dans un objet poly. Il peut ainsi
choisir pour chaque mesure la transcription quil prfre. Pour cela, il suffit de chercher dans la
liste des rsultats les mesures quil souhaite garder et les concatner dans une nouvelle liste.
4.1.4 Grace notes

Comme nous lavons vu la partie 4.1.3.1, lors de la construction de larbre de rythme, des
grace notes peuvent tre insres dans larbre. Il sagit dune extension nouvelle du formalisme
darbre de rythme. Le format est le suivant : lorsquun arbre de la forme (D(Subdivisions)) a au
29
moins un zro dans sa liste Subdivisions, alors il sera considr comme une note accompagne de
grace notes. La dure de cette note est donne par D, et le nombre de grace notes est donn par
le nombre de 0 dans Subdivisions. Par exemple,larbre (1(0 1 0 0)) est considr comme une note
de dure 1, laquelle sont attaches une grace note avant la note et deux aprs.
Dans OpenMusic, la reprsentation graphique des grace notes nest pas encore gre. Une note
laquelle une grace note est attache va tre considre comme un accord de deux notes, o la
deuxime note aura un lger dcalage temporel (offset), positif ou ngatif en fonction de la position
de la grace note par rapport la note principale. Un exemple de reprsentation dans OpenMusic
dune note avec des grace notes est donn Figure 4.4.
Figure 4.4 Reprsentation des grace notes dans OpenMusic. A gauche, un exemple darbre de rythme
permettant de reprsenter les grace notes est prsent. A droite, laccord correspondant larbre de gauche.
On voit que la note tombant sur le temps est la deuxime, il y a une grace note avant et deux aprs.
4.2 Dveloppements pour OMrewrite

La bibliothque OMrewrite inclue des fonctions permettant la conversion darbres de rythme
dOpenMusic vers le format darbres de rythme symboliques, des fonctions pour faire de la rcri-
ture darbres et un prototype de quantificateur par rcriture. Nous avons galement ralis des
dveloppements pour cette bibliothque. Nous avons limin certaines erreurs qui se produisaient
lors de la conversion darbres de rythmes dOpenMusic vers les arbres de rythme symboliques. Nous
avons galement amlior le systme de quantification par rcriture, en rendant plus flexible la
cration de larbre de profondeur maximale. Dsormais, ce dernier peut tre construit partir dun
schma de subdivision simple, dcrivant les subdivisions successives la manire de lalgorithme
k-best, mais en interdisant les OrList. On ne laisse pas de choix dans les subdivisions, on dcrit
simplement les subdivisions successives. Ainsi, le schma (3 2 4) donnera larbre reprsent Figure
4.5. La gestion des signatures rythmiques a galement t amliore, en permettant de les mani-
puler explicitement (dans le systme prcdent, une heuristique permettait de la deviner, souvent
avec des erreurs).
Cette librairie est trs intressante utilise en complment de lalgorithme k-best dvelopp.
En effet, elle permet dobtenir des reformulations des rythmes obtenus. En particulier, elle permet
de simplifier les solutions o lalgorithme a subdivis inutilement un segment ne contenant quune
note. Ce cas est frquent, comme nous le verrons plus tard. On peut ainsi soit garder toutes
les solutions, mme celles comportant des subdivisions inutiles, ou bien au contraire rcrire ces
solutions pour ne garder que celles qui sont vraiment diffrentes les unes des autres.
30

Figure 4.5 Cet arbre est gnr laide de la liste de subdivisions (3 2 4)
4.3 Analyse de complexit de lalgorithme k-best

On utilise les notations suivantes :
amax : Arit maximale que lon peut trouver dans le schma de subdivision
dmax : Profondeur maximale du schma de subdivision (correspond la longueur cumule des AndLists)
cmax : Nombre maximum de choix darit quon a pour une subdivision
k : Nombre de solutions que lon demande lalgorithme de renvoyer
t : Dure totale du flux dentres quantifier
n : Nombre dinstants contenus dans une mesure quantifier
Dans cette section, nous allons valuer la complexit en temps des diffrentes tapes de lalgorithme
k-best. La complexit sera donne dans le pire des cas, non sans discuter des cas les plus courants,
et nous dtaillerons quelques exemples.
4.3.1 Mise en forme de lentre

La mise en forme de lentre se fait en dcoupant le flux dentre en mesures et en crant
partir de chaque mesure un objet utilisable par lalgorithme. Pour crer un objet utilisable par
lalgorithme, il faut galement calculer la rsolution du schma, ce qui se fait en calculant le plus
petit multiple commun des produits des arits de chaque schma de subdivision possibles.
Le dcoupage en mesures se fait en temps linaire avec le nombre de mesures, et donc la dure
totale du flux quantifier. La cration de chaque entre se fait en temps linaire avec le nombre
dinstants contenus dans la mesure, et le calcul de la rsolution du schma se fait en temps linaire
avec le nombre de schmas de subdivision possibles, soit au pire dmax cmax . La complexit de la
mise en forme de lentre est donc en O(t(n + dmax cmax )).
4.3.2 Construction de lautomate

La construction de lautomate se fait en temps linaire par rapport au nombre dtats, cest--
dire au nombre dentres de la table de hachage. Le nombre dentres est dtermin par le schma de
subdivision, il peut tre born grossirement par (amax cmax )dmax . Plus prcisment, pour obtenir
le nombre de chemins possibles (et donc le nombre dtats), il faut multiplier les lments des
AndLists et additionner ceux des OrLists. Ainsi, le schma de subdivision ((2|3) ((4 5)|(5 4))),
qui est quivalent donner le choix entre les schmas (2 4 5), (2 5 4), (3 4 5) et (3 5 4), donne lieux
(2 + 3) ((4 5) + (5 4)) = 200 chemins (dans ce cas, (amax cmax )dmax = (5 2)3 = 1000).
Notons que dans la pratique, le nombre dtats effectif sera souvent infrieur au nombre de
chemins possibles. En effet, pour acclrer le traitement, on ne construit pas les tats correspondant
des subdivisions dune portion du segment quantifier qui ne contient pas dentres. Lorsquon a
peu dentres par rapport la granularit permise par le schma de subdivision, cette optimisation
31
peut faire chuter grandement le nombre dtats dans lautomate. Par exemple, si on considre le
schma prcdent, et une entre ne contenant quun seul instant quantifier situ au dbut du
segment, alors le deuxime et le troisime tiers ( fortiori la deuxime moiti) du segment sont
vides. Tous les chemins commenant par (2 2), (3 2) ou (3 3) ne seront donc pas crs, ce qui fait
chuter le nombre dtats (1 + 1) ((4 5) + (5 4)) = 80.
Ensuite, chaque tat, linitialisation des listes de candidats se fait en temps linaire par
rapport cmax , puisquon place dans chaque liste un candidat pour chaque arit possible (une liste
ne contenant que des 1 de longueur gale larit) plus le candidat correspondant au cas o on ne
subdivise plus.
La complexit de cette tape est donc en O(cmax (amax cmax )dmax )
4.3.3 Obtention des k meilleurs arbres

On distingue deux cas : la construction du meilleur arbre, et la construction des k 1 suivants.
4.3.3.1 Meilleur arbre

Pour obtenir le meilleur arbre une fois lautomate construit et initialis, il faut dabord valuer
les poids de tous les candidats pour chacun des tats (puisque aucun poids na encore t valu).
On procde en commenant par les feuilles (la liste de candidats ne contient alors que le candidat
correspondant au cas o on ne subdivise plus, dont le poids est directement calcul), et chaque
noeud, on remonte en valuant le poids du candidat partir de celui des fils. Le calcul du poids
dun pre est linaire en fonction du nombre de fils. On peut ainsi calculer en une passe le poids
de tous les candidats des feuilles jursqu la racine.
En considrant le pire cas, on a donc (amax cmax )dmax tats, pour lesquels il faut calculer cmax
poids, chacun partir de amax fils. La complexit de cette tape est donc en O((amax cmax )dmax +1 ).
Cette complexit est beaucoup sur-value, dune part parce que le nombre dtats est sur-
valu (nous lavons vu la partie prcdente), et dautre part parce quil est impossible que
tous les candidats de chaque liste soient tous de longueur amax , et on naura pas forcment cmax
candidats chaque tape non plus.
4.3.3.2 Construction des k-1 arbres suivants

Une fois que les candidats initiaux ont t valus, la situation est diffrente. A chaque fois que
pour un chemin donn, un run est ajout la liste des meilleurs arbres depuis la liste des candidats,
on rajoute la liste des candidats autant de candidats que larit du run ajout, cest--dire dans
le pire des cas amax . Chacun des runs sera identique celui qui a t ajout, sauf un des fils qui
sera diffrent (cf. partie 3.2.3.2). Pour valuer le poids de chacun de ces nouveaux candidats, il ny
aura donc quun seul poids fils valuer, celui du fils qui est diffrent, puisque les poids des fils
qui sont identiques ont dj t calculs lors de lvaluation du poids du candidat qui vient dtre
ajout la liste des meilleurs arbres. Par exemple, si on considre que le run (1 1 1) vient dtre
ajout la liste des meilleurs runs, 3 nouveaux candidats sont ajouts la liste : (2 1 1), (1 2 1) et
(1 1 2). Pour valuer de chacun de ces runs, il suffira de calculer les deuxime meilleurs arbres pour
chacun des fils, puisque les premiers ont dj t calculs pour obtenir le poids du run (1 1 1) : il
ny a donc que 3 poids valuer.
On aura donc chaque candidat au pire amax poids valuer, chacun appartenant une ligne
diffrente de la table de hachage (chacun des amax poids valuer correspond un lment diffrent
du run, et donc un fils diffrent). Pour valuer un de ces poids, il faudra valuer tous les poids
non valus de la liste de candidats correspondante. Or, daprs le raisonnement prcdent, on sait
que cette liste de candidats contiendra au pire amax candidats dont le poids nest pas valu, et
pour chacun de ces candidats, il y a au pire 1 fils valuer. Sachant que pour les feuilles, il ny
32
a quun seul candidat possible, donc aucun poids valuer, et qu la racine, il y a au plus amax
poids valuer, il y a donc au plus admaxmax
poids valuer.
Le calcul du poids dun arbre partir du poids de ses fils se fait en temps proportionnel au
nombre de fils, donc en temps proportionnel amax . Une fois les poids calculs, il faut classer
le poids du candidat qui vient dtre calcul dans la liste des candidats. La liste des candidats
contient dans le pire des cas de lordre de kamax candidats, puisque chaque tape, on rajoute
amax candidats. Comme on utilise une structure de tas pour la liste des candidats, le classement
du poids du candidat se fait en O(log(kamax ))
Pour valuer les k 1 arbres suivants, il faut donc effectuer k 1 fois les oprations dcrites
prcdemment dans cette partie. La complexit de lobtention des k 1 arbres suivants est donc
dans le pire des cas en O(k(admax
max
amax log(kamax ))).
En ralit, cette complexit sera plus faible. Au del du fait que toutes les arits ne sont pas
gales amax , on najoute pas non plus amax candidats la liste des candidats chaque tape. En
effet, si par exemple, pour un arbre binaire, le run (2 1) vient dtre ajout la liste des meilleurs
arbres, on ajoute les runs (3 1) et (2 2) la liste des candidats. Si le meilleur arbre suivant est
(1 2), cette fois, on najoutera la liste des candidats que (1 3), puisque (2 2) a dj t ajout
la liste des candidats et quon limine les doublons.
De plus, tous les poids nauront pas besoin dtre valus. En effet, certaines valeurs de poids ne
peuvent pas tre values (par exemple, le 2me meilleur arbre pour une feuille nexiste pas, la seule
possibilit tant de ne pas resubdiviser et daligner les entres la borne la plus proche). Ces runs
impossibles valuer sont stocks avec une valeur spciale de poids (+). Lorsque lon souhaite
valuer le poids dun run, et que pour lun des fils, la meilleure possibilit est un run avec un poids
+, on sait quon ne pourra pas valuer le poids du run pre, on lui attribue donc directement le
poids +. Cela permet dune part de ne pas valuer les poids des autres fils, et de ne pas passer
par ltape de calcul du poids du pre partir de celui des fils.
La complexit de lobtention des k meilleurs arbres est donc en :
O((amax cmax )dmax +1 + k(admax

max +1
log(kamax )))
Selon le schma de subdivision et le nombre de solutions demandes, cest donc plutt la construc-
tion du premier arbre ou lobtention des k 1 suivants qui prdominera. On constate aussi que le
temps de calcul nest pas proportionnel au nombre de solutions que lon souhaite obtenir : il y a un
cot initial assez fort, mais lobtention de solutions supplmentaires est relativement peu couteuse.
4.3.4 Construction de larbre de sortie

La construction de larbre de sortie se fait en parcourant la table de hachage depuis ltat racine
jusquaux feuilles. A chaque noeud, on ne fait aucun traitement, on regarde simplement dans la
table de hachage si on resubdivise ou non, et dans le cas o on resubdivise, combien dlments
sont aligns gauche de la subdivision et droite.
Dans le cas o on resubdivise, on appelle rcursivement la fonction de construction de larbre sur
les fils du noeud considr, on peut donc ngliger la complexit de ces tapes devant la complexit
dans le cas dune feuille. Il y a au pire des cas admax
max
feuilles. La complexit de ltape de construction
de larbre est donc en O(admax max
).
Notons que cette tape est ralise pour chaque solution possible, la construction de k arbres
se fait donc en O(kadmax
max
)
4.3.5 Exemples
Nous avons ralis quelques test de rapidit dexcution de lalgorithme que nous avons im-
plment. Les tests ont t raliss sur un ordinateur iMac sous le systme dexploitation OS X
33
N n Schma E k t (en s)
1 5 A 31 10 0.325
20 0.538
B 139 10 0.609
20 0.829
10 A 41 10 0.392
20 0.615
B 159 10 0.684
20 0.995
5 A 41 10 1.939
20 3.043
B 159 10 3.407
20 4.959
Figure 4.6 Rsultats pour une entre dune seule mesure
10.10, quip dun processeur Intel Core i5 3,8 GHz et dune mmoire vive de 4 Go. Pour mesurer
le temps dexcution, nous avons utilis la fonction Lisp get-internal-real-time, appele au
dbut et la fin de lexcution de lalgorithme de quantification. Les tests ont t raliss avec
diffrents paramtres, les rsultats sont rassembls dans le tableau Figure 4.6. Dans ce tableau, les
colonnes sont :
N : Nombre de mesures quantifier
n : Nombre de notes quantifier dans chaque mesure
Schma : Le schma de subdivision utilis. Le schma A est un schma simple correspondant
une mesure 4 temps binaire : (4 2 2 2). Le schma B est un schma plus complexe, per-
mettant diffrentes subdivisions : (((2|3) (2|3) 2) | (5 (2|3) 2) | ((7|11|13))). Il est quivalent
laisser le choix entre les schmas ((2|3) (2|3) 2), (5 (2|3) 2), et subdiviser une seule fois en
7, en 11 ou en 13.
E : Nombre dtats dans lautomate (dpend uniquement du schma de subdivision et des
instants quantifier)
k : Nombre de solutions demandes
t : Temps de calcul des solutions (en s).
Ces quelques rsultats nous permettent de vrifier un certain nombre de comportements de
lalgorithme expliqus la partie prcdente :
La taille de lautomate est importante pour la vitesse dexcution de lalgorithme. Le temps
dexcution de lalgorithme pour le schma A est presque deux fois plus court que pour
le schma B. En outre, lorsque lon rajoute des notes, on rajoute des tats, et on voit, en
comparant les rsultats pour 5 notes et pour 10 notes, que cela a une petite influence sur
le temps dexcution. Il faudra donc veiller utiliser le schma le plus petit possible, et ne
pas inclure de subdivisions dont on sait lavance quont ne veut pas les obtenir.
Une fois lautomate cr, retourner dautres solutions est effectivement moins coteux : le
temps mis pour obtenir 20 solutions nest pas gal au double du temps mis pour obtenir 10
34
solutions. On constate galement que le temps mis pour obtenir les 10 solutions supplmen-
taires dpend peu de lautomate. On peut en dduire que le fait davoir un gros automate
est pnalisant surtout la construction de lautomate et linitialisation, et assez peu lors
de lobtention de solutions supplmentaires.
Quantifier 5 mesures prend autant de temps que de quantifier 5 fois une seule mesure. En
effet, chaque nouvelle mesure, on reconstruit un nouvel automate, et on repart donc de
zro.
Cet implmentation est plutt longue excuter (5 secondes pour obtenir 5 mesures de
partition). Il faudrait trouver des moyens dacclrer les traitements. Des solutions seront
proposes au chapitre 5.2.
4.4 Rsultats
4.4.1 Exemples de rsultats
Un exemple de patch est donn en Figure 4.7. Des exemples de rsultats sont donns aux Figures
4.8 4.11. A chaque fois, on donne lentre (donne sur la premire ligne), et les 10 meilleures
transcriptions selon lalgorithme. Sauf indication contraire, lentre est quantifie en prenant des
mesures quatre temps, et un tempo de 60 la noire. Sur lentre, les positions thoriques des
temps sont marques en pointills.
Figure 4.7 Un exemple de patch pour quantifier une srie de notes. Ici, la boucle omloop ne sert qu
placer les diffrentes propositions dans un objet poly.
A partir de ces quelques rsultats, on peut faire plusieurs constats :

Influence du schma de subdivision : Le schma de subdivision influe grandement sur les
rsultats possibles. Si lon a une ide des rsultats que lon souhaite obtenir, en particulier
35
Figure 4.8 Ici on ne quantifie quun temps. Le schma utilis est (((2|3) (2|3) 2) | (5 (2|3) 2) | ((7|11|13))).
Les traits bleus indiquent les dures des notes.
Figure 4.9 Une mme entre quantifie avec deux schmas diffrents : gauche,
(((2|3) (2|3) 2) | (5 (2|3) 2) | ((7|11|13))), droite, (((2|3) (2|3) 2) | (4 (2|3) 2) | ((5|7|11|13))).
si lon ne souhaite avoir que des rythmes binaires, utiliser un schma adapt garantit lob-
36
Figure 4.10 Le schma utilis est (4 (2|3) (2|3)). Ici, une quantification qui semblerait logique serait
de prendre la 3me proposition pour la premire mesure et la 4me pour la deuxime mesure.
tention de rsultats correspondant aux attentes, comme par exemple dans la Figure 4.10.
Au contraire, si lon na aucun priori sur la forme des rsultats que lon souhaite obtenir,
il peut tre intressant de prendre un schma offrant de nombreuses possibilits, mais on
risque dobtenir des rythmes complexes (en particulier dans le cas de subdivisions par 5
ou 7), comme on peut le voir dans la partie gauche de la Figure 4.9. On peut galement
rgler linfluence du paramtre de complexit relatif larit des subdivisions pour limiter
les occurences de telles subdivisions.
Grace notes : On remarque que les grace notes sont plutt frquentes dans les exemples
considrs, en particulier dans les exemples de la Figure 4.9. L encore, un meilleur rglage du
paramtre de complexit relatif aux grace notes permettra dempcher quelles ne soient trop
frquentes. Notons cependant quon ne pourra jamais les empcher compltement, mme en
rendant ce paramtre compltement discriminant. En effet, cest lors de la construction de
larbre, cest--dire la toute fin de lalgorithme, que lon sait effectivement si il y a des grace
notes ou non. Avant cela, on ne peut pas en tre sr : si plusieurs entres correspondant
des notes sont alignes la mme extrmit dune subdivision, on est sr quil y aura
des grace notes, mais si une entre correspondant une note est aligne droite, elle peut
donner lieu une grace note si le segment suivant a une entre correspondant une note
aligne gauche, ou non, dans le cas contraire.
37
Figure 4.11 On quantifie quatre noires avec peu dimprcision. Le schma utilis est (4(2|3)(2|3)).
Seules les rythmes 5, 9 et 10 correspondent des dures diffrentes du premier.
Liaisons : On remarque que souvent, parmi les solutions proposes, certaines sont quivalentes,
cest dire quune fois joues, elles donnent exactement les mmes dures. Par exemple, dans
la Figure 4.11, la deuxime proposition est la mme que la premire, sauf que la premire
noire a t remplace par deux croches lies, ce qui vaut la mme dure. Lautomate a
t construit pour viter certaines de ces subdivisions inutiles, en ne subdivisant pas des
segments vides. Ici, les segments ne sont pas vides, ils contiennent chacun un instant
quantifier. Lalgorithme va donc proposer malgr tout ces solutions redondantes, car en re-
subdivisant, il est possible que linstant contenu dans le segment ne soit alors plus align
au mme endroit. Ce nest en fait qu la reconstruction de larbre que lon constate que
les solutions sont quivalentes. On peut adopter deux attitudes face ces solutions redon-
dantes. Soit elles peuvent tre vues comme des doublons, auquel cas, on va chercher sen
dbarasser, soit elle peutvent tre vues comme dautres faons valides de noter le rythme
dentre, auquel cas on les conserve, et on laisse le choix lutilisateur dadopter lune ou
lautre. Nous avons pris le deuxime parti dans cette implmentation.
Un exemple o notre algorithme montre ses limites est le suivant : on cherche quantifier avec
un tempo de 60 la noire une note trs courte, dune dure de 100 ms, commenant au dbut du
temps, suivie dun silence. Les rsultats renvoys par notre algorithme sont donne en Figure 4.12.
On voit que la meilleure transcription ne tient pas compte du silence. Cela vient du fait que comme
linstant de dbut de la note et linstant de dbut du silence sont tous les deux proches de la borne
38
gauche du segment, lalgorithme estime quil est moins couteux daligner les deux instants gauche
du segment sans subdiviser du tout. Ce choix est justifiable : si les deux instants correspondaient
deux dbuts de notes, la reconstruction de larbre, on obtiendrait une note laquelle est attache
une grace note, ce qui serait une notation tout fait satisfaisante pour ce genre de rythme.
Le problme vient en fait de la reconstruction de larbre de rythme. La notation qui corres-
pondrait cet alignement serait une grace note attache un silence. Or cette notation nexiste
ni dans la thorie musicale, ni dans le formalisme utilis dans OpenMusic. Ne pouvant pas noter
une grace note accroche un silence, nous reconstruisons larbre en estimant que la note prend
toute la dure de la subdivision, plutt que de considrer que cest le silence qui lemporte. Cela
revient en fait aligner le dbut du silence droite de la subdivision, et non gauche, comme
cela a t fait pour le calcul de la distance (alignement au plus proche). Il y a donc une diffrence
entre le rsultat renvoy par lalgorithme et larbre reconstruit, ce qui est un vritable problme.
Une solution cet aspect sera propose la partie 5.2.2.2.
Figure 4.12 On quantifie une note courte suivie dun silence. Le schma de subdivision utilis est
(((2|3) (2|3) 2) | (5 (2|3) 2) | ((7|11|13))). Le meilleur rsultat ne tient pas compte du silence.
4.4.2 Comparaisons avec omquantify

La Figure 4.13 montre les rsultats obtenus laide de la fonction omquantify dOpenMusic
pour les mmes entres que celles tudies la partie 4.4.1. On ralise tout dabord des tests avec
les paramtres par dfaut domquantify : toutes les subdivisions infrieures 8 sont autorises, et
le paramtre de prcision, qui permet de privilgier plus ou moins les notations prcises par rapport
aux notations complexes, est rgl 0.5. On constate que pour beaucoup dentre elles, on obtient
des rythmes difficiles lire. Dans le premier exemple, on obtient un septolet l o lautre algorithme
proposait plutt des divisions simples, en deux ou en trois. Pire encore, une note est limine. Cela
provient du fait que la fonction true-durations, utilise pour mettre en forme les dures, a insr
39
un court silence entre les deux notes. omquantify va donc chercher la fois quantifier le court
silence et la note suivante, chose quil ne peut pas faire avec les contraintes imposes (on dcoupe
le temps au maximum en 8 parties gales). La fonction va donc liminer une des deux dures, et
cest la note qui est limine plutt que le silence. Dans le deuxime exemple, on obtient nouveau
beacoup de septolets, difficilement lisibles. Notre algorithme, quant lui, renvoie une solution
contenant beaucoup de grace notes, ce qui nest pas non plus idal puisque trs peu prcis. Dans le
troisime exemple, si certains temps sont quantifis de faon vraisemblable, on aurait par exemple
prfr que le premier temps soit reprsent par deux croches que par un septolet. Encore une fois,
notre algorithme va prfrer avoir recours aux grace notes. Dans le quatrime exemple, le dcalage
de 60 ms (trs faible, donc) de la troisime note est retranscrit dans la notation en un dcalage
dune triple croche. Ces notations sont difficiles lire, alors que les diffrences avec des notations
plus simples, par exemple certaines notations renvoyes par notre algorithme, sont minimes.
On ajuste prsent les diffrents paramtres de omquantify pour obtenir des notations plus
vraisemblables, et plus en accord avec les schmas de subdivisions utiliss (toutes les subdivisions
ne sont pas autorises par nos schmas). Les rsultats sont affichs Figure 4.14. Ainsi, en interdisant
les septolets, on obtient de meilleurs rsultats dans tous les exemples. Sur le premier exemple, cela
permet dobtenir la bonne figure rythmique, mais cause du silence rajout par true-durations,
on a un demi soupir la place de la dernire croche. Pour le deuxime exemple, on interdit
les septolets et on rgle le paramtre de prcision 0.1 pour obtenir un rythme assez simple.
Pour le troisime exemple, interdire les septolets et rgler la prcision 0.2 donne de trs bons
rsultats : part le sextolet, le rythme obtenu correspond ce quun annotateur humain aurait pu
transcrire. Pour le quatrime exemple, l encore, la fonction true-durations rajoute un silence,
ce qui complique la notation.
Globalement, les rsultats domquantify, si on prend le temps dajuster les paramtres, sont un
peu meilleurs que la meilleure transcription obtenue par notre algorithme, mais notre algorithme a
lavantage de proposer diffrentes solutions, parmi lesquelles se trouve le plus souvent une solution
convenable.
Un exemple intressant o notre algorithme obtient de meilleurs rsultats quomquantify est
celui de la Figure 4.15. Ici, la suite de dures que lon souhaite quantifier est la suivante (en
ms) : 333, 111, 111, 161, 284. Les pointills sont placs toutes les 333 ms. Ce rythme correspond
donc au premier rythme de la Figure 4.15 b), o la dernire note a t lgrement retarde. La
solution renvoye par omquantify utilise un septolet, car elle minimise lerreur sur le temps entier.
A linverse, notre algorithme va fonctionner subdivision par subdivision : dans le deuxime tiers
du temps, cela vaut la peine de subdiviser nouveau, mais dans le troisime tiers, ce nest pas la
peine, le fait de subdiviser encore ferait trop monter la complexit par rapport au gain de prcision
que cela reprsente. On ne subdivise donc pas plus loin et on obtient une notation facile lire, sans
dnaturer le rythme dentre.
40
1)
omquantify
1-best
2)
omquantify
1-best
3)
omquantify
1-best
4)
omquantify
1-best
Figure 4.13 Rsultats renvoys par la fonction omquantify, compars aux meilleurs rsultats renvoys
par notre algorithme. Les donnes ont t auparavant mises en forme laide de la fonction true-durations.
41
1)
omquantify
1-best
2)
omquantify
1-best
3)
omquantify
1-best
4)
omquantify
1-best
Figure 4.14 Rsultats renvoys par la fonction omquantify en ajustant les paramtres, compars aux
meilleurs rsultats renvoys par notre algorithme.
42
a)
b)
c)
Figure 4.15 a) Entre quantifier. b) Rsultats renvoys par notre algorithme. c) Rsultat renvoy
par la fonction omquantify
43
Chapitre 5
Bilan et perspectives
5.1 Bilan
Notre stage au sein de lquipe Reprsentations Musicales lIrcam tait consacr la quan-
tification rythmique dans le contexte particulier de lenvironnement de composition assiste par
ordinateur OpenMusic.
Dans ce rapport, aprs une rapide explication sur le rythme, nous avons dlimit le problme de
la quantification rythmique, dcrit quelques formalismes de reprsentation arborescente du rythme,
et prsent des solutions existant pour ce problme dans le chapitre 1.
Nous avons interrog des utilisateurs dOpenMusic pour connatre leurs usages des outils de
quantification, ainsi que les ventuelles amliorations quils souhaiteraient y voir, et nous avons
rassembl les conclusions de ces entretiens dans le chapitre 2. Nous avons pu dgager plusieurs
grands axes damlioration prconiss par les utilisateurs rencontrs. Les compositeurs voquent
un besoin de contrle fin du processus de transcription de loeuvre composes, puisque ce processus
fait partie intgrante de la cration de loeuvre. Ils voquent en particulier des interfaces permettant
de spcifier au logiciel de quantification des paramtres signifiants dun point de vue musical. Nous
avons galement pu remarquer la difficult de la gestion des silences, pourtant essentiels la
musique, ainsi que des grace notes.
Suite ces entretiens, nous avons dvelopp un algorithme, appel algorithme k-best, permet-
tant de rpondre en partie aux besoins des utilisateurs. Cet algorithme a t dcrit au chapitre 3.
Il se base sur le formalisme dautomates darbres pondrs et permet dnumrer, de faon com-
putationnellement efficace, les k arbres de rythme de plus faible poids selon une certaine mesure,
prenant en compte la prcision et la complexit de la notation laquelle ils correspondent (le choix
de ces mesures a galement t discut).
Dans le chapitre 4, nous avons prsent les diffrents choix qui ont t faits lors de limplmen-
tation de lalgorithme k-best, nous avons galement dtermin la complexit en temps de notre
algorithme et ralis des essais pour valuer son temps dexcution. Cet algorithme est plus long
excuter que lalgorithme actuel dOpenMusic, mais offre des perspectives dusage intressantes.
Nous avons prsent des rsultats donns par cet algorithme et les avons compars ceux de loutil
actuel. Les rsultats sont comparables, mais la meilleure gestion des silences et des grace note
par notre algorithme fait quon peut souvent obtenir de meilleurs rsultats parmi ses premires
propositions quen ajustant les paramtres de lalgorithme actuel.
Nous allons dans la fin de ce rapport proposer diffrentes pistes damliorations, la fois pour
rendre notre systme plus performant dans ses rsultats et pour aborder des problmatiques vo-
ques par les utilisateurs dOpenMusic qui nont pas t tudies dans ce stage.
44
5.2 Perspectives
Nous lavons vu, les rsultats sont meilleurs quavec les outils existants dans certains cas, en par-
ticulier lorsque lon souhaite quantifier plus ou moins finement diffrents endroits dun segment,
mais la rapidit dexcution est bien meilleure pour les outils existants. Dans cette partie, nous
discuterons des diffrentes amliorations que lon pourrait envisager pour amliorer les rsultats
de la quantification.
5.2.1 Critres de choix des arbres

Nous avons vu que le choix des diffrents crites qui permettent de classer les arbres sont
absolument dterminants. Une tude plus approfondie de ces critres serait donc un premier moyen
damliorer les rsultats de lalgorithme
5.2.1.1 Choix des mesures de distance

La mesure de distance que nous utilisons est une mesure assez simple : cest la somme des erreurs
de quantification. Choisir une autre fonction de distance pourrait tre intressant. En particulier,
ici, on na aucune information sur la faon dont lerreur est rpartie. Une seule grosse erreur peut
donner la mme valeur de prcision que plusieurs erreurs rparties. Or, perceptivement, dans le cas
o il ny a quune seule grosse erreur, on aura limpression que le rythme de sortie est trs diffrent
du rythme dentre, alors que dans le cas o lerreur est rpartie, la diffrence sera moins sensible.
Il faudrait donc trouver des mesures de prcision qui privilgient les cas o lerreur est rpartie.
On pourrait penser en particulier calculer la similarit cosinus [21] entre le vecteur des instants
dentre et celui des instants de sortie, qui a pour proprit dtre insensible aux homothties,
ou encore adapter lide des rapports entre dures successives explore dans [19], mais dans les
deux cas, il faudra adapter ces mesures, puisque notre algorithme est rcursif et na jamais de
connaissance globale de la squence quantifier, sa vision est restreinte au segment relatif au
noeud courant. On pourra galement envisager de prendre la somme des carrs des erreurs ou de
leurs cubes, comme cela a t fait en particulier dans [1], pour dsavantager plus fortement les gros
carts par rapport aux petits.
5.2.1.2 Choix des mesures de complexit

Pour la mesure de complexit, on peut galement imaginer dautres mesures de complexit
que celles utilises. En particulier, on pourrait raliser des analyses sur des corpus de partitions
pour dterminer quels motifs, quels arbres ou sous-arbres de profondeur donne sont les plus
frquents, et estimer que plus un arbre est frquent, moins il est complexe. Pour cela, on pourrait
sappuyer sur [22], dans lequel des automates k-testables (analogues du n-gram pour les arbres)
sont construits pour rechercher des similarits entre des pices de musique. On pourrait galement
essayer de dterminer quand des liaisons vont apparaitre dans le rsultat final, ou estimer avec
plus de prcision le nombre de grace notes, mais l encore, cela suppose davoir une connaissance
plus globale de lentre quantifier, ce qui sera difficile raliser dans le cadre de lalgorithme
tel quil est conu. Par contre, un moyen envisageable dempcher quil ny ait trop de grace
notes serait de pnaliser plus fortement les grace notes lorsquelles sont une faible profondeur
de larbre que lorsquelles sont une grande profondeur. Cela nest applicable que quand on sait
quil y aura une grace note. Ainsi, lorsque lon a deux entres alignes la mme borne de la
subdivision, lalgorithme prfrera subdiviser encore quand la subdivision correspond une valeur
longue, comme une ronde ou une blanche, et prfrera noter une grace note quand il sagit dune
valeur courte, comme une croche ou une double croche.
45
5.2.1.3 Choix de la fonction de poids
La fonction de poids utilise, cest dire la manire dont sont combines les mesures de distance
et de complexit pour dterminer le poids dune solution, est elle aussi trs simple, on pourrait
essayer de considrer des fonctions plus volues. Pour cela, il faudrait tudier de prs quelles fonc-
tions permettent vrifier la proprit de monotonie, et cest un problme qui nest pas vident. Si
lon garde lide dune simple combinaison linaire, alors il faudrait faire des tests plus consquents,
sur de plus grands corpus, pour dterminer quels coefficients permettent dobtenir les meilleurs r-
sultats. En particulier, il serait intressant de raliser des tests sur le corpus Kostka-Payne [23],
qui contient la fois des donnes quantifies et des performances de pices extraites de [14], pour
obtenir, via des techniques dapprentissage automatique, les coefficients qui minimisent les erreurs
sur ce corpus. Rendre ces coefficients paramtrables par lutilisateur, par exemple en ajoutant
un paramtre permettant de rgler linfluence relative des mesures de distance et de complexit
permettrait un contrle plus fin du compositeur sur les rsultats obtenus.
5.2.2 Sur les automates

5.2.2.1 Stockage en mmoire des automates
Actuellement, chaque fois quun nouvel automate est construit, on dtruit le prcdent. Or
il arrive souvent que lon construise un nouvel automate : chaque fois que lentre ou le schma
de subdivision sont modifis, un nouvel automate est construit, et quand on quantifie des entres
qui durent plusieurs mesures, on construit un nouvel automate pour chaque mesure. De plus, la
construction dun nouvel automate est trs coteuse : en plus de devoir reconstruire la table de
hachage et initialiser les listes de candidats, on perd toutes les solutions qui ont t calcules
auparavant. En effet, si par exemple, on veut renvoyer les 10 meilleures solutions pour une entre
de deux mesures, les 10 meilleures seront calcules pour la premire mesure, puis on construit un
nouvel automate, et les 10 meilleures pour la deuxime. Si on souhaite ensuite obtenir la 11me
meilleure solution pour la premire mesure, il faudra recalculer les 10 premires avant de pouvoir
calculer la 11me. On perd donc lun des principaux avantages que nous fournissait lakgorithme
utilis : le fait quil soit peu coteux de gnrer de nouvelles solutions une fois lautomate cr et
les premires solutions trouves. Trouver un systme pour stocker les automates en mmoire serait
donc une amlioration primordiale du point de vue de la rapidit dexcution de lalgorithme. On
pourrait par exemple stocker un nombre fixe dautomates et supprimer au fur et mesure ceux
qui ont t le moins utiliss, ou bien laisser le soin lutilisateur de supprimer les automates dont
il ne souhaite plus se servir.
5.2.2.2 Choisir un autre automate

Dans la construction de lautomate, nous crons un tat par chemin, et les entres lintrieur
de ce segment sont alignes sur la borne la plus proche. Or, nous lavons vu la partie 4.4.1, il
arrive que dans une subdivision contenant deux entres xi et xi+1 , correspondant respectivement
au dbut dune note et au dbut dun silence, toutes les deux situes plus proches de la borne
de gauche que de celle de droite, le calcul de la distance soit fait en alignant les deux entres
gauche, mais larbre reconstruit la sortie aligne xi gauche et xi+1 droite, ce qui fausse les
rsultats. Une premire solution ce problme serait de modifier la fonction de complexit pour
quelle pnalise fortement ces cas, en particulier lorsquils se produisent la base de larbre et donc
engendrent des diffrences importantes, afin de forcer lalgorithme subdiviser plus profondment.
Une autre solution serait de modifier lautomate pour ne plus contraindre les onsets tre aligns
la borne la plus proche, mais laisser lalgorithme dcider de la meilleure solution.
Pour cela, il faudrait, pour chaque chemin, crer non plus un seul tat, mais plusieurs, en
fonction du nombre dentres contenue dans le segment. Ainsi, si le segment correspondant un
chemin contient 3 entres x1 , x2 et x3 , on crera 4 tats : un tat qui aligne toutes les entres
46
gauche, un tat qui aligne x1 et x2 gauche, et x3 droite, un tat qui aligne x1 gauche, et x2
et x3 droite, et un tat qui aligne toutes les entres droite. A chaque tat, on calcule ensuite
la distance |xi yi |. La somme des distance point point sera videmment la plus petite lorsque
chaque point est align la borne la plus proche, mais en adaptant les valeurs de complexit, on
pourrait obtenir dautres rsultats intressants.
Il faut noter que choisir cette nouvelle forme dautomate augmentera grandement le nombre
dtats dans lautomate. On autorise plus de solutions, on augmente donc les chances de trouver
la bonne, mais il est aussi plus coteux de les explorer. Daprs ltude de la partie 4.3, la taille de
lautomate est critique pour le temps dexcution de lalgorithme, une telle solution ne sera donc
pas forcment recommandable, surtout pour la quantification dentres longues. En particulier, le
nombre dtats ne dpendra plus uniquement du schma de subdivision, mais augmentera aussi
avec le nombre dentres aligner, ce qui ntait pas vraiment le cas jusqu prsent.
5.2.3 Interfaces
La question des interfaces dutilisation des logiciels, qui tait un verrou souvent voqu lors
des entretiens avec les utilisateurs dOpenMusic, na pas pu tre aborde en profondeur au cours
de ce stage. Nanmoins, nous pouvons proposer des ides pour concevoir un outil plus facilement
manipulable par les utilisateurs.
5.2.3.1 Prciser les paramtres significatifs

Un des besoins voqus par les utilisateurs est celui de pouvoir indiquer lalgorithme, plutt
que la signature et le tempo, qui ne sont pas forcment connus priori, des paramtres porteurs
de sens musical. En particulier, fixer les barres de mesure, ou les notes sur lesquelles sont censs
tomber les temps forts de la musique aurait plus de sens, puisque ce sont des paramtres dont les
compositeurs ont en gnral une ide avnt la quantification.
On pourrait par exemple proposer un outil qui permettrait de placer certains temps forts, la
manire du pr-traitement qui est ralis par AR et dcrit par la Figure 2.2. Une interface dans
OpenMusic permettant de segmenter un flux de notes a t propose dans [5], elle est en particulier
utilise par OM (cf partie 2.2) dans ses analyses pour segmenter en mesures. Cet interface pourrait
tre enrichie de diverses fonctions spcifiques la quantification rythmique. Lutilisateur placerait
par exemple quelques temps forts via cette interface affichant la srie de notes, puis un algorithme
proposerait des valeurs de tempo, et afficherait les pulsations correspondantes sur la srie de notes.
Lutilisateur peut ainsi facilement visualiser la valeur de tempo qui lui semble la meilleure. Il peut
ensuite dplacer certaines pulsations pour les faire concider avec des dbuts ou des fins de notes.
Une fois ces ajustements raliss, loutil retourne une srie dinstants de dbut et une srie de
dures recales, ainsi que la valeur de tempo correpondant, qui peuvent ensuite tre utiliss par
lalgorithme de quantification. Cette tape permettrait galement dliminer certains problmes
lis au dcoupage en mesures voqu la partie 4.1.2, en particulier lorsque la premire note dune
mesure est joue lgrement en avance et donc un petite partie dborde sur la mesure prcdente.
Sur cette mme interface, on pourrait galement placer les barres de mesure, et ainsi, en dduire
les signatures. On peut avoir deux approches. Soit on considre que lutilisateur donne toutes
les barres de mesures. Dans ce cas, en dduire les signatures est facile, il suffit de compter les
temps entre chaque barre de mesure. On peut aussi considrer quil nen donne que quelques unes.
Retrouver toutes les barres de mesure est alors plus compliqu, mais peut tre fait en trouvant des
diviseurs communs des nombres de temps sparant deux barres de mesures.
On obtiendrait alors facilement tous les paramtres ncessaires la quantification, en les fixant
laide dune interface plutt que simplement en essayant plusieurs jeux de paramtres.
47
5.2.3.2 Editeur de schmas de subdivision
Le format des schmas de subdivision est relativement compliqu. Il est difficile la fois crire
et relire, et est trs sujet erreur. De plus, il ny a actuellement pas de moyen de vrifier que le
schma donne bien lautomate que lon souhaite, moins dafficher toutes les entres de la table de
hachage. Dvelopper une interface facilitant lcriture et la lecture des schmas serait dune grande
aide pour les utilisateurs. On pourrait par exemple reprsenter le schma par un graphe orient, o
des flches indiquent pour chaque subdivision quelles sont les prochaines subdivisions possibles (en
prenant garde de ne pas crer de cycles, auquel cas lautomate serait de taille infinie). Un exemple
est fourni en Figure 5.1. On pourrait aussi proposer un certain nombre de schmas de subdivision
classiques, que lutilisateur combinerait ensuite selon ce quil souhaite obtenir.
2 2 3
3
3
2
Figure 5.1 Reprsentation du schma de subdivision ((2|3) ((2 3) | ((3|5) 2))) par un graphe orient.
5.2.4 Apprentissage des prfrences de lutilisateur

Une piste qui avait t explore dans [17] tait dapprendre les prfrences de lutilisateur.
Le postulat de dpart est que le fait de transcrire une ide musicale en partition fait partie du
processus de cration dune oeuvre, et donc chaque compositeur a un style de notation qui lui
est propre. A partir des choix faits par lutilisateur parmi les diffrentes quantifications proposes
par loutil que nous avons dvelopp, on peut apprendre au fur et mesure le style de notation
de lutilisateur. Par exemple, laide dune interface, lutilisateur choisit parmi les propositions
renvoyes par lalgorithme celle quil souhaite garder, et celles au contraire quil ne souhaite plus
voir apparaitre. Les solutions limines ne devront plus tre proposes par lalgorithme, et celles
qui sont slectionnes devront avoir un poids plus faible que celles qui nont pas t slectionnes.
Lutilisateur peut aussi dcider de ne rejeter quune partie de la solution : si dans une mesure deux
temps, on a une noire et un quintolet de croches, lutilisateur peut prciser que cest le quintolet
quil refuse de voir apparatre nouveau. Ensuite, en analysant les caractristiques des solutions
retenues ou rejetes, telles que la profondeur de larbre, le nombre de grace notes, le nombre de
liaisons, les nombres doccurences de chaque arit, on en dduit les caractristiques des solutions
retenues et limines.
On peut ensuite utiliser ces prfrences dans lalgorithme, en utilisant des techniques dappren-
tissage de langage darbres pondrs, comme une nouvelle mesure de complexit des solutions pour
amliorer la gnration de solutions. On a alors un automate pour la mesure de prcision, construit
chaque mesure, qui ne dpend que de lentre et du schma de subdivision, et un autre automate
pour la mesure de complexit, qui est appris au fil des choix de lutilisateur.
Une autre possibilit est dutiliser cette connaissance non pas dans lalgorithme, mais plutt
comme un post-traitement, permettant dliminer doffice certaines solutions, et gnrer les sui-
vantes sans que lutilisateur nintervienne. Cette deuxime option permet de prendre en compte
48
les liaisons et les grace notes, deux paramtres qui, nous lavons vu, sont difficilement valuables
pendant le droulement de lalgorithme mais qui le sont facilement une fois larbre reconstruit.
Une dernire possibilit serait dutiliser ces choix pour apprendre un schma de subdivision.
Il sagit ici dun problme difficile, mais qui serait trs bnfique, car comme noue lavons vu, le
format du schma de subdivision est difficile manipuler. De plus, le schma est utilis dans la
construction des automates, donc modifier le schma implique de reconstruire tous les automates,
et il est plus difficile den valuer plusieurs.
49
Bibliographie
[1] Carlos Agon, Grard Assayag, Joshua Fineberg, and Camilo Rueda. Kant : A critique of pure
quantification. In Proceedings of the International Computer Music Conference, pages 529,
1994.
[2] Carlos Agon, Karim Haddad, and Grard Assayag. Representation and rendering of rhythm
structures. In Web Delivering of Music, 2002. WEDELMUSIC 2002. Proceedings. Second
International Conference on, pages 109113. IEEE, 2002.
[3] Grard Assayag, Camilo Rueda, Mikael Laurson, Carlos Agon, and Olivier Delerue. Computer-
assisted composition at IRCAM : From PatchWork to OpenMusic. Computer Music Journal,
23(3) :5972, 1999.
[4] Marc Bezem, Jan Willem Klop, and Roel de Vrijer. Term rewriting systems. Cambridge
University Press, 2003.
[5] Jean Bresson and Carlos Prez-Sancho. New Framework for Score Segmentation and Analysis
in OpenMusic. In Sound and Music Computing, pages 11, Copenhagen, Denmark, 2012. cote
interne IRCAM : Bresson12c.
[6] Ali Taylan Cemgil, Peter Desain, and Bert Kappen. Rhythm quantization for transcription.
Computer Music Journal, 24(2) :6076, 2000.
[7] H. Comon, M. Dauchet, R. Gilleron, C. Lding, F. Jacquemard, D. Lugiez, S. Ti-

son, and M. Tommasi. Tree automata techniques and applications. Available on :
http://www.grappa.univ-lille3.fr/tata, 2007. release October, 12th 2007.
[8] Peter Desain and Henkjan Honing. The quantization of musical time : A connectionist ap-
proach. Computer Music Journal, pages 5666, 1989.
[9] Pierre Donat-Bouillud. Transcription rythmique dans OpenMusic. Stage, 2013.
[10] Manfred Droste, Werner Kuich, and Heiko Vogler. Handbook of weighted automata. Springer
Science & Business Media, 2009.
[11] John E Hopcroft and Jeffrey D Ullman. Formal languages and their relation to automata.
1969.
[12] Liang Huang and David Chiang. Better k-best parsing. In Proceedings of the Ninth Internatio-
nal Workshop on Parsing Technology, pages 5364. Association for Computational Linguistics,
2005.
[13] Florent Jacquemard, Pierre Donat-Bouillud, and Jean Bresson. A structural theory of rhythm
notation based on tree representations and term rewriting. In Mathematics and Computation
in Music, volume 9110, page 12. Springer, 2015.
50
[14] Stefan Kostka and D Payne. Workbook for tonal harmony. New York, 1995.
[15] Mikael Laurson. PATCHWORK : A visual programming language and some musical applica-
tions, volume 6. Sibelius Academy Helsinki, 1996.
[16] Christopher S Lee. The rhythmic interpretation of simple musical sequences : towards a
perceptual model. Musical structure and cognition, 3 :5369, 1985.
[17] Adrien Maire. Quantification musicale avec apprentissage sur des exemples. 2013.
[18] Benoit Meudic. Dtermination automatique de la pulsation, de la mtrique et des motifs
musicaux dans des interprtations tempo variable doeuvres polyphoniques. PhD thesis,
Paris 6, 2004.
[19] Declan Murphy. Quantization revisited : a mathematical and computational model. Journal
of Mathematics and Music, 5(1) :2134, 2011.
[20] Geoffroy Peeters. Template-based estimation of time-varying tempo. EURASIP Journal on
Applied Signal Processing, 2007(1) :158158, 2007.
[21] Ali Mustafa Qamar. Generalized Cosine and Similarity Metrics : A Supervised Learning
Approach based on Nearest Neighbors. Theses, Universit de Grenoble, 2010.
[22] David Riso-Valero. Symbolic Music Comparison with Tree Data Structure. PhD thesis, Ph.
D. Thesis, Universitat dAlacant, Departamento de Lenguajes y Sistemas Informaticos, 2010.
[23] David Temperley. An evaluation system for metrical models. Computer Music Journal,
28(3) :2844, 2004.
[24] David Zicarelli and M Puckett. Max/msp. Cycling, 74 :19902001, 2002.
51

Rapport de Stage ATIAM - Adrien Ycart

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Rapport de Stage ATIAM - Adrien Ycart

Uploaded by

Copyright:

Available Formats

Quantification rythmique dans OpenMusic

To cite this version:

HAL Id: hal-01202257

HAL is a multi-disciplinary open access Larchive ouverte pluridisciplinaire HAL, est

Stage de master ATIAM

Je remercie tous les compositeurs et utilisateurs dOpenMusic que jai

Je remercie Karim Haddad, pour le temps quil a eu la gentillesse de

Enfin, je remercie mes camarades et collgues pour leurs discussions tou-

2 Entretiens avec les utilisateurs dOpenMusic 8

3 Automates darbres et quantification 16

4 Dveloppements, valuation et rsultats 27

1.1 Description du problme

1.1.2 Le problme de la quantification rythmique

Dans ce stage, nous nous intresserons uniquement au problme de la quantification rythmique.

1.1.3 Deux approches pour la quantification

1.2 Reprsentation du rythme

1.2.1 Arbres de rythme dOpenMusic

Arbre symbolique Arbre de rythme d'OpenMusic

1.3 Etat de lart

Entretiens avec les utilisateurs

2.1.2 Mthode de travail actuelle

Conversion en Fichier MIDI Ajustement du Fichier MIDI Partition

AudioSculpt / Melodyne Cubase omquantify

Figure 2.1 Processus de travail dAR

Tempo track Tempo track Tempo track

2.1.4 Pistes damlioration

Tactus constant Signature constante

Extraction de Premiers temps

Extraction de Liste d'instants Dcoupage en Liste d'instants

AudioSculpt + recalage omquantify

Figure 2.4 Processus de travail dOM

2.2.3 Pistes damlioration

2.3.2 Mthode de travail

2.3.3 Pistes damlioration

2.4.2 Algorithmes gntiques

2.4.3 Choix de la reprsentation

2.4.4 Utilisation des algorithmes gntiques pour la quantification

Automates darbres et quantification

3.1 Fondements thoriques

3.1.1 Automates darbres et grammaires hors-contexte

3.1.2 Schma de subdivision

3.1.3 Automates darbres pondrs

P (rythme|entree) P (entree|rythme)P (rythme)

P oids d0 un arbre (distance entre l0 entree et le rythme)(complexite du rythme)

3.1.4 Arbre de poids minimal

i [1..k], w(a0i ) > w(ai ) w(a0 ) > w(a)

3.2 Principe de lalgorithme dnumration des meilleures so-

3.2.1 Entres et sorties de lalgorithme

3.2.2 Construction de lautomate

Figure 3.2 Le noeud rouge est rfrenc par le chemin (3 1)(2 2)

3.2.2.1 Reprsentation interne des arbres

3.2.2.2 Format de lautomate

le run (1 1...1), o le nombre de 1 est gal larit de la subdivision.

3.2.3 Droulement de lalgorithme

3.2.3.1 Une tape de lalgorithme

3.2.3.2 Ajout des candidats suivants la liste des candidats

Cette rgle dcoule de la proprit de monotonie. En effet, si par exemple on considre le

3.2.4 Un exemple simple

Lautomate construit a donc les tats suivants :

liste vide (racine)

Etat Liste de candidats Liste des meilleurs runs

Etat Liste de candidats Liste des meilleurs runs

Etat Liste de candidats Liste des meilleurs runs

3.3 Choix des mesures de poids