Discussion :

[BioKore]

Bonjour à tous,

Alors voilà, je compte essayer de programmer une couche de convolution en C++, mais les sources que je trouve sur le sujet me paraissent trop légères (haut niveau).
Je comprends bien le fonctionnement des filtres, comment est établi la "features map", les raisons pour lesquelles on ajoute du padding etc... MAIS ! Je ne vois pas du tout où interviennent nos neurones dans cette couche, et je me demande même si, dans le noyau de convolution en lui-même, on a des neurones....

Souvent les sources que je trouve s'arrêtent là et partent de suite sur la résolution d'un problème simple via les bibliothèques que l'on trouve pour python, mais n'expliquent finalement en rien comment est réalisée plus profondément la couche de convolution.

Une idée de l'architecture "réelle" de ce genre de réseaux ? Ou sinon, un lien vers une source expliquant le fonctionnement plus loin que l'obtention des features map via l'application de filtres sur une image (les additions et multiplications, je connais, ça va ) ?

Merci d'avance.

[dourouc05]

De ce que j'en ai compris (ne prends pas ce que je dis pour parole d'évangile, s'il te plaît ), appliquer une convolution est l'équivalent d'un neurone : tu remplaces le vecteur de paramètres par la matrice de convolution (plutôt le tenseur, mais passons), tu as un petit paramètre de biais, tu appliques ta fonction d'activation sur chaque couche de chaque pixel indépendamment (sans cette fonction d'activation, pas besoin de plusieurs couches, puisque la convolution est une opération linéaire).

[BioKore]

Bonjour,

Merci pour ce retour ! Bon, ça ne m'explique pas tout effectivement, mais au moins, on pense la même chose ! Chaque "pixels" issus du tenseur de sortie de la couche de convolution en elle-même correspond alors à la valeur agrégée que doit prendre en considération un neurone (ou alors, comme tu le dis, à la sortie directe d'un neurone à activation linéaire à part entière). Donc : un filtre appliqué à une partie de l'image nécessite alors un seul neurone. On est donc proche, finalement, à la différence près des poids qui sont partagés, d'une couche partiellement connectée. Je dirais même qu'il s'agit d'un cas particulier de couche à neurones partiellement connectés.

Si je prends donc pour parole d'évangile ce que tu viens de me dire (), je commence alors à percevoir comment implémenter la chose, même si rien n'est fait et que cela ne veut pas dire pour autant que ce sera facile pour moi.... J'avance un peu !

Reste donc la question de la rétro-propagation..... Pour une feature particulière, on va donc avoir X poids dont chacun doit être mis à jour avec des valeurs de différents deltas ! Comme ça, à froid, je serais d'avis de moyenner ces deltas, mais j'ai peur que l'on perde en précision de cette manière non ?

D'autres avis sur le sujet ?

Merci d'avance !

[dourouc05]

La rétropropagation me semble aussi un peu magique ici, mais je ne l'ai pas étudiée en détail… As-tu vu https://pdfs.semanticscholar.org/5d7...9124e5dcd1.pdf ?

[BioKore]

Non, c'est a première fois que je vois ce document là. Pour être honnête, mes dernières recherches concernent plutôt l'apprentissage par renforcement en ce moment, mais je me permet d'étoffer ma bibliothèque "neuronale" en parallèle ; ça me sera très utile par la suite. J'ai donc finalement peu de ressources sur le sujet des couches de convolution.

Donc merci pour cette source, je vais voir si ce document répond en partie à mes questions.

[BioKore]

Alors,

Après avoir analysé un peu ton document, et avoir trouvé une série vidéo d'initiation (assez intéressante tout de même) aux réseaux de convolution de Andrew Ng, même si tout le monde connaît je pense), voici ce que j'en tire :

