Partage
  • Partager sur Facebook
  • Partager sur Twitter

Prob de Réseau de neurones

Il Apprend mal...

    13 octobre 2007 à 6:05:43

    J'ai commencé à m'iterressé aux réseaux de neurones, puis après de longue recherche je me suis lancé...
    J'ai lu un tuto sur http://www.hacking.free.fr/paris8/Backpropagation.htm et je me suis lancé dans l'analyse du code :o:p qu'il fournit et je l'ai esseyé; tout marchais, mais pour ceux qui iront voir vous verrez que c'est du C et non du C++... :colere2:

    Alors je me suis dit que puisque j'ai du temps à perdre je vais faire une classe avec et je vais tout réécrire de la même façon que j'écris d'hab , comme cela je vais mieux comprendre (en le réécrivant j'étais obliger de comprendre ^^ ) et le code va être extrêmement plus clair. :D

    Bon, après quelque heures de programmation hardu et interminable (c dure de taper sur un clavier :lol: ), j'ai finalement réeusi.
    Mais, quand je suis arrivé pour le testé la boucle pour l'apprentissage ne se terminait pas (l'erreur global variait tjrs, mais ne descendais jamais plus qu'elle ne montais :colere2: )
    Après avoir modifié mon code et avoir rajouté du code pour savoir ce qui se passe dans mon prog. Mon prog marchait (fonctionnait pour ceux qui prennent les mots au pied de la lettre :p ), mais l'erreur global, après avoir déscendu radicalement, restait la même et cela avant même d'avoir assez descendu...
    Et j'ai découvert (j'ai oublié de mentionné que c'était un réseaux de neurones qui est entrainé pour reproduire la fonction ou exclusif(XOR))) qu'il n'y avait qu'avec les argument FALSE et FALSE (-1 et -1) que ça ne mar... fonctionnait pas.

    Bref, au lieu de me donner cela:
    -1,-1 -1
    -1, 1 1
    1,-1 1
    1, 1 -1

    ça me donne cela:
    -1,-1 -0.0630987 (ce n'est qu'à titre d'exemple,mais ça ressemble tjrs à ça)
    -1, 1 1
    1,-1 1
    1, 1 -1

    Pour ceux qui ont l'envie de fouiller dans mon code et m'aidé.voici mon code source:
    console.zip
    console.rar
    • Partager sur Facebook
    • Partager sur Twitter
      13 octobre 2007 à 14:43:12

      A ta place, j'aurais créé une autre classe 'Neurone', question de décharger 'ann' un peu.
      N'hésite pas à utiliser les conteneurs de la STL.
      • Partager sur Facebook
      • Partager sur Twitter
        13 octobre 2007 à 15:25:24

        C'est vrai que ann est plutôt bien rempli mais une fois que tu l'a créer t'a plus besoin du toucher à grand chose... mais je crois que je vais tout de même esseyer ce que tu dis.

        Je débute en C++ et je ne sais pas c quoi STL o_O . (je n'ai pas le temps tout de suite pour cherhcer il faut que j'aille travailler,alors je te le demande)
        C'est une librairie? (strandard peut-être???)

        Et si tu est assez gentil pourrais-tu me dire (bien m'expliquer) comment utiliser les templates svp (j'ai vu rapidement c'était quoi hier, mais je ne sais pas m'en servir.)
        J'aimerais remplacer mon #define par une template et aussi ce serait pratique pour faire un classe de liste chaîné et d'arbre (grosse job en vue :D ).
        • Partager sur Facebook
        • Partager sur Twitter
        Anonyme
          13 octobre 2007 à 15:41:37

          Citation : M.Psyco

          Je débute en C++ et je ne sais pas c quoi STL o_O . (je n'ai pas le temps tout de suite pour cherhcer il faut que j'aille travailler,alors je te le demande)
          C'est une librairie? (standard peut-être???)

          Oui c'est la bibliothèque (et pas librairie) standard. Quelques liens : http://www.gotapi.com/ccpp - http://www.cppreference.com/ - http://www.cplusplus.com/reference/ .

          Citation : M.Psyco

          Et si tu est assez gentil pourrais-tu me dire (bien m'expliquer) comment utiliser les templates svp (j'ai vu rapidement c'était quoi hier, mais je ne sais pas m'en servir.)

          Mieux vaut que tu fasses une recherche pour savoir ce que c'est, il faudrait un vrai tuto (et pas un simple post) pour savoir ce que c'est.
          • Partager sur Facebook
          • Partager sur Twitter
            13 octobre 2007 à 16:02:16

            SL = Standard Library
            STL = Standard Template Library

            vas voir la FAQ de Developpez
            • Partager sur Facebook
            • Partager sur Twitter
              13 octobre 2007 à 17:00:50

              Bon d'accord je vais chercher sur developpez.com pour les templates...
              Mais mon problème de réseau de neurone n'est tjrs pas corriger... :(

              [Edit] J'avais même pas remarqué que vous m'aviez proposé d'aller sur developpez.com... et je savais même pas que STL étais un lib... une bibliothèque pardon :p de template quand j'aivais demandé de savoir comment se servir des template... Quel hasard... :lol: (pas si drôle...) [Edit]
              • Partager sur Facebook
              • Partager sur Twitter
                13 octobre 2007 à 19:03:11

                Je vois que tu est déjà bien fourni en documentation, je tiens tout de même à ajouter:Un trés bon site, en espérant que tu ne sois pas allergique à l'anglais :D .
                • Partager sur Facebook
                • Partager sur Twitter
                Anonyme
                  13 octobre 2007 à 19:51:11

                  Citation : magnanime

                  Je vois que tu est déjà bien fourni en documentation, je tiens tout de même à ajouter:

                  Un trés bon site, en espérant que tu ne sois pas allergique à l'anglais :D .

                  Tu n'as pas du lire mon post.......... :(
                  • Partager sur Facebook
                  • Partager sur Twitter
                    14 octobre 2007 à 0:09:47

                    La backprop, tous les tutos en parlent, et pourtant ... c'est pas vraiment efficace. On obtient de meilleurs résultats avec d'autres algos -- je ne sais plus si c'est la quick prop, ou la resilient-prop que j'aimais bien, cela fait tellement longtemps que je n'ai plus pratiqué ...

                    Le mieux, c'est de commencer par prototyper ton RdNA pour savoir quelle architecture, et quel algo d'apprentissage sont utilisables avec tes données. Il n'est pas impossible qu'en cours de route tu aies à prétraiter tes données en plus (comment dire que cette phase de pré-traitement est critique).

                    SNNS est (était?) un excellent outil de prototypge (Matlab est pas mal aussi, mais un peu beaucoup très cher si tu n'es pas dans un labo/une boite/une école qui a déjà des licences).
                    Une fois le prototypage passé, tu pourras t'occuper de la mise en oeuvre.

                    Des trucs utiles pour le portage en C++ : des classes vecteur et matrices (mathématiques -> boost.ublas, blitz++, ...), et std::vector pour stocker tes vecteurs (mathématiques) de données d'apprentissage. Si tu sais exprimer ton problème avec des maths, le codage des algos devriendra extrêment plus simple, et sans renoncer aux performances.

                    Si tu as un background mathématique suffisant (i.e. plein de maths à BAC+2 ?), tu as les SVM (weuweuweu kernel-machines point org (si ça existe encore)). Leur avantage, c'est qu'ils fonctionnent en force brute, nul besoin de prétraiter autant qu'avec les RdNAs.
                    • Partager sur Facebook
                    • Partager sur Twitter
                    C++: Blog|FAQ C++ dvpz|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS| Bons livres sur le C++| PS: Je ne réponds pas aux questions techniques par MP.
                      14 octobre 2007 à 1:24:13

                      Tu vois, mon problème est que je n'ai que 15 ans, ça fait 2 jours que je sais comment programmer un réseaux de neurones (et c'est le seul modèle que je sais programmé) et pour l'exprimer mathématiquement c'est encore pire, car je ne vois pas les notions de vecteur, de scalaire et de matrice avant quelque années... (à cause que je n'ai que 15 ans)
                      Par-contre en cherchant sur Wiki j'ai appris les définitions... en gros ce que je sais c'est qu'une matrice on pourrait comparer cela à un tableau (mais qui peut avoir, évidemment, plus de 2 dimensions) et les vecteur je sais que c'est un groupe de deux points et un scalaire je n'ai aucun idées de ce que c'est.

                      Alors pour me servir de biblio de vecteur et de matrice... j'ai quelque peu (juste assez) de dificulté...
                      Une biblio que j'adorerais savoir utiliser c'est la lib standard de liste chaînée.
                      • Partager sur Facebook
                      • Partager sur Twitter
                        14 octobre 2007 à 11:39:38

                        Citation : hiura

                        Citation : magnanime

                        Je vois que tu est déjà bien fourni en documentation, je tiens tout de même à ajouter:

                        Un trés bon site, en espérant que tu ne sois pas allergique à l'anglais :D .

                        Tu n'as pas du lire mon post.......... :(


                        escuse-moi hiura.
                        PS:
                        M.Psyco >> les scalaires sont juste des nombres tels que tu les connais : (1, 2, 5.33, ...).
                        Ou alors des matrices à une case, si tu préfère.
                        • Partager sur Facebook
                        • Partager sur Twitter
                          14 octobre 2007 à 15:04:51

                          Si tu débutes en C++, tu devrais éviter la généricité pour l'instant, concentre toi sur le polymorphisme (quoi que, c'est pas évident non plus ...)
                          • Partager sur Facebook
                          • Partager sur Twitter
                            15 octobre 2007 à 3:06:18

                            Je débute en C++, mais ça fait quatre ans que je programme alors je suis rendu habituer à avoir de nouvelle chose (et je les absorbe comme un éponge) alors je suis correct ak le polymorphisme.

                            J'ai fait un paquet de recherche su les templates et c'est là que je vois les possibilité... J'avais l'intention de faire quelque chose pour pouvoir écrire une fonction qui fonctionne avec plusieurs type (pour ceux qui veulent plus de détails vous n'avez qu'à demander), mais maintenant que je sais que l'on peux le faire ak les templates...
                            Mais d'un autre côté je peux le faire plus simplement ou en tout cas plus flexiblement. (j'aime rajouté des détails aléchant pour piquer votre attention :p )


                            Et merci beaucoup magnanime :D , disons que ça aide ma compréhension de certain article ou tuto ;) . (quand on me parle de qqch que je connais pas pour explique qqch de nouveau pour moi, je comprend tout croche, ou presque :-° )
                            • Partager sur Facebook
                            • Partager sur Twitter
                              15 octobre 2007 à 17:02:28

                              Pour les références j'aime bien le site http://www.gotapi.com qui englobe plusieurs site de références (dont cppreference et dinkumware) dans une interface de navigation simple


                              Ne te sens pas moins capable d'apprendre ce que tu veux dû à ton jeune âge. Les ressources sont là sur le Net pour les "éponges à savoir" ;). Nous sommes aussi là pour ça. Il est certain qu'un réseau neuronal est un concept assez avancé mais il est réalisable en découpant le problème en un maximum de petites parties!

                              Je n'ai pas le loisir de pouvoir regarder ton code mais selon tes commentaires je sens que tu as la bonne façon de penser pour bien programmer. Mais au lieu de voir à grande échelle, débute par un petit problème et ensuite on s'attaquera à un plus gros!

                              Je sais que tu programmes déjà depuis quelque temps mais l'apprentissage d'un nouveau langage nécessite quelques projets assez simple pour bien prendre en main toute les petites caractéristiques du langage et les normes définies par la communauté.


                              Bonne chance compatriote nationaliste :D
                              • Partager sur Facebook
                              • Partager sur Twitter
                              Anonyme
                                15 octobre 2007 à 17:13:38

                                Citation : MatteX

                                Pour les références j'aime bien le site http://www.gotapi.com [...]

                                Mais y a personne qui me lit ou bien. :'(
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  15 octobre 2007 à 18:43:50

                                  Disons que je plussois ton post :D
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    15 octobre 2007 à 21:41:22

                                    Citation : M.Psyco

                                    Tu vois, mon problème est que je n'ai que 15 ans, ça fait 2 jours que je sais comment programmer un réseaux de neurones (et c'est le seul modèle que je sais programmé) et pour l'exprimer mathématiquement c'est encore pire, car je ne vois pas les notions de vecteur, de scalaire et de matrice avant quelque années... (à cause que je n'ai que 15 ans)
                                    Par-contre en cherchant sur Wiki j'ai appris les définitions... en gros ce que je sais c'est qu'une matrice on pourrait comparer cela à un tableau (mais qui peut avoir, évidemment, plus de 2 dimensions) et les vecteur je sais que c'est un groupe de deux points et un scalaire je n'ai aucun idées de ce que c'est.

                                    Alors pour me servir de biblio de vecteur et de matrice... j'ai quelque peu (juste assez) de dificulté...
                                    Une biblio que j'adorerais savoir utiliser c'est la lib standard de liste chaînée.



                                    Un scalaire, c'est un poisson..

                                    Ok -> []
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      15 octobre 2007 à 22:58:37

                                      Citation : M.Psyco

                                      Tu vois, mon problème est que je n'ai que 15 ans, ça fait 2 jours que je sais comment programmer un réseaux de neurones (et c'est le seul modèle que je sais programmé) et pour l'exprimer mathématiquement c'est encore pire, car je ne vois pas les notions de vecteur, de scalaire et de matrice avant quelque années... (à cause que je n'ai que 15 ans)
                                      Par-contre en cherchant sur Wiki j'ai appris les définitions... en gros ce que je sais c'est qu'une matrice on pourrait comparer cela à un tableau (mais qui peut avoir, évidemment, plus de 2 dimensions) et les vecteur je sais que c'est un groupe de deux points et un scalaire je n'ai aucun idées de ce que c'est.

                                      Alors pour me servir de biblio de vecteur et de matrice... j'ai quelque peu (juste assez) de dificulté...
                                      Une biblio que j'adorerais savoir utiliser c'est la lib standard de liste chaînée.


                                      OK. Tu risques de peiner n peu pour comprendre les principes sous-jascents.
                                      Une simple propagation, on peut se la faire à la main, mais ... c'est rustique et facile de faire des erreurs de programmation. Si on regarde le modèle mathématique, une propagation, c'est juste un "O = W . I" -- W étant la matrice de poids entre deux couches, I le vecteur état de la couche entrance, et O le vecteur sortant (et "." la multiplication). Du coup une bibliothèque de calcul matriciel peut être intéressante vu que tout est déjà codé.

                                      Sinon, plein de choses à voir dans la SL.


                                      Citation : hiura

                                      Citation : MatteX

                                      Pour les références j'aime bien le site http://www.gotapi.com [...]

                                      Mais y a personne qui me lit ou bien. :'(


                                      T'inquiète, on s'y fait. ^^
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                      C++: Blog|FAQ C++ dvpz|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS| Bons livres sur le C++| PS: Je ne réponds pas aux questions techniques par MP.
                                        15 octobre 2007 à 23:37:01

                                        Sérieusement, pour ce qui est de l'âge, je ne pense pas que sa pose problème. J'ai aussi 15 ans et j'absorbe tout facilement. Le truc c'est qu'il faut être déterminé, mais tu ne sembles pas en manquer, de détermination ;)

                                        Donc bonne chance à toi avec tes réseaux de neurones :)
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        Anonyme
                                          16 octobre 2007 à 0:16:50

                                          Citation : lmghs

                                          Citation : hiura

                                          Citation : MatteX

                                          Pour les références j'aime bien le site http://www.gotapi.com [...]

                                          Mais y a personne qui me lit ou bien. :'(


                                          T'inquiète, on s'y fait. ^^


                                          C'est réconfortant ? :-° passons. ;)

                                          Un petit tipps en passant pour les intéressés des multiplications : alt250.

                                          Sinon, je dois avouer que tu m'impressionnes! 15 ans et tu arrives à comprendre des choses plutôt complexes! Fortiche. Moi j'y arrivais pas à ce point. Bonne continuation dans ton projet!
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            16 octobre 2007 à 5:00:07

                                            C'est pas l'âge qui me pose problème c'est qu'en math j'avance pas asez vite en classe que ce que je voudrais (mais d'un autre côté ça me permet de mieux maîtriser les notions).

                                            Citation : Mattex

                                            Je sais que tu programmes déjà depuis quelque temps mais l'apprentissage d'un nouveau langage nécessite quelques projets assez simple pour bien prendre en main toute les petites caractéristiques du langage et les normes définies par la communauté.



                                            J'avais déjà des base de POO et je connaisais le vocabulaire (sans nécéssairement savoir ce que ça voulais dire) AVANT de commencer le C. Alors ça aide et peut-être que je débute (2-3 semaines) mais j'ai déjà fait plein de petit prog (pong ak SDL) et je me suis pratiqué en portant des prog que j'avais fais du C, du BASIC ou Assembleur au C++ avant de faire mon réseaux.
                                            J'ai fait (plûtot repris ce code) juste pour me pratiquer (et pouvoir l'utiliser ailleur aussi).


                                            hiura ---->> Sans Mattex je n'aurais jamais connu le site gotapi.com :p ... je blague
                                            par contre, c'est vrai que je n'avais pas vu, mais c'est dû au fait que je ne suis pas aller voir sur les sites... Je me suis contenté de Google et de developpez.com

                                            Et pour revenir à mon prog, ajd j'ai esseyé qqch vite fait. J'ai repris le code original et j'ai fait un classe qui l'utilisait (j'ai eu quelque problèmes d'inclusion :colere2: ), puis j'ai esseyer mon code (rabouté*). J'ai corrigé deux trois erreur simple puis là je me suis retrouvé ak des erreur d'allocation dû au fait que j'avais mis du C dans mon code C++ (à cause de mes problèmes d'inclusion). Je les ai corrigé aussi et quand j'ai esseyer mon code. Il m'a donné la même erreur qu'il avait fait avant que je change quelque chose dans ma première classe (en gros il plante quand il "set" les entrées).

                                            Donc, puisque le code fonctionne parfaitement en C (vraiment parfaitment; la seule chose qui manque c'est un fonction pour qu'il apprenne les modèle "tout seule" question d'allégé le code), j'en ai déduis que le code fait quelque chose qui fonctionne parfaitement en C mais qui nécessite une petite modification pour le C++.
                                            Pour ceux qui veulent un exemple: le malloc qui doit être modifié (cast) ou remplacer par new (mieux) pour ne pas avoir de warning (ou pire :( ) lors de la compilation.

                                            Je vous rappel que ce deuxième code n'étais qu'un test et je n'ai pris qu'un petit 15min. de ma vie pour le faire, alors c'est "normal" que j'ai mit du C dans mon code C++ :-° (avec mon code des méthodes de ma classe(la seule) en plus!! :p ).


                                            *Je voulais mettre un lien vers les expression québecoise sur wiki, mais ils ont supprimer la page.
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                            Anonyme
                                              16 octobre 2007 à 13:04:59

                                              Pour info, j'ai trouvé quelques erreurs dasn ton code et je pense que ça vient de là.

                                              Montre ton code sur le forum, pour qu'on puisse corriger...
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                17 octobre 2007 à 0:14:29

                                                Je n'avais pas mis mon code directement dans le forum car il est un peu long, mais puisque tu le demandes je vais le faire.
                                                Désoler pour le peu de commentaire, mais je ne suis pas du genre à faire des commentaires détaillés et de toute façon ça me force à relire et relire mon code pour le comprendre dans les détails (avec le temps je me suis beaucoups beaucoups amélioré). Et il y a cette page: Backprog pour l'expliquer un peu.

                                                Main:


                                                1. #include <math.h>
                                                2. #include "ann.h"
                                                3. #define T 1
                                                4. #define F -1
                                                5. #define annFloat double
                                                6. using namespace std;
                                                7. int hasard(int min, int max);
                                                8. int main() {
                                                9.     srand(time(NULL));
                                                10.     int tailleCouche[] = {2, 4, 1};
                                                11.     ann reseau(3,(int*)tailleCouche);
                                                12.     int nbr=4;
                                                13.     annFloat entree[4][2] = {  {F,F}, {F,T}, {T,F},  {T,T}};
                                                14.     annFloat sortie[4] = {  F, T, T, F  };
                                                15.     //reseau.apprendre((annFloat**)entree,(annFloat*)sortie,4);
                                                16.     annFloat globalError = 1,sortie_reseau,tmp,erreur;
                                                17.     int i = 0,iter,k,num;
                                                18.     while (globalError > 0.00000001) {
                                                19.         cout<<"error: "<<globalError<<endl;
                                                20.         for (iter=0; iter < 100; iter++) {
                                                21.             num = hasard(1,nbr);
                                                22.             reseau.setEntree((annFloat*)entree[num]);
                                                23.             tmp=sortie[num];
                                                24.             reseau.learnAnn( (annFloat*)&tmp);
                                                25.         }
                                                26.         globalError = 0;
                                                27.         if(i==10000){
                                                28.             for (k=0; k < nbr; k++) {
                                                29.                 reseau.setEntree((annFloat*)entree[k]);
                                                30.                 reseau.getSortie(&sortie_reseau);
                                                31.                 cout<<entree[k][0]<<"  "<<entree[k][1];
                                                32.                 cout<<"  "<<sortie_reseau<<"  "<<sortie[k]<<endl;
                                                33.             }
                                                34.             system("pause");
                                                35.         }
                                                36.         for (k=0; k < nbr; k++) {
                                                37.             reseau.setEntree((annFloat*)entree[k]);
                                                38.             reseau.getSortie(&sortie_reseau);
                                                39.             erreur = sortie_reseau - sortie[k];
                                                40.             globalError += erreur * erreur;
                                                41.         }
                                                42.         globalError /= nbr;
                                                43.         globalError = sqrt(globalError);
                                                44.         i++;
                                                45.      }
                                                46.     for (k=0; k < 4; k++) {
                                                47.          reseau.setEntree((annFloat*)entree[k]);
                                                48.          reseau.getSortie(&sortie_reseau);
                                                49.          printf("entrees: %f et %f, sortie donnee par le reseau: %f, sortie voulue: %f\n",
                                                50.          entree[k][0],entree[k][1],sortie_reseau,sortie[k]);
                                                51.     }
                                                52.     cout<<"---Resultat trouve en "<<i*100<<" iteration"<<endl;
                                                53. }
                                                54. int hasard(int min, int max) {
                                                55.     return (rand() % (max - min + 1)) + min;
                                                56. }


                                                Ann.h


                                                1. #ifndef ANN_H
                                                2. #define ANN_H
                                                3. #define annFloat double
                                                4. static annFloat MAGICAL_WEIGHT_NUMBER = 1.0f;
                                                5. static annFloat MAGICAL_LEARNING_NUMBER = 0.009f;
                                                6. /*
                                                7. static annFloat MAGICAL_WEIGHT_NUMBER = 0.001f;
                                                8. static annFloat MAGICAL_LEARNING_NUMBER = 0.001f;
                                                9. */
                                                10. class ann
                                                11. {
                                                12.     public:
                                                13.         ann();
                                                14.         ann::ann(int nombreCouche, int* taille_Couche);
                                                15.         virtual ~ann();
                                                16.         void ann::getSortie(annFloat *vecteur);
                                                17.         void ann::setEntree (annFloat *vecteur);
                                                18.         void ann::learnAnn(annFloat *desired_out);
                                                19.         void ann::apprendre(annFloat **entree,annFloat* sortie,int nbr);
                                                20.     protected:
                                                21.     private:
                                                22.         annFloat *poidsSynaptique;
                                                23.         annFloat *valeurNeurone;
                                                24.         annFloat *valeurErreurNeurone;
                                                25.         annFloat *neuroneEntree;
                                                26.         annFloat *neuroneSortie;
                                                27.         annFloat *valeurErreurSortie;
                                                28.         int *indexCouche;
                                                29.         int *tailleCouche;
                                                30.         int *indexSynapse;
                                                31.         int nbrCouche;
                                                32.         int nbrNeurone;
                                                33.         int nbrSynapse;
                                                34.         int tailleCoucheEntree;
                                                35.         int tailleCoucheSortie;
                                                36. };
                                                37. #endif // ANN_H


                                                Ann.cpp


                                                1. #include <math.h>
                                                2. #include <iostream>
                                                3. #include <time.h>
                                                4. #include "ann.h"
                                                5. #define annFloat double
                                                6. int hasard(int min, int max);
                                                7. ann::ann(){
                                                8.     //ctor
                                                9. }
                                                10. ann::ann(int nombreCouche, int* taille_Couche){
                                                11.     nbrCouche=nombreCouche;
                                                12.     tailleCouche= new int[nbrCouche];
                                                13.     indexCouche= new int[nbrCouche];
                                                14.     int i;
                                                15.     /*Calcul du nombre de neurones dans le réseau et affection des valeur
                                                16.     du tableu tailleCouche*/
                                                17.     nbrNeurone = 0;
                                                18.     for (i = 0; i < nbrCouche; i++) {
                                                19.         tailleCouche[i] = taille_Couche[i];
                                                20.         indexCouche[i] = nbrNeurone;
                                                21.         nbrNeurone += tailleCouche[i];
                                                22.     }
                                                23.     valeurNeurone = new annFloat[nbrNeurone];
                                                24.     valeurErreurNeurone = new annFloat [nbrNeurone];
                                                25.     tailleCoucheEntree = tailleCouche[0];
                                                26.     tailleCoucheSortie = tailleCouche[nbrCouche-1];
                                                27.     neuroneEntree = valeurNeurone;
                                                28.     neuroneSortie = &valeurNeurone[indexCouche[nbrCouche-1]];
                                                29.     valeurErreurSortie = &valeurErreurNeurone[indexCouche[nbrCouche-1]];
                                                30.     indexSynapse = new int[nbrCouche-1];
                                                31.     /*Calcul du nombre de synpse et affection des valeurs du tableau
                                                32.     indexSynapse*/
                                                33.     nbrSynapse = 0;
                                                34.     for (i = 0; i < nbrCouche-1; i++) {
                                                35.         indexSynapse[i] = nbrSynapse;
                                                36.         nbrSynapse += (tailleCouche[i]+1) * tailleCouche[i+1];
                                                37.     }
                                                38.     /*Allocation de mémoire pour le tableau poidsSynaptique et
                                                39.     affection alléatoire de poids synaptique comprit entre
                                                40.     -MAGICAL_WEIGHT_NUMBER et +MAGICAL_WEIGHT_NUMBER*/
                                                41.     poidsSynaptique = new annFloat[nbrSynapse];
                                                42.     for (i = 0; i < nbrSynapse; i++) {
                                                43.         poidsSynaptique[i] = MAGICAL_WEIGHT_NUMBER * (annFloat)rand() / RAND_MAX - MAGICAL_WEIGHT_NUMBER/2;
                                                44.     }
                                                45. }
                                                46. ann::~ann(){
                                                47.     delete[] tailleCouche;
                                                48.     delete[] indexCouche;
                                                49.     delete[] valeurNeurone;
                                                50.     delete[] valeurErreurNeurone;
                                                51.     delete[] indexSynapse;
                                                52.     delete[] poidsSynaptique;
                                                53. }
                                                54. void ann::getSortie(annFloat *vecteur) {
                                                55.     int i;
                                                56.     for (i = 0; i < tailleCoucheSortie; i++) {
                                                57.         vecteur[i] = neuroneSortie[i];
                                                58.     }
                                                59. }
                                                60. void ann::setEntree (annFloat *vecteur) {
                                                61.     if (vecteur != NULL) {
                                                62.         int i;
                                                63.         for (i = 0; i < tailleCoucheEntree; i++) {
                                                64.             neuroneEntree[i] = vecteur[i];
                                                65.         }
                                                66.     }
                                                67.     int i;
                                                68.     int index_synapse;
                                                69.     index_synapse = 0;
                                                70.     for (i = 1; i < nbrCouche; i++) {
                                                71.         int j;
                                                72.         for (j = indexCouche[i]; j < indexCouche[i] + tailleCouche[i]; j++) {
                                                73.             annFloat sum = 0.0;
                                                74.             int k;
                                                75.             for (k = indexCouche[i-1]; k < indexCouche[i-1] + tailleCouche[i-1]; k++) {
                                                76.                 sum += valeurNeurone[k] * poidsSynaptique[index_synapse];
                                                77.                 index_synapse++;
                                                78.             }
                                                79.             sum += poidsSynaptique[index_synapse];
                                                80.             index_synapse++;
                                                81.             valeurNeurone[j] = sum;
                                                82.             if (i != nbrCouche - 1) valeurNeurone[j] = sinh(tanh(valeurNeurone[j]));
                                                83.         }
                                                84.     }
                                                85. }
                                                86. void ann::learnAnn(annFloat *desired_out) {
                                                87.     int i;
                                                88.     annFloat global_error = 0;
                                                89.     int index_synapse = indexSynapse[nbrCouche-2];
                                                90.     for (i = 0; i < tailleCoucheSortie; i++) {
                                                91.         valeurErreurSortie[i] = neuroneSortie[i] - desired_out[i];
                                                92.         //printf(" %d = %f \n", 7, reseau->valeur_erreur_neurone[7]);
                                                93.         int j;
                                                94.         for (j = indexCouche[nbrCouche-2]; j < indexCouche[nbrCouche-2]
                                                95.              + tailleCouche[nbrCouche-2]; j++) {
                                                96.             annFloat weightChange;
                                                97.             weightChange = MAGICAL_LEARNING_NUMBER * valeurErreurSortie[i] * valeurNeurone[j];
                                                98.             poidsSynaptique[index_synapse] -= weightChange;
                                                99.             if (poidsSynaptique[index_synapse] > 5) poidsSynaptique[index_synapse] = 5;
                                                100.             if (poidsSynaptique[index_synapse] < -5) poidsSynaptique[index_synapse] = -5;
                                                101.             index_synapse++;
                                                102.         }
                                                103.         annFloat weightChange;
                                                104.         weightChange = MAGICAL_LEARNING_NUMBER * valeurErreurSortie[i];
                                                105.         poidsSynaptique[index_synapse] -= weightChange;
                                                106.         if (poidsSynaptique[index_synapse] > 5) poidsSynaptique[index_synapse] = 5;
                                                107.         if (poidsSynaptique[index_synapse] < -5) poidsSynaptique[index_synapse] = -5;
                                                108.         index_synapse++;
                                                109.     }
                                                110.     for (i = nbrCouche - 2; i > 0; i--) {
                                                111.         int j;
                                                112.         int jj= 0;
                                                113.         int index_synapse = indexSynapse[i-1];
                                                114.         for (j = indexCouche[i]; j < indexCouche[i] + tailleCouche[i]; j++,jj++) {
                                                115.             int k;
                                                116.             int index_synapse2 = indexSynapse[i] + jj;
                                                117.             valeurErreurNeurone[j] = 0;
                                                118.             for (k = indexCouche[i+1]; k < indexCouche[i+1] + tailleCouche[i+1]; k++) {
                                                119.                 valeurErreurNeurone[j] += poidsSynaptique[index_synapse2] *
                                                120.                 valeurErreurNeurone[k];
                                                121.                 index_synapse2+=tailleCouche[i]+1;
                                                122.             }
                                                123.             for (k = indexCouche[i-1]; k < indexCouche[i-1] + tailleCouche[i-1]; k++) {
                                                124.                 annFloat weightChange;
                                                125.                 weightChange = 1.0 - valeurNeurone[j] * valeurNeurone[j];
                                                126.                 weightChange *= valeurErreurNeurone[j] * MAGICAL_LEARNING_NUMBER;
                                                127.                 weightChange *= valeurNeurone[k];
                                                128.                 poidsSynaptique[index_synapse] -= weightChange;
                                                129.                 index_synapse++;
                                                130.             }
                                                131.             annFloat weightChange;
                                                132.             weightChange = 1.0 - valeurNeurone[j] * valeurNeurone[j];
                                                133.             weightChange *= valeurErreurNeurone[j] * MAGICAL_LEARNING_NUMBER;
                                                134.             poidsSynaptique[index_synapse] -= weightChange;
                                                135.             index_synapse++;
                                                136.         }
                                                137.     }
                                                138. }
                                                139. void ann::apprendre(annFloat **entree,annFloat* sortie,int nbr/*nombre de modele contenu dans entree*/){
                                                140.     annFloat globalError = 1,sortie_reseau,tmp;
                                                141.     int i = 0,iter,k,num;
                                                142.     while (globalError > 0.00000001) {
                                                143.         std::cout<<"error: "<<globalError<<std::endl;
                                                144.         for (iter=0; iter < 100; iter++) {
                                                145.             num = hasard(1,nbr);
                                                146.             setEntree((annFloat*)entree[num]);
                                                147.             tmp=sortie[num];
                                                148.             learnAnn( (annFloat*)&tmp);
                                                149.         }
                                                150.         globalError = 0;
                                                151.         for (k=0; k < nbr; k++) {
                                                152.             setEntree((annFloat*)entree[k]);
                                                153.             getSortie(&sortie_reseau);
                                                154.             annFloat erreur = sortie_reseau - sortie[k];
                                                155.             globalError += erreur * erreur;
                                                156.         }
                                                157.         globalError /= nbr;
                                                158.         globalError = sqrt(globalError);
                                                159.         i++;
                                                160.      }
                                                161.     for (k=0; k < 4; k++) {
                                                162.          setEntree((annFloat*)entree[k]);
                                                163.          getSortie(&sortie_reseau);
                                                164.          //printf("entrees: %f et %f, sortie donnee par le reseau: %f, sortie voulue: %f\n",
                                                165.          //entree[k],entree[k],sortie_reseau,sortie[k]);
                                                166.     }
                                                167.     std::cout<<"---Resultat trouve en "<<i*100<<" iteration"<<std::endl;
                                                168. }



                                                Je sais que le code n'est pas clair, mais c'est dans mon intention de l'éclaircir un peu...
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                Anonyme
                                                  17 octobre 2007 à 8:50:51

                                                  petite question: pourquoi tu n'inclues pas ann.cpp dans le main ?
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    17 octobre 2007 à 10:20:52

                                                    Citation : damien73

                                                    petite question: pourquoi tu n'inclues pas ann.cpp dans le main ?

                                                    Parcequ'il a inclut le header, le fichier contenant le prototype des fonctions "ann.h"
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    Si vous aimez quand ça coupe --> http://lcdd.stass.eu
                                                    Anonyme
                                                      17 octobre 2007 à 10:42:46

                                                      Et parce qu'on inclut jamais les sources, toujours les headers.
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        18 octobre 2007 à 1:25:41

                                                        Pour répondre à damien73, tu n'as pas besoin de l'inclure (en fait tu ne devrais pas), car de la façon que ça fonctionne, le compilateur cré un fichier binaire (qui diffèrent selon la sorte de mircoprosseceur que tu as, la plupart du temps c'est dans la famille des x86). Puis le linker (éditeur de lien), s'occupe de mettre l'adresse des fonction externes du "main.cpp" et de s'occuper que l'appel se fasse de la bonne façon (il y a plusieurs façon de le faire) et pour cela il a besoin d'avoir le prototype.

                                                        p.s. Je ne suis pas totalement sur de l'ordre ou de si c'est le linker qui s'occupe de la manière dont est appelé les fonctions, mais en tout cas, il n'a besoin que des prototypes. Les fonction qui sont dans un autre fichier seront compiler dans un autre fichier binaire (fichier objet que l'on appel (*.o ou *.obj)).
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                        Anonyme
                                                          18 octobre 2007 à 12:42:59

                                                          Citation : M.Psyco

                                                          Pour répondre à damien73, tu n'as pas besoin de l'inclure (en fait tu ne devrais pas), car de la façon que ça fonctionne, le compilateur cré un fichier binaire (qui diffèrent selon la sorte de mircoprosseceur que tu as, la plupart du temps c'est dans la famille des x86). Puis le linker (éditeur de lien), s'occupe de mettre l'adresse des fonction externes du "main.cpp" et de s'occuper que l'appel se fasse de la bonne façon (il y a plusieurs façon de le faire) et pour cela il a besoin d'avoir le prototype.

                                                          p.s. Je ne suis pas totalement sur de l'ordre ou de si c'est le linker qui s'occupe de la manière dont est appelé les fonctions, mais en tout cas, il n'a besoin que des prototypes. Les fonction qui sont dans un autre fichier seront compiler dans un autre fichier binaire (fichier objet que l'on appel (*.o ou *.obj)).



                                                          Je vais revoir mon cours.....
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            25 octobre 2007 à 5:33:23

                                                            Bon, il ne se passe pas grand chose et mon problème n'est toujours pas règlé (je n'ai pas travailler beaucoup dessus recemment, j'avais des exam et de projet en retard à remettre). Alors je mets ce poste Pour le remettre dans la première page quelque temps et si ça n'avance pas plus alors je vais continué tout seul malgré tout.
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter

                                                            Prob de Réseau de neurones

                                                            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                            • Editeur
                                                            • Markdown