Discussion :

[BioKore]

Bonjour à tous,

Afin de mieux comprendre le fonctionnement des réseaux de neurones, je me suis lancé dans la création d'un réseau FC en langage C (juste parce que je suis plus familier avec le C qu'un autre langage). Le but étant d'apprendre, je réalise ce dernier sans librairie quelconque.

Après un premier résultat "fructueux" sur un sujet linéaire trivial : l'addition, j'ai alors continué mon chemin et je m'essaye alors à la reconnaissance d'écriture (de chiffres) sur les bases de données de MNIST. j'utilise donc un réseau de 784 entrées (les images sont de 28 * 28) pour une seule sortie linéaire et mes essais se font entre 300 et 1200 neurones pour entre 1 et 4 couches cachées. Mes fonctions sont sigmoïdes et / ou linéaires et / ou tanh. Fonction d'agrégation sommatrice standard.
La méthode d'apprentissage est réalisée par rétro propagation du gradient d'erreur. L'erreur de sortie est exprimée en RMS (0.5*(t - y)²) et le taux d'apprentissage alfa est fixé entre 0.05 et 0.5 selon les essais.

La base de données d'apprentissage (récupérée sur mnist) comprends 60000 images de chiffres compris entre 0 et 9 ; la base de test en fait 10000 si ma mémoire est bonne.


voici les résultats de mes premiers essais :

Lors de l'apprentissage, en général, je remarque que l'erreur (sur un chiffre particulier quelconque entre 0 et 9) ne fait qu'osciller entre 0.001<x<12
Dès lors que je lance les tests, la valeur de sortie est toujours la même (~ 5) sur toutes les images proposées.

Alors bien que je n'exclue pas de possibles erreurs de programmation, je me demandais tout de même si l'erreur ne venait pas plutôt de mon choix sur le type de sorties, et / ou de la configuration générale de mon réseau.


Selon vous, l'erreur pourrait-elle être liée au fait que je demande une seule fonction linéaire de sortie plutôt que 10 de type Heaviside voire même sigmoïdes ou soft-max (pour en revenir plutôt à un problème de classification) ?

Pour ceux qui ont déjà fait ce type d'exercice, quelle configuration du réseau me conseilleriez-vous pour un tel sujet ?

D'avance, je vous remercie pour vos retours ; n'hésitez pas à me demander plus de détails si besoin.

[BioKore]

Sujet résolu. J'ai refait mon réseau pour un faire un "classificateur" pur (10 sorties tangente hyperbolique), la sortie la plus élevée correspond à l'indice du chiffre à trouver.

Cependant, petite bizarrerie, pour que mon système m'affiche correctement le résultat souhaité, je dois réaliser ma rétro propagation AVANT la propagation (ou alors je propage une fois avant et une fois après)

Je me demande si ce n'est pas juste un coup de chance du coup.... Je vais tout de même essayer d'utiliser ce réseau sur un autre type de problème avant de crier hourra. Je vais aussi y ajouter une couche soft-max histoire d'en faire quelque-chose de plus propre.

Suite au prochain épisode...

[dourouc05]

Cependant, petite bizarrerie, pour que mon système m'affiche correctement le résultat souhaité, je dois réaliser ma rétro propagation AVANT la propagation (ou alors je propage une fois avant et une fois après)

Effectivement, ça n'a pas de sens : pour effectuer ta rétropropagation de gradient, tu dois faire une passe avant (calculer la sortie du réseau).

Sinon, la solution d'une sortie par classe possible fonctionne souvent bien ! Comme sortie, tu peux aussi utiliser la sigmoïde comme fonction d'activation : plus classique, la sortie s'interprète comme la probabilité d'obtenir telle classe. C'est un peu plus propre conceptuellement, mais ça ne devrait pas changer grand-chose.

[BioKore]

Oui, je m'en suis finalement aperçu, un soucis dans l'affectation de mes poids initiaux, qui offraient une réponse correcte au problème, mais dans la phase d'apprentissage uniquement (aucune possibilité de généraliser).