- Notre vision des choses concernant l'élaboration des features map via la propagation est la bonne, à la différence qu'il s'agit en fait plutôt d'un "cross-correlation" que d'une vrai convolution, qui nécessite, elle, une rotation des filtres (un peu comme les réseaux de notre cerveau !). Mais, compte-tenu des circonstance, un abus de langage sur ce terme est courant et les couches de convolution que l'on trouve dans les bibliothèques "standards" font fi de cette rotation. Donc on est bon ! Si j'arrive à l'implémenter sans, ce sera déjà un énorme pas pour moi --> ne pas oublier que cette rotation doit intervenir en sens inverse lors de la rétro-propagation entre deux couches de convolution d'ailleurs ; il ne s'agit pas simplement de présenter les filtres à l'envers).

- sur la rétro-propagation justement, ton document me semble traiter là chose comme pour un réseau partiellement connecté (et présente d'ailleurs les fameuses rotations !) ; les poids partagés sont donc remis à jour autant de fois qu'il y a de neurones. Cependant, ce que j'en pense, c'est que l'impact importe peu. En réalité, l'erreur d'activation du neurone est proportionnelle à la valeur des inputs d'entrée. Il va donc de soi que les dérivées multipliées par les entrées sont proportionnelles aussi ! En gros, si un filtre appliqué sur un champ donné affiche une grosse erreur, et sur un autre champ une erreur moins grande, la mise à jour des poids sera équivalente entre les deux. Nous convergerons donc nécessairement vers les mêmes poids, et donc vers la même feature. Mais tout ça mérite d'être confirmé ! Ce n'est que MON interprétation du sujet...

Néanmoins, il n'en reste pas moins un autre sujet obscure (mais que j'approfondirais plus tard) : comment s'assurer que les différents filtres que l'on va appliquer à notre tenseur d'entrée sont bien tous différents ? Évidemment, l'initiation de tous les poids de manière aléatoire réduit un peu le risque mais pas entièrement je pense.... Ce serait bête de perdre en performance 1) de temps d'apprentissage et 2) de généralisation sur une telle erreur.... D'où l'importance, je pense, de visionner de temps à autres les valeurs des filtres appris.... A creuser mais bon.



Bref, je vous laisse réagir sur le sujet ; qu'en pensez-vous ? De mon côté je vais tâcher de dégager un peu de temps pour l'implémentation de tout ça.... Mais j'ai peur que ça me bouffe le peu de temps que je peine à consacrer au problème de l'apprentissage par renforcement


Merci !

[Matthieu76]

Pour faire très simple une couche de covolution c'est ça :

• I sont les entrées de ta couche (7*7 = 49 entrées)
• K est la le nombre de poids par neurones (ici 9) En faite chaque valeur de ta matrix de convolution est un poids de ton neurone. Cela permet au réseaux de neurones de faire sa propre transformation d'image en créant ses propes filtres.https://en.wikipedia.org/wiki/Kernel_(image_processing)
• I*K est le nombre ne neurons sur ta couche convolution (5*5 = 25 neurones)
• I*K*K est le nombre total de poids sur ta couche de convolution ( 25*9 = 225 au lieu de 49*25 soit 1225 pour une couche "classique" full connectée)

Au lieu que ton premier neurones soit connecter au 49 inputs de ta couche, il n'est connecter qu'aux 9 premiers puis tu décales de 1 à chaque fois.
Tu ne change rien au code de ton neurones ni au code de ta backpropagation, juste aux connections.

PS : Pour la MNIST, une matrix de 3*3 c'est trop petit et ça va juste revenir à pixeliser ton image d'entrée, si tu veux une vrai convolution utilise plutôt du 5*5 ou 6*6.

Tiens voici ce que propose TensorFlow comme Achitecture : https://www.tensorflow.org/versions/master/tutorials/layers

Let's build a model to classify the images in the MNIST dataset using the following CNN architecture :

• Convolutional Layer #1: Applies 32 5x5 filters (extracting 5x5-pixel subregions), with ReLU activation function (uniquement si tu n'as pas centrée tes données en 0)
• Pooling Layer #1: Performs max pooling with a 2x2 filter and stride of 2 (which specifies that pooled regions do not overlap)
• Convolutional Layer #2: Applies 64 5x5 filters, with ReLU activation function
• Pooling Layer #2: Again, performs max pooling with a 2x2 filter and stride of 2
• Dense Layer #1: 1,024 neurons, with dropout regularization rate of 0.4 (probability of 0.4 that any given element will be dropped during training)
• Dense Layer #2 (Logits Layer): 10 neurons, one for each digit target class (0–9).

