Discussion :

[RedSkidy]

Bonjour,
je m'intéresse depuis peu aux réseaux de neurones et j'aimerais en créer un pour de l'analyse d'image (détection de visage par exemple). j'ai a peu près tout compris sauf une chose et pas des moindres : lors d'une convolution, on passe un filtre sur l'image pour chaque pixel, il faut plusieurs filtres différents qui vont générer chacun une nouvelle image, puis on réduit leur taille (max-pooling) et on recommence pour chaque nouvelle image avec d'autres filtres. mais la question c'est : Comment faire pour qu'il apprenne automatiquement les bon filtres a utiliser ? Pour la partie analyse finale a coup de neurones, il suffit de modifier les poids des connexions en fonction de l'erreur calculée mais pour les filtres ? on peut pas se baser sur l'erreur vu que le réseau de neurone n'est pas entraîné, et on peut pas entraîner le réseau de neurones si de toute façon les filtres par défaut sont inutiles... si ?
merci d'avance.

[ToTo13]

En fait si :-)
Dans une couche de convolution, chaque map (aussi appelé feature map) a son propre noyau de convolution. Chaque noyau est initialisé aléatoirement au début, puis il est entrainé normalement, car chaque poids du noyau s'entraine comme un neurone.
Gros détail lors de l'entrainement d'une couche de convolution. Le noyau étant appliqué à toute la map, l'erreur est donc calculée en fonction de TOUT les neurones de la map, il faut donc la bufferiser.

[RedSkidy]

donc ça s’entraîne comme un réseau multi-couche normal (back-propagation) ? c'est ce que je j'espérais mais ça me paraissait un peu trop beau pour être vrai comme solution...
est-ce qu'il y a un endroit ou je pourrais trouver un bon tuto là dessus ? parce que tous ceux que j'ai trouvé c'était "alors en fait c'est très simple il suffit de calculer l'erreur et de la propager dans tout le réseau, et pour ça : *math* *math encore plus compliqué* *fonction cost* *dérivée partielle* *un peu plus de math*..." et a 16 ans... j'ai clairement pas le niveau en math, après si je comprend le principe ça va mais les formules brutes ça m'aide pas trop .
en tout cas merci beaucoup pour cette réponse

[ToTo13]

Alors les réseaux de neurones c'est math, math, math encore plus compliquées, voire encore plus compliquées et pour finir math.
Et non, je ne connais pas de tuto abordable sans mathématiques.
Garde bien en tête que les poids du kernel entrainable de chaque map d'une couche de convolution, s'applique à toute les maps de la couche précédente et concernent tout les neurones de la map à laquelle ils appartiennent. Donc c'est une énorme convolution sur toutes les maps de la couche précédente.
Donc lors de la back-propagation, chaque neurone de la map va recevoir une multitude d'erreurs. Il faut sauver toutes ces erreurs, jusqu'à ce que toutes les erreurs aient été sommées. Ce n'est qu'à ce moment là que tu mets à jours les poids.

[RedSkidy]

merci pour ta réponse.
ça fait 2 jours que j'essaye de comprendre et je crois que j'ai a peu près compris :
-on part des sorties et on compare avec la sortie attendue (simple soustraction ?)
-on augmente ou diminue le poids des connexions en fonction de leur participation a l'erreur. une chose que j'ai pas compris : imaginons qu'on ait 2 valeurs a et b en entrée et une sortie s. si on attend s = 0, que a = 1 et b = -0.6. comment peut-on savoir si il faut réduire le poids de a ou augmenter celui de b ou a quel point il faut changer le poids de chacun ? ça ce fait par le calcul ? (je vois pas comment) y'a une règle du type on change en priorité les poids dont la valeur absolue est la plus faible/plus forte ? plus l'écart avec la valeur attendue est grand plus on change ?
- après ça on obtiens la sortie attendue pour l'avant dernière couche. on fait les calculs a l'envers pour obtenir les entrées qui aboutissent a cette sortie (j'ai cru comprendre qu'il y avait besoin d'une dérivée quelque part, c'est ici ?)
-les entrées attendues a une couche sont les sorties attendues a la couche précédente, on peut donc répéter le processus jusqu'au début du réseau.
- quand on arrive a la partie convolution, on considère les kernels comme des groupes de neurones, on refait alors une convolution en calculant cette fois non pas la valeur des pixels de l'image de sortie (feature map) mais l'erreur entre ceux-ci et la valeur attendue calculée précédemment.
-on répète jusqu'à la fin.
dernière question : comment s'y prendre avec le pooling ?
merci beaucoup.

