Markov in Dub - Nicolas de DREUILLE

Transcription

UV Libre Markov in Dub
Markov in Dub
Nicolas de Dreuille
Juin 2002
Remerciements
Henri MAZUE, Carlos TEIXERA, Bénédicte RINALDI, Marie SOYEUX, Vincent
LORIMY
Sommaire
REMERCIEMENTS ............................................................................................................................................ 1
INTRODUCTION : .............................................................................................................................................. 3
DU DUB A MARKOV :........................................................................................................................................ 3
LES MODELES DE MARKOV :........................................................................................................................ 5
LES CHAINES DE MARKOV DISCRETES :............................................................................................................... 6
Présentation du modèle :............................................................................................................................... 6
Apprentissage et vraisemblance :.................................................................................................................. 6
Conclusion : .................................................................................................................................................. 7
LES MODELES DE MARKOV CACHES A OBSERVATIONS DISCRETES [3]: ............................................................... 8
Présentation du modèle :............................................................................................................................... 8
Apprentissage et problèmes liés : .................................................................................................................. 8
Evaluation : ................................................................................................................................................................ 9
Explication : ............................................................................................................................................................. 10
Apprentissage : ......................................................................................................................................................... 11
Conclusion : ................................................................................................................................................ 12
LES MODELES DE MARKOV CACHES FACTORIELS [4]: ....................................................................................... 13
Présentation du modèle :............................................................................................................................. 13
Apprentissage et problèmes liés : ................................................................................................................ 14
Algorithme général :................................................................................................................................................. 14
Calcul exact lors de l’étape E : ................................................................................................................................. 14
Echantillonnage de Gibbs :....................................................................................................................................... 14
Mean field approximation : ...................................................................................................................................... 15
L’approximation structurée : .................................................................................................................................... 16
Etape M : .................................................................................................................................................................. 17
Conclusion : ................................................................................................................................................ 17
CONCLUSION SUR LES MODELES :...................................................................................................................... 19
IMPLEMENTATION ........................................................................................................................................ 19
PRETRAITEMENT DES DONNEES :....................................................................................................................... 19
IMPLEMENTATION EN MATLAB : ....................................................................................................................... 20
Prétraitement :............................................................................................................................................. 20
Apprentissage :............................................................................................................................................ 20
Chaînes de Markov : ............................................................................................................................................ 20
Modèle de Markov caché : ....................................................................................................................................... 21
Vraisemblance :........................................................................................................................................... 21
Chaînes de Markov : ............................................................................................................................................ 21
Distribution de probabilités du prochain symbole : .................................................................................... 22
Chaînes de Markov :................................................................................................................................................. 22
Génération d’une séquence :....................................................................................................................... 23
Chaînes de Markov :................................................................................................................................................. 23
TESTS SOUS MATLAB : ...................................................................................................................................... 25
Influence des différents paramètres............................................................................................................. 25
Ensemble de validation ?............................................................................................................................. 26
Génération de séquence............................................................................................................................... 27
IMPLEMENTATION EN JAVA :............................................................................................................................. 28
Diagrammes de classes ............................................................................................................................... 28
Avancement : ............................................................................................................................................... 29
CONCLUSION : ................................................................................................................................................. 30
BIBLIOGRAPHIE : ........................................................................................................................................... 31
Nicolas de Dreuille
2
Introduction :
Les musiques électroniques font de nos jours de plus en plus appel à l’outil
informatique, et ce à tous les stades de production ou presque. La structure répétitive de
certaines d’entre elles renforce d’ailleurs cette impression d’intervention humaine quasiment
absente dans le processus de développement. Nous nous sommes donc interrogés sur la
possibilité d’une composition assistée par un ordinateur ou d’un apport d’une sorte
d’"intelligence" à cette musique.
Les modèles de Markov permettent justement de caractériser et même de simuler des
séries temporelles auxquelles pourraient êtres assimilés ces morceaux.
Après avoir présenté brièvement le cheminement de nos pensées jusqu’à cette idée,
nous présenterons le modèle et tenterons de le tester sur un jeu de données de test à l’aide de
MATLAB. Enfin, nous mettrons en place les bases d’une implémentation future en JAVA.
Du dub à Markov :
Au début du vingtième siècle, les noirs jamaïcains commencent de se battre pour
l’abolition de l’esclavage dans leur pays, ils puisent dans leurs racines africaines et fondent le
rastafarisme, qui peut être ressenti comme un moyen de résistance ethnique. Ils commencent
alors de jouer le nyabinghi, mélange de percussions et de chants issu des réminiscences du
folklore Africain ayant traversé l’atlantique.
Quelques années plus tard ce style métissé aux divers courants musicaux en vogue tels
que le calypso ou le rythm&blues donneront naissance au ska, puis au rock steady et enfin au
fameux reggae au début des années soixante dix.
A l’époque, les 45 tours sortent accompagnés d’une version instrumentale. Les "sound
systems", sortes de discothèques mobiles en plein air sont alors les vecteurs médiatiques de
cette musique. Un "selector" y diffuse ces fameuses "versions" sur lesquelles des "DJ"
chantent les paroles originales ou improvisent. L’important était à l’époque de produire le son
le plus impressionnant possible, c’est pourquoi les producteurs commencent à travailler les
instrumentaux pour mettre en valeur les percussions et la basse. C’est la naissance du dub qui
n’est donc à la base qu’un instrumental reggae un peu étoffé.
En 1973/74, deux génies, King-Tubby et Lee "Scratch" Perry commencent à utiliser la
stéréo ainsi que certains effets comme la distorsion la reverb l’écho. Le dub se tourne alors
résolument vers l’expérimentation électronique.
Dans les années 80, le phénomène est internationalisé, les effets se multiplient, les
musiciens deviennent de véritables ingénieurs du son, alchimistes créant une synergie au sein
de leurs machines. L’ère du tout numérique est amorcée et l’informatique commence à
intervenir dans la production musicale.
De nos jours, le dub, s’il a tendance à renouer avec ses racines instrumentales et
exotiques, reste l’étalage de technologies que nous connaissons. Une musique syncopée où les
samples jouent avec les effets, le tout rythmé des percussions puissantes menées par une ligne
de basse ronde et envoûtante qu’agrémente encore souvent le contre-temps omniprésent cher
au reggae.
Ce qui est intéressant dans la genèse de ce style, c’est qu’elle s’est faite historiquement
sur une quarantaine d’années, mais a évolué en termes de technologie à une vitesse
prodigieuse. Ceci peut s’expliquer par le fait qu’il puise ses sources dans la musique
Nicolas de Dreuille
3
traditionnelle africaine, que ses initiateurs soient très traditionalistes, et qu’il soit né à une
époque à laquelle la médiatisation et l’avancée technologique on beaucoup fait progresser la
musique.
Ce constat amène une question : quelles pourront être les apports des dernières
technologies ? On a déjà vu les home studio et un nombre sans cesse croissant de logiciels qui
ont démocratisé la production musicale et rendu son traitement toujours plus facile, peut être
ne lui manque-t-il que l’intelligence ? Or les techniques d’apprentissage popularisées sous le
nom d’intelligence artificielle pourraient pallier à ce défaut. Imaginez qu’un compositeur
puisse transmettre sa sensibilité à une machine… C’est ce que nous allons tenter d’étudier
dans ce projet.
L’approche est simple, les musiques électroniques telles que le dub la house ou même
le hip hop sont souvent relativement répétitives, ce qui a fait naître l’idée de la découper en
samples et de fournir un éditeur permettant d’organiser ces derniers afin de produire des
morceaux. La gamme e-jay par exemple est l’outil le plus populaire permettant de réaliser ce
type d’opération. On se souvient aussi du format de fichier mod qui permettait d’arranger des
samples.
Nous allons utiliser ce principe et tenter d’apprendre l’art et la manière d’arranger ces
morceaux afin de le reproduire ensuite, tentant ainsi de créer un morceau de musique à
"géométrie variable".
A cette fin, nous devrons tout d’abord trouver un modèle mathématique permettant de
réaliser cet apprentissage, et ensuite de générer une série temporelle.
Nicolas de Dreuille
4
Les modèles de Markov :
Comme nous l’avons dit précédemment, nous allons décomposer un morceau de
musique en fragments que nous appellerons samples et nous designerons le descriptif de leur
arrangement par un enregistrement.
Celui-ci sera composé pour chaque granule de temps t, d’un vecteur d’entiers
représentant l’indice du sample à jouer pour chaque voix, une voix pouvant être assimilée à
un instrument. En termes de série temporelle, chacun des éléments de ces vecteurs sera
assimilé à un symbole d’un alphabet défini au fur et à mesure de la lecture, et pourra être
assimilés à un entier permettant de retrouver le symbole concerné.
Nous nous restreindrons donc à l’étude d’un vecteur d’entiers soit une série temporelle
discrète et partirons par ailleurs de l’hypothèse selon laquelle l’ensemble des samples joués à
un instant, soit le symbole courant dépend de ceux joués avant.
Notre enregistrement peut donc être traité à l’aide d’un outil simple : les chaînes de
Markov.
Morceau
Nicolas de Dreuille
Sample1
Sample3
Sample2
Sample4
Symbole 1, Symbole 2
Symbole 1
Symbole 2
Sample1
Sample3
Sample2
Sample4
5
Les chaînes de Markov discrètes d’ordre 1 :
Présentation du modèle :
Considérons un système pouvant être décrit à tout instant par un état parmi N
distincts : S1 , S 2 … S N . Les transitions d’un état à un autre ou à lui même se font à intervalles
réguliers dans le temps (t=1,2…) selon une distribution de probabilités liée aux états. Soit qt
l’état courant. Une description probabiliste courante prendrait en compte tous les états
précédents, mais dans une chaîne de Markov discrète d’ordre K, seuls les K ordres précédents
sont pris en compte.
P[qt = Sit qt −1 = S it −1 ,..., q1 = Si1 ] = P[qt = S it qt −1 = S it −1 ,..., qt − K = Sit − K ] (1)
Notre étude porte sur les chaînes d’ordre 1, les chaînes d’ordres supérieurs pouvant
être simulés en faisant des combinaisons de symboles.
On a donc la distribution suivante des probabilités de transition :
[
]
aij = P qt = S j qt −1 = S i , 1 ≤ i, j ≤ N
D’où les propriétés suivantes :
N
aij ≥ 0, ∑ aij = 1
j =1
A ces probabilités de transition, on associe des probabilités d’émission :
π i = P[q1 = S i ],1 ≤ i ≤ N
Apprentissage et vraisemblance :
L’apprentissage des chaînes de Markov se résume à un simple comptage, il suffit en
effet de compter les émissions et les transitions en incrémentant par exemple les éléments
d’un vecteur ayant la longueur de π et d’une matrice ayant les dimensions de a, puis de
normaliser le vecteur et les lignes de la matrice.
Soit O une séquence d’observation, on appelle la vraisemblance de O pour un Modèle
que nous nommerons M P[O M ] . Soit par exemple O = S 3 , S 2 , S 2 , S1 on a
P[O M ] = P[S 3 , S 2 , S 2 , S1 M ] = P[S3 ].P[S 2 S3 ].P[S 2 S 2 ].P[S1 S 2 ]
Nicolas de Dreuille
6
P[O M ] = π 3 .a32 .a22 .a21
Conclusion :
Les chaînes de Markov sont un modèle très simple, ce qui rend très facile
l’implémentation, mais quelques problèmes se posent : la matrice utilisée a pour dimension le
carré de la taille de l’alphabet, si celui ci est important, la matrice peut donc être énorme et
relativement vide. Mais le problème principal ne se situe pas au niveau de l’implémentation,
ce modèle est un peu réducteur pour être appliqué à un tel problème. Tentons donc
d’appliquer un modèle un peu plus complexe.
Nicolas de Dreuille
7
Les modèles de Markov cachés à observations discrètes d’ordre 1
[3]:
Les modèles de Markov cachés étendent le concept des chaînes dans la mesure ou
l’observable est une fonction d’états cachés, eux même régis par une chaîne de Markov, ce
qui revient à dire que l’organisation paramétrée est un phénomène sous-jacent non connu dont
dépendent les séquences observées.
Soit N le nombre d’états cachés que nous noterons S = {S1 , S 2 ,..., S N } et qt l’état caché
courant.
Soit M le nombre de symboles observables par état, nous noterons ces
symboles V = {V1 ,V2 ,...,VM } .
On a donc la distribution suivante des probabilités de transition entre états cachés :
[
]
aij = P qt +1 = S j qt = S i , 1 ≤ i, j ≤ N
La distribution des probabilités des observables sera la suivante :
[
]
b j (k ) = P vk qt = S j , 1 ≤ i, j ≤ N
Les probabilités d’émission :
π i = P[q1 = Si ],1 ≤ i ≤ N
Soit T le nombre d’observations d’une séquence on la notera O = O1 , O2 ,..., OT .
Le modèle est donc défini par λ = ( A, B, π )
Apprentissage et problèmes liés :
Nicolas de Dreuille
8
Soit T le nombre d’observations d’une séquence on la notera O = O1 , O2 ,..., OT .
Avant de commencer à penser à l’apprentissage, il nous faut répondre à deux
problèmes classiques des HMM, soit :
• L’évaluation où l’on cherche à déterminer la vraisemblance d’une séquence,
soit P[O λ ]
•
L’explication où l’on cherche à déterminer la meilleure séquence ayant pu
mener à une séquence soit Q = q1 , q2 ,..., qT telle que P[Q O, λ ] soit maximal.
Ensuite seulement on pourra passer à l’apprentissage, soit l’ajustement du modèle afin
de maximiser P[O λ ] .
Evaluation :
En principe, le calcul de P[O λ ] reviendrait à effectuer la somme sur toutes les
séquences Q de longueur T de P[O, Q λ ] = P[O Q, λ ]P[Q λ ] avec
P[O, Q λ ] = ∏ P[Ot , Qt λ ] = bq1 (O1 )...bqT (OT )
T
t =1
et P[O, Q λ ] = π q1 a q1q2 ...a qT −1qT
Ce calcul a pour complexité de 2TN T opérations, ce qui est très vite incalculable.
Heureusement, l’algorithme forward-backward permet un calcul beaucoup plus rapide.
Soit la variable forward α (i ) = P (O1 ,..., Ot , qt = S i λ ) soit la probabilité de la séquence
partielle O1 ,..., Ot et de l’état Si au temps t d’après un modèle λ . Nous pouvons la calculer de
manière récursive et ainsi arriver à nos fins comme suit :
•
Initialisation : α1 (i ) = π i bi (O1 ) , 1 ≤ i ≤ N
•
N