Je savais pas non plus mais pour info une couche de pooling c'est ça:

Une simple pixellisation basique mais avec des neurones...

[Rbender]

Un schéma de mon cru pourra peut être t'aider à visualiser. Ici je représente une couche de convolution sans padding avec un filtre 3X3.



Dans une couche de convolution certains poids sont fixé à 0 et certains poids sont partagé par plusieurs arrêtes/synapses. En gros c'est une reparamétrisation d'une couche classique qui tente d'utiliser la structure particulière d'un signal (image, son, etc), cette structure particulière est du à la continuité sous jacente des signaux observé (les pixels proches contiennent la même information sur une image, des pixels éloigné contiennent des informations presque indépendante).

Les couche de convolution permette une invariance par translation et une réduction colossal du nombre de paramètres à apprendre. Pour plus d'info je te conseil de lire "Gradien Based Learning Applied to Document Recognition" du fameux Yann Lecun (article fondateur des CNN) et plus particulièrement la partie sur les couche de convolution page 6.

[BioKore]

Bonjour,

Merci pour cette illustration. Il est vrai que je n'ai pas mis le post en "résolu", mais en ce qui concerne la propagation du réseau, je pense avoir avoir compris le fonctionnement.
D'ailleurs, je préfère insister sur ce sujet si d'autres cherchent à comprendre le fonctionnement de la convolution, dans ton cas, il ne s'agit que d'un seul filtre ! En effet, un seul filtre demande malgré tout plusieurs neurones. Par exemple, sur une image 9 * 9 de 1 dimension (niveau de gris par exemple), avec un seul filtre 3 * 3 sans padding et avec un stride de 3 (horizontal et vertical), nous aurons alors 4 neurones.

De même, je pense avoir compris le fonctionnement de l'apprentissage d'un tel réseau. Ce dernier ne diffère d'ailleurs pas de l'apprentissage par rétro propagation du gradient d'erreur que l'on peut retrouver sur un réseau feed-forward classique. En effet, de cette manière, avec un filtre initialisé aléatoirement, via l'apprentissage, nous forçons ce dernier à s'adapter à la caractéristique la plus proche de son initialisation aléatoire initiale. C'est donc pour cette raison que, sur plusieurs filtres initialisés aléatoirement, au final, chacun se spécialisera dans la détection d'une caractéristique particulière au fil de l'apprentissage.

Enfin, j'ajouterais que, si la popularité d'un tel système tient à son biomimétisme ainsi qu'à l'optimisation apportée par rapport à un réseau entièrement connecté, ce dernier type de réseau apporte au moins 4 hyper-paramètres en plus si ce n'est plus (je dois me renseigner plus sur ce sujet).

Maintenant, tout ce que je viens d'expliquer est la simplification de ce que j'ai pu comprendre moi même. Si j'ai tout faux ou que certains points sont à développer de manière plus compréhensible, n'hésitez pas à me le faire savoir.

[Matthieu76]

ce dernier type de réseau apporte au moins 4 hyper-paramètres en plus si ce n'est plus

Lesquelles ? Il n'y a qu'un seul hyper-paramètre en plus c'est le nombre de poids des neurones de la couche de convolution (la taille de la matrice de convolution). Pour du traitement d'images on utilisera une matrice carré (4, 9, 16, 25, etc.) car les données d'entrée sont en 2 dimensions, mais on pourrait aussi très bien faire de la convolution sur des séries temporelles par exemple, même si dans ce cas on préférerait utiliser des RNN (recurrent neural network). Quoique, pour traiter de la vidéo il faut un RNN avec une ou plusieurs couches de convolution.

[BioKore]

