Discussion :

[TyeFromEzella]

Bonsoir tout le monde !
Voilà, je débute dans le monde de l'intelligence artificiel, et donc j'ai parcouru de long en large ce forum pour trouver de la documentation...
J'ai donc été dirigé vers le tutoriel de Alp Mestan ( presque tous les threads en parlent alors ... ).
Je me suis donc attelé à la représentation de la fonction bouleenne OU comme d'écrit dans le tuto, mais après lecture et relecture y'a toujours un truc qui me chagrine (certain vont surement trouver ça nul) :
Comment se fait il que les informations (les entrées du neurones) peuvent prendre des valeurs réelles dans [0, 1] ???
Naturellement pour moi les seules valeurs possibles en entrée seraient 1 ou 0....
Auriez vous une réponse à m'apporter ??

je vous remercie par avance!
Et bonne soirée.


Tye

[Clercq]

Le plus simple est de ce mettre dans un espace 2D. Imagine que tu as un repère xy dans lequel tu as n donnée, chaque donnée étant représenté par sa coordonnée (xi, yi) (i.e x1, x2). Du coup tu peux facilement imaginer dans un repère continu. Ton but est alors de trouver la droite qui permet de séparer tes données en deux groupes (cas du perceptron "de base").



Ton perceptron reçois alors un corpus (xi, yi, ci) ci étant la classe associé à ma donnée.

Le cas 0 1 est un cas d'école peut être trop simple ...

ce que tu cherche en n'est autre qu'un vecteur W = [w0 w1 w2] qui n'est autre qu'une équation de droite ...

(w0+x1*w1+x2*w2) > 0 -> C1
(w0+x1*w1+x2*w2) < 0 -> C2

J'espère que cela pourra t'aider. Sachant que dans le cas du perceptron multi-couche tu est dans un repère nD, sinon le raisonnement est le même, tu as a trouver l'équation d'un hyperplan (ni plus ni moins )

Toujours dans le cas du perceptron

avec F(x) = sum i=1..N (xi*wi) + w0.

[TyeFromEzella]

alors je te remercie pour ton explication très claire !
J'ai bien compris ce que tu as écrit, mais du coup je suis perdu et j'arrive pas me représenter un cas concret ...
Pourrais tu me montrer un exemple d'utilisation de la fonction OU ? genre, je sais pas... dans une phase du jeu de morpion ? un autre jeu ? un problème tout bête quoi...
merci encore !

[Clercq]

Je pense qu'il y a peut être une confusion dans l'utilisation des RN.

Un RN est simplement une boite noir que l'on a entrainé à donner des sorties en fonction des entrés. Dans le cas de l'exemple de la fonction OU le RN à "apprit" la fonction Fou(x), ainsi quand tu lui demande 0 1, il te répond C1 (équivalent a =1); pour 0 0 -> C2 (eq =0) ...

Dans le cas du jeux de morpion je ne vois pas d'application des RN intéressante. Si ton but est de faire une intelligence pour un jeu de ce type penche toi plutôt sur les méthodes type MINI-MAX, et coupe Alpha-beta.

En réfléchissant, une application sur le jeu du morpion serait d'apprendre des configuration de jeu d'y associé des probabilité de gain, et à partir de ces probabilité déterminé des classes, ex proba < 0,6, configuration nul C0; 0,6 < proba 0,9 tente, C1; proba > 0,9 fonce, C2.
En ayant un certain nombre (enorme) de configuration étiqueté (ex config1 = C2, config2 = C0, ..., confign=C1), tu peut apprendre à ton RN a reconnaitre une bonne configuration de jeu d'une mauvaise, ainsi en testant plusieurs config avant de joué, tu choisit une qui est dans la classe la plus prometteuse et tu joue.
Problème 1 : L'espace d'apprentissage est énorme (9 pour un jeu de base)
Problème 2 : Il n'est pas sur que sans apprendre toutes les possibilté ton RN reponde correctement, en effet je ne sais pas si il y a un moyen de discriminé une bonne solution d'une mauvaise ... à voir.

Sinon le principe est là .

[TyeFromEzella]

Merci encore pour ton aide, j'y vois de plus en plus clair