Récurrence : α t +1 ( j ) = ∑ α t (i )aij b j (Ot +1 ) , 1 ≤ t ≤ T − 1 , 1 ≤ j ≤ N
 j =1

•
Finalement, on a P[O λ ] = ∑α T (i )
N
i =1
De la même façon la variable backward β (i ) = P (Ot +1 ,..., OT , qt = S i λ ) soit la
probabilité de la séquence partielle restante Ot +1 ,..., OT et de l’état Si au temps t d’après un
modèle λ . Nous pouvons la calculer de manière récursive et ainsi arriver à nos fins comme
suit, ce qui s’avérera utile par la suite :
•
Initialisation : β T (i ) = 1 , 1 ≤ i ≤ N
•
Récurrence : β t (i ) = ∑ aij b j (Ot +1 ) β t +1 ( j ) , T = T − 1, T − 2...1 , 1 ≤ i ≤ N
N
j =1
Nicolas de Dreuille
9
•
Finalement, on a P[O λ ] = ∑ P[α ]β (i )
N
i =1
t
t
La complexité de ces algorithmes n’est que de TN 2 ce qui explique leur utilisation par
rapport au calcul précédent.
Explication :
Ce problème est plus complexe que l’évaluation dans la mesure où l’on ne cherche pas
à obtenir un résultat exact, mais optimal. En effet plusieurs chemins existent en général qui
permettent d’obtenir une séquence d’observables, on va donc chercher celle dont la
probabilité est maximale. Il n’est naturellement pas question de parcourir tous les chemins
afin de calculer leur probabilité, une solution naïve consisterait à déterminer les états les plus
vraisemblables individuellement.
α (i) β t (i)
α (i) β t (i)
γ t (i) = P(qt = S i O, λ ) = t
= N t
P(O λ )
∑α t ( j)β t ( j)
j =1
P (O λ ) est un facteur de normalisation permettant que γ t (i ) soit une probabilité telle
que
N
∑γ
i =1
t
(i ) = 1 on a donc qt = arg max[γ t (i )] , 1 ≤ t ≤ T
1≤i ≤ N
Cette méthode maximise le nombre d’états corrects, mais pose quelques problèmes à
cause du mode de sélection individuel sans prendre en compte la vraisemblance de la
séquence obtenue. Par exemple, si certaines transitions sont impossibles, on pourrait se
retrouver avec une séquence ayant cette transition.
Il faut donc trouver un meilleur critère d’optimalité, soit vraiment maximiser
P[Q O, λ ] ou P[Q, O λ ] ce qui est équivalent.
L’algorithme de Viterbi permet d’effectuer cette opération :
δ t (i ) = max P(q1 ,..., qt = i, O1 ,..., Ot λ )
q1 ,..., qt −1
δ t (i ) étant la plus grande probabilité le long d’un chemin donné au temps t pour les t
dernières observations et s’arrêtant au temps Si. On a donc