Je ne me suis pas penché sur la convolution sur d'autres sujets que la reconnaissance d'images, mais globalement je dirais :
- padding (2 paramètres si asymétrique)
- stride (2 paramètres si asymétrique)
- Volume des filtres (2 paramètres si asymétrique)
- nombre de paramètres
- probablement d'autres paramètres dont je n'ai pas connaissance

J'ajouterais que les données d'entrée d'une couche de neurones à convolution peut être de dimension quasi infinie... Sur la première couche déjà, il est tout à fait envisageable d'avoir 4 voire 5 dimensions (ou même plus) pour une image. Si on a seulement 5 features sur une image 3D, la profondeur bascule à 15. Si la couche suivante analyse 5 features aussi, on en arrive à une profondeur de 75. De ce fait, je te laisse imaginer la profondeur des couches suivantes, qui par construction seront de dimension quasi-systématiquement supérieures. De plus, 5 features, c'est faible.

Chacun de ces paramètres émane de l'architecture que l'on donne à notre réseau et définissent la qualité de l'apprentissage et / ou de généralisation de ce dernier. De par se fait, je considère donc ces paramètres comme des hyper-paramètres ayant une importance certaine sur les capacités d'un réseau de neurones à convolutions.

Concernant la récursivité des réseaux neuronaux, s'il en existe une, cette dernière n’apparait pas au niveau de la convolution, mais à la rigueur, au niveau du réseau entièrement connecté qui réalise l'analyse finale. Ce sujet n'a donc pas de rapport avec celui abordé sur ce post.

[Rbender]

Effectivement mon schéma illustre une couche de convolution très simpliste mais la représentation par graph devient très vite illisible pour une telle couche ( ce n'est pas pour rien qu'on représente ces couches par des volumes ). Je suis assez d'accord avec tes remarques et j'aimerais y ajouter quelques trucs :

Pour la passe avant (forward) d'un réseaux de neurones feed-forward il suffit de faire X_n = F[W_n-1X_n-1] ( avec X_n l'encodage à la couche n, W_n les poids à la couche n et F la fonction d'activation), dans le cas de couche de convolution les matrice de poids W sont sparse et ont une structure bien particulière du fait des poids partagés qui permet de voire ce calcul comme la convolution du volume par différents filtres ce qui demande moins de calcul que la façon classique.
Pour la passe arrière (backward) il me semble qu'il n'y a aucune différence avec une couche classique mais peut être que je me trompe.

Pour la différence entre les filtres il me semble que sans contrainte ils peuvent partagé une même partie d'information mais on peut éviter ça en ajoutant une contrainte de sparsité de l'encodage c'est ce que j'ai compris des sparse auto encoder mais je ne suis pas du sûr de cette info.

[BioKore]

[...] dans le cas de couche de convolution les matrice de poids W sont sparse et ont une structure bien particulière du fait des poids partagés qui permet de voire ce calcul comme la convolution du volume par différents filtres ce qui demande moins de calcul que la façon classique.

Ah ? selon moi le fonctionnement d'un noyau de convolution, en ce qui concerne le côté calculatoire, se déroule de la même manière que sur un Feed-Forward classique... En quoi l'organisation des poids joue un rôle sur la fonction même du noyau ? c'est n'est plus X_n = F[W_n-1X_n-1] ?

Faudrait que je tente de coder un noyau de convolution simple, ça m'aiderait probablement à comprendre certaines subtilités que je ne perçoit pas encore....

[Matthieu76]

Sur la première couche déjà, il est tout à fait envisageable d'avoir 4 voire 5 dimensions (ou même plus) pour une image.

Pour moi tu passes juste le RBG de ton image et basta, tu as 2 dimensions pour la convolution, x et y. Et du coup 3 pour la 3D, x, y et z. Pourquoi en rajouter ?

Je ne me suis pas penché sur la convolution sur d'autres sujets que la reconnaissance d'images, mais globalement je dirais :
- padding (2 paramètres si asymétrique)
- stride (2 paramètres si asymétrique)
- Volume des filtres (2 paramètres si asymétrique)
- nombre de paramètres
- probablement d'autres paramètres dont je n'ai pas connaissance