Enfait le jeux du morpion était juste une exemple ... je ne souhaite pas programmer ce type de jeux (pour l'instant), je cherchais juste un exemple d'application pour utiliser la fonction OU avec mon neurone ...

quand tu dis ca :

Un RN est simplement une boite noir que l'on a entrainé à donner des sorties en fonction des entrés. Dans le cas de l'exemple de la fonction OU le RN à "apprit" la fonction Fou(x), ainsi quand tu lui demande 0 1, il te répond C1 (équivalent a =1); pour 0 0 -> C2 (eq =0) ...

je comprends tout à fait avec des valeurs en entrée comme 0 ou 1 !
mais avec des valeurs comme 0.4, 0.8 là je ne comprends pas ....
comment peut on avoir des valeurs réelle pour une fonction OU ???

[Clercq]

Je pense que le plus simple est que tu oublie la fonction OU qui n'est qu'un exemple d'application et non le fonctionnement interne de l'algorithme.

En essayant de faire simple l'algorithme est le suivant :

J'ai en entrée un corpus du type (x,y,classe)^n, dans le cas 2D classe = +1 ou -1.
J'initialise W=[w0 w1 w2] les coordonné de ma droite séparatrice F(x) de façon aléatoire.

1) Je choisie une donnée aleatoirement.
2) ensuite je fais x*w2+y*w1+w0 = tmp et je regarde le signe de tmp,
- si celui ci correspond au signe de la classe de ma donnée je passe a la donnée suivante 1).
- sinon je met à jour W de la manière suivante :

w2 = w2+sigma*x*classe avec sigma au pif d'environ 0.05,
w1 = w1+sigma*x*classe
w0 = w0+sigma*classe

et je passe a la donnée suivante 1).

Je boucle tant que l'erreur est supérieur à 0.001 par exemple.

On voit bien qu'il n'y a pas de OU, ni de restriction au valeur 0 1, par contre cet algorithme permet d'apprendre la fonction OU.

[TyeFromEzella]

je crois que c'est le "permet d'apprendre la fonction OU. " qui me bloque....

petites questions sur ce que tu as dit :

J'ai en entrée un corpus du type (x,y,classe)^n, dans le cas 2D classe = +1 ou -1.

Dans ce cas là, classe est soit positif, soit négatif nan ? Ou c'est vraiment égal à +1 ou -1 ?

pour ce qui est de la correction des poids :

w2 = w2+sigma*x*classe avec sigma au pif d'environ 0.05,
w1 = w1+sigma*x*classe
w0 = w0+sigma*classe

ce ne serait pas plutôt :
w2 = w2+sigma*x*classe avec sigma au pif d'environ 0.05,
w1 = w1+sigma*y*classe
w0 = w0+sigma*classe
??
Et w0 (le seuil ?) n'est pas sensé être invariable ???



Sinon,
aurait tu un exemple de programme, ou un exercice (avec code source/corrigé) qui utiliserai un neurone ? je comprends mieux avec un exemple concret...

Moi j'ai dans ma tête une application mais je ne sais pas si ça colle :
je veux déterminer la couleur d'un pixel..
pour commencer je veux déjà savoir si il est de couleur "noir" donc soit il est "noir" soit il ne l'est pas ...
Apparemment je serais en Dimension 3 dans ce cas là car j'ai 3 informations pour mon pixel (R, V, B), c'est ça ?
Es ce que je peux résoudre ce problème avec mon neurone "tout bête" ?


merci pour ta patience Clercq !!

[Clercq]

Désolé pour l'erreur, en effet c'est y et non x, un malheureux copier coller.
En ce qui concerne w0, il correspond au b dans y=ax+b, il permet de ne pas être forcé à passer par l'origine.

En effet dans le cas de deux classes on a soit + soit -, que l'on représente par +1/-1, mais il faut retenir que l'on compare les signe, en fait pour savoir si une donnée est bien classé, dans le cas bi classe on multiplie la prédiction par la classe effective, si le produit est positif la donnée est bien classé, si il est négatif, la donnée est mal classé.

En ce qui concerne le code je donne ici un de mes vieux code Octave, il permet de montrer comment fonctionne le perceptron sur un corpus de points générés aléatoirement suivant une loi normal.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
% genere un ensemble de K données de deux classes, de densités gaussiennes de moyennes m1 et m2 de Matrice de covariance = identité.
 
function [X, S] = genere_donnees(K, m1, m2)
X=[];
S=[];
for i =1:K
  if randn <0
    X=[X ; m1+randn(1,2)];
    S=[S ; -1];
  else
    X=[X ; m2+randn(1,2)];
    S=[S;1];
  end