δ t +1 ( j ) =  max δ t (i )aij .b j (Ot +1 )

i

On en déduit l’algorithme suivant sachant que l’on ne cherche pas des probabilités
mais un chemin qui sera stocké dans la variable ψ t ( j ) :
•
•
Initialisation : δ1 (i ) = π i .bi (O1 ) , 1 ≤ i ≤ N
ψ 1 (i ) = 0
Récurrence : δ t ( j ) = max δ t −1 (i )aij .b j (Ot ) , 2 ≤ t ≤ T , 1 ≤ j ≤ N
[
ψ ( j ) = arg max[δ (i )a ].
1≤i ≤ N
t
Nicolas de Dreuille
1≤i ≤ N
t −1
]
ij
10
•
Finalement, on a P * = max[δ T (i )]
*
T
q
1≤i ≤ N
= arg max[δ T (i )]
1≤i ≤ N
et on retrouve le chemin avec qt* = ψ t +1 (qt*+1 ) , t=T-1,T-2,…,1
Nous avons maintenant tous les outils qui nous permettront de réaliser l’apprentissage.
Apprentissage :
Il nous faut maintenant ajuster λ afin de maximiser la vraisemblance de l’observable.
Il n’existe pas de solution analytique connue permettant de réaliser cette opération, mais on
peut cependant maximiser localement P[O λ ] , ce qui peut être réalisé par l’algorithme de
Baum-Welch, une méthode EM (expectation modification).
Soit ξ t (i, j ) = P(qt = S i , qt +1 = S j O, λ ) la probabilité d’être à l’état Si à t et à Sj à t+1
sachant le modèle,
ξ t (i, j ) =
P (qt = S i , qt +1 = S j , O λ )
P(O λ )
α t (i )aij b j (Ot +1 )β t +1 ( j )
=
N
N
∑∑α (i )a b (O )β ( j )
i =1 j =1
t
ij
j
t +1
t +1
N
On obtient donc γ t (i ) = ∑ ξ t (i, j )
j =1
Si l’on somme γ t (i ) sur t=1…T-1, on obtient une quantité qui peut être assimilée au
nombre de fois où l’état Si est visité.
De la même façon si l’on somme ξ t (i, j ) su t=1…T-1 on une quantité pouvant être
assimilée au nombre de transitions entre Si et Sj.
On peut ainsi réestimer les paramètres du modèle.
π i = γ 1 (i)
T −1
aij =
∑ ξ (i, j )
t =1
T −1
t
∑γ
t
t =1
T −1
(i )
∑ γ t (i )
b j (k ) =
t =1
Ot =vk
T −1
∑γ
t =1
t
(i )
Il a été prouvé par Baum et ses collègues, que λ est plus probable que λ au sens où
P O λ > P[O λ ] , on tend donc vers une solution optimale.
[ ]
Ces mêmes personnes ont aussi démontré que la maximisation
auxiliaire de Baum, soit Q (λ , λ ) = ∑ P(Q O, λ )log P O, Q λ
[(
)]
de la fonction
Q
Il nous faut donc itérer cette opération jusqu’à une condition d’arrêt qu’il nous reste à
déterminer. C’est une méthode de maximum de vraisemblance. Il est tout de même important
Nicolas de Dreuille
11
de savoir que cet algorithme ne mène qu’à un maximum local sur une surface d’optimisation
relativement complexe.
Conclusion :
Ce modèle, s’il est beaucoup plus élaboré que les chaînes de Markov, peut encore
sembler limité dans la mesure où le phénomène étudié, soit un morceau de musique sur
plusieurs voix, peut sembler plus complexe. On peut en effet considérer que si le thème
principal peut être assimilé à un fil directeur, chaque voix influence le morceau différemment.
Or de récentes recherches ont mis en évidence le problème de découvrir des causes multiples
indépendantes influençant des données. Les HMM Factoriels font partie de ces recherches.
Nicolas de Dreuille
12
Les modèles de Markov cachés factoriels [4]:
Les modèles de Markov cachés factoriels se différencient des HMM classiques par le
fait que chaque observable est déterminé par plusieurs états cachés.
On a donc des états cachés de la forme qt = qt(1) ,..., qt( m ) ,...qt( M ) , chacun pouvant prendre
K (m ) valeurs, pour plus de simplicité, on se restreindra à K (m ) = K , ∀m . Sachant que les
probabilités de transition P (qt qt −1 ) devraient être définies pour les K M combinaisons des
variables qt( m ) , l’absence de contraintes sur les structures de transitions nous amènerait donc à
une matrice de transitions en K M * K M , ce qui n’est pas intéressant pour deux raisons : d’une
part ça reviendrait à étudier un HMM de K M états, d’autre part, il est très peu probable
d’arriver à apprendre une structure complexe entre les états cachés du fait des interactions
totalement libres et de la complexité des algorithmes qui permettraient de le faire exponentiels
en K.
Nous nous concentrerons donc sur un HMM factoriel dont les états cachés sont
contraints, et considérerons donc une structure où les états sont indépendants.
M
(
P (qt qt −1 ) = ∏ P qtm qtm−1
m =1
)
On arrive ainsi à M matrices de transition K*K
On remarque sur la figure que la probabilité d’émission dépend de toutes les variables
d’états cachés. Ce qui peut se traduire pour des observations continues par l’hypothèse
qu’elles suivent une distribution gaussienne dont la moyenne est déterminée par une fonction
linéaire des variables d’états cachés.
Représentons donc chaque état caché par un vecteur de dimension K de valeur 1 sur
une position et 0 sur les autres. On a alors
Nicolas de Dreuille
13
'
M
M
 1

