Bonjour,

Je contactes la communauté car j'ai quelques soucis sur mon projet : Les réseaux de neurones.

Comme aucun code n'est "intelligent" en lui même (en tous cas en C++), j'en ai déduit que le problème venait du développeur : moi.

Il faut savoir que le réseau de neurones que je comptes faire, c'est un réseau très basique : un réseau Feed Forward.

La première étape de cette conception, à été de clarifié qui est qui, j'ai put en faire un diagramme sur un exemple simple : la fonction XOR.

Les explications :

• O(i) : c'est une matrice de l'output de la couche i
• W(i) : c'est une matrice des weights de la couche i
• B(i) : c'est une matrice des bias de la couche i

Selon internet : O(i) = sigmoïd( W(i) * O(i-1) + B(i) est la fonction pour demander a la couche i (!=0) ce qu'elle "pense"

C'est la formule que j'ai appliqué sur mon réseau a partir de la couche 1 à la couche 2 (dans cet exemple)

En ce qui concerne l'apprentissage, j'en ai déduit que dans mon réseau, il faudra faire :

// calcul de l'erreur initiale
Error = Target - Output ;

// boucle principale
for(int i(NetworkSize) ; i > 1 ; i--){
    // calcul du gradient
    Gradient = hadamard(d_sigmoïd(Layer[i]), Error) * learningRate ;

    // calcul des nouveaux parametres
    Weight[i] = Weight[i] + ( Gradient * Layer[i-1] ) ;
    Bias[i] = Bias[i] + Gradient ;

    // calcul de l'erreur de la couche précédente
    Error = Weight[i].transpose() * Error ;
}

Malheureusement, l'apprentissage ne fonctionne pas. J'ai fais des mesures de performances d"erreurs, et il se trouve que le réseau n'arrive pas a diminuer l'erreur avec mes 4 exemples de la fonction XOR

Pour chacun des 10 000 entrainements je prends l'erreur de mes 4 exemples avec le réseau entrainé avec un des 4 cas de la fonction XOR

Le problème, c'est que mon erreur devrait tendre vers 0 avec tous ces entrainements, mais visiblement, au bout de 10 000 entrainement, le réseau dit qu'il y a, a peu près, autant de chance que la sortie soit un 1 ou un 0 a n'importe quel exemple donné en paramètre.

Vous pouvez trouver com code ici

Merci d'avoir lu

-
Edité par >KryptOs_ 26 février 2018 à 11:07:42

Bonjour, ta descente de gradient est étrange , elle devrait ressembler a ça pour une sigmoïde,

pour le calcul de l'erreur de chaque poids (sauf sortie) attribuer au neurones cachées

delta=fn-1(x)*(1-fn-1(x))*somme(w*fn(x))

pour la sortie l'erreur est (sortie unique)

delta=Yattendu-Yresultant

puis faire pour la mise a jour

W(i)=W(i)*facteur_progress*O(i+1)*delta

pour une sigmoïde
ou x est la valeur passé a ton neurone avant d'affecter la fonction d'activation qui dans une retro-propagation est la dérive de celle-ci, biais compris, soit ton x=W(i) * O(i-1)+ B(i)

ensuite tes neurones cachées doivent avoir un biais chacun, pas le même, et celui ci peut aussi être modifié dans l'apprentissage (pas obligatoire)

pour mieux comprendre je te conseil la vidéo de ce canadien lien

10000 itération attention au sur-aprentissage, code un algo qui décidera d’arrêté ton apprentissage pour une erreur mini

-
Edité par Matheau85gyque 27 février 2018 à 21:47:56

Bonjour, et merci !

Pour ce qui est du au sur apprentissage, je ne me fais pas de soucis car tous les exemples capables d'être demandés sont des exemples d'apprentissage. Mais je vois quels problèmes ça engendrerais de trop entrainer son réseau (reconnaissance des exemples uniquement).

Ici je travaille avec des matrices, et surtout avec une notation totalement différente que dans ta vidéo. J'ai pu néanmoins vérifier ma formule d'apprentissage, elle est juste. J'essaye de passer toutes ses opérations en opérations matricielles. J'ai pu observé qu'il fais sa backpropagation en deux temps et apparemment il pourrait le faire en une seule fois.

Je ne comprends pas vraiment tes formules. Qu'est-ce que fn ?

Matheau85gyque a écrit:

W(i)=W(i)*facteur_progress*O(i+1)*delta

x=Somme(W(i) * O(i-1))+ B(i)

-
Edité par Matheau85gyque il y a environ 4 heures

Je n'ai pas compris tes deux formules.

Dans la première, j'ai l'impression qu'il manque un W(i) a moins que ton facteur_progress soit plus grand que 1 ?

Dans la deuxième, je ne voit pas du tout ce que tu veux dire par Somme().

Dans le livre Make your own neural network de Tariq RASHID, on nous explique comment simplifier l'expression de propagation des erreurs. De cette première expression à la deuxième, l'expression simplifiée

Merci de ta réponse.

-
Edité par >KryptOs_ 24 mars 2018 à 18:10:15

fn est la fonction d'activation donc fn(x) reviens a un neurone pour toi un O(i) mais je suis pas habituer a l’écriture matriciel; pour le Somme()  c'est pour visuellement voir qu'on est sur une somme pondéré des neurone par les poids sans prendre en compte la sigmoïde (la encore je me suis perdu avec ton écriture matricielle) ton écriture est bonne. Et oui il manque un W(i) car c'est la formule du deltaW(i) en faite. Si tu est sur de tes formules c'est que ça viens soit de la structure de ton réseaux (peut probable avec un apprentissage) soit de ta programmation

edit : pour debugé essai de n'apprendre que un exemple et si l'erreur diminue sur celui-ci ton apprentissage a un probleme avec plusieurs exemple qui s’annule les un les autres

-
Edité par Matheau85gyque 26 février 2018 à 20:03:05

Bon j'ai trouvé. pour faire simple un exemple en annule bien un autre, essai de lui faire apprendre que trois exepmle ou que deux et il convergera bien,du coup pour recoudre le xor il faut pas présenté les exemples dans l'ordre classique, en effet un 0.0 est annulé par un 0,1 et un 1,0 par un 1,1, voila pourquoi ton réseau converge vers des erreur d'incertitudes, ce problème ce résolve si tu met un biais par neurone caché et par sortie et que tu met a jour ceux ci de la même manière que les poids, perso avec les biais mis a jour je converge bien mes erreurs vers 0 dans tout cas

-
Edité par Matheau85gyque 28 février 2018 à 13:22:32

Bonjour,

Tout d'abord, excuse moi de ne pas avoir répondu dans l'immédiat et par conséquent de ne pas avoir pu te remercier. Merci pour ton aide .

J'ai beaucoup réfléchis ces vacances, et j'ai émis plein d'hypothèses. J'ai eu pas mal de fausses hypothèses, mais je crois avoir trouver une anomalie dans mon code.

En effet, lorsque j'ai eu envie de voir le stade de mon réseau - état des biais, et des poids - je trouves que ma propagation se fais très mal a l’intérieur de mon réseau.

Sur cette image, on voit la différence entre l'initialisation du réseau de façon random à gauche, et le réseau entrainé a droite.

A première vue : "Oui, il apprends bel et bien : les paramètres du dernier neurone sont significativement différent !". Mais il suffit de relever le nez pour constater que les valeurs de chaque neurones se rapprochent de la valeur initialisée random.

La question ne se pose pas : j'ai un problème de propagation, mais lequel ? Je n'arrive pas à identifier quel est le problème car il n'y a aucune variable liée à la façon dont l'information se propage dans mon réseau. Le learning_rate est un paramètre qui agit uniquement sur la façon dont le réseau entier réagit à l'apprentissage, non ?

-
Edité par >KryptOs_ 21 mars 2018 à 16:42:21

Salut,

Juste un petit truc concernant la manière dont tu défini tes neurones dans ton fichier :

Tu devrais t'assurer que chaque terme est clairement unique, d'autant plus que tu lui donne une forme proche du XML...

Comme tu donnes deux valeurs (différentes!!!! ) pour weight, tu risques d'introduire un conflit de très mauvais aloi au moment de récupérer les informations qui se trouvent dans ton fichier; surtout si tu te base sur le terme utilisé avant le caractères = pour déterminer la donnée décrite

Tu aurais donc très certainement intérêt à utiliser des termes clairement différents pour représenter chacune des données de tes neurones ( quitte à ce que ce soit weight1 et weight2, et à ce que tu décide clairement à quoi chacun de ces termes correspond ), car, tu n'as pas fourni le code qui permet d'extraire les données de ton fichier, mais je suis presque sur que si tu observe les données représentées à l'intérieur des matrices de poids à l'aide de ton debugger, tu verras qu'il en manque à peut de chose près la moitié (voire, qu'une matrice de poids est carrément vide )