end
 
i1=find(S==-1);
i2=find(S==1);
figure(1);
clf;
#plot(X(i1,1),X(i1,2),'+',X(i2,1),X(i2,2),'*');
#hold on
 
endfunction;
 
function y = randperm(N)
	[ordered_nu_ms, y] = sort( rand(N, 1));
endfunction
 
function [XApp, YApp, XTest, YTest] = diviseBD(E, S, Taux)
	N = size(E) (1);
	NApp = floor(N*Taux);
	I = randperm(N);
	J = I(1: NApp);
	K = I(NApp+1: N);
	XApp = E(J, :);
	YApp = S(J, :);
	XTest = E(K, :);
	YTest = S(K, :);
endfunction
 
function taux=taux_erreur(E,S,W)
	M=E*W.*S;
	I_Non_Zero = find(M<0);
	taux=size(I_Non_Zero)(1)/size(E)(1);
endfunction
 
function [w_opt, Err_app, Err_test]=perceptron(Ea, Sa, Et, St, Eps)
	W = rand(3,1);
	t=1;
	abs=[];
	Err_a_cum=[];
	Err_t_cum=[];
	do
		for i=1 : length(Ea)
			cond = Ea(i,:)*W.*Sa(i,:);
			if( cond >= 0 )
				w_opt = W;
				condition = 0;
			else
				w_opt = W+Eps*Sa(i,:)*Ea(i,:)';
				condition = 1;
			endif
			W = w_opt;
		endfor
		Err_app = taux_erreur(Ea,Sa,w_opt);
		Err_test = taux_erreur(Et,St,w_opt);
		Err_a_cum = [Err_a_cum, Err_app];
		Err_t_cum = [Err_t_cum, Err_test];
		abs=[abs, t];
		t=t+1;
	until( ( Err_app == 0 ) || (t>=200));
	#subplot (2, 1, 1);
	figure(2);
	hold off;
	plot(abs, Err_a_cum, '-', abs, Err_t_cum, '-');
endfunction
 
function tracer(W, XApp, YApp, XTest, YTest)
	i1=find(YApp==-1);
	i2=find(YApp==1);
 
	ord = -(XApp(:,2).*W(2,:)+XApp(:,1).*W(1,:))./(W(3,:));
	#hold off;
	#subplot (2, 1, 2);
	figure(1);
	hold on;
	plot(XApp(:,2), ord, '-', XApp(i1,2),XApp(i1,3),'+', XApp(i2,2),XApp(i2,3),'*');
endfunction
 
m1 = [-3 0];
m2 = [2.5 0];
K=1000;
[Xa, Sa] = genere_donnees(K, m1, m2);
 
[XApp, YApp, XTest, YTest] = diviseBD(Xa, Sa, 0.5);
Col1 = ones(size(XApp)(1), 1); #Ajout d'une colonne de 1 pour w0 -> x1*w2+x2*w1+1*w0
Ea = [Col1, XApp];
 
Col2 = ones(size(XTest)(1), 1);
Et = [Col2, XTest];
 
Eps = 0.001;
 
[w_opt, Err_app, Err_test]=perceptron(Ea, YApp, Et, YTest, Eps); #appel de la fonction
 
tracer(w_opt, Ea, YApp, Et, YTest)

Dans le cas de la séparation de pixel couleur tu te retrouve bien sur un espace 3D, tu n'a donc plus une droite qui sépare mais un plan, on parle dans le cas général d'hyper-plan. Le principe reste le même, en fait ton vecteur W doit avoir la taille de la dimension de tes donnée + 1 (pour w0)

Par contre le perceptron n'est utilisable que dans le cas de donnée linéairement séparable ... Sinon il faut regarder du coté des Réseaux de neurones, encore appelé perceptron multicouche .

[Alp]

Merci de corriger les incompréhensions qui reignent après la lecture de mon article Clercq ! Si j'avais le temps, je me retaperai un peu tout ça pour mieux expliquer...