Là je ne suis pas vraiment d'accord, pour moi ça ne serre à rien d'avoir 50 hyper-paramètres, déjà parce que la plupart des hyper-paramètres ne font que très peu bouger le résultat final, ce n'est pas là ou il faut concentrer le travaille, et deuxièmement c'est le but du réseaux de résoudre des problèmes avec très peu d'hyper-paramètres. Pour moi on devrait juste indiqué le nombre de couche, nombres de neurones par couches, et type de la couche (RNN ou CNN) avec 1 ou 2 hyper-paramètres par type de couche et pas plus.

Quand je lis des articles ou les chercheurs utilisent une 10e hyper-paramètres en plus pour gagné 0.5% de classification sur leur jeux de données je préfère en 1000 fois les articles ou des chercheurs ont le même taux de classification que les autres avec un minimum de hyper-paramètres. Idéalement le mieux sera d'en avoir aucun. De toute façon les hyper-parameters on les met un peu au pif :

"50 neurones c'est pas assez bah mettons-en 200, ah 200 c'est trop long à calculer bon bah va pour 100, ça à l'air pas trop mal comme."

Si c'est pour faire ça autant avoir 0 hyper-paramètres et intégrer tous hyper-paramètres dans algorithm d'apprentissage.

Et puis s'il faut définir 50 hyper-paramètres avant de faire apprendre un réseaux de neurones sur un jeu de données précis, j'appelle plus ça de l'IA moi !

[Rbender]

Si tu fais le calcul matriciel direct tu feras plein de calcul inutile. imaginons tu a [[2,0],[0,1]]*[3,4] tu à 4 produits à faire 2*3 + 0*4 = 6 et 0*3 + 1*4=4 mais si tu connais à l'avance que tu as une matrice diagonale il suffit de faire 2 produits 2*3=6 et 1*4=4 c'est le même principe avec la convolution comme on sait pour quelle position les poids sont null il n'y a pas besoin de faire ces calculs et donc c'est beaucoup plus rapide à calculer.

De plus il me semble que comme le degrés de libertés est réduit, la surface à optimiser est moins compliquer et donc l'apprentissage sera moins long.

[Rbender]

Pour moi tu passes juste le RBG de ton image et basta, tu as 2 dimensions pour la convolution, x et y. Et du coup 3 pour la 3D, x, y et z. Pourquoi en rajouter ?

Il me semble qu'il parle du nombre de filtres dans la première couche, tu peux en prendre autant que tu veux.

Et puis s'il faut définir 50 hyper-paramètres avant de faire apprendre un réseaux de neurones sur un jeu de données précis, j'appelle plus ça de l'IA moi !

Je pense que le problème n'est pas forcément le nombre d'hyperparamètres mais le fait qu'on ne puisse pas avoir d'argument pour les choisir à priori et qu'on est obliger d'en tester plein pour rien. Je pense qu'il faut nourrir l'IA avec le maximum d'a priori qu'ont les humains, c'est une fantaisie de croire qu'une IA puisse apprendre sa propre structure en un temps convenable.

[BioKore]

Si tu fais le calcul matriciel direct tu feras plein de calcul inutile. imaginons tu a [[2,0],[0,1]]*[3,4] tu à 4 produits à faire 2*3 + 0*4 = 6 et 0*3 + 1*4=4 mais si tu connais à l'avance que tu as une matrice diagonale il suffit de faire 2 produits 2*3=6 et 1*4=4 c'est le même principe avec la convolution comme on sait pour quelle position les poids sont null il n'y a pas besoin de faire ces calculs et donc c'est beaucoup plus rapide à calculer.

De plus il me semble que comme le degrés de libertés est réduit, la surface à optimiser est moins compliquer et donc l'apprentissage sera moins long.

D'accord ; cela ne concerne donc que l'aspect "performances", je comprends effectivement que d'autres méthodes de calcul puissent êtres appliqués dans le cas de poids partagés. Finalement, ça parait même logique.

