RNA Perceptron multicouche

**Skynyrd777** · 16/02/2012, 23h57

Bonjour,

J'ai découvert il y a peu les réseaux de neurones artificiels. J'ai réussi à programmer un simple neurone à seuil qui apprend des fonctions booléennes linéairement séparables. J'ai ensuite réussi à programmer un perceptron multicouche (PMC) (on choisit le nombre de couches, de neurones par couche, la taille de la rétine, de la couche de sortie) ainsi que l'algorithme de rétropropagation du gradient pour l'apprentissage à partir d'une base d'exemples. Je programme tout ça en OCaml (je suis en CPGE et c'est le langage utilisé en cours et je l'aime bien

).

J'arrive à faire apprendre à mon PMC différentes fonctions (comme des affines, des sinusoïdes.. comme sur cet applet : http://agerodol.pagesperso-orange.fr...let_retro.html). Mais voilà mon problème : impossible de faire apprendre à mon PMC la simple fonction XOR. (j'ai essayé avec plusieurs couches cachées et différents nombres de neurones en vain)

En fait, mon PMC utilise des sigmoïdes comme fonction de transfert et de ce fait j'obtiens pour les vecteurs calculés des réels dans [0;1] (dans la pratique je n'obtiens pas les valeurs 0 et 1). Je pense donc que mon PMC est adapté pour apprendre des fonctions mais pas du tout pour apprendre des fonctions logiques comme le XOR, le OR, le AND....

Je voulais donc savoir si les PMC à sigmoïdes permettaient l'apprentissage de problèmes de logique (dans le sens "à valeurs dans {0;1}") ou alors pas du tout ? Je suis coincé à ce stade car je ne peux pas non plus utiliser mon PMC pour apprendre un jeu de morpion par exemple !

Si quelqu'un est intéressé par les sources (OCaml) de mon PMC (voir celles du perceptron simple) je peux les passer dans le thread sans soucis

Merci beaucoup d'avance !
Bonne soirée.

PS. Mes connaissances en la matière proviennent (quasi) exclusivement de cet article : http://www.grappa.univ-lille3.fr/pol...sortie005.html

**Alexis.M** · 17/02/2012, 08h50

Ben pour avoir des valeurs binaires il suffit de seuiller la sortie après la phase d'apprentissage.

Autre point, mais qui n'est pas forcement relatif au problème du xor, la fonction d'activation des neurones de la dernière couche d'un réseau multi-couche peut être linéaire afin notamment de ne pas être limité à l'intervalle (0,1).

Pour la fonction xor, un réseau à 1 couche cachée à deux neurones suffit.

**Franck Dernoncourt** · 17/02/2012, 14h02

Envoyé par Alexis.M

Pour la fonction xor, un réseau à 1 couche cachée à deux neurones suffit.

Here is example of one computation using the network above. This network is a simple neural network, which functions as an XOR. This neural network has two input neurons, two hidden neurons, and one output neuron. The table below indicates the desired input and ouput of the XOR network. If we use A and B as input sets for the above network, we will acheive the desired output. Take, for example, the input set {1,0} the 1 causes neuron A to fire while neuron B does not because its input value does not meet the threshold value of one. Thus neuron A fires giving neurons C and D values of {1,-1} since only C meets the threshold value of one only it fires. Since C fires it outputs a value of 1 to E, which meets the threshold value and causes the output neuron to fire. You can try for yourself the calculations for all other possible input sets to see if you get the right answer.

(source : http://library.thinkquest.org/29483/neural_index.shtml)

**Skynyrd777** · 17/02/2012, 18h14

Merci pour vos réponses.

Je pense qu'il a quelque chose qui pose problème dans mon algorithme de rétropropagation (j'ai appliqué le pseudo-code donné ici). J'ai beau le relire plusieurs fois, je n'arrive pas à trouver quoi. Ce qui m'étonne c'est qu'il fonctionne bien pour des fonctions sinusoïdales etc...

