Neural movements


Some links will not be active (without an internet connection).

download

Principle
Content
The menus
Thje program
Use


















































Principle


This application shows:

How to build neural networks type perceptron multi couches

How to build trajectories

by to approaches:
rotations defined by:
       angle an and axis xr,yr,zr
       giving rise at two types of trajectories: rotation and axis.
quaternions of thr form w,x,y,z,with:
       an=2*acos(w)
       x,y,z such as module(x,y,z)=sin(a/2) made of a list
       quaternion w,x,y,z is an unit 4D vector (module 1).
Movement of a volume i is defined by a trajectory of quaternions by spherical interpolation a list
qi,1 qi,2 ... qi,nq of nq quaternions.
For several volumes Shoulder,Humerus,Radius,Wrist,Fingers there are as many trajectories.

How using those features

to program an arm:
       imitating interactively a real arm.
       interacting intelligently with a real actor he imitated the postures.

Note:

To program einC language thsi outside anyflo it will be necessary:
1) program neural networks.
2) program the quaternions and the spherical interpollation.
3) program a real time interface.

Defining motions

Rotary movements are defined in file .rota of form:

r1,1 r1,2 ... r1,nq
r2,1 r2,2 ... r2,nq
...
rnv,1 rnv,2 ... rnv,nq

Where ri,j=a,x,y,z is a rotation defined by its angle a and its axis x,y,z.
The movements of quaternions are defined in files .quat of form:

q1,1 q1,2 ... q1,nq
q2,1 q2,2 ... q2,nq
...
qnv,1 qnv,2 ... qnv,nq

Where qi,j=w,x,y,z is a quaternion.

These movement files can be built from motion capture of a real actor.

A real time interaction requires motion capture and interpretation interfaced.

Contenu

Folder env


*.h: anyflo configuration files.
*.rota: files describing movements.

anyflo_video.js

Java scrypte launching anyflo in video format.

initb.h

Configuration file in folder env.

mouv_neur.func

Function in anyflo language.

mouv_neur.htm

This file.

mouv_neur.js

Java scrypte launching the application.

demo1_network.js