(m) m 
−1 
P (vt qt ) ∝ exp −  vt − ∑W qt  C  vt − ∑W ( m ) qtm 
m =1
m =1



 2 
où W ( m ) sont les contributions à la moyenne de chaque variable d’état caché, et C la
matrice de Covariance.
Apprentissage et problèmes liés :
Algorithme général :
L’algorithme d’apprentissage des FHMM est un algorithme EM comme celui de
Baum-Welch.
Tout d’abord, il nous faut définir la vraisemblance logarithmique espérée des données
complètes, soit l’observable et les états cachés.
Q φ new ,φ = E log P Q, O φ new φ , O avec φ = W ( m ) , π ( m ) , P ( m ) , C et π ( m ) = P q1( m ) ,
(
(
) { [(
)] }
)
{
}
( )
P ( m ) = P qt( m ) qt(−m1) .
L’étape E consiste à développer Q à l’aide des équations précédentes. En utilisant
. comme abréviation de E{.φ , O}, on trouve que Q peut être exprimé sous forme d’une
fonction de trois types de probabilités sur les variables d’états cachés qt(m )
qt(−m1) qt( m )' . On remarque que selon les notations des HMM,
qt( m ) qt( n )' et
qt( m ) correspond à γ t et
qt(−m1) qt( m )' à ξ t alors que qt( m ) qt( n )' n’a pas d’équivalent.
L’étape M utilise ces hypothèses pour maximiser Q, Dempster et al. (1977), en
utilisant l’inégalité de Jensen, ont montré que chaque itération des étapes E et M augmente la
vraisemblance P (O φ ) jusqu’à convergence en un maximum local.
L’étape M comme pour les HMM, est relativement simple et calculable, mais le
problème se pose surtout au niveau de l’étape E.
Calcul exact lors de l’étape E :
Un algorithme naïf de calcul exact de l’étape existe, mais il consiste à transformer le
FHMM en un HMM à K M états sur lequel on utilise l’algorithme forward-backward. Il a
donc une complexité en O TK 2 M . Ce problème est dû à la nature coopérative du modèle.
(
)
Echantillonnage de Gibbs :
Plutôt que de calculer les probabilités à posteriori exactes, on peut les approximer en
utilisant une procédure d’échantillonnage, et ainsi éviter une somme sur le nombre
exponentiel de modèles d’états cachés, quitte à perdre un peu en précision. Une des plus
simples est l’échantillonnage de Gibbs. Pour une séquence O de longueur T, la procédure
commence par établir une séquence Q aléatoire. Ensuite à chaque t, chaque vecteur d’états
cachés est mis à jour stochastiquement selon ses distributions de probabilité fondées sur tous
les autres vecteurs d’états cachés.
Nicolas de Dreuille
14
( {
}
qt( m ) ~ P qt( m ) qt( n ) : n ≠ m , qt( m ) , vt ,φ
)
Une fois les variables d’états cachés échantillonnées, on a réestimé Q. La séquence des
Q après chaque itération définit une chaîne de Markov sur l’espace des états du modèle, qui,
si les probabilités sont toutes non nulles, doit converger vers les probabilités à posteriori des
états par rapports aux observations.
Ainsi, après un nombre à définir d’itérations, les échantillons de la chaîne de Markov
peuvent être considérés comme approximant les probabilités postérieures. Les statistiques
nécessaires pour calculer qt(m ) qt( m ) qt( n )' et qt(−m1) qt( m )' seront collectées en utilisant les états
visités et les probabilités estimées pendant la procédure.
Le problème de l’échantillonnage est qu’il est difficile de réellement diagnostiquer la
convergence.
Mean field approximation :
Voici une deuxième approximation des probabilités à posteriori des états cachés à la
fois calculable et déterministe. L’idée est d’approximer la distribution à posteriori P par une
distribution calculable Θ . Toute distribution approximante du type Θ(Q O ) fournit une borne
inférieure sur la vraisemblance qui peut être utilisé pour un algorithme d’apprentissage
efficace, ce qui est facile à démontrer.
D’après l’inégalité de Jensen, on peut dire que
log P(O ) = log ∑ P(Q, O )
Q
 P(Q, O ) 
