コード例 #1
0
        /*****************************************************************/
        // 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);
        }
コード例 #2
0
        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;
                }
            }
        }