@Matthieu :

3d = RGB ; je ne vois pas où sont tes x, y z... dans le cas d'une image tu peux même avoir d'autres informations telles que la luminosité, contraste etc.... Nous pouvons déjà, sur le simple échantillon qu'est une image, se retrouver avec une grande profondeur. Même si le nombre de filtres appliqués par dimension peut varier (rien ne nous oblige à mettre autant de filtres sur une dimension que sur l'autre), nous nous retrouvons presque systématiquement avec un volume de sortie très profond. Si on prends d'autres types d'entrées que des images, la profondeur de base de l'échantillon peut explosé avant même d'entrer dans le réseau. Verdict : il est important de traiter un minimum ses entrées et d'anticiper quelles vont être les données initiales de ton échantillon les plus représentatives. C'est la première piste d'optimisation à apporter au système.

Il ne faut pas voir le nombre d'hyper-paramètres comme quelque chose de néfaste. Au contraire, cela permet de jouer grandement sur l'optimisation d'un RdN. Visiblement, tu n'essaie pas encore de sujets complexes nécessitant de grands RdN, sinon, tu comprendrais vite que le fonctionnement "au pif" s'avère extrêmement chronophage sur des sujets complexes. Et que passer 2 mois à trouver mathématiquement, ou par la logique, quelles valeurs prendre pour tes hyper paramètres est en fait beaucoup moins long (et beaucoup moins cher !!) que de faire des essais au petit bonheur la chance....

Enfin, pour rebondir sur le commentaire de Rbender :

[...] c'est une fantaisie de croire qu'une IA puisse apprendre sa propre structure en un temps convenable.

Je suis d'accord d'un côté, mais moins d'un autre. Aujourd'hui, il est absolument certain que les périodes d'apprentissage sont longues, et les principaux moyens de réduire ces temps sont les moyens (calculs GPU, clusters GPU, machines quantiques etc...). Cependant, nous cherchons aussi des résultats proches de la perfection. Dès lors, la recherche actuelle me semble porter plus sur la précision dans l'utilisation des algorithmes que sur la qualité d'apprentissage des RdN. C'est d'ailleurs concernant ce dernier point que j'axe mes recherches actuelles : pour une problématique donnée (spécifique ou généraliste), comment optimiser les temps d'apprentissage des RdN ? Ici le but n'est pas d'atteindre une précision de 100% mais de réduire drastiquement les temps d'apprentissage d'algorithmes permettant d'obtenir au moins 98%.
En gros, je cherche à faire apprendre à un algorithme comment apprendre efficacement. Dans mon cas justement, la multiplication des hyper paramètres est, dans la mesure de l'acceptable, une bonne chose.

C'est un sujet très intéressant, mais il me semble avoir besoin de m'améliorer en développement avant de pouvoir commencer mes premiers essais

[Matthieu76]

si tu connais à l'avance que tu as une matrice diagonale il suffit de faire 2 produits 2*3=6 et 1*4=4 c'est le même principe avec la convolution comme on sait pour quelle position les poids sont null il n'y a pas besoin de faire ces calculs et donc c'est beaucoup plus rapide à calculer.

On ne peut pas connaitre à l'avance la valeurs des poids, sinon pourquoi faire une descente de gradient lors de l’apprentissage ? De plus les poids d'un neurones ne peuvent et ne doivent jamais être égale à 0.

Je pense que le problème n'est pas forcément le nombre d'hyperparamètres mais le fait qu'on ne puisse pas avoir d'argument pour les choisir à priori et qu'on est obliger d'en tester plein pour rien. Je pense qu'il faut nourrir l'IA avec le maximum d'a priori qu'ont les humains, c'est une fantaisie de croire qu'une IA puisse apprendre sa propre structure en un temps convenable.

