Ejemplo n.º 1
0
        public void Calculate(double[] INVector, double[] CibleVector, double[] CourantVector, NeuroneSortieListe pNeuronOutputs)
        {
            int count          = 0;
            var premiereCouche = Couches.First();

            if (Couches.Count > 1)
            {
                foreach (var neuron in premiereCouche.neurones)
                {
                    if (count < premiereCouche.neurones.Count)
                    {
                        //neuron.Sortie = 9;
                        neuron.Sortie = INVector[count];
                        count++;
                    }
                }


                // Calcul sur les couches cachées
                for (int i = 1; i < Couches.Count; i++)
                {
                    Couches[i].Calculate();
                }

                // Charge la sortie
                if (CourantVector != null)
                {
                    var lit = Couches[Couches.Count - 1];

                    for (int i = 0; i < lit.neurones.Count; i++)
                    {
                        CourantVector[i] = lit.neurones[i].Sortie;
                    }
                }


                if (pNeuronOutputs != null)
                {
                    pNeuronOutputs.Clear();
                    pNeuronOutputs.Capacity = Couches.Count;

                    foreach (CoucheBase cc in Couches)
                    {
                        var coucheSortie = new NeuroneSortie(cc.neurones.Count);
                        for (int i = 0; i < cc.neurones.Count; i++)
                        {
                            coucheSortie.Add(cc.neurones[i].Sortie);
                        }

                        pNeuronOutputs.Add(coucheSortie);
                    }
                }
            }
        }
Ejemplo n.º 2
0
        public void Backpropagate(
            ErreurListe dErr_wrt_dXn,
            ErreurListe dErr_wrt_dXnm1,
            NeuroneSortie CoucheCouranteSortie,
            NeuroneSortie CourantPrecedenteSortie,
            double etaTauxApprentissage
            )
        {
            try
            {
                double sortie;
                double oldValue;
                double newValue;

                ErreurListe dErr_wrt_dYn = new ErreurListe(neurones.Count);

                double[] dErr_wrt_dWn = new double[poids.Count];
                for (int i = 0; i < poids.Count; i++)
                {
                    dErr_wrt_dWn[i] = 0.0;
                }

                bool memorise = (CoucheCouranteSortie != null) && (CourantPrecedenteSortie != null);

                for (int i = 0; i < neurones.Count; i++)
                {
                    if (memorise != false)
                    {
                        sortie = CoucheCouranteSortie[i];
                    }
                    else
                    {
                        sortie = neurones[i].Sortie;
                    }

                    dErr_wrt_dYn.Add(hyperbolic.derivee(sortie) * dErr_wrt_dXn[i]);
                }


                //////////////
                uint indexNeurone;

                int _Index = 0;
                foreach (Neurone nn in neurones)
                {
                    foreach (Dentrite dd in nn.dentrite)
                    {
                        indexNeurone = dd.NeuroneIndex;

                        if (indexNeurone == 0xffffffff)
                        {
                            sortie = 1.0;
                        }

                        else
                        {
                            if (memorise != false)
                            {
                                sortie = CourantPrecedenteSortie[(int)indexNeurone];
                            }
                            else
                            {
                                sortie = CouchePrecedente.neurones[(int)indexNeurone].Sortie;
                            }
                        }
                        dErr_wrt_dWn[dd.PoidstIndex] += dErr_wrt_dYn[_Index] * sortie;
                    }
                    _Index++;
                }

                _Index = 0;
                int nIndex = 0;

                foreach (Neurone neuron in neurones)
                {
                    foreach (Dentrite dd in neuron.dentrite)
                    {
                        indexNeurone = dd.NeuroneIndex;

                        if (indexNeurone != 0xffffffff)
                        {
                            nIndex = (int)indexNeurone;
                            dErr_wrt_dXnm1[nIndex] += dErr_wrt_dYn[_Index] * poids[(int)dd.PoidstIndex].Value;
                        }
                    }

                    _Index++;
                }


                // Mise a jour des poids
                for (int j = 0; j < poids.Count; ++j)
                {
                    oldValue       = poids[j].Value;
                    newValue       = oldValue - etaTauxApprentissage * dErr_wrt_dWn[j];
                    poids[j].Value = newValue;
                }
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }