NEURAL NETWORK

Voir:
Cours sur les réseaux neuronaux
Cours sur le connexionnisme
demo1_network.func
network_audio.func
Network command


GÉNÉRALITÉS
PERCEPTRON MULTI COUCHES
RÉSEAU DE KOHONEN
RÉSEAU ADAPTATIF
APPRENTISSAGE
EXEMPLES

















































GÉNÉRALITÉS

Definition
fac
matrix
Fonction de ransfert
generation
poids
generation des poids
Validate
Utilisation

Définition d´un objet de type network

network(id)T
         Construit le réseau vide id type T.
T is:
       "fac: perceptron multi couches (par dédefaut).
       texture: réseau de Kohonen.
       near: réseau complètement connecté.
       interaction: réseau adaptatif.

type network(id)
         Retourne la chaine type du réseau id.
type network(id)=t
       Change ce type.
After changing the type it is necessary to:
         generate network(id)

validate network

validate network(id) Returns (cpt,err,stat) with:
       cpt: nombre de passes effectuées.
       err: maximum de l´erreur commise.
       stat=1: quand le réseau est adapté.

APPRENTISSAGE

Généralités
Apprentissage supervisé
Apprentissage compétitif de Kohonen
Apprentissage adaptatif
Constantes d´apprentissage
Utilisation

Généralités

Étant donné un esemble représentatif de patterns, on ajuste les poids synaptiques en utilisant un ensemble de règles d´apprentissage.
Après que les poids ont été modifiés par l´apprentissage on marque les taux de réussite sur un ensemble de test différent del´ensemble d´apprentissage.
Rosenblatt (1958) proposa un système d´apprentissageavec ayant la propriété que, si les motifs de l´ensemble d´apprentissage (c´est à dire un ensemble de vecteurs caractéristiques binaires) peuvent être séparés par un certain choix des poids et un seuil, alors le systèmeconvergera vers un équilibre des poids satisfaisant. ;

Apprentissage supervisé

Perceptron multi couches
       Un apprentissage supervisé (sur un réseau de type fac, ou perceptron multi couches) est donné par des couples (Mi,Li):
         Mi = input motifs.
       Li = output law.
         l´adaptation du réseau en nb passes est réalisé par: validate(nb)network(id).
Ce type de réseau multicouches "feedforward" est entrainé par l´algorithme de la rétropropagation de l´error).
Définition de couples d´apprentissages
motif(0)network(id)=M
         Crée un motif d’entrée.
law(0)network(id)=L
         Crée une loi de sortie.
Toutes les entrées doivent avoir la même dimension.
Toutes les sorties doivent avoir la même dimension.
Il doit y avoir autant de sorties que d’entrées.
Déroulement d´un apprentissage
validate(nb) network(1);
         Adapte les poids du réseau (par l´algorithme de la "rétropropagation") en nb passes, et retourne le nombre de passes utiles (lorsque le réseau est adapté), si ce nombre est nb il faut poursuivre l´apprentissage.
validate(nb) coe(c1,c2) network(1)
         Permet de faire varier le coefficient "eta" entre c1 (à la passe 1) et c2 (à la passe nb). Par defaut 1.0, 0.01.
(ajustement de la constante d´apprentissage).
validate(nb) error(eps) network(1);
         Permet de définir une error acceptable. Par defaut eps=0.1
interaction validate(nb,1) network(1);
         Permet un traîtement en parallèle de l´adaptation.
Utilisation
S=validate motif(M) network(id);
         Retourne la sortie S du réseau id correspondant à l´entrée M.
Exemple
net(n)
{
ini ini network;no edit;
if(n==NIL)n=1;
/* Construction du network */
/* ---------------------- */
network(1)fac;
         fac(0)network(1)=1,2,3; /* Couche d´entree*/
         fac(0)network(1)=4,5; /* Couche cachee */
         fac(0)network(1)=6,7,8; /* Couche de sortie */
/* Définition des poids */
/* --------------------------- */
mass(1,4)network(1)=.5;
mass(1,5)network(1)=.3;
mass(2,4)network(1)=.3;
mass(2,5)network(1)=.2;
mass(3,4)network(1)=.1;
mass(3,5)network(1)=.1;
mass(4,6)network(1)=.1;
mass(4,7)network(1)=.3;
mass(4,8)network(1)=.5;
mass(5,6)network(1)=.2;
mass(5,7)network(1)=.4;
mass(5,8)network(1)=.6;
/* Couples d´apprentissage */
/* ----------------------------- */
motif(0)network(1)=1,2,3;law(0)network(1)=.1,.3,.7;
motif(0)network(1)=3,2,1;law(0)network(1)=.2,.3,.;
/* Apprentissage */
/* ------------- */
$"NB = ",validate(n)network(1)error(.01);NL;
/* Utilisation du network (verification) */
/* ------------------------------------ */
$validate motif(1,2,3)network(1);NL;
$validate motif(3,2,1)network(1);NL;
}
res(n); Adapte le réseau en n passes.
par exemple res(300); product:
NB = 246.000000
0.102514 0.293342 0.690866
0.199652 0.308365 0.409970
Le réseau s´est adapté en 246 passes.
Pour un exemple montrant la résolution du XOR par un réeseau voir (demo network).