[ToTo13]

Avant de t'attaquer à un CNN, intéresse toi simplement à un réseau de neurones de type "fully connected", c'est bien plus simple à développer. Teste le ensuite sur les problèmes XOR et Double Spirales.

Oui il y a des dérivés lors de la mise à jour des poids, c'est comme ça que fonctionne la rétro-propagation (back-propagation en anglais), c'est une descente de gradients. Si tu ne comprends pas les dérivées (qui sont vues en 1ère S/ES, du moins à mon époque), il faut alors que tu regardes le code d'une librairie existante.

Et pour le calcul de l'erreur au niveau de la couche de sortie, ça peut être une simple soustraction, mais il y a des dizaines de fonctions différentes.

[RedSkidy]

C'est par là que je voulais commencer en effet mais d'abord je voulais bien avoir tout compris pour bien savoir dans quoi je me lançait...
J'ai donc commencé un réseau simple (FC) et j'ai fini la partie "feedforward" (j'utilise OpenCL et j'apprend a m'en servir au passage d'où le temps de réponse)
j'en suis maintenant a la partie backpropagation et j'arrive toujours pas a comprendre les différents tutos...
C'est pas explicable par du texte ? genre : "on prend la dérivée de tel fonction en x et on multiplie par x-y puis on fait pareil a la couche d'après" parce que tout ce que j'ai vu c'est des gros tas d’équations avec des notations que je connais pas...

EDIT : Bon j'ai réussis a trouver a tuto pas trop mal expliqué et voilà ce que j'ai compris : (source : https://mattmazur.com/2015/03/17/a-s...ation-example/)
si on a un neurone de sortie :
- 2 entrées i1 et i2
- le poids des 2 entrées w1 et w2
- une valeur de sortie O
- une valeur de sortie attendue T
- en utilisant une fonction de seuillage tanh (tangeante hyperbolique)

On ajoute une variable R pour le taux d'apprentissage (0.3 ou 0.5 par exemple)
On note D = -(T-O)*(1-O²)
les nouvelles valeurs a donner à w1 et w2 sont :
w1+ = w1 - i1*D*R
w2+ = w2 - i2*D*R

après ça on additionne les valeurs de D pour chaque neurone de la couche de sortie multiplié par le poid de la connexion au neurone, le résultat est stocké dans la variable S
on remplace maintenant le "-(T-O)" de la formule par S pour toute les couches suivantes (ou plutôt précédentes du coup)
D = S*(1-O²)

est-ce que c'est bien ça ?

[ToTo13]

Je n'ai plus les formules en tête, mais tu pourrais être intéressé pour cet exemple pas à pas.

[RedSkidy]

C'est la source que j'avais cité pour les formules mais merci quand même x)

[ToTo13]

Oups, désolé :-(
Je me rappelle l'avoir suivi lorsque j'avais développé mon propre RdN.
Mais il y a tellement de couches différentes que je préfère utiliser les librairies existantes.

[RedSkidy]

C'est sûr que utiliser des bibliothèques c'est plus simple mais j'aime bien faire les trucs bas niveau comme ça je suis sais comment ça marche a l’intérieur, ça permet d'apprendre (j'ai appris les bases d'OpenCL par exemple) et si c'est bien fait ça peut même être plus optimisé. (bon après faut être fort pour dépasser des bibliothèques pros...)