Je tiens juste à mentionner à notre membre que la fonction OU n'est pas le centre du cours sur les réseaux de neurones.
Je l'ai choisie plutôt pour montrer une illustration concrète de ce que sont les informations reçues en entrées, les poids (y compris le seuil), les fonctions d'activations, etc.
Le fait est qu'avec un seul neurone on peut simuler la fonction OU. La puissance (et surtout le surnom de "boite noire") des réseaux de neurones vient justement de leur mise en réseau. Quand tu vas lier plusieurs neurones comme ça sur plusieurs couches, c'estl à que tu vas pouvoir approcher des fonctions incroyablement complexes, dont tu n'arrives même pas à te faire une représentation dans ta tête, rien qu'en appliquant un algorithme d'apprentissage, pour peu que tu ais choisi une bonne structure (i.e le bon nombre de couches, de neurones dans les couches cachées, etc).

Le plus difficile lorsque tu veux _utiliser_ les réseaux de neurones, c'est justement de modéliser ton problème de sorte à pouvoir "le donner à manger à un réseau de neurones".

Bon courage en tout cas. Je vais essayer de repasser pour donner des réponses plus complètes.

[TyeFromEzella]

Merci à vous deux !
Je viens de faire un grand pas en avant grâce à vos explications !

Merci Clercq pour ton code source. Je trouve la syntaxe de l'Octave un peu bizar, mais je vais analyser ça et voir comment ça marche


