public Particle_swarm_optimization(FFANN ffann, double[][] stdDataset)
        {
            Random Rand = new Random();

            Cohesion   = Rand.NextDouble();
            Separation = Rand.NextDouble();
        }
Exemple #2
0
 public void ShowNetwork(FFANN ffann)
 {
     for (int i = 0; i < ffann.NumLayers; i++)
     {
         ffann.layer[i].showLayerAction();
     }
 }
Exemple #3
0
 public Layer(short n, FFANN parent, Random rand)
 {
     N          = n;
     ffann      = parent;
     perceptron = new Perceptron[ffann.NumPercept[N]];
     for (int i = 0; i < ffann.NumPercept[N]; i++)
     {
         perceptron[i] = new Perceptron(i, this, rand);
     }
 }
Exemple #4
0
 public void ShowWeights(FFANN ffann)
 {
     for (int i = 0; i < ffann.NumLayers; i++)
     {
         for (int j = 0; j < ffann.NumPercept[i]; j++)
         {
             Console.Write("\n");
             for (int k = 0; k < ffann.layer[i].perceptron[j].NumSynapses; k++)
             {
                 Console.WriteLine("Layer " + i + " percettrone " + j + " sinapsi " + k + ": " + ffann.layer[i].perceptron[j].getSynapsys(k));
             }
         }
     }
 }
        //Calcola la variazione dei pesi sinaptici da applicare a ciascun collegamento sinaptico.
        //Per ogni neurone interno sommo gli errori delle SUE SINAPSI e basta.
        private double Delta(FFANN ffann, int j, int k, int q)
        {
            double delta = 0;

            if (j == ffann.NumLayers - 2)
            {
                delta = (-desired_output[q] + ffann.layer[j + 1].perceptron[q].getAction()) * (ffann.layer[j + 1].perceptron[q].getAction() * (1 - ffann.layer[j + 1].perceptron[q].getAction()));
            }
            else
            {
                delta = dterr[j + 1][q] * (ffann.layer[j + 1].perceptron[q].getAction() * (1 - ffann.layer[j + 1].perceptron[q].getAction()));
            }

            dterr[j][k] += delta * ffann.layer[j].perceptron[k].getSynapsys(q);
            return(c1 * delta * ffann.layer[j].perceptron[k].getAction());
        }
        //Costruttore, si occupa dell'allenamento vero e proprio.
        public RPropPlus(FFANN ffann, double[][] stdDataset)
        {
            int epochs = 0;

            double[][][] delta = new double[ffann.NumLayers - 1][][]; //Matrice delta che conterrà le correzione dei pesi da applicare alla fine della propagazione.
            desired_output = new double[ffann.NumPercept[ffann.NumLayers - 1]];
            dterr          = new double[ffann.NumLayers - 1][];

            //inizializzazione di delta[][][].
            for (int i = 0; i < ffann.NumLayers - 1; i++)
            {
                delta[i] = new double[ffann.NumPercept[i]][];
            }
            for (int j = 0; j < delta.Length; j++)
            {
                for (int i = 0; i < delta[j].Length; i++) //Calcolo il numero totale di sinapsi nella rete.
                {
                    delta[j][i] = new double[ffann.NumPercept[j + 1]];
                }
            }
            //Fine inizializzazione delta[][][].

            //Inizializzo ed azzero la matrice dterr.
            for (int i = 0; i < ffann.NumLayers - 1; i++)
            {
                dterr[i] = new double[ffann.NumPercept[i]];
                for (int z = 0; z < ffann.NumPercept[i]; z++)
                {
                    dterr[i][z] = 0;
                }
            }
            //Fine azzeramento.

            do                                              //Scorro le epoche in cui la rete si allenerà.
            {
                for (int i = 0; i < stdDataset.Length; i++) //Scorro tutti i samples nel dataset.
                {
                    Error = 0;

                    ffann.Predict(stdDataset[i]); //Calcolo le uscite della rete dato il sample i.

                    //Copio i valori desiderati in un vettore comodo e calcolo l'Errore Quadratico Medio.
                    for (int j = 0; j < ffann.NumPercept[ffann.NumLayers - 1]; j++)
                    {
                        desired_output[j] = stdDataset[i][ffann.NumPercept[0] + j];
                        Error            += 0.5 * Math.Pow(ffann.layer[ffann.NumLayers - 1].perceptron[j].getAction() - desired_output[j], 2);
                    }
                    //End

                    //Calcolo i delta dei pesi sinaptici.
                    for (int j = ffann.NumLayers - 2; j >= 0; j--)            //Scorro la rete dal penultimo layer al primo, per avere accesso diretto ai pesi sinaptici da correggere.
                    {
                        for (int k = 0; k < ffann.NumPercept[j]; k++)         // Scorro i percettroni dello strato j.
                        {
                            for (int q = 0; q < ffann.NumPercept[j + 1]; q++) // Scorro le sinapsi.
                            {
                                delta[j][k][q] = Delta(ffann, j, k, q);
                            }
                        }
                    }

                    //Setto i nuovi pesi applicando i delta dei pesi sinaptici.
                    for (int j = 0; j < ffann.NumLayers - 1; j++)
                    {
                        for (int k = 0; k < ffann.NumPercept[j]; k++)
                        {
                            for (int q = 0; q < ffann.NumPercept[j + 1]; q++)
                            {
                                ffann.layer[j].perceptron[k].setSynapsys(ffann.layer[j].perceptron[k].getSynapsys(q) + delta[j][k][q], q);
                            }
                        }
                    }

                    //è necessario azzerare dterr per ogni sample analizzato.
                    for (int j = 0; j < dterr.Length; j++)
                    {
                        for (int z = 0; z < dterr[j].Length; z++)
                        {
                            dterr[j][z] = 0;
                        }
                    }
                    //Fine azzeramento.
                }

                //Stampa l'errore quadratico medio se if è true.
                if (epochs % 1000 == 0)
                {
                    Console.WriteLine("\nErrore Quadratico Medio: " + Error + "\n");
                }
                epochs++;
                if (Error <= 0.00001)
                {
                    Console.Write("\nEpoche: " + epochs + "\n");
                }
            } while ((epochs != 100000) && (Error >= 0.00001));
        }
 private void Mutate(FFANN ffann)
 {
 }
 private void Cross(FFANN ffann)
 {
 }
        public Genetic(FFANN ffann, double[][] stdDataset)
        {
            Random Rand = new Random();

            Fitness = Rand.NextDouble();
        }
