GÉNÉRALITÉS
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
É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é.