Donc retour à la case départ, je me retrouve avec un réseau dont il est impossible de faire apprendre quoi que ce soit. Après plusieurs vérifications, modifications d'architecture, ré-implémentation du SGD sous différentes formes etc.... l'erreur (d'apprentissage) est toujours soit oscillatoire autour d'une valeur impossible (tous les indices du vecteur de sortie restent à 1 et -1, dans le cas de 10 sorties tangente hyperbolique).

Pourtant, bien que mon bagage "matheu/méca" soit relativement loin, je suis à l'aise avec les équations de dérivé de l'erreur totale et je ne pense pas m'être planté dans l'implémentation de la SGD...... Je n'arrive vraiment pas à voir d'où peut venir mon erreur....

- Mes poids sont (maintenant corrects) situés aléatoirement entre -1 et 1; --> Q : de manière générale ces valeurs sont-elles assez générales ?
- Les biais sont bien, eux aussi pondérés et modifiés lors de la SGD; --> Q : je n'en suis pas certain, mais avec Sigmoïde et Htan, les biais initialisés à -1 n'introduisent-ils pas d'erreurs particulières ?
- Mon taux d'apprentissage pour mes essais est maintenant "fixe" à 0.6; Je pense conserver cette valeur tant que je ne vois pas de convergence "significative". J'opterais pour un pas variable par la suite.
- j'ai refait les vérifications plutôt deux fois qu'une, les vecteurs E/S de mes fichiers d'apprentissage sont corrects à tout moment dans mon code; --> Q: les valeurs de chaque indice du vecteur d'entrée sont situés entre 0 et 255; est-il nécessaire de baisser ces valeurs pour un meilleur rendu (éviter que les poids s'enflamment) ?
- ma fonction de SGD.... Cette dernière n'est pas bien compliquée et je l'ai reprise et refondue entièrement à 3 reprises ces 3 derniers jours pensant qu'elle était l’origine de mes soucis. Je n'exclue pas qu'elle possède encore une erreur cachée, mais cela me surprendrait (deux implémentations différentes donnent un comportement similaire).


- reste à vérifier ma fonction principale de propagation...... Qui marchais bien avec l'addition, mais je viens d'y penser, cette dernière à donc le même bug de poids que celui décelé récemment --> une piste de progrès potentielle...... Mais c'est malgré tout fou que le modèle de l'addition, en généralisation, fonctionne avec une telle erreur (et si bien !).

Bref, je pense être bon pour revoir l'ensemble de mon réseau depuis le début une n ème fois depuis un mois.

En tout cas, merci pour ton retour dourouc05. Si le forum me le permet, je continuerais à m'exprimer sur ce fil tant que je n'aurais pas de résultats "satisfaisant" (5 = '5' quoi...).

[dourouc05]

- Mes poids sont (maintenant corrects) situés aléatoirement entre -1 et 1; --> Q : de manière générale ces valeurs sont-elles assez générales ?

Je dirais que tu devrais utiliser des valeurs plus petites : là, tu risques régulièrement d'avoir des arguments assez grands pour ta fonction d'activation (donc des dérivées petites) — des zéros feraient beaucoup de merd. Par contre, pour tes biais, un zéro suffit largement.

- Mon taux d'apprentissage pour mes essais est maintenant "fixe" à 0.6; Je pense conserver cette valeur tant que je ne vois pas de convergence "significative". J'opterais pour un pas variable par la suite.

Si la valeur est trop grande pour ton problème, tu risques d'avoir énormément d'oscillations…

Sinon, pour mettre la partie SGD de côté, tu peux tenter d'implémenter une méthode d'optimisation plus classique (BFGS, ce genre de choses, en remplaçant la recherche en ligne par un taux d'apprentissage). Si ça foire toujours, c'est que ça ne vient pas de là .

[BioKore]

Merci pour ce retour dourouc05, mais, enfin, j'ai résolu mon problème..... Avec toutes les manipulations que j'ai faites, je me suis rendu compte que le bug venait simplement de la passation du mauvais tableau à ma fonction de SGD

J'ai donc, depuis hier soir à 23h59, un modèle d'apprentissage fonctionnel. Observations :

- 60000 images d'apprentissage (28 * 28, soit 784 pixels en entrée de valeurs comprises entre 0 et 255)
- 10000 images de test (mêmes propriétés que les images d'apprentissage, cela va de soit)
- 220 neurones sur la couche d'entrée, fonction RELU, biais -1 (je pense que, étant donné les valeurs d'entrées, le biais est ici presque useless, je vais tout de même vérifier le poids affecté aux biais après l'apprentissage dans mes fichiers de sauvegarde)
- 80 neurones sur la seconde couche, fonction sigmoïde, biais = -0.5
- 10 neurones de sortie, sigmoide, biais = -0.5;
- tous les poids initiaux sont allouée entre 0.1 et -0.1 (suite à suggestion de dourouc05, qui m'a permis de gagner ~ 2% d'erreurs sur les tests).
- alfa = 0.6. Si je mets moins (0.4) ou plus (0.7), l'erreur m'a tout l'air de s'amplifier (mais je dois faire plus de test avant de pouvoir affirmer ça).
- entre 28% et 30% d'erreurs en généralisation lors des tests

Cependant, bien que l'erreur totale, Et = 0.5*(t - y)², ait tendance à converger vers 0, cette dernière oscille assez largement tout au long de l'apprentissage (je dirais entre 0.00000 et 0.70000), mais à vue de nez, je dirais que la moyenne est plutôt autour de 0.004.
Si je suis l'évolution du delta d'une valeur en particulier lors de l'apprentissage, celui-ci tends, bien qu'en oscillant aussi légèrement, vers 0.

Bien que je soit très content d'avoir atteint cette première étape, j'aimerais pouvoir tomber l'erreur à moins de 5% avant de m'engager vers mon prochain défi. Je ne pense pas que ce soit trop demander quand on vois que certains arrivent à des erreurs de moins de 2% sur ce même exercice avec des réseaux FC (perceptrons multicouches) de 300 neurones (source : site MNIST).

Maintenant, je dois donc m'attaquer à l'optimisation, et c'est là que je pense, à mon humble avis, devoir revoir mes cours de maths et monter d'un cran (à moins que je ne fasse d'un brin de paille une montagne, mais j'en doute).

Ayant énormément de questions sur le sujet, plutôt que de rallonger ce post déjà bien trop long, peut-être que quelqu'un pourrait y répondre simplement en m'orientant simplement vers des ressources traitant de l'optimisation de ce type de réseau (en mode vulgarisé si possible, je ferais les recherches sur les détails moi-même par la suite) ?

PS : réalisant des tests en parallèle à l'écriture de ce post, c'est avec joie que je viens de voir ma console indiquer 20% d'erreurs, simplement en divisant les poids par 10 !!! --> Merci encore dourouc05 !!!

[dourouc05]

Un point méthodologique : pour déterminer les paramètres de ton réseau (taux d'apprentissage, nombre de neurones, etc.), divise au moins tes données en jeux d'apprentissage (pour construire le modèle) et de test (pour calculer l'erreur une fois le réseau appris), voire utilise la validation croisée (exemple : http://scikit-learn.org/stable/tutor...selection.html).

Pour l'optimisation, pas mal de gens utilisent SGD (surtout quand toutes les données ne tiennent pas en mémoire) et Adam (ce dernier étant plus difficile à implémenter).

Si tu as de telles variations en faisant varier les poids initiaux, tente aussi d'augmenter le nombre d'itérations. Le principe des réseaux neuronaux n'est pas d'avoir beaucoup d'intelligence (surtout dans le code, sauf pour la performance), mais plutôt de lancer des monceaux de puissance de calcul un peu au hasard…

[BioKore]

Bonjour et merci pour ce retour.


En ce qui concerne le premier point, je suis d'accord, je comptais faire de l'apprentissage fractionné, et/ou une sorte de batch fractionné... Je tenterais d'implémenter ça dans 2 ou 3 semaines (je n'ai pas beaucoup de temps pour mes projets perso en ce moment )

Par contre, je ne comprends pas tes deux autres points. "Optimisation via SGD" ; n'est-ce pas déjà ce que je fais via l'apprentissage ? Stochastic Gradient Descent ?

Enfin, le nombre d'itérations... Pour ma part, je ne fais qu'une itération par exemple. Effectivement, bien que cela tombe sous le sens, je n'avais jamais pensé à en faire plus shame on me ! Cette modification étant rapide à faire, je vais voir si je trouve le temps d'implémenter ça dans la semaine et je reviens poster mes résultats !

Merci !

[BioKore]

J'ai implémenté la partie itérative pour l'apprentissage ; cependant, a part un essai me permettant de diminuer mon erreur à ~13% (3 itérations sur l'ensemble de la population d'apprentissage avec diminution du alfa entre chaque itération), tous mes autres essais sont "infructueux".

les différents essais que j'ai pu faire sont :
- 2 à 5 itérations sur l'ensemble de la population d'apprentissage avec modification ou non du alfa entre chaque apprentissage
- 2 à 24 itérations par élément de population (soit 24*60000 itérations sur l'ensemble de la population)
- un mix des deux précédents essais.

Dans tous ces cas (sauf un), je me retrouve avec soit une augmentation de l'erreur, soit une diminution ridicule de cette dernière vis-à-vis du temps de calcul nécessaire.

Mes compétences en tant que codeur étant maigres, et souhaitant avant tout m'assurer la compréhension du processus, ce dernier est assez "sale", je perds donc certainement quelques secondes sur chaque itération. Je n'ai donc pas tenté d'aller au delà des 24 itérations par indice de population, mais c'est peut-être un axe de progrès.
De même, je n'ai encore aucun bout de code me permettant de visualiser les potentielles erreurs liées au sur-apprentissage, d'où l'objectif de mon précédent post consistant à faire de l'apprentissage fractionné.

Étant donné le temps que j'ai à allouer sur le sujet pour le moment, je ne pense pas pouvoir éclaircir mon code ET implémenter l'apprentissage fractionné avant 3 semaines au moins.

D'ici là, peut-être sauriez-vous me conseiller ou m'indiquer un rapport alfa / itérations qui pourrait être "adapté" à ma problématique ?
Depuis quelques essais, je tiens un tableur dans lequel j'indique pour chaque essai les éléments suivants :
- type d'architecture (nombre de couches, neurones, type de fonction d'activation etc...), bien que je n'ai fait l'essai que sur un seul type pour le moment
- valeur du alfa
- nombre d'itération
- erreur résultante.

Je pense à terme réaliser une régression polynomiale de ces différents essais pour pouvoir déterminer le rapport optimal alfa / itérations, mais bon, cela risque d'être long et me demander trop d'essais... A voir..
A tester aussi, l'itération "complète" où l'on fait l'apprentissage jusqu'à atteindre une erreur epsilon donnée... Ceci me parait être une bonne idée, mais je ne testerais ceci que lorsque j'aurais réalisé l'implémentation de l'apprentissage fractionné... Sinon, je pense être bon pour plusieurs jours de calculs.

Bref, à retenir, je suis content d'avoir pu descendre sous les 14%, c'est déjà ça.

[BioKore]

Bonjour et bonne année !

Bon, entre une huître et une coupe de champagne j'ai pu implémenter une partie de ce que je voulais faire, ainsi que faire quelques essais.

Premier choix, la segmentation des données d'apprentissage, afin de pouvoir réaliser les itérations sur des blocs de données plutôt que sur l’ensemble. Par exemple, je prends les 600 premiers éléments, je fais 128 itérations. Je passe aux 600 éléments suivants, 128 itérations etc... jusqu'à faire toute la population (je le rappelle, 60000 éléments). Entre chaque itération, je teste le réseau sur 100 éléments de la population de test afin de voir comment évolue l'erreur. A la fin du processus, je teste l'ensemble de la population de test (10000 éléments, différents de la population d'apprentissage).

Second choix, 128 itérations sur l'ensemble de la population, alfa fixe ou pas (j'ai essayé différentes méthodes de variation pour ce facteur).

J'ai réussi a descendre à 12% d'erreurs (peut-être même 11% et quelques), mais impossible de tomber en dessous. J'ai l'impression que le premier choix m'offre finalement moins de précisions que le second (sur apprentissage ? possible, il est plus difficile d'identifier la hausse de l'erreur avec cette méthode, selon mon implémentation). Aussi, si je fait un test sur 100 éléments, je peux avoir 7% d'erreurs, mais ces 7% se transforment en 12 ou 13% si je fais le test sur les 10000 éléments.

Bref, j'ai gagné un peu, mais je suis encore loin des 5% que je m'impose. D'ailleurs, lorsque je réalise mes itérations sur toute la population (second choix ci-dessus), je converge "rapidement" vers 12%, mais à partir de là, ça oscille ou descend très lentement, peu importe les modifications de alfa.... Une idée sur la problématique ? suis-je arrivé aux limites de mon architecture (3 couches totalisant 300 neurones) ?

Toute idée est la bienvenue !
Merci !

[Matthieu76]

Bonjour, je n'ai pas lu tout le post, je l'ai juste survolé mais cette phrase m'a interpeller

Par exemple, je prends les 600 premiers éléments, je fais 128 itérations.

Pourquoi ne pas directement utiliser un batch de 600 ?
En gros, tu fais la moyen des entrées des 600 premiers éléments et la moyen des sortie des 600 premiers éléments puis tu effectues un seul apprentissage avec un learning rate élever. Comme ça tu ne fais que 100 apprentissages par passage de ton jeu d'apprentissage (600 * 100 = 60000), ensuite tu mélanges tes éléments puis tu recommences jusqu'à ce que cela converge. Après tu peux toujours diminuer le batch progressivement une fois la convergence atteinte !

PS : J'ai déjà bosser sur la MNIST pendant mon stage de fin d'étude et là je code comme toi ma propre librairie de réseaux de neurone en C++/CUDA pour faire jouer une IA à Street Fighter. Si mon projet t'intéresse ou si tu veux juste discuter, contacte-moi par message privé, je cherche des passionnés de Deep Learning pour discuter.

[BioKore]

Bonjour et merci pour ce retour.

J'ai bien pensé à essayer un apprentissage batch, mais je n'ai pas encore implémenté cette fonctionnalité. Je vais essayer de me dégager un peu de temps pour tester... Mais je dois d'abord étudier un peu le fonctionnement de ce type d'apprentissage, je ne m'y suis jamais vraiment intéressé. J'espère que je ne vais pas avoir trop de mal pour implémenter ça.

Au passage, mes valeurs alfa étaient jusqu'à présent soit fixes soit évolutives selon des méthodes "inventées" de ma part. Cependant, je viens de trouver sur le net deux types d'évolution de ce taux promettant quelques avantages : Asservissement par la méthode du gradient (alfa = 0,001/(1+|delta|)), soit la méthode de Goldstein (Minoux).
Bien que la détermination de ce taux ne soit pas cruciale, je vais tout de même commencer par ça et voir ce que ça donne.

Merci encore !

[Matthieu76]

Si tu veux modifier ton alpha, regarde le momentum. C'est une formule du genre :

delta = delta + 0.9 * previous delta;

En gros tu ajoutes à chaque fois le delta précédent comme ça si ton delta est tout le temps positif, ça augmente de plus en plus, si ton delta est tout le temps négatif, ça diminue de plus en plus, et si le delta est une fois positif, une fois négatif, ça bouge que de 0.1 * delta environ. Avec le momentum, l'erreur converge beaucoup plus vite vers un minimum.

Et en plus c'est 3 lignes à coder

[BioKore]

Si tu veux modifier ton alpha, regarde le momentum. C'est une formule du genre :

delta = delta + 0.9 * previous delta;

En gros tu ajoutes à chaque fois le delta précédent comme ça si ton delta est tout le temps positif, ça augmente de plus en plus, si ton delta est tout le temps négatif, ça diminue de plus en plus, et si le delta est une fois positif, une fois négatif, ça bouge que de 0.1 * delta environ. Avec le momentum, l'erreur converge beaucoup plus vite vers un minimum.

Et en plus c'est 3 lignes à coder

Bonjour, et merci pour ce coup de pouce ! Il s'agit de tout ce que j'aime : une solution plein de promesses pour peu de code. Je n'avais effectivement pas pensé à modifier directement les delta.
Quoi qu'il en soit, je ne me réjouis pas trop vite non plus ; mon PC est actuellement en train de mouliner sur la chose. Seuls les résultats me dirons ce qu'il en est vraiment, mais les premières itérations ont l'air de montrer une convergence plus rapide.

Par contre, le coefficient de 0.9 dans ton calcul me parait bien trop élevé à mon goût (simple constat tout à fait personnel et non mathématiques), aussi a 0.1 j'avais de meilleurs résultats qu'à 0.5, mais il faut tout de même que je vois sur un test complet (plus de 20 itérations en tout cas), peut-être me rendrais-je compte que 0.9 est la meilleur solution finalement.

La suite au prochain épisode !

[Matthieu76]

Bah en gros le coefficient 0.9 fait que 1 exemples d'apprentissage n'a pas beaucoup importance dans le code cela évite à ton réseaux de faire du cas par cas, le momentum à un peu le même effect qu'un batch. Il y a même des cas où on peu prendre un coefficient de 0.99.

PS : Si ton code est lent et que tu utilises des vecteurs, vérifie bien que tu fais du passages par référence au lieu de recopier tout le vecteur; Aussi dans tes options de compilation, rajoute -O3 (optimization 3) si tu compiles avec GCC ou GNU et /02 si tu utilise MSVC (regarde sur internet); ton code compilera un poil plus lentement mais s’exécutera 2 fois plus vite.

[BioKore]

Bonjour,

Pour le passage des valeurs, j’essaie de toujours privilégier les pointeurs. Je ne passe donc normalement que des pointeurs. Enfin, je dis ça, mais il faudrait que je refasse mon code un peu plus propre dans tous les cas. Je suis certain que tout un tas d'optimisations de ce genre sont possibles, mais pour ça, il faudrait que j'arrive à me dégager plus de temps...

Pour le coup du -O3, c'est magique ! Je n'aurais pas pensé que les optimisations de compilations marcheraient si fort (pourtant en y repensant....). J'ai vraiment gagné en vitesse d'exécution ! Merci beaucoup !

Par contre, pour en revenir au momentum, j'ai vu un truc du genre il y a peu dans un des multiples pdf divers et variés que j'ai, mais le calcul m'a l'ai plus complexe. On retrouve effectivement le d+1 = dc + 0.9d, mais on soustrait aussi plusieurs termes... Je n'ai plus tout le calcul en tête mais je tâcherais de retrouver ça.
D'ailleurs concernant les résultats, d'hier, voici le constat :
- avec l'application du momentum avec un coef de 0.1, j'ai une convergence bien plus rapide sur les premières itérations. Je passe de 88,5% d'erreurs (réseau tout juste initialisé) à 16% sur la première itération, puis 14% puis 13% puis 12%, mais à partir de là, je bloque dans les 12%....
- J'ai laissé tourné toute la nuit sur 400 itérations et on ne descend pas en dessous de 12,07%, et ça commençais à remonter à partir de 300 itérations environ. Cependant, je suis partis d'un pas de 0,34 et est trop rapidement descendu à moins de 0,05 (j'ai mis un règle pour le alfa mais la règle était bien trop souple...).

Aussi, je viens de lancer le test avec un coef de momentum de 0.9 et, première surprise (toujours avec un alfa de 0,34), la première itération m'envoie au dessus de l'erreur initiale ! Depuis, 40 itérations sont passées et je me retrouve toujours à 89,90% (initial à 88,5%). De plus, le comportement me parait très oscillatoire (sans réelle surprise néanmoins).

Verdict : il faut que je décortique un peu plus en détail ce qu'il se passe mathématiquement lors de l'apprentissage... Mon fond de physique me permet de comprendre les calculs en eux mêmes, mais je pense que l'interprétation n'est pas assez profonde.

[Matthieu76]

Aussi, je viens de lancer le test avec un coef de momentum de 0.9 et, première surprise (toujours avec un alfa de 0,34), la première itération m'envoie au dessus de l'erreur initiale ! Depuis, 40 itérations sont passées et je me retrouve toujours à 89,90% (initial à 88,5%). De plus, le comportement me parait très oscillatoire (sans réelle surprise néanmoins).

Salut,
déjà 0.34 de alpha c'est beaucoup trop, reste plutôt sur 0.05 voir 0.01. Ensuite avec un coef de momentum de 0.9 tu devrais justement beaucoup moins osciller ! Je sais pas c'est bizarre, tu l'as peut-être mal codé... ou essaye avec un alpha très très petit, c'est peut-être ça le problème.

PS : D'après ce que j'ai lu le biais dois être fixer à 1 et non -0.5, bon après le réseaux s'adapte donc ça devrait pas changer grand-chose mais c'est plus... "propre".


PS n°2 : http://playground.tensorflow.org/ regarde ça, ça devrait t'amuser un bon moment.

[BioKore]

Bonjour et merci pour ce retour !

J'avais peur de devoir me lancer dans 50000 itérations avec un taux si faible. Les fois où j'ai essayé avec un tel taux, je m’arrêtais aux 10 premières itérations en ne voyant que très peu de progression.
Cependant, je viens de relancer la machine avec alfa = 0.01 et k = 0.9 (momentum), et, effectivement, les premières itérations montrent un faible avancement mais s'accélèrent néanmoins par la suite ! Je vais laisser tourner cette nuit comme ça, on verra demain ce que ça donne.


Merci encore !

[Matthieu76]

Cool, J'aimerais beaucoup voir ton code pour le comparer avec le mien, j'avais commencé un projet sur la MNIST avec ma librairie de NN mais mon PC est mort et j'ai pu récupérer que mon projet principales sur mon IA Street Fighter !

[Matthieu76]

Pour l'initialisation de tes poids, j'ai lu dans un bouquin et sur internet qu'il faillait prendre du racine de n. Je te conseil de prendre un truc du genre :

interval = [-sqrt(3/n); sqrt(3/n)]