Il existe des réseaux de neurones qui forment leurs propres architectures et aussi des réseaux de neurones qui déterminent eux même les valeurs de leurs hyper-paramètres. Un simple algo génétique permet de déterminer les hyper-paramètres de façons plutôt correct mais le temps de calculs est plutôt long. D'ailleurs on peut même déterminer les valeurs des poids avec de l'algo génétique, sans backpropagation.

3d = RGB ; je ne vois pas où sont tes x, y z... dans le cas d'une image tu peux même avoir d'autres informations telles que la luminosité, contraste etc.... Nous pouvons déjà, sur le simple échantillon qu'est une image, se retrouver avec une grande profondeur. Même si le nombre de filtres appliqués par dimension peut varier (rien ne nous oblige à mettre autant de filtres sur une dimension que sur l'autre), nous nous retrouvons presque systématiquement avec un volume de sortie très profond.

Le rouge, vert, bleu, la luminosité, le contract et autre ne sont pas des dimensions. Il faut appliquer une convolution sur des données qui on une localisation entre elle (principalement des données spéciales ou temporelles). Bref, là ou on peut mesurer une distance. Une convolution permet de "regrouper" des informations proches. Pour une image ce que l'on met dans la matrice de convolution ce sont des pixels (peu import ce que continent tes pixels) car 2 pixels proche ont plus de chance de regrouper une information commune contrairement à 2 pixels éloigné. Les 2 dimensions sont donc les 2 coordonnée de ton pixel x et y. Comme pour du textes par exemple, analyser des mots côte à côte permet de mieux comprendre le texte contrairement à lire des mot aux hasards et là la dimension pour ta convolution ça devient la distance entre chaque mot.

Un exemple beaucoup plus parlant mais aussi plus dur à comprendre c'est la différence entre le jeu d’échec et le jeu de go.

• Pour le jeu de go, on fait de la convolution car un pion blanc ne peut être menacer que pas un pion proche, un pion noir placé à l'autre bout du plateau n'influencera pas ce pion blanc.
• Par contre aux échec on ne peut absolument pas faire de convolution car peut import la distance en 2 pièces, une tour pourra toujours manger une pièce s'il celle-ci est en ligne droite.

PS : D'ailleurs pour de la vidéo il y a 3 dimensions, x et z plus t le temps car 2 pixels peuvent être proche en du même axe vertical (x), proche en du même axe horizontal (y), ou proche du même moment de la vidéo (t).

[Rbender]

On ne peut pas connaitre à l'avance la valeurs des poids, sinon pourquoi faire une descente de gradient lors de l’apprentissage ? De plus les poids d'un neurones ne peuvent et ne doivent jamais être égale à 0.

On connaît les poids car on les fixent comme tel, considérer qu'il n'y a pas de connexion entre 2 neurones et dire que le poids associé à cette connexion est nul est équivalent puisque les neurones récepteurs reçoivent la somme de l'encodage précédent pondérés par les poids de connexions. Une couche de convolution c'est une couche dense où l'on a reparamétrisé les poids en fixant certains poids à 0 et avec des connexions qui partagent les même poids comme je le montre dans le schéma ci dessus.

Il existe des réseaux de neurones qui forment leurs propres architectures et aussi des réseaux de neurones qui déterminent eux même les valeurs de leurs hyper-paramètres. Un simple algo génétique permet de déterminer les hyper-paramètres de façons plutôt correct mais le temps de calculs est plutôt long. D'ailleurs on peut même déterminer les valeurs des poids avec de l'algo génétique, sans backpropagation.

Plus les modèles sont complexe plus il faut du temps et surtout des données pour pouvoir être appris et ce n'est pas forcément souhaitable. Évidemment tout dépend du problème.

[Matthieu76]

Plus les modèles sont complexe plus il faut du temps et surtout des données pour pouvoir être appris et ce n'est pas forcément souhaitable. Évidemment tout dépend du problème.

La complexité du model n'est en rien lié au nombre de données. Si le réseaux de neurones apprends sur un ensemble de données simple avec peu de données, que le modèle soit très complexe ou non cela ne change rien. Un model plus complexe n'a pas besoin de plus de données mais juste plus de temps.