EXEMPLES D´
APPRENTISSAGE AVEC DES RÉSEAUX NEURONAUX
Cet article fait suite à
Danse avec moi.
1 Apprentissage supervisé
1-1 Le capteur de mouvement Gypsy
Le capteur de mouvement Gypsy est un exosquelette
constitué de 18 points
d´articulation de type rotule:
Les deux chevilles
Les deux genoux
Les deux hanches
Les deux poignets
Les deux coudes
Les deux épaules
Les deux clavicules (dans une version future)
Le bassin
Le thorax
Le cou
La tête
Et une position gyroscopique attachée au bassin
Chacun de ces 19 noeuds a 3 degrés de liberté
(les 3 angles d´Euler de rotation autour
des axes d´un repère local lié au père de ce noeud), le
capteur dans son ensemble a donc 3 * 19 = 57 degrés de
liberté.
1-2 Structure d´un réseau en couches
Nous construisons un réseau neuronal a trois
couches:
Une couche d´entrée dont chaque neurone est
connecté à un degré de liberté ai,0 du gypsy (nous
avons choisi un vecteur d´entrée de 45 composantes pertinentes parmi les 57
possibles).
Une couche de sortie, deux fois plus grande
(donc, dans cet exemple, comprenant 90 neurones),
connectée à un projet constitué de couples
(ai,1,ai,2) d´angles contrôlant
les joints.
Et une couche cachée de 57 neurones:
45 angles en entrée
57 neurones cachés
90 angles en sortie
Les poids des connexions entre ces 57 + 57 + 90 = 202
neurones sont representés dans une matrice de 202 * 202 = 40804
nombres flotants:
1-3 Apprentissage
Les couples
d´apprentissage
sont de la forme:
(E, S), avec:
E = une valeur angulaire d´entrée ai,0 delivrée par le capteur
S = un couple de valeurs angulaires de sortie
(ai,1,ai,2) utilisé comme
un projet de mouvement. Plus précisément, lorsque le
réseau est sollicité, la position courante du corps fournit un vecteur:
e = (e1, e2, ..., e45)
qui est presenté en entrée au réseau,
celui-ci propage ces valeurs à travers la couche cachée jusqu´à
la dernière couche qui delivre un vecteur de sortie:
s = ((s1,1,s1,2), (s2,1,s2,2), ...
(s45,1,s45,2))
Dans un premier temps la matrice des poids est initialisée aléatoirement.
Dans un deuxième temps, on définit un ensemble de couples d´apprentissage:
((E1,S1), (E2,S2), ...,
(En,Sn))
Pour chaque couple, l´entrée Ei est
présentée au réseau qui calcule alors une sortie Ci,
en général différente de la sortie théorique Si. La différence
entre ces deux sortie est utilisée comme signal d´erreur pour corriger
les poids des connexions (par la méthode de la
rétropropagation de l´erreur).
Le taux de correction peut d´ailleurs varier au cours de l´apprentissage:
D´abord grand pour corriger rapidement les erreurs importantes du début, puis diminuant
pour corriger plus finement les petites erreurs intervenant en fin d´apprentissage.
Puis Ei est de nouveau presenté en entrée du réseau qui recalcule
une sortie (en général meilleure que la précédente,
puisque les poids ont été corrigés de façon à minimiser cette erreur).
De proche en proche le réseau améliore ainsi sa réponse à l´entrée Ei.
Lorsque l´erreur commise tombe en dessous d´un certain seuil fixé à l´avance
on considère que le réseau a appris le couple (Ei,Si).
On recommence l´experience avec un autre couple (Ej,Sj)
jusqu´à ce que le réseau ait appris ce couple.
Mais, lorsqu´on lui présente de nouveau l´entrée Ei d´un couple précédemment
appris, on constate en général une moins bonne réponse que lors du premier
essai: Un nouvel apprentissage semble donc détruire partiellement les
précédents, il sera donc nécessaire de tous les recommencer
chaque fois que l´on en introduira un nouveau. Cela explique
pourquoi cette méthode converge très lentement (dans l´exemple décrit ici, il
a fallu en moyenne 20000 séries d´apprentissages sur une dizaine de couples pour obtenir
une erreur satisfaisante inférieure à 1 pour cent). Lors d´un apprentissage
dynamique (c´est à dire lorsque celui-ci est réalisé pour
adapter le système à un environnement changeant en temps réel), nous
avons simule une parallélisation de l´algorithme en répartissant les
calculs dans un intervalle temporel de façon à ne pas détériorer les
performances de l´installation interactive, par exemple en ne réalisant que
quelques essais de la forme:
Ei -> calcul -> Ci -> corrections des poids
à chaque image.
1-4 Interprétation
Un projet est défini par la concaténation des vecteurs e et s:
p = ((e1,s1,1,s1,2),
(e2,s2,1,s2,2), ...
(e45,s45,1,s45,2))
Chaque triplet ((ei,si,1,si,2)
est étendu (par une cubique) en une trajectoire contine T graduée dans
le temps par une loi de mouvement dépendant de la dynamique du mouvement
capté.
En général le réseau est sollicité par un événement extérieur
qui vient interrompre le projet Proj1 courant par un projet Proj2
qui doit être rendu tangent au précédent (ce qui donne Proj3 sur
la figure ci-dessous),
ceci afin d´éviter des discontinuités de la vitesse.
Nous avons implémenté différentes interprétations du vecteur de sortie
qui peut être converti:
Soit directement en angles contrôlant les rotations des joints.
Soit encore comme des couples dynamiques appliqués aux joints.
La première méthode autorise un meilleur contrôle,
la seconde donne une perception plus réaliste du mouvement.
2 Méthodologie
2-1 Méthode manuelle
Nous définissons manuellement la position d´entrée du réseau
ainsi que les deux positions de sortie caractérisant un projet. Pour cela,
grâce à l´interface programmable d´anyflo, nous avons
désigné ces positions sur un mannequin de synthèse affiché à
l´écran et dont on pouvait manipuler interactivement les membres.
En fin d´acquisition de tous les couples d´apprentissage, le
calcul de la rétropropagation de l´erreur était lancé et la
matrice résultante était sauvée sur le disque. Cette méthode
permet un contrôle exhaustif des positions mais n´est pas
très naturelle.
2-2 Méthode stochatisque
Des positions aléatoires peuvent être générées en
respectant les contraintes biomécaniques imposées au modèle
de corps humain utilisé. On obtient ainsi une très grande variété
de mouvements, mais ceux-ci sont trop arbitraires.
2-3 Algorithmes génétiques
voir aussi
L´évolutionnisme en image de synthèse
On code en binaire un vecteur d´entrée (en mappant par exemple un
angle exprimé par dizaines de degrés sur un
mot de 5 bits, suffisant pour coder 32 valeurs entières) sur un génotype
de 45 * 5 = 225 bits. Les fonctions de génération, de sélection, de
croisement, de mutation et d´évaluation de populations génétiques
d´anyflo sont utilisées pour faire évoluer une population initialisée
aléatoirement. À chaque regénération de la population chaque
génotype est décodé en un vecteur d´entrée qui est passé au
réseau neuronal, lequel fournit un projet; celui-ci est exécuté,
fournissant un mouvement qui est noté: Par exemple si on
favorise les mouvements qui se terminent sur une position d´équilibre,
la population évoluera vers des génotypes de rééquilibrage. Si on
favorise les mouvements qui optimisent la distance parcourue,
la population évoluera vers des génotypes de marche, etc...
La figure suivante montre l´interface d´anyflo utilisée pour
faire évoluer de telles populations (sur un exemple simplifié dont
les génotypes sont codés sur 32 bits):
Sur la première ligne figure le génome d´un individu sélectionné.
Sur la deuxième ligne figure le génome d´un autre individu seléctionné.
Sur la troisième ligne figure le génome d´un individu obtenu
par croisement des deux précédents (en prenant la partie colorée
en bleu de chacun d´eux).
L´image montre une étape de l´animation du mouvement résultant. La
note de l´individu ainsi généré est calculée à la fin du processus.
3 Résultats
3-1 Premier exemple: Figures de rééquilibrage
L´apprentissage s´est fait à partir de 4 couples modèles
dont les entrées sont notées motif et dont les sorties
sont notées (loi1,loi2):
À titre d´exemple on a donné les angles normalisés entre 0 et 1 (par
mappage du segment [-PI,PI] sut [0,1]):
Premier couple: Équilibre avant:
Motif
Loi1
Loi2
Rotx Roty Rotz
Rotx Roty Rotz
Rotx Roty Rotz
0.50000,0.50000,0.45000
0.50000,0.50000,0.45000
0.50000,0.50000,0.63281
0.50000,0.50000,0.50000
0.50000,0.50000,0.59179
0.50000,0.50000,0.62564
0.50000,0.50000,0.57291
0.50000,0.50000,0.49609
0.50000,0.50000,0.59999
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.57499
0.50000,0.50000,0.50781
0.50000,0.50000,0.57499
0.50000,0.50000,0.50000
0.50000,0.50000,0.42187
0.50000,0.50000,0.49414
0.50000,0.50000,0.50000
0.61913,0.50000,0.50000
0.50781,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.37890,0.50000,0.50000
0.47330,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.50000
0.50000,0.50000,0.45000
0.50000,0.50000,0.63997
0.50000,0.50000,0.45000
0.50000,0.50000,0.50000
0.50000,0.50000,0.67317
0.50000,0.50000,0.50000
0.50000,0.50000,0.57617,
0.50000,0.50000,0.27604
0.50000,0.50000,0.43619
Deuxième couple: Équilibre arriere:
Troisième couple: Marche:
Quatrième couple: Saut:
Premier exemple d´entrée aléatoire (non apprise):
Les deux exemples suivants montrent la propriété de
généralisation des réseaux neuronaux:
Ceux-ci sont capables de répondre correctement à des exemples non
appris (pourvu que l´ensemble des couples d´apprentissage
échantillonnent bien l´espace des situations possibles).
Deuxième exemple d´entrée aléatoire (non apprise):
3-2 Deuxième exemple: Figures de déséquilibrage
Premier couple: Déséquilibre avant:
Deuxième couple: Déséquilibre arrière.
Troisième couple: Chute:
Quatrième couple: Chute:
Premier exemple d´entrée aléatoire (non apprise):
Deuxième exemple d´entrée aléatoire (non apprise):
3-3 Troisième exemple: Figures de danse
Premier couple:
Deuxième couple:
Premier exemple d´entrée aléatoire (non apprise):
Deuxième exemple d´entrée aléatoire (non apprise):
3-4 Quatrième exemple: Autres figures
Premier couple:
Deuxième couple:
Premier exemple d´entrée aléatoire (non apprise):
Deuxième exemple d´entrée aléatoire (non apprise):