Alors je vais essayer de récapituler (si c'est ok j'imagine que ça en aidera plus d'un ) :
Alors,
->la tout première étape est d'essayer de trouver l'équation d'un hyper-plan (pour moi (pour l'exemple de mon pixel) ce serait l'équation d'un plan) qui colle à mon problème. Tout les points qui seront d'un coté du plan seront "BON", les autres seront "MAUVAIS".
-> l'équation trouvée sera utilisée pour la fonction d'activation de mon neurone
-> Ensuite il faut trouver les "bons" poids pour que mon neurone me donne la bonne sortie en fonction des entrées (les entrées sont les coordonnées d'un point de mon hyper-plan) et pour ça deux solutions :
-> soit les poids sont facile à trouver et là beh ... c'est facile
-> soit c'est plus chaud et là j'envoie mon neurone à l'école. Procédure d'apprentissage etc ... et pour ça il faut une batterie de bons résultats. par exemple pour l'exemple du pixel je dis :
(255, 255, 255, +1) car c'est 'blanc' => OK
(0 , 0 , 0 , -1) car c'est 'noir' => PAS OK
etc ....

Alors, alors, à vos stylo rouge !!
(j'espère que je suis pas complètement à coté de la plaque, pke là tout est à peu près clair dans ma tête. )

[Clercq]

Je vais essayer d'être le plus explicite possible :

Etape 1° Il faut un corpus de donnée étiqueté (255, 255, 255, +1), (15, 24, 125, -1), (251, 21, 245, -1) ...

Etape 2° Tu initialise ton neurone aléatoirement (en règle générale).
Etape 3° Ton neurone doit être entrainé, pour cela tu lui donne tes données à manger, si il y a erreur de prédiction, alors tu modifie W
Etape 4° Tu répéte l'étape 3° tant que ton neurone fait des erreurs, ou pendant N itérations.

Ici W peut être vu comme tes poids synaptique, après agrégation des ces poids, on peut voir la fonction signe comme fonction d'activation, en effet celle-ci permet de "transformer" les informations réel en information "classe +" ou "classe -".

[TyeFromEzella]

haaa, j'étais bon alors, nan ??

mais l'apprentissage est il obligatoire ? Admettons que je connaisse les "bons" poids ... ???

Avez vous une méthode particulière pour trouver la fonction d'activation qui collera le mieux au problème ?

[Clercq]

Pour répondre de façon "intuitive", je dirais que si tu connais les bon poids, donc dans le cas d'un perceptron l'équation de ta droite séparatrice, tu n'a nul besoin du perceptron, et tu utilise directement ta droite , à savoir que la régression linéaire est encore le meilleur moyen d'avoir une droite séparatrice quand on a pas beaucoup de point.

Pour un problème plus compliqué que la 2D, connaitre les poids est moins trivial, 3D va encore mais après ... D'où l'utilisation d'algorithme qui les trouve pour toi.

Pour des problèmes encore plus compliqués, je pense au cas non linéaire ... Connaitre les poids revient à connaitre le polynome d'ordre n de l'hyper plan qui sépare tes données ... Connaitre les poids est vraiment moins trivial .

Pour résumé, si tu connais les poids nul besoin d'un tels algorithme, par contre si tu ne les connais pas alors ces algorithmes (Perceptron, RdN ...) prennent tout leur sens.

En ce qui concerne les fonctions d'activation je dirais d'ordre général :
- Perceptron : fonction signe.
- RdN : fonction sigmoïde.

[TyeFromEzella]

Okk ok , je commence à être bien au point là sur la théorie !

combien faut il de "données étiquetées" en général pour avoir de bon résultats ??
j'imagine que plus on en a mieux c'est, nan ?

[Clercq]

Tu te confronte ici au même problème que les statistique

"Ma population d'apprentissage est elle représentative ?"

Pour imager, si tu veux discriminer deux classes défini par des gaussiennes et de variance faible et de moyenne assez distante, tu as besoin de point de point pour apprendre la droite de séparation. Par contre plus tu augmente la variance plus tu aura besoin de point d'apprentissage.
Ex : Discriminer les grands et les petits, si les grands était tous compris entre 1,80 et 2,10 et les petits entre 1,20 et 1,40, on voit bien qu'un petit échantillon de la population est nécessaire pour apprendre à différencier les petits des grands.
Par contre si les grands sont compris entre 1,65 et 2,0 et les petit entre 1,20 et 1,64, on imagine qu'il faut des échantillons plus grand pour être sur de bien représenter mes populations.

Bien sûr cet exemple est trivial, mais il montre deux choses:
- Si je connais les populations à la frontière alors j'apprends facilement, mais comment savoir que je connais ces populations ???
- La question est bien une question de représentativité et non de nombre ... Attention !.

Je suis d'accord que l'on peut considérer que prendre un nombre énorme de point peut être une façon d'avoir la représentativité (et encore !!!), mais juste pour le souligné, je ne sais pas si dans ton cas c'est vrai, mais étiqueter des données est souvent cher ! En temps et en argent (pour les société bien sûr )

[TyeFromEzella]

dsl pour le temps de réponse, jai eu un petit week end prolongé

Merci encore pour tes réponses.. je vais relire tout ca, et tenté de faire mon premier programme.

je reviendrai surement dans le coin pour de nouvelles questions
bonne soirée

[TyeFromEzella]

Voila, comme je l'avais dit, je reviens à la charge ...
Alors cette fois j'ai acheté un bouquin sur les RdN et à un moment il explique comment faire la fonction ET ...
bref il donne la solution avec :
Wx = 0.5, (poids de x )
Wy = 0.5 (poids de y )
et W0 = -0.8 ( seuil)

Donc moi j'ai cherché la solution tout seul dans mon coin et je suis sortit avec :
Wx = 0.2
Wy = 0.2
W0 = -0.8 ....
et ça marche aussi !!!

alors qui a raison ????
Est ce qu'il y a une histoire d'apprentissage ???


merci encore par avance

[Clercq]

Bonjour,

Désolé pour le temps de ma réponse, j'ai eu des journées prolongés .

Pour répondre simplement à ta question : Il existe une infinité de droite qui sépare les points tels que le séparation obtenu réalise le ET logique.

Si tu relance ton expérience tu t'apercevra que tu ne retrouve pas le même résultat .

La vérification est simple :
0.5x+0.5y-0.8 = 0 <=> y = -x+0.8/0.5 est bien une droite tels que le points (1,1) et les points (-1,-1),(0,-1) et (-1,0) sont séparés.
or 0.2x+0.2y-0.8 = 0 <=> y = -x+0.8/0.2 l'est aussi.

[TyeFromEzella]

OK !
Y'a une infinité de droite dans tous les cas ? pke bon la c'est la fonction ET mais j'ai testé aussi OU, XOR, x+yz etc .... et a chaque fois je peu changer les poids ...

[Clercq]

Il y a en effet toujours une infinité de solution, dans le cas d'un apprentissage dans le cas réel on s'aperçoit qu'il faut avoir un corpus de donnée représentatif afin d'obtenir une droite qui "classe" aux mieux.

En effet si l'on veut classé une donnée tangente aux deux classes, une personne qui mesure 1,61, alors que la classe "petit" s'arrête a 1,60 et que dans la classe grand on à pas de représentant a la limite inférieur, alors notre droite qui classe bien notre corpus d'apprentissage pourrait bien mal classé ce nouveau point.

On en revient à la représentativité des données.

Il existe une unique droite par contre qui sépare aux mieux les données -> les moindres carré, déterminé par régression linéaire, mais malheureusement bien trop couteux dans des corpus réel (dans le cas de base). D'où l'utilisation d'algorithme comme le perceptron.