Apprentissage compétitif de Kohonen

Apprentissage compétitif pour les réseaux de Kohonen de type texture.

Définition d´un réseau de type texture

         network(id)texture;
         fac(0)network(id)=[1,np];
         fac(0)network(id)=[np+1,np+n*n];
Définit un réseau a 2 couches:
         Une couche d´entrée de np neurones.
         Une couche de sortie de n*n neurones disposés selon une grille carrée de côté n (constituant la carte de Kohonen).

Définition des propriétés

Comme ci dessus, on peut rentrer des motifs par:
motif(0)network(1)=m_1,m_2,...,m_np;
Modifier les masses, les fonctions de transferts, etc ...

Apprentissage

Définition des patterns d´entrée
motif(0) network(1)=liste de valeurs;
         Ajoute une entrée.
Remarque:
         Les motifs doivent avoir la même dimension que la couche d´entrée.

Déroulement d´un apprentissage

validate(n)network(1);
         Lance un apprentissage compétitif (en n passes) sur le réseau 1 pour les motifs qui ont été rentrés.
validate(n)network(1)coe(c1,c2)
         Pour faire varier la constante d´apprentissage.
validate(n)network(1)error(eps)
         Pour préciser la tolérance.
validate(n)network(1)debug
         Mode debuging.
interaction validate(nb,1) network(1)
         Permet un traîtement en parallèle de l´adaptation.
Les neurones de la carte de Kohonen (la couche de sortie) se spécialisent dans la reconnaissance de patterns présentés en entrée. La propriété de généralisation se traduit par le fait que le réseau est capable de reconnaître des exemples no appris.

Utilisation

validate motif(m)network(1);
         Retourne la carte de Kohonen, c´est à dire la liste des activations des neurones de la couche de sortie.
validate motif(m)network(1)neuronne;
         Retourne le numéro du neuron vainqueur et son activation.

Apprentissage adaptatif

L´algorithme de cohérence de flux stipule que le flux des actions (outputs) est cohérent avec le flux des perceptions (input), fournit un moyen pour entrainer des réseaux neuraunaux de type near en ne donnant que les entrées (les sorties étant automatiquement calculées).

Définition d´un réseau de type near

network(id)near;
L´apprentissage ne nécessite que des entrées, les sorties seront automatiquement générées. L´ensemble des couples d´entrées sorties {Mi,Li}0<=i<n définit un double flux, celui des entrées: {Mi}i et celui des sorties {Li}i. Seul le premier est donné (par exemple à partir d´une capture) et constitue une mémoire de travail pour le processus de cohérence de flux qui produira automatiquement le deuxième (par exemple des stimuli sensoriels envoyés à un système musculaire faisant agir un être artificiel).

Définition des propriétés

Pour créer une couche d´entrée de neurones:
       fac(0) network(id)=[1,ne];
Pour créer une couche cachée de nc neurones:
       fac(0) network(id)=[ne+1,ne+nc];
Pour créer une couche de sortie de ns neurones:
       fac(0) network(id)=[ne+nc+1,ne+nc+ns];
Pour générer des motifs d’entrée:
       motif(0)network(id)=m;
Tous les motifs doivent avoir les mêmes dimensions.
Pour générer les propriétés (neurones et matrix) du réseau:
       generate network(id);
Notons que tous les neurones sont connectés et que la matrice est entièrement modifiée (à l´exception de la diagonale qui est nulle) lors de l´apprentissage. Les facettes ne décrivent donc pas les liaisons (comme dans les réseaux de type fac).

Utilisation

Apprentissage préalable
validate(nb,cpt)error(err)coe(c1,c2)network(num);
         nb=nombre de cycles, cpt pour un traitement en parallèle.
         err=erreur maximale.
         c1,c2=bornes de la constante d’apprentissage.
         num=numéro duu réseau.

Apprentissage dynamique

validate(nb,cpt)motif(m)error(err)coe(c1,c2)network(num)roll;
Le motif m est mis à la fin de la pile circulaire des motifs, le réseau est entraîné en nb essais. Utilisation :
1) Création d’un réseau de n motifs (de dimension ne), les sorties ont une dimension ns.
network near(id);
fac(0)network(id)=[1,ne]; /*Couche d’entrée */
fac(0)network(id)=[ne+1,ne+ns]; /* Couche de sortie */
for(i=1,n)motif(0)network(num)=[1,ne];
generate network(num);