-
Edité par koala01 23 mars 2018 à 1:23:55

Bonjour,

Merci pour tes conseils, je vais directement modifier tout ça. Je n'ai jamais fais de XML, j'ai essayer de me baser sur le langage HTML pour ranger mes éléments. J'ai codé cette sauvegarde rapidement car je voulais simplement voir ce qu'il se passe à l’intérieur. Au début je voulais me servir du fait que le premier weight apparait avant le deuxièmme. Je vais me renseigner sur ce langage, pour mettre mon stockage à jours vis à vis des normes...

Malheureusement la même question me revient à l'esprit : pourquoi ma propagation à du mal à agir sur les neurones de couches précédentes ?

Et la question reste toujours la même: commence par vérifier dans ton débuggeur si tes neurones et tes liens sont correctement représentés...

La très grosse majorité des problèmes, quand ils ne sont pas dus à un utilisateur qui introduit une connerie, sont dus à une donnée mal comprise ou mal interprétée par ton application.

La lecture incorrecte ou la mauvaise interprétation des données lors de leur récupération depuis "une source extérieure" (un fichier, dans le cas présent) est donc en excellente position pour être une candidate de choix à la raison qui provoque ton problème

Le débuggeur (que tout bon développeur C++ devrait être capable d'utiliser correctement) est l'outil par excellence qui permet de confirmer les soupçons que je fais poser sur la manière dont tu récupères tes données depuis ton fichier.

Car, pour l'instant, je ne peux pas faire grand chose d'autre, vu que j'ignore tout de la manière dont tu les as récupérées

Mais, si tu nous montrais le code que tu as utilisé pour récupérer les données depuis ton fichier, nous pourrions surement en dire bien plus

Apparemment, un petit point s'impose.

Mon réseau à un problème de rétro-propagation. J'ai essayé de trouver le problème en essayant de voir à l'intérieur de mon réseau, j'ai donc rapidement coder une fonction de sauvegarde 

Les étapes dans mon main sont :

Créer le réseau et l'initialiser de façon random

Mettre l'état du réseau dans un fichier

Entraîner le rèseau avec les exemples XOR (×10 000)

Mettre l'état du réseau dans un autre fichier

Donc je n'ai pas de récupération de données dans un fichier.

La liaison entre les couches sont justes car, dans le cas contraire, le réseau ne serai pas en mesure de produire une sortie 🤔

-
Edité par >KryptOs_ 24 mars 2018 à 18:03:58

essai de débuger sur ta retro propagation alors, et regarde si ton algorithme fait bien sont taf, sinon essai ton algorithme sur papier, vérifie paramètre par paramètre vérifie que ton erreur est bonne, en sortie , que tes delta suive bien la retro propagation ,...

et surtout essai tout sa sur l'apprentissage d'une simple fonction AND plus simple que le XOR pour débugé

-
Edité par Matheau85gyque 30 mars 2018 à 22:23:39