Voila ce n'est pas la version utiliser dans le TPE (celle du TPE était en Visual Basic pour des raison de simplicité)

Mon TPe est maintenant terminer. Pour celui-ci j'ai utiliser une petite optimisation du programme. Elle consiste a ne pas traiter les neurones dans un ordre aléatoire mais a traité toute une couche d'un seul coup. Cela permet de gagner en vitesse de "convergeance" et surtout de simplifier le code source.

la dans le cas de ce reseau, le plus facile c'est si l'on a une image en noir et blanc. Mais je pensse que sa marche aussi avec des couleurs mais sa va etre plus dur a transmettre au reseau et il va falloir des millions de neurones. Je ne suis pas un expert en reseau de neurone, (je ne suis que en Terminale et j'ai commençé a m'interressé au reseau de neurone au debut de l'année (scolaire).).
Mais pour la couleur je pensse que le modele de Hopfield n'est pas bon, il faudrais utiliser un perceptron.(il faut que j'en fasse un pour mon TPE donc je le mettrais sur ccpfrance.com quand il sera terminé).
Et desoler pour l'orthographe je rajouterai un s a poid(s), et je vais voir se que je peux faire pour la lisibilité.

Oui  tu a presque bien compris comment sa marche !!!
(et effectivement des bool sa sufirait mais j'y avais pensser en faisant le code et finalement j'etait revenu a des int je ne sais plus pourquoi je pensse par simplicité pour utiliser -1 et 1 plutot que 0 et 1.

Comment sa marche :

1/L'apprentissage regle tous les poids

2/ A chaque neurone correspond une place du tableau

3/ Chaque neurone calcul sa sortie en fonction de tous les autres neurones:
                     Sortie [j]= Somme (poid[i] * S[i])
                     Sortie[j]=sortie du neurone que l'on est en train de traiter
                     Sortie[i]=sortie du neurone i
                     poid[i]=poid associé a la liaison i-j

4/ Quand tous les neurones on ete traiter (dans un ordre aleatoire) on reprend au 3/ . Jusqu'a ce que les sortie sont "stable" (ne change plus)
(Hopfield a demontrée que son reseaux converger donc cela devrais se produire)

5/ La sortie du reseau est ensuite la sortie de chaque neurone quand les sorties sont "stable" (ne change plus)

ben c'est pas dur du tout de trouver un  truc qui ne sera pas decrypter avant quelque siecle utilise le DES (clef 56bits cryptage par bloc dee 64bits) il est utiliser dans les carte bancaire et normalement n'a pas encore ete casser sinon si tu es un peu parano utilise un IDEA (clef128bits block 64bits il existe une version 128 128 sa s'appelle CAST) la t tranquil perssonne ne le decodera sans la clef !!!! sinon dans les chiffrement en continu tu as A5,RC-5,SEAL ... et dans les chiffrement a clef publique : RSA est trés bien avec une clef de  1024 mais c'est un peu plus dur a realiser ( c'est tres ch*** les nb de 200 chiffres) !!!

Je vais voir pour le prog exemple actuellement je travail sur un reseaux type perceptrons multicouche

Concretement ce qu'il apprend sa peut-etre n'importe quoi mais dans le cas des reseau de Hopfield on essais plutot de reconnaitre des forme  par exemple si on lui apprend les 26 lettre de l'alphabet on peut realiser une application  qui quand on scanne une page du dictionnaire reconnait toutes les lettre et l'enregistre sous forme d'un TXT (concretement ces programmes s'appellent des OCR)

Exemple:
trier les envelope a la poste selon les code postaux :
on a 10 caractere a reconnaitre : 0 1 2 3 4 5 6 7 8 9
il faut donc minimum 0.13*10 Neurones soit 76 on prend 100 Neurone pour simplifier.
nos pattern seront de 10*10 (car 10*10=100 Neurone)
on realise le pattern du 0 puis du 1 , ... et on les apprend o reseau
int modele_a_apprendre[10][100]={{modele du 0},{modele du 1}, ...};
exemple de pattern(pour 160 neurones):

int Trois[160]={
0,1,1,1,1,1,1,1,0,0,
1,1,1,1,1,1,1,1,1,0,
0,1,1,1,1,1,1,1,1,1,
0,0,0,0,0,0,1,1,1,1,
0,0,0,0,0,0,0,1,1,0,
0,0,0,0,0,0,1,1,1,0,
0,0,0,1,1,1,1,1,1,0,
0,0,1,1,1,1,1,1,0,0,
0,0,0,1,1,1,1,1,0,0,
0,0,0,0,0,0,1,1,1,0,
0,0,0,0,0,0,0,1,1,0,
0,0,0,0,0,0,0,1,1,1,
0,0,0,0,0,0,1,1,1,1,
0,1,1,1,1,1,1,1,1,0,
1,1,1,1,1,1,1,1,0,0,
0,1,1,1,1,1,1,0,0,0,
};

ensuite on fait:

notre_reseau.Apprendre(nos_10_modeles, 10);

et voila notre reseau et pres !!!

maintenant pour l'utiliser il faut realiser un pattern de 10*10 d'un chiffre (par exemple un chiffre manuscrit assez ressemblant a un des modeles appris)

ensuite on fait :

notre_reseau.Calcul_Sortie(pattern_du_chiffre_manuscrit);

puis on lit le resultat si notre chiffre manuscrit a reconnaitre été un 3, on auras dans sortie le pattern du chiffre 3 appris au depard (ou un resultat trés proche , beaucoup plus proche que le 3 manuscrit)

comme sa on dirait que sa sert a rien!! mais faut pensser au OCR, reconnaissance de courbe,  ... il y a plein d'utilisation

desoler j'avais oublier ce petit detail de toute façon c'etait une verssion pour attendre la je me suis connecter pour mettre la nouvelle verssion !! (beaucoup plus "pro")