Effectivement, quand je lui donne la table du xor, mon pmc renvoie des valeurs très proches de 0.5 (mais ces valeurs n'indiquent pas le bon résultat une fois arrondies au plus proche entre 0 et 1, par exemple je donne 0 et 0 et il renvoie 0.40) ; je n'ai pourtant seuillé la sortie qu'après l'apprentissage.

Je me permet de vous passer l'architecture du pmc et de l'algo d'apprentissage, si quelqu'un a le courage d'y jeter un coup d'oeil, je lui en serais vraiment reconnaissant car là je plante..

Je construit le pmc comme un tableau de matrices (le tableau représente les couches, la première dimension des matrices représente les neurones et la seconde dimension les poids). La rétine n'est pas comprise dans cette architecture.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
let nbr_lay = 2;;
let nbr_neu = [|2;1|];;
let len_ret = 2;;
 
let pmc1 = 
  let t = ref (Array.make nbr_lay (ref [| [| |] |])) in
    begin
      !t.(0) <- ref (Array.make_matrix nbr_neu.(0) len_ret 0.);
      for i = 1 to nbr_lay -1 do
        !t.(i) <- ref (Array.make_matrix nbr_neu.(i) (nbr_neu.(i-1)) 0.)
      done;
      t
    end;;

Voici une fonction qui évalue : on lui passe une rétine (un tableau) et elle renvoie un tableau de tableau contenant les neurones marquées de leurs valeurs calculées (rétine comprise). La sigmoïde intervient ici.

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
let pmc_eval pmc k r = 
  let t = ref (Array.make (nbr_lay + 1) (ref [| |])) in
    begin
      !t.(0) <- ref (Array.make len_ret 0.);
      for i = 1 to nbr_lay do
        !t.(i) <- ref (Array.make nbr_neu.(i-1) 0.)
      done;
      for i = 0 to len_ret -1 do
        !(!t.(0)).(i) <- r.(i)
      done;
      for i = 1 to nbr_lay do
        for j = 0 to nbr_neu.(i-1) -1 do
          let sum = ref 0. in
            begin
              for k = 0 to (Array.length !(!t.(i-1))) -1 do
                sum := !sum +. !(!t.(i-1)).(k) *. !(!pmc.(i-1)).(j).(k)
              done;
              !(!t.(i)).(j) <- 1. /. (1. +. exp (-1. *. k *. !sum))
            end
        done
      done;
      t
    end;;

Enfin l'algorithme de rétropropagation du gradient est là (désolé c'est un peu gros) :

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
let pmc_rpg pmc eps th k n st =
  begin
    for i = 0 to nbr_lay - 1 do (* initialisation des poids *)
      for j = 0 to nbr_neu.(i) - 1 do
        for k = 0 to (Array.length !(!pmc.(i)).(j)) - 1 do
          !(!pmc.(i)).(j).(k) <- (Random.float 1.) -. 0.5
          (* !(!pmc.(i)).(j).(k) <- 0. *)
        done
      done
    done;
    let e = ref 0 in
      for c = 0 to n do
        if !e = (Array.length st) then e := 0;
        let d = ref (Array.make nbr_lay (ref [||])) and pmc_filled = pmc_eval pmc k (fst st.(!e)) in
          begin
            for i = 0 to nbr_lay - 1 do (* creation du tableau des delta *)
              !d.(i) <- ref (Array.make nbr_neu.(i) 0.)
            done;
            for j = 0 to nbr_neu.(nbr_lay - 1) - 1 do (* calcul des delta sur la couche de sortie *)
              let oi = !(!(pmc_eval pmc k (fst st.(!e))).(nbr_lay)).(j) in !(!d.(nbr_lay - 1)).(j) <- oi *. (1. -. oi) *. ((snd st.(!e)).(j) -. oi)
            done;
            for i = nbr_lay -2 downto 0 do (* calcul des delta sur les couches internes *)
              for j = 0 to nbr_neu.(i) - 1 do
                let sum = ref 0. and oi = !(!(pmc_eval pmc k (fst st.(!e))).(i + 1)).(j) in
                  begin
                    for k = 0 to nbr_neu.(i + 1) - 1 do
                      sum := !sum +. !(!d.(i + 1)).(k) *. !(!pmc.(i + 1)).(k).(j)
                    done;
                    !(!d.(i)).(j) <- oi *. (1. -. oi) *. !sum
                  end
              done
            done;
            for j = 0 to nbr_neu.(0) - 1 do (* modification des poids synaptiques *)
              for k = 0 to len_ret - 1 do
                let delta = eps *. !(!d.(0)).(j) *. (fst st.(!e)).(k) in
                  begin
                    !(!pmc.(0)).(j).(k) <- !(!pmc.(0)).(j).(k) +. delta;
                  end
              done
            done;
            for i = 1 to nbr_lay - 1 do
              for j = 0 to nbr_neu.(i) - 1 do
                for k = 0 to nbr_neu.(i - 1) - 1 do
                  let delta = eps *. !(!d.(i)).(j) *. !(!pmc_filled.(i)).(k) in
                    begin
                      !(!pmc.(i)).(j).(k) <- !(!pmc.(i)).(j).(k) +. delta;
                    end
                done
              done
            done;
          end;
        e := !e + 1
      done
  end