Entraînement dynamique

: w=validate(nb)motif(m)error(err)coe(c1,c2)network(num)roll;
Le motif m est empilé dans la liste circulaire des motifs, le réseau est entraîné sur nb essais. W est la sortie correspondant à l’entrée m. Les sorties sont calculer de façon à minimiser la différence des variations des entrées et des sorties (méthode dite de la cohérence de flux (voir aussi émergence et résonance). Un tel réseau s’utilise typiquement sur le mode interactif en fournissant une entrée sous la forme d’un flux de données issues par exemple d’un capteur.

Constantes d´apprentissage

Modification des constantes d´apprentissage

Les constantes d´apprentissagecan sont initilisées par:
meta coe network(num)=0,max_c1,c1,c1, 0,max_c2,c2,c2 with:
       max_c1: maximum de c1.
       c1: valeur courante de c1.
       max_c2: maximum de c2.
       c2: valeur courante de c2.
Les 9 champs sont obligatoires.
Ces paramètres sont affichés par la commande: displ network(id).

Utilisation

Une fois l´apprentissage achevé
S = validate motif(M) network (id) retourne la sortie S correspondant à l´entrée M.

EXEMPLES

Perceptron

La fonction demo1_network.func donne un exemple de programmation d´un réseau à couches apprenant à reconnaître des alphabets par des apprentissages supervisés. Le menu donne accès à:

DEM

Un réseau de 2 entrées modifiables en cliquant dans un repère (coordonnées x et y du point désigné), dont la matrice des poids synaptiques peut être modifiée aléatoirement en cliquant sur NOISE et ayant des couches cachées dont le nombre peut être choisi sur l´échelle cach.
Les sorties sont connectées aux joints d´un squelette qui s´anime lorsque les entrées sont modifiées.
Le réseau précablé par la fonction NOISE n´apprend rien.

RES

Donne accès au sous menu RES, choisir l´une des cases LIR FLO APP:
LIR
Cliquer sur un le nom d´un fichier alphabet *.alp.
BOO
Choisir le nombre de couches cachées cach, les côtés nx et ny des caractères de type booméen et leur nombre nb.
FLO
Choisir le nombre de couches cachées cach, les côtés nx et ny des caractères de type flottant et leur nombre nb.
FLO
Choisir les côtés nx et ny des caractères de type flottant, leur nombre nb et le nombre de couches cachées cach.

Les motif (rouge) sont présentés en entrée du réseau lequel donne une sortie (jaune) qui est différente de la sortie (vert) (égale à l´entrée) (car la matrice des poids synaptiques a été initialisée aléatoirement), pour entrainer le réseau cliquer sur:
APP
Apprentissage: la courbe des erreurs apparait en bas et à droite de l´écran, les constantes d´apprentissage apparaissent en bas (coe1 coe2 variant automatiquement). Normalement la sortir (en vert) converge vers l´entrée choisie. S´il n´y a pas convergence on peut modifier les constantes à la mouse, on peut également réinitialiser la matrice en cliquant sur l´échelle NOISE ou encore changer le nombre de couches cachées (sur l´échelle cach).
ALEA
Modifier alea: les motifs d´entrée sont bruités, le réseau les reconnait quand même.

VOL

Donne un exemple de volume "intelligent" sachant s´adapter à un environnement changeant. Cliquer sur la case AUT génère la commande:
network axis rota vol(Num_VOL)=Num_RES_VOL;
exprimant que le réseau Num_RES_VOL est attaché au volume Num_Vol.
r1=rand2f(-1,1),rand2f(-1,1),rand2f(-1,1);r2=rand2f(-1,1),rand2f(-1,1),rand2f(-1,1);
EXEC=compile message("traj(100)axis(0,0,1, r1, r2)vol(Num_Vol_VOL)period(-1)");

munit les axes du volume de trajectoires aléatoires. Le rôle du réseau adaptatif est alors de tenter de stabiliser le volume.

La fonction perceptron.func donne un exemple plus général.

Réseau compétitif

La fonction kohonen.func donne un exemple de programmation d´un réseau de Kohonen détectant des régularités dans un ensemble de patterns.
kohonen_2.js lance kohonen(2): ensemble 2D.
kohonen_3.js lance kohonen(3): ensemble 3D.
Remarque:kohonen(n > 3): lance la fonction pour une reconnaissance du signal audio échantillonné sur 2^n valeurs.
La couche d´entrée est composée de n neurones (coordonnées d´un point de l´ensemble).
La couche de sortie est une grille de 7 neurones.
initialisation
Initialise un espace de patterns disposés aléatoirement.
action
Génération d´un autre espace de patterns aléatoires dont chacun d´eux donne un neuron vainqueur en sortie caractérisé par sa couleur.
On constate que les points d´une même couleur sont regroupés dans une même région, ce qui montre que le réseau les a classifié.