Reseaux neuronaux : modele de hopfield

Commenter

Contenu du snippet

Une classe qui peut-etre utiliser pour simuler un reseaux de Hopfield (tous les neurones sont connecter a tous les autres)

Un reseau de neurone comme celui de Hopfield sert normalement a faire de la reconnaisance de forme (apres lui avoir appris ce qu'est un 1, un 2 , ... le programme peu reconnaitre des 1 , des 2 manuscrit assez proche du modele appris (comme dans les Palms)).

pas encore de ZIP mais sa va venir !!

Source / Exemple : 


//Hopfield.h

#include <stdlib.h> //pour calloc

//definition d'un neurone (08/01/04 19:22)
class Hopfield
{
private:

#define egal(a,b) (a == b ? 1 : -1) //1 si egaux -1 si different
#define T(a) (a<0 ? -1 : 1)	//signe

int** poids; //poids associer entre les neurones i & j : "poids[i][j]" 

public:

int* sortie;
int nb_neurone;

//fonction du reseau
void Apprendre(int** Modele,int nb_modele); //apprendre une series de modeles
void Definir(int nb_neurone); //initialise tous les poids a 0
void Calcul_Sortie(int* entree);

};//fin de la class Hopfield

void Hopfield::Apprendre(int** Modele,int nb_modele) //apprendre une series de modeles
{
for (int i = 0; i< nb_neurone; i++)
for (int j = 0; j<nb_neurone; j++) //ttes les liaisons
for (int k=0; k<nb_modele; k++){ //ts les modeles
if (i==j)
poids[i][j]=0;
else
poids[i][j]+= egal(Modele[k][i],Modele[k][j]);
}
}

void Hopfield::Definir(int nb_neurone) //initialise tous les poids a 0
{

int i;
Hopfield::nb_neurone=nb_neurone;

free (poids);
free(sortie);

poids = (int**) calloc(nb_neurone,sizeof(int*));
sortie = (int*) calloc(nb_neurone,sizeof(int));

for (i=0; i<nb_neurone; i++)
poids[i]= (int*) calloc(nb_neurone-i,sizeof(int)); 

for (i = 0; i< nb_neurone; i++)
for (int j = 0; j<nb_neurone; j++) //ttes les liaisons
poids[i][j]=0; 
}

void Hopfield::Calcul_Sortie(int* entree)
{
int modif = true;
int* temp;

temp =(int*)calloc(nb_neurone,sizeof(int));

for (int i = 0 ; i<nb_neurone;i++)
{
sortie[i]=entree[i];
temp[i]=0;
}

while (modif !=false) //tant que l'on a pas atteint un etat stable
{
modif = false;

for (int i= 0 ; i<nb_neurone; i++)
{
for (int j = 0 ; j<nb_neurone ; j++)
{
temp[j]+=poids[i][j] * sortie[j];
}
}//etape Calcule
for (int i=0; i<nb_neurone; i++)
if (sortie[i]!=T(temp[i]))
{
sortie[i]=temp[i];
modif=true;
}
}//etat stable trouver ?
}

Conclusion :


Pour utiliser cette classe :

#include <Hopfield.h>

//pour crée le reseau :
Hopfield Nom_du_reseau(nombre_de_neurone);

Nom_du_reseau.initialise();

//pour lui apprendre un ou plusieur modele:
Nom_du_reseau.Apprendre(modeles_a_apprendre, nombre de modeles);

//pour calculer sa sortie
Nom_du_reseau.Calcul_Sortie(entree_du_reseau);

//La forme des entrée ,sortie est:
int* soit entrée[nombre_de_neurone]
sortie[nombre_de_neurone]

//la forme des modeles est:
int** soit modele[nombre_de_modele][nombre_de_neurone]

ATT: un reseau de Hopfield ne peut pas memoiriser plus de 0.13*nombre_de_neurone modeles sinon il devient "amnesique"

Voila je crois que tout est dit !!

PS: Ce code est le sujet de mon TPE de SI merci de me le dire si vous y voyez des erreurs !

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.