= log ∑ Θ(Q O )

Q
 Θ(Q O ) 
 P(Q, O ) 
≥ ∑ Θ(Q O )log 

Q
 Θ(Q O ) 
La différence entre cette limite et la vraisemblance logarithmique étant donnée par la
divergence de Kullback-Liebler :
 P(Q, O ) 
KL(Θ P ) = ∑ Θ(Q O )log 

Q
 Θ(Q O ) 
On choisit donc l’approximation la plus simple pour laquelle les variables d’état sont
indépendantes.
T
(
M
Θ(Q θ ) = ∏∏ Θ qt( m ) θ t( m )
{ }
t =1 m =1
)
les paramètres θ = θ tm étant les moyennes des variables d’état.
(
)
Θ qt( m ) θ t( m ) = θ t( m )
Cette approximation est connue sous le nom de "mean field approximation" que l’on
calcule avec
Nicolas de Dreuille
15
θ t( m ) new = ϕ {W ( m ) ' C −1 (v t − vˆ t ) + W ( m ) ' C −1W ( m )θ t( m ) − 12 ∆( m ) + (log P ( m ) )θ t(−m1 ) + (log P ( m ) )'θ t(+m1) }
M
avec vˆ t = ∑W ( l )θ t( l )
l =1
∆( m ) est le vecteur des éléments diagonaux de W ( m ) ' C −1W ( m ) , et ϕ {X } =
exp{X i }
∑ exp{X i }
i
est la non linéarité softmax qui permet une normalisation exponentielle à la somme de 1.
Chaque vecteur d’état caché est mis à jour avec une complexité en O(TKM) par
itération. La convergence est déterminée par l’observation de la divergence de KullbackLiebler, en pratique elle est très rapide (2 à 10 itérations). Une fois la convergence atteinte, les
paramètres de l’étape E sont facilement obtenus :
qt( m ) = θ tm
qt( m ) qt( n )' = θ tmθ tm−1 '
q
(m)
t −1
q
( m )'
t
θ t( m )θ t( n ) ' , m ≠ n
=
diag θ t( m ) , m = n
{ }
L’approximation structurée :
L’approximation précédente partait de l’hypothèse selon laquelle les variables d’état
étaient complètement indépendantes, ce qui est une supposition assez extrême.
L’approximation structurée reste calculable, mais conserve une plus grande partie de la
structure originale. Le HMM factoriel est ici approximé par M HMM distincts au sein
desquels l’inférence est implémentée à l’aide de l’algorithme forward backward.
Cette structure offre aussi une borne inférieure sur la vraisemblance logarithmique.
On utilisera l’approximation suivante :
M
(
Θ(Q θ ) = ∏ Θ q1( m ) θ
m =1
)∏ Θ(q
T
(m)
t
t =2
qt(−m1) ,θ
)
où Θ(q1( m ) θ ) = π ( m ) h1( m )
(
) (
)
Θ qt( m ) qt(−m1) ,θ = P qt( m ) qt(−m1) ,φ ht( m ) = P ( m ) ht( m )
Les paramètres de cette distribution sont θ = {π ( m ) , P ( m ) , ht( m ) } les probabilités
d’émission et de transition des états cachés, et un biais variant dans le temps pour chaque
variable.
De la même façon qu’auparavant, on obtient
ht( m ) new ∝ exp W ( m ) ' C −1 (v t − vˆ t ) + W ( m ) ' C −1W ( m ) qt( m ) − 12 ∆( m )
{
}
M
avec vˆ t = ∑W (l ) qt(l )
l =1
( m)
t
Le paramètre h
obtenu est l’entrée des variables d’état qt( m ) dans le HMM m. Son
utilisation permet de recalculer qt(m )
grâce à l’algorithme forward-backward, qui sert donc
ici à minimiser la divergence de Kullback-Liebler.
Nicolas de Dreuille
16
Etape M :
Une fois une de ces méthodes choisie, il faut effectuer l’étape de maximisation. A
cette fin, il nous faut tout d’abord développer Q.
T
M
M M


Θ = − 12 ∑ vt ' C −1vt − 2∑ vt ' C −1W ( m ) qt( m ) + ∑∑ tr W ( m ) C −1W ( m ) qt( m ) qt( n ) 
t =1 
m =1
m =1 n =1

{
M
T
M
{(
}
}
)
+ ∑ q1( m ) ' log π ( m ) + ∑∑ tr log P ( m ) qt(−m1) qt( m ) ' − log Z
m =1
t = 2 n =1
où Z est un terme de normalisation indépendant des états et observations permettant
d’avoir une somme de probabilités égale à un.
Pour maximiser cette quantité, il nous faut annuler sa dérivée par rapport au paramètre
à réestimer :
T
∂Θ
 M (n) (n) (m)

=
W qt qt ' − vt qt( m ) '  = 0 .
∑
∑

(m)
∂W
t =1  n =1

On obtient donc
h
W
new

 T
 T
=  ∑ vt qt '  ∑ qt qt '  ,

 t =1
 t =1
où h signifie le pseudo inverse de Moore-Penrose.
De la même façon on obtient
π ( m ) new = q1( m )
T
Pi ,new
j =
∑
qt(,mi ) qt(−m1)', j
t =1
T
∑
t =1
qt(−m1)', j
Finalement pour réestimer la covariance, il faut dériver par rapport à C −1
T
1
1 M M ( n) (n) ( m)
∂Θ
M

(m)
(m)
1
C
v
q
'
W
'
v
v
'
W qt qt ' W ( m ) ' .
=
+
−
−
∑
∑
∑∑
t
t
t t
2

−1
2
2 m=1 n=1
∂C
t =1  m =1

On obtient donc
M
T
M
C new = ∑ vt vt '−∑∑W ( m ) qt( m ) vt '
m =1
t =1 m =1
On note que pour M=1, cet algorithme est équivalent à celui de Baum-Welch.
Conclusion :
Si le FHMM semble beaucoup plus intéressant que le simple HMM autant en termes
de capacité d’apprentissage que de vitesse, il reste un problème à résoudre. En effet, il a été
présenté pour des observations continues suivant une distribution gaussienne, or, nous
Nicolas de Dreuille
17
disposons de données discrètes et rien ne nous permet d’affirmer que leur distribution sera
gaussienne.
Le modèle peut être généralisé pour gérer ce type d’observations, mais on se heurte
alors à différents problèmes : Si l’on tente de modéliser les probabilités d’émission sous
forme d’une matrice, elle sera de dimension D* K M ce qui n’est pas concevable.
Il existe des méthodes d’approximation de cette matrice, mais elles compliquent
l’algorithme EM .
Le HMM factoriel ne pourra donc pas être utilisé dans le cadre de cette étude.
Nicolas de Dreuille
18
Conclusion sur les modèles :
Comme nous venons de voir, deux des modèles présentés seulement sont applicables à
l’apprentissage de nos données :
• Les chaînes de Markov, qui constituent un modèle simple et facile à mettre en
œuvre, mais au pouvoir d’apprentissage limité par sa simplicité
• Les modèles de Markov cachés qui sont un peu plus difficiles à appréhender et
à mettre en œuvre mais semblent pouvoir offrir un apprentissage plus poussé.
Le modèle que nous choisirons est destiné à pouvoir fonctionner sur un nombre
raisonnable de données d’apprentissage, l’utilisateur ne pouvant raisonnablement pas fournir
beaucoup plus de 50 enregistrements. Nous effectuerons donc des tests sur un jeu de donnée
typique afin de déterminer la légitimité de chaque modèle.
Il pourrait par ailleurs être intéressant de travailler sur des modèles d’ordre k supérieur
à 1, soit dépendant des k derniers évènements.
Implémentation
Prétraitement des données :
Comme nous l’avons vu, les données originales peuvent être assimilées à une matrice
d’entiers de largeur le nombre de voix que nous nommerons Nv, et de longueur le nombre
d’enregistrements * leurs longueurs respectives. Nous avons ensuite transformé cette matrice
en vecteur d’entiers en considérant chaque ligne comme un symbole d’un dictionnaire à
définir. Naïvement, nous aurions pu considérer le dictionnaire comme l’ensemble des
combinaisons de Nv entiers, ce qui aurait constitué un dictionnaire en puissance Nv. Mais
comme on peut considérer que les symboles non visités par les observables auront une
probabilité d’apparition nulle, on peut limiter le dictionnaire aux seuls symboles apparaissant
dans le jeu de données.
Par ailleurs nous avons vu pour les chaînes de Markov que la simulation d’un ordre
K>1 se faisait par combinaison des symboles, nous construirons donc à cette fin chaque
symbole en concaténant le symbole courant aux k-1 symboles précédents.
Nous pourrons aussi tester cette méthode pour les HMM sans toutefois pouvoir
affirmer qu’il s’agit d’un HMM d’ordre K car cette "mémoire" n’est définie que sur les
observables.
Nous avons maintenant des données utilisables par les modèles présentés
précédemment, nous pouvons donc tester nos algorithmes sous Matlab.
Nicolas de Dreuille
19
Implémentation en Matlab :
Afin de réaliser des tests sur les modèles, nous devons tout d’abord implémenter le
prétraitement et l’apprentissage, mais aussi quelques fonctions destinées à évaluer la qualité
de cet apprentissage :
• La vraisemblance logarithmique d’une séquence O soit − log(P[O Modèle])
permettra d’évaluer la vraisemblance d’une séquence. Plus celle ci est proche
de zéro, plus le modèle est apte à produire la séquence
• La distribution de probabilités du prochain symbole émis suivant une séquence
donnée afin d’éprouver plus facilement l’adéquation avec nos données.
• La génération de séquence qui est le produit final et qui nous permettra de voir
dans quelle mesure nos modèles sont aptes à produire une séquence
convenable.
Prétraitement :
% =========================================================================
% Markov in dub, prétraitement des données
%
% En entrée :
X, les données brutes
%
ordre, l'ordre simulé qui entraine la concaténation de
symboles.
%
% En sortie :
Xfin les données formattées en vecteurs d'entiers
contenus dans un Cell-Array
%
alphabet l'alphabet des symboles, matrice dont chaque colonne
est un symbole repéré par son n° de colonne
%
Nalphabet le nombre de symboles.
%
% =========================================================================
function [Xfin,alphabet,Nalphabet] = alphabet(X,ordre);
Apprentissage :
Chaînes de Markov :
Comme nous l’avons vu, l’apprentissage est simple et se fait par comptage, le
comptage s’est fait sans normaliser au fur et à mesure afin d’éviter d’éventuelles erreurs de
précision.
% =========================================================================
% Markov in dub, apprentissage des Chaînes de Markov
%
% En entrée :
X, les données formatées à l'aide de la fonction alphabet
%
NBAlpha le nombre de symboles dans l'alphabet
%
Nicolas de Dreuille
20
% En sortie :
Pi les probabilités d'émission
%
Probas, les probabilités de transition
%
% =========================================================================
function [Pi,Probas] = chaines(X,NBAlpha);
Modèle de Markov caché :
Il a fallu implémenter l’étape E et l’étape M, l’optimisation a été réalisée sur la
fonction auxiliaire de Baum.
% =========================================================================
% Markov in dub, apprentissage d'un Modèle de Markov caché
%
% En entrée :
%
nbalphabet le nombre de symboles dans l'alphabet
%
K le nombre d'états cachés (default 3)
%
cyc le nombre maximum de cycles de Baum Welch (default 100)
%
tol la condition d'arret, tolérance sur l'évolution de la
vraisemblances (default 0.0001)
%
% En sortie :
E les probabilités d'émission des observations
%
P, les probabilités de transition des états cachés
%
Pi, les probabilités d'émission des états cachés
%
LL, la courbe de vraisemblance logarithmique
%
% =========================================================================
function [E,P,Pi,LL]=DHMM(X,nbalphabet,K,cyc,tol)
Vraisemblance :
Comme nous l’avons vu, elle se calcule facilement par L = − log( P[O M ]) = π 3 ∏ aij
% =========================================================================
% Markov in dub, vraisemblance d'une série de sequences pour les Chaînes de
Markov
%
% En entrée :
%
%
%
% En sortie :
Vraisemblance, la vraisemblance pour chaque Sequence de X
%
% =========================================================================
function vraisemblance = vraisemblanceChaines(X,Pi,Probas);
Nicolas de Dreuille
21
La vraisemblance calculée lors de l’apprentissage n’étant pas calculée de la même
façon que celle des chaînes de Markov, une fonction est donc spécialement dédiée, elle
somme les alphas après un forward.
% =========================================================================
% Markov in dub, vraisemblance d'une série de sequences pour un HMM
%
% En entrée :
%
%
%
%
% En sortie :
Vraisemblance, la vraisemblance pour chaque Sequence de X
%
% =========================================================================
function vraisemblance = vraisemblanceDHMM(X,E,P,Pi);
Distribution de probabilités du prochain symbole :
On cherche PPS = P(O t +1 O1 ,..., Ot )
Ici pas de fonction car il s’agit simplement de la ligne correspondant dans la matrice
de transition.
Le problème est un peu compliqué car on ne connaît pas l’état caché courant à la fin
d’une séquence, mais la variable forward nous permet de l’estimer, on a en effet
α (i ) = P(O1 ,..., Ot , qt = S i λ ) . Or b j (k ) = P vk qt = S j , d’où PPS = α .b .
[
]
% =========================================================================
% Markov in dub, distribution de probabilités du prochain symbole
%
% En entrée :
Observations la séquence
%
%
%
%
Nicolas de Dreuille
22
% En sortie :
probas, la distribution de probabilités du prochain
carractère
%
% ========================================================================
function probas = ProbasProchain(Observations,E,P,Pi);
Génération d’une séquence :
La génération d’une séquence est un processus stochastique, en effet, il ne faut pas
chercher à maximiser la probabilité du prochain symbole, car on risquerait d’entrer dans une
boucle. Il nous faut donc choisir aléatoirement le prochain symbole d’après la distribution de
probabilités de transition ou d’émission. La fonction suivante a donc été développée.
% =========================================================================
% Markov in dub, obtention d'un indice aléatoire dans une distribution de
probabilités
%
% En entrée :
distrib, la distribution (! la somme doit absolument être
=1)
%
% En sortie :
indice, indice choisi
%
% =========================================================================
function indice = getRandFromDistrib(distrib);
La génération d’une séquence consiste à choisir le premier symbole à l’aide des
probabilités d’émission, puis les suivants à l’aide des probabilités de transition jusqu’à obtenir
le symbole terminal.
% =========================================================================
% Markov in dub, génération de séquence en utilisant les chaines de markov
%
% En entrée :
%
%
alphabet, l'alphabet des symboles généré par la fonction
alphabet()
%
ordre, l'ordre simulé dans l'alphabet
%
% En sortie :
output, la sequence retournée sous sa forme initiale
%
Observable, la sequence sous forme de vecteur d'entiers
%
% =========================================================================
function [output,Observable] = generationChaines(Pi,P,alphabet,ordre);
Nicolas de Dreuille
23
La génération d’une séquence revient à choisir le premier état caché à partir des
probabilités d’émission des états cachés, puis chaque état caché suivant à partir des
probabilités de transition, puis pour chaque état caché, obtenir un observable à partir des
probabilités d’émission des observables.
% =========================================================================
% Markov in dub, génération de séquence en utilisant les chaines de markov
%
% En entrée :
%
%
%
alphabet, l'alphabet des symboles généré par la fonction
alphabet()
%
ordre, l'ordre simulé dans l'alphabet
%
% En sortie :
output, la sequence retournée sous sa forme initiale
%
Observable, la sequence sous forme de vecteur d'entiers
%
% =========================================================================
function [output,Observable] = generationHMM(E,P,Pi,alphabet,ordre);
Nicolas de Dreuille
24
Tests sous Matlab :
Influence des différents paramètres
Ces fonctions, une fois implémentées, nous ont permis de réaliser une série de tests
permettant de déterminer la légitimité de l’utilisation ultérieure de tel ou tel modèle.
Le premier test effectué a été un comparatif en temps et en vraisemblance
logarithmique des différents modèles avec différents paramètres :
Ind
Données
type
Nb états
cachés
ordre
1 2 3
Limitées
Chaine
X
HMM
5 10
1
1
2
3
4
5
6
7
8
9
10
11
12
15
5
10
15
5
10
15
2
3
13 14 15
Complètes
Chaine
X
17
18
19
20
21
22
23
24
HMM
5
10
15
5
10
15
5
10
15
1
1
2
3
16
2
3
Interprétation de l’histogramme
Nicolas de Dreuille
25
On note grâce à ce jeu de tests l’influence de quatre facteurs sur deux types
d’observation, en notant bien que la vraisemblance logarithmique ainsi définie est fonction
inverse de la probabilité d’une séquence :
•
L’importance du dictionnaire de données : on remarque que la vraisemblance
log augmente avec le nombre de données participant à l’apprentissage pour le
HMM, ce qui paraît normal, dans la mesure ou la taille du dictionnaire
augmente. Par contre, ce facteur a moins d’influence sur les chaînes de
Markov.
Le nombre de données est multiplié par deux, on peut donc dire que
l’augmentation de temps est raisonnable.
•
Le type de modèle utilisé a la plus grande influence sur le temps et la
vraisemblance log. On prendra en compte l’influence sur le temps :
l’apprentissage des chaînes est quasi instantané, mais pas l’influence sur la
vraisemblance, car le calcul est tout de même relativement différent.
•
Le nombre d’états cachés quant à lui augmente considérablement le temps de
calcul et diminue la vraisemblance, on peut donc considérer qu’un nombre
supérieur d’états cachés peut induire un meilleur apprentissage. Il ne semble
par contre pas raisonnable d’en utiliser beaucoup plus de 10.
•
L’ordre quant à lui n’a pas la même influence sur les deux modèles, dans le cas
des chaînes il diminue la vraisemblance log, et dans l’autre il l’augmente. Ce
qui peut s’expliquer par le fait que cette simulation d’ordre sur l’observable n’a
pas vraiment lieu d’être dans un HMM.
Dans les deux cas, le temps de traitement augmente.
En conclusion on peut dire que chaque modèle a ses avantages : les chaînes de Markov
apprennent très vite avec peu de données, et les HMM ont un apprentissage plus poussé mais
moins facile à paramétrer.
Ensemble de validation ?
Il aurait aussi été intéressant de procéder à des tests avec un ensemble de validation,
mais ce type de test s’est révélé impossible. En effet, le principe était de construire un
alphabet et un ensemble de vecteurs à partir des données initiales, puis de réaliser un
apprentissage sur la moitié seulement de ces vecteurs, afin de comparer la vraisemblance des
deux ensembles. Mais comme dans pratiquement tous les vecteurs de validation il existait au
moins une transition de probabilité trop proche de zéro, la vraisemblance tendait alors vers
l’infini et la moyenne finale était faussée.
On peut tout de même en tirer un enseignement, soit que l’échantillon produit pour
créer le jeu de données doit présenter le plus de diversité possible afin de multiplier les
possibilités de transition. On peut ajouter que ce résultat est positif, dans la mesure où si l’on
introduit une "faute de goût" dans un morceau et qu’on éprouve sa vraisemblance log, il y a
de fortes chances qu’elle soit grande.
Nicolas de Dreuille
26
Génération de séquence
Aucune méthode mathématique ne sera appliquée pour déterminer la qualité de la
génération des séquences. On pourrait par exemple utiliser la méthode du plus proche voisin
et comparer ensuite les deux séquences, mais l’intérêt serait limité.
Il nous a semblé que la meilleure solution était de donner les impressions de l’auteur
du jeu de données sur la séquence de sortie.
•
•
Les chaînes de Markov, surtout quand on utilise un ordre légèrement supérieur
à 1, permettent d’obtenir un enregistrement dont les séquences sont
relativement bien assemblées en termes d’enchaînement. C’est à dire que de
grosses fautes ne sont pas commises. Mais l’enregistrement n’a pas la structure
d’introduction développement qu’on a tenté d’apprendre au modèle.
Les HMM par contre ont plus tendance à produire ce genre d’architecture,
mais produisent des séquences relativement chaotiques en termes
d’enchaînement.
Ces critiques sont cependant fondées sur l’observation de matrices, ce qui est un bien
piètre critère d’analyse d’une harmonie musicale. Il nous faudra donc éprouver ce processus
avec de vrais samples, et donc programmer une interface de construction des enregistrements
et un lecteur, ce qui implique déjà l’implémentation des algorithmes étudiés dans un langage
plus généraliste, en l’occurrence le Java.
Nicolas de Dreuille
27
Implémentation en Java :
Il existe déjà une classe sur le Web codant les HMM en java, mais la licence ne nous
convenait pas, c pourquoi l’implémentation sera reprise dans le cadre de ce projet.
Malheureusement, il ne restait plus beaucoup de temps pour cette étape du projet,
l’important était donc de bien spécifier afin de rendre le développement ultérieur facile en cas
de codage incomplet. C’est pourquoi nous nous concentrerons sur le diagramme de classes,
les algorithmes étant décrits et même implémentés en MATLAB.
Diagrammes de classes
Une classe appelée Markov, se spécialisant en Chain et HMM centralisera donc les
traitements, soit l’apprentissage, les méthodes de test et la génération de séquences.
Nicolas de Dreuille
28
Son constructeur comporte un objet de type TimeSeries, qui centralise le
prétraitement, soit la mise à disposition de données à partir de fichiers.
Enfin il nous faut pouvoir générer et ensuite sauvegarder un modèle de Markov. La
classe MarkovModel qui comporte une spécialisation pour chaque type de modèle devra
réaliser ces opérations.
Avancement :
Une partie a déjà été développée, soit tout TimeSeries et les classes agrégées. Le
développement de la classe Markov et de celles qui en héritent à débuté mais n’est pas
terminé.
Comme nous l’avons dit précédemment, les spécifications sont suffisamment claires
pour que le travail puisse être repris ensuite, il ne reste qu’à adapter les fonctions MATLAB
en méthodes Java, soit utiliser le paradigme objet, transformer les indices et recoder quelques
fonctions matricielles.
Nicolas de Dreuille
29
Conclusion :
L’idée originale de ce projet était d’utiliser les chaînes de Markov afin de réaliser une
Classe java permettant de réaliser un apprentissage sur un morceau de musique découpé.
On voit bien ici l’importance de l’étude préliminaire qui nous a fait étudier des
modèles plus ou moins évolués, et évaluer ensuite la possibilité de les intégrer dans la
réalisation.
Un projet à tendance initiale développement fait intervenir des connaissances de
statistiques, de génie logiciel, et des concepts étudiés en RNA. Une bonne connaissance de
l’Anglais a par ailleurs été nécessaire pour comprendre la documentation.
On a donc affaire à un projet innovant relativement général qui semble devoir
ressembler à ce que sera plus tard notre métier.
Nicolas de Dreuille
30
Bibliographie :
1 : http://www.wtm-paris.com/art_dubvf.html
2 : http://www.ejay-fr.com/
3 : L.R. Rabiner, “Tutorial on Hidden Markov Models and Selected Applications in
Speech Recognition”, in Proceedings of the IEEE, vol. 77, no. 2, February 1989, pp. 257-286.
74
4 : Z. Ghahramani, M.I. Jordan, “Factorial Hidden Markov Models”
Nicolas de Dreuille
31

Markov in Dub - Nicolas de DREUILLE

Transcription

Documents pareils

Table des matieres du chapitres 1 - TCTS Lab

Untitled - Full Dub

Tutoriel pour Free Video Dub Comment supprimer des parties

Analyse de la variation spatio-temporelle des objets dans les

une révolution pour l`évaluation des engagements

1-19-01-10-Musique grandiose 13 morceaux, 54,2 minutes, 81,6 Mo

:version sound system

bio Didier Ambact - L`Association Fragile

Dub` pour l`éternité

Yousri Kessentini, Ingénieur recherche et développement

Champs aléatoires de Markov couples et segmentation des images