Java scrypte launching the neural networks demo.
demo1_network.func: program (in anyflo language) of the demo.
corps_simple.func: program (in anyflo language) building a simplified body (used by demo1_network().

The menus

Main menu
EXPL: explanations.
RESEAU: creates a neural network.
GEN: generates a genetic.
INI: reset
COL: oui/non col.
PEAU: oui/non affichage de la peau.
EXT: oui/non ext.
FONC: affiche les noms des fonctions, cliquer sur l´un d´eux en affiche le texte.
PASaPAS: mode pas à pas, cliquer sur CONTINUE (vert) avance d´une image, cliquer sur X (rouge) sort de ce mode.
Attention: ne pas cliquer sur RETURN, ce qui aurait pour effet de relancer le programme...

Un message clignotant indique chaque fois la marche à suivre, la case du menu qu´il faut cliquer pulse pendant environ 4 secondes.
EXIT: pour quitter le programme.

EXPL: sous menu des explications

HEL: help de ce sous menu.

ROTA: cliquer sur un nom d'os (Épaule, Humerus, Radius, etc...) puis modifier l´angle de rotation rota et l´axe, le bras bouge en conséquence.
Cliquer sur TOUS() sélectionne tous les os.
Cliquer dans le cadre vert change l'oeil.

COMPLEX: isomorphisme des rotations planes et des nombres complexes:
Modifier les composantes a et b du nombre complexe unitaire z=a+i*b, le point rouge affiché sur le cercle de rayon 1 représente l´angle correspondant de cosinus a et de sinus b.

QUAT: isomorphisme des rotations de l´espace et des quaternions:
Modifier l´angle de rotatiuon rota et l´axe du nombre quaternion unitaire q=w+i*a+j*b+k*c, le point rouge P affiché sur la sphère de rayon 1 représente la rotation d´angle 2*acos(w) et d´axe OP.
Cliquer dans le cadre vert change l'oeil.

MOUV: interpolation sphérique de 2 quaternions:
Deux quaternions q1=w1,x1,y1,z1 et q2=w2,x2,y2,z2 sont représentés par deux points P1(rouge) et P2 (vert) de la sphère de rayon unité.
Modifier le coefficient d´interpolation u, le point P représentant le quaternion interpolé entre q1 et q2 s´affiche sur la sphère entre P1 et P2.
Modifier les quaternions sur les échelles.
La formule d´interpolation est sphérique:
c1=(sin((1-u)*a))/sin(a) c2=(sin(u*a))/sin(a) q=c1*q1+c2*q2
AUTO(): interpolation automatique.
Cliquer dans le cadre vert change l'oeil.

MOUVS:
Une POSITION ets représentée par un quaternion.
un MOUVEMENT Élémentaire est représenté par une liste de quaternions interpolés. et de sinus b.
Un MOUVEMENT MULTIPLE (par exemple des os constituant le bras) est représenté par une suite de telles listes c´est à dire par une matrice de quaternions.
On a stocké sur le disque un tel mouvement par un fichier .rota

RESEAU: sous menu de création d´un réseau

HEL: help de ce sous menu.
MIME: sous menu de création d´un réseau mimétique.
AUTRE: sous sous menu de création de réseaux d´un autre type (en développement).
Sous sous menu MIME
       HEL: help.
       Cliquer sur CREER:
       Cliquer sur ALEA: cré un couple d´apprentissage aléatoire.
       Cliquer sur LIRE: cliquer sur un nom.rota, le fichier est chargé comme (couple d´apprentissage (avec loi=motif, c´agrave; dire sortie=entrée).
       Cliquer sur APP: apprentissage, la courbe dérreur s´affiche et doit tendre vers zéro. S´il n´y a pas convergence on peut cliquer sur NOISE pour bruiter la matrice des poids synaptiques ou sur coe1 et coe2 qui sont les constantes d´apprentissage. On peut aussi bruiter les motifs et les lois en cliquant une petite valeur sur l´échelle alea.
       Cliquer sur MATRICE: affiche la matrice des poids synaptiques.
AUTRE: en développement.

GEN: génération d´une génétique

HEL: help.
Cliquer sur ROTA traitement des rotations ou
sur QUAT traitement des quaternions ou
APP: affiche l´apprentissage.
MATRICE: affiche la matrice des poids synaptiques.
Cliquer sur INTER: mode interactif
Un petit bras vert apparait dans un cadre à gauche, cliquer dans le cadre modifie sa position qui sert de modèle au bras apparaissant à droite. Le mouvement du petit bras est passé en entrée du réseau qui fournit, en sortie, le mouvement du bras. Selon le mode choisi ROTA ou QUAT les rotations ou les quaternions sont utilisés.
Si APP est validé l´apprentissage est affiché: on peut modifier les paramètres (comme expliqué dans APP).
On peut voir, sur la courbe d´erreur, le réseau s´auto configurer en temps réel.
On peut aussi cliquer sur les motifs (verts) pour provoquer le mouvement correspondant.

Le programme
Les fonctions
Les variables

Les fonctions

Menu principal:
mouv_neur(): fonction principale.
externes(): déclaration des variables externes.
init(): initialisations.
generer_menu(): génération des menus.
MEN(): première fonction du menu principal de nom MEN.
HEL(): fonction help du menu principal.
INI(): réinitialisations.
COL(): oui/non col.
PEAU(): affichage des peaux.
EXT(): oui/non ext.
FONC(): affichage des fonctions.
fonc_FONC(): appelée à chaque image si FONC est validée.
PASaPAS(): mode pas à pas.
EXIT(): sort du programme.
DEUX_POINTS(): désactive les affichages des échelles, des menus, des messages et des textes.

Sous menu EXPL
EXPL(): première fonction du sous menu EXPL.
EXPL_HEL(): help du sous menu EXPL.
fonc_EXPL(): appelée à chaque image si EXPL est validée.
EXPL_ROTA(): explication des rotations.
fonc_EXPL_ROTA(): appelée à chaque image si EXPL_ROTA est validée.
EXPL_COMPLEX(): explication des nombres complexes unitaires associés à aux rotations planes.
fonc_EXPL_COMPLEX(): appelée à chaque image si EXPL_COMPLEX est validée.
EXPL_QUAT(): explication des quaternions unitaires associés aux rotations de l´espace.
fonc_EXPL_QUAT(): appelée à chaque image si EXPL_QUAT est validée.
MOUV(): explication de l´interpolation sphérique des quaternions.
fonc_EXPL_MOUV(): appelée à chaque image si EXPL_MOUV est validée.
AUTO(): interpolation automatique.
EXPL_MOUVS(): explication de plusieurs mouvements.
fonc_EXPL_MOUVS(): appelée à chaque image si EXPL_MOUVS est validée.
AUTO(): interpolation automatique.

Sous menu RESEAU
RESEAU():première fonction du sous menu CREER.
RESEAU_HEL(): help du sous menu CREER.
fonc_RESEAU(): appelée à chaque image si CREER est validée.
SET_PARAM_RESEAU(): calcul des paramètres du réseau.
RESEAU_MIME(): réseau mimétique

Sous menu RESEAU_MIME du menu RESEAU
RESEAU_MIME():première fonction du sous menu CREER.
       RESEAU_MIME_HEL(): help du sous menu RESEAU_MIME.
       fonc_RESEAU_MIME(): appelée à chaque image si RESEAU_MIME est validée.
RESEAU_MIME_CREER(): cré d´un réseau à couches cachées (de type perceptron):
       RESEAU_MIME_ALEA: crée un motif et une loi identiques formant un couple d´apprentissage (qui sont visualisés en vert et rouge).
       RESEAU_MIME_LIRE: cliquer sur un , le fichier est chargé et constitue un couple d´apprentissage.
       fonc_LIRE(): appelée a` chaque image si RESEAU_MIME_LIRE est validé.
       RESEAU_MIME_APP: lance l´apprentissage.
       RESEAU_MIME_MATRICE: affichage de la matrice.
CREER_QUAT(): validation des trajectoires de quaterniuons.

Sous menu GEN
GEN():première fonction du sous menu GEN.
GEN_HEL(): help du sous menu GEN.
fonc_GEN(): appelée à chaque image si GEN est validée.
GEN_INTER(): interaction.
       fonc_GEN_INTER(): appelée a` chaque image si GEN_INTER est
GEN_ROTA(): validation des rotations.
GEN_QUAT(): validation des quaternions.
GEN_APP(): affichage de l´apprentissage.
GEN_MATRICE(): affichage de la matrice.

Interaction

F0(): appelée une seule fois en début de l´interaction.
F5(): appelée à chaque image aprè l´affichage des volumes, permet l´affichage d´échelles et de textes sur l´image.

Fonctions utilitaires:
dim_ecr(): calcule les dimensions en fonction de la taille de l´écran.
set_message(): initialise un message clignotant.
coder_bras(): code le mouvement du bras.
lire_rota(): lit un fichier de mouvements nom.rota dans la mémoire courante.
cou_vol(): change la couleur du volume selectionné
TOUS(): sélectionne tous les volumes.
aff_quat(): affiche un quaternion.
rendre_visible(): affiche Vol ou Peaux.
rendre_invisible(): invalide l´affichage.
modif_param(): affiche les échelles de saisie des paramètres.
VOL_QUAT(): retourne l´évaluation de la position du bras par rapport à la mémoire num.
tourner_Vol0(): tourne les volumes Vol0 dans la mémoire -1 (en mode INTER).
creer_reseau(): création d´un réseau.
aff_reseau(): affichage d´un réseau.
Vol0_Vol(): Vol0 -> réseau _> Vol..
motif_loi_alea(): génère un couple d´apprentissage aléatoire.
tester_creer(): retourne -1 si CREER n'est pas validé.

Fonctions de construction:
cons_bras(inc): construction d´un bras d´indice inc.
cons_rotule(): construction d´une rotaule (épaule et poignet).
cons_doigt(): construction d´un doigt.
cons_doigt_1(): construction d´une phalange.
cons_peau_main(): construction des peaux.
cons_peau(): construction d´une peau.

Codage te décodage:
CODAGE(): transformation d´une rotation de l´espace (an,xr,yr,zr) en un quatrenion (w,x,y,z) puis codage sur 4*Nb_Bit caracteres 0 et 1.
DECODAGE_ROTA(): décodage d´un génome codant une rotation en une rotation.
DECODAGE_ROTA_QUAT(): décodage d´un génome codant une rotation en un quaternion.
DECODAGE_QUAT_QUAT(): décodage d´un génome codant un quaternion en un quaternion.

Génération des trajectoires:
GEN_TRAJ()
GEN_TRAJ_ROTA(): génération des trajectoires de rotations.
GEN_TRAJ_QUAT(): génération des trajectoires de quaternions par interpolation sphérique.

Les variables


Sem_AUTO: interpolation automatiue (1), manuelle (0).
Inc=200: incrément des numéros des volumes d´une description d´un bras à un autre.
Lead,Epaule,Humerus,Radius,Poignet,Pouce,Indexe,Majeur,Annulaire,Petit,Doigts: noms des os.
Peau_Bras,Peau_Main,Peau_Pouce,Peau_Indexe,Peau_Majeur,Peau_Annulaire,Peau_Petit: noms des peaux.
Nb_Part: nombre d´individus (particules) de la génétique.
Nb_Quat: nombre de quaternions composant un mouvement élémentaire.
Nb_Vol: nombre de volumes animés.
Nb_Mem: nombre de mémoires codant des mouvements lus.
Ni: variations du nombre d´images d´une trajectoire.
Num: numéro du volume sélectionné.
Dim_Mot,Cassure,Mot1,Mot2,Mot3,Mot0: mots utilisés par EXPL_ALGOGEN.
Pend: mouvement pendulaire ou non.
Amp: variation du coefficient d´amplitude.
Alea: variation du coefficient de bruitage des motifs et des lois..

Utilisations
Reconnaissance de mouvements
Génération de mouvements

Reconnaissance de mouvements

Il suffit de décrire des mouvements dans des fichiers .rota qui seront chargés comme couples d´apprentissage. Ils seront reconnus, après apprentissage, ainsi que des mouvements voisins.

Génération de mouvements

Des mouvements non appris passés en entrée du réseau donneront, en sortie, des mouvements nouveaux qui ne sont ni des barycentres des mouvements appris ni arbitraires, en ce sens on peut dire que le réseau improvise.