Exemple #10
0
        static void Main(string[] args)
        {
            string[][] Dataset;
            double[][] stdDataset;
            double[]   data;
            string[]   colTypes;

            Console.WriteLine("Ciao e benvenuto nella Learning Part di Jarvis 0.1.");
            Console.ReadKey();

            //Segmento di prova per la standardizzazione dei dati in ingresso (Solo numerici e categorici, no audio/immagini)
            string buffer;
            string datasetPath = "C:/Users/Shea/Documents/Visual Studio 2015/Projects/ConsoleApplication1/Dataset.txt";

            Console.WriteLine("Ora leggo il Dataset " + datasetPath + ":");
            Console.ReadKey();

            int numSamples;
            int i = 0;

            StreamReader reader = new StreamReader(datasetPath);

            colTypes   = reader.ReadLine().Split(' ');
            numSamples = File.ReadAllLines(datasetPath).Length - 1;
            Dataset    = new string[numSamples][];
            data       = new double[colTypes.Length];

            while ((buffer = reader.ReadLine()) != null)
            {
                Dataset[i++] = buffer.Split(' ');
            }
            ;

            Console.WriteLine("\nDataset letto: \n");
            for (i = 0; i < Dataset.Length; i++)
            {
                Console.Write("\n");
                for (int j = 0; j < Dataset[0].Length; j++)
                {
                    Console.WriteLine("{0} ", Dataset[i][j]);
                }
            }
            Console.ReadKey();
            Console.WriteLine("\nLettura effettuata con successo. Provvedo ora a standardizzare il dataset...");
            Console.ReadKey();

            Standardizer std = new Standardizer(Dataset, colTypes);

            stdDataset = std.StandardizeAll(Dataset);
            Helpers helper = new Helpers();

            Console.WriteLine("Dati standardizzati:\n");
            helper.ShowMatrix(stdDataset, numSamples, stdDataset[0].Length);
            Console.ReadKey();
            //Fine segmento di Prova

            Console.WriteLine("Dati standardizzati con successo. Ora inizializzo la Rete Neurale...");
            Console.ReadKey();

            FFANN ffann = new FFANN(colTypes.Length, stdDataset[0].Length - Dataset[0].Length + 1); //Setting Network parameters & Creating it.

            Console.WriteLine("\nStruttura della Rete Neurale: \n");
            helper.ShowWeights(ffann);
            Console.ReadKey();

            Console.WriteLine("Rete inizializzata correttamente, ora avvìo l'allenamento della Rete Neurale mediante Backpropagation...");
            Console.ReadKey();

            RPropPlus trainer = new RPropPlus(ffann, stdDataset);

            Console.WriteLine("\nNuova struttura della Rete Neurale: \n");
            helper.ShowWeights(ffann);
            Console.ReadKey();

            Console.WriteLine("Allenamento avvenuto con successo, inserire i dati di prova per effettuare una predizione: ");
            string[] buff;
            char     c;

            do
            {
                do
                {
                    buffer = Console.ReadLine();
                    buff   = buffer.Split(' ');
                } while (buff.Length != colTypes.Length - 1);



                data = std.GetStandardRow(buff);
                ffann.PredictShow(data);
                Console.ReadKey();
                Console.WriteLine("\nProvare ancora? 'y' = yes, others = no: ");
            } while (Console.ReadLine().Equals("y"));
        }