double[,] tabpoids; // Matrice d'adjacence des poids synaptiques
#endregion Fields
#region Constructors
// Constructeur
// On initialise un réseau de neurones à partir du nombre d'entrées, du nb de couches
// et du nb de neurones par couche
public Reseau(int nbentrees, int nbcouches, int neuronesparcouche)
{
int i, j, k, cpt;
Neurone neurone;
// Nombre de neurones
// nbneurones= nbentrees+(nbcouches-2)*neuronesparcouche+1;
// Initialisation des listes avant de poursuivre
listeneurones = new List<Neurone>();
tabcouches = new List<Neurone>[nbcouches];
for (i = 0; i < nbcouches; i++)
{
tabcouches[i] = new List<Neurone>();
}
cpt = -1;
for (i = 0; i < nbentrees; i++)
{
cpt++;
neurone = new Neurone(cpt, 0);
listeneurones.Add(neurone);
tabcouches[0].Add(neurone);
}
// On fait les couches cachées :
for (i = 1; i < nbcouches - 1; i++)
for (j = 0; j < neuronesparcouche; j++)
{
cpt++;
neurone = new Neurone(cpt, i);
listeneurones.Add(neurone);
tabcouches[i].Add(neurone);
// Connexion avec neurones couche précédente
for (k = 0; k < tabcouches[i - 1].Count; k++)
{
tabcouches[i - 1][k].sorties.Add(neurone);
neurone.entrees.Add(tabcouches[i - 1][k]);
}
}
// On fait le neurone de sortie
cpt++;
neurone = new Neurone(cpt, nbcouches - 1);
listeneurones.Add(neurone);
tabcouches[nbcouches - 1].Add(neurone);
// Connexion avec neurones couche précédente
for (k = 0; k < tabcouches[nbcouches - 2].Count; k++)
{
tabcouches[nbcouches - 2][k].sorties.Add(neurone);
neurone.entrees.Add(tabcouches[nbcouches - 2][k]);
}
// Initialisation de la matrice des poids synap. : 0= pas de synapse
int nbneurones = listeneurones.Count;
tabpoids = new double[nbneurones, nbneurones];
Random rnd = new Random();
for (i = 0; i < nbneurones; i++)
for (j = 0; j < nbneurones; j++)
tabpoids[i, j] = rnd.NextDouble()*2-1;
}
/*****************************************************************/
// Calcul nécessaire pour backprop
private double sommedelta(Neurone neur)
{
int i;
Neurone neuronesucc;
double somme;
somme = 0;
for (i = 0; i < neur.sorties.Count; i++)
{
neuronesucc = neur.sorties[i];
somme = somme + tabpoids[neur.GetNumero(), neuronesucc.GetNumero()]
* neuronesucc.Getdelta();
}
return(somme);
}
/*****************************************************************/
// Calcul nécessaire pour backprop
private double sommedelta(Neurone neur)
{
int i;
Neurone neuronesucc;
double somme;
somme = 0;
for (i = 0; i < neur.sorties.Count; i++)
{
neuronesucc = neur.sorties[i];
somme = somme + tabpoids[neur.GetNumero(), neuronesucc.GetNumero()]
* neuronesucc.Getdelta();
}
return somme;
}
double[,] tabpoids; // Matrice d'adjacence des poids synaptiques
// Constructeur
// On initialise un réseau de neurones à partir du nombre d'entrées, du nb de couches
// et du nb de neurones par couche
public Reseau(int nbentrees, int nbcouches, int neuronesparcouche)
{
int i, j, k, cpt;
Neurone neurone;
// Nombre de neurones
// nbneurones= nbentrees+(nbcouches-2)*neuronesparcouche+1;
// Initialisation des listes avant de poursuivre
listeneurones = new List <Neurone>();
tabcouches = new List <Neurone> [nbcouches];
for (i = 0; i < nbcouches; i++)
{
tabcouches[i] = new List <Neurone>();
}
cpt = -1;
for (i = 0; i < nbentrees; i++)
{
cpt++;
neurone = new Neurone(cpt, 0);
listeneurones.Add(neurone);
tabcouches[0].Add(neurone);
}
// On fait les couches cachées :
for (i = 1; i < nbcouches - 1; i++)
{
for (j = 0; j < neuronesparcouche; j++)
{
cpt++;
neurone = new Neurone(cpt, i);
listeneurones.Add(neurone);
tabcouches[i].Add(neurone);
// Connexion avec neurones couche précédente
for (k = 0; k < tabcouches[i - 1].Count; k++)
{
tabcouches[i - 1][k].sorties.Add(neurone);
neurone.entrees.Add(tabcouches[i - 1][k]);
}
}
}
// On fait le neurone de sortie
cpt++;
neurone = new Neurone(cpt, nbcouches - 1);
listeneurones.Add(neurone);
tabcouches[nbcouches - 1].Add(neurone);
// Connexion avec neurones couche précédente
for (k = 0; k < tabcouches[nbcouches - 2].Count; k++)
{
tabcouches[nbcouches - 2][k].sorties.Add(neurone);
neurone.entrees.Add(tabcouches[nbcouches - 2][k]);
}
// Initialisation de la matrice des poids synap. : 0= pas de synapse
int nbneurones = listeneurones.Count;
tabpoids = new double[nbneurones, nbneurones];
Random rnd = new Random();
for (i = 0; i < nbneurones; i++)
{
for (j = 0; j < nbneurones; j++)
{
tabpoids[i, j] = rnd.NextDouble() * 2 - 1;
}
}
}