public void TestSOM()
        {
            // create the training set
            IMLDataSet training = new BasicMLDataSet(
                SOMInput, null);

            // Create the neural network.
            var network = new SOMNetwork(4, 2)
            {
                Weights = new Matrix(MatrixArray)
            };

            var train = new BasicTrainSOM(network, 0.4,
                                          training, new NeighborhoodSingle())
            {
                ForceWinner = true
            };
            int iteration = 0;

            for (iteration = 0; iteration <= 100; iteration++)
            {
                train.Iteration();
            }

            IMLData data1 = new BasicMLData(
                SOMInput[0]);
            IMLData data2 = new BasicMLData(
                SOMInput[1]);

            int result1 = network.Classify(data1);
            int result2 = network.Classify(data2);

            Assert.IsTrue(result1 != result2);
        }
Example #2
0
        public SOMColors()
        {
            InitializeComponent();

            network  = CreateNetwork();
            gaussian = new NeighborhoodRBF(RBFEnum.Gaussian, WIDTH, HEIGHT);
            train    = new BasicTrainSOM(network, 0.01, null, gaussian);

            train.ForceWinner = false;
            samples           = AIFH.Alloc2D <double>(15, 3);

            for (int i = 0; i < 15; i++)
            {
                samples[i][0] = rnd.NextDouble(-1, 1);
                samples[i][1] = rnd.NextDouble(-1, 1);
                samples[i][2] = rnd.NextDouble(-1, 1);
            }

            train.SetAutoDecay(100, 0.8, 0.003, 30, 5);
        }
Example #3
0
        public SOMColors()
        {
            InitializeComponent();

            this.network  = CreateNetwork();
            this.gaussian = new NeighborhoodRBF(RBFEnum.Gaussian, SOMColors.WIDTH, SOMColors.HEIGHT);
            this.train    = new BasicTrainSOM(this.network, 0.01, null, gaussian);

            train.ForceWinner = false;

            samples = new List <IMLData>();
            for (int i = 0; i < 15; i++)
            {
                IMLData data = new BasicMLData(3);
                data.Data[0] = RangeRandomizer.Randomize(-1, 1);
                data.Data[1] = RangeRandomizer.Randomize(-1, 1);
                data.Data[2] = RangeRandomizer.Randomize(-1, 1);
                samples.Add(data);
            }

            this.train.SetAutoDecay(100, 0.8, 0.003, 30, 5);
        }
Example #4
0
        private void Do()
        {
            network  = CreateNetwork();
            gaussian = new NeighborhoodRBF(RBFEnum.Gaussian, WIDTH, HEIGHT);
            train    = new BasicTrainSOM(network, 0.01, null, gaussian);

            train.ForceWinner = false;

            samples = new List <IMLData>();
            for (int i = 0; i < 200; i++)
            {
                var data = new BasicMLData(3);
                data.Data[0] = RangeRandomizer.Randomize(-1, 1);
                data.Data[1] = RangeRandomizer.Randomize(-1, 1);
                data.Data[2] = RangeRandomizer.Randomize(-1, 1);
                samples.Add(data);
            }

            train.SetAutoDecay(100, 0.8, 0.003, 30, 5);

            iteration           = 0;
            updateTimer.Enabled = true;
        }
        static void Main(string[] args)
        {
            BasicMLDataSet data_training = new BasicMLDataSet();
            Random         rdn           = new Random();
            ////////////////////////////////////////////////////////////////////////////

            //simulação de dados por arquivo:
            var           neuralFile = File.ReadAllLines(@"C:\Users\bredi\Desktop\TCC\TCC\neural_1.txt");
            List <string> NeuralList = new List <string>(neuralFile);

            double[][] entradafull = new double[NeuralList.Count][];
            double[][] saidafull   = new double[NeuralList.Count][];

            int i = 0;

            foreach (var item in NeuralList)
            {
                var t = item.Split(new string[] { "::" }, StringSplitOptions.None);

                double[] entrada = new double[]
                {
                    //System.Convert.ToDouble(t[0]),//hora
                    System.Convert.ToDouble(t[1]), //tempA
                    System.Convert.ToDouble(t[2])  //setA
                    //System.Convert.ToDouble(t[3]),//tempB
                    //System.Convert.ToDouble(t[4])//setB
                };
                entradafull[i] = entrada;

                /*double a = System.Convert.ToDouble(t[5]);
                 * if (a == 1)
                 *  a = 0.5f;
                 * else
                 *  a = 0.5f;
                 * double b = System.Convert.ToDouble(t[6]);
                 * if (b == 1)
                 *  b = 0.5f;
                 * else if (b == 0)
                 *  b = 0.5f;*/

                double[] saida = new double[]
                {
                    System.Convert.ToDouble(t[5])//saidaA
                    //System.Convert.ToDouble(t[6])//saidaB
                };

                saidafull[i] = saida;
                i++;

                data_training.Add(new BasicMLData(entrada), null);
            }

            //IMLDataSet data_training = new BasicMLDataSet(entradafull, saidafull);//ANTIGO COM SAIDA

            //////////////////////////////////////////////////////////

            int N_entradas = 2;
            int tamanho_X  = 100; //100
            int tamanho_Y  = 100; //100
            int N_saidas   = tamanho_X * tamanho_Y;

            int    interacoesPlanejada = 1000;
            int    vizinho_inicial     = 50;//50
            int    vizinho_final       = 1;
            double rate_inicial        = 1;
            double rate_final          = 0.1;

            //Criação de rede SOM.(número de entradas, número de saídas)
            SOMNetwork network = new SOMNetwork(N_entradas, N_saidas);

            network.Reset();

            //Criação da função de ativação.(função gaussiana 2D, largura da rede, altura da rede)
            NeighborhoodRBF gaussian = new NeighborhoodRBF(RBFEnum.MexicanHat, tamanho_X, tamanho_Y);

            //(rede neural, taxa de aprendizado, conjunto de treinamento, função de vizinhança)
            BasicTrainSOM train = new BasicTrainSOM(network, 0.01, null, gaussian);

            train.ForceWinner = false;
            train.SetAutoDecay(interacoesPlanejada, rate_inicial, rate_final, vizinho_inicial, vizinho_final);

            //TREINAMENTO RANDOMICO:
            for (int decay = 0; decay < interacoesPlanejada; decay++)
            {
                var idx = int.Parse(Math.Round(rdn.NextDouble() * saidafull.Length).ToString()) - 1;
                if (idx == -1)
                {
                    idx = 0;
                }
                var data = data_training[idx].Input;
                train.TrainPattern(data);
                train.AutoDecay();
                Console.WriteLine(string.Format("Epoch {0}, Rate: {1}, Radius: {2}, Error: {3}", decay, train.LearningRate, train.Neighborhood.Radius, train.Error));
            }

            /*for (int tx = 0; tx < interacoesPlanejada; tx++)
             * {
             *  train.Iteration();
             *  train.AutoDecay();
             *  Console.WriteLine(string.Format("Epoch {0}, Rate: {1}, Radius: {2}, Error: {3}", i, train.LearningRate, train.Neighborhood.Radius, train.Error));
             * }*/

            //////////////////////////////////////////////////////////
            //arquivo visual//////////////////////////////////////////////////////////

            string[,] arrayprint = new string[tamanho_X, tamanho_Y];


            for (int x = 0; x < tamanho_X; x++)
            {
                for (int y = 0; y < tamanho_Y; y++)
                {
                    arrayprint[x, y] = "  ";
                }
            }

            /*for (int TempA = 15; TempA < 25; TempA++)
             * {
             *  for (int SetA = 15; SetA < 25; SetA++)
             *  {
             *      for (int TempB = 15; TempB < 25; TempB++)
             *      {
             *          for (int SetB = 15; SetB < 25; SetB++)
             *          {
             *              BasicMLData dataentradateste = new BasicMLData(new double[] { TempA, SetA, TempB, SetB });
             *              var retorno = network.Classify(dataentradateste);
             *              //Console.WriteLine(retorno + " ||| SetA: " + SetA + " | TempA: " + TempA + " ||| SetB: " + 20 + " | TempB: " + 0);
             *              var tuple = convertToXY(retorno, tamanho_X, tamanho_Y);
             *              var array_v = arrayprint[tuple.Item1, tuple.Item2];
             *              if(array_v == "  ")
             *              {
             *                  string saida = "";
             *                  if(TempA >= SetA)
             *                      saida += "a";
             *                  else if(TempA < SetA)
             *                      saida += "A";
             *                  else
             *                      saida += "#";
             *
             *                  if (TempB >= SetB)
             *                      saida += "b";
             *                  else if (TempB < SetB)
             *                      saida += "B";
             *                  else
             *                      saida += "#";
             *
             *                  arrayprint[tuple.Item1, tuple.Item2] = saida;
             *              }
             *          }
             *      }
             *
             *  }
             * }*/

            List <int> Lista_0 = new List <int>();
            List <int> Lista_1 = new List <int>();

            for (int TempA = -49; TempA < 50; TempA++)
            {
                for (int SetA = -49; SetA < 50; SetA++)
                {
                    BasicMLData dataentradateste = new BasicMLData(new double[] { Normalizacao.Norm_Temp(TempA), Normalizacao.Norm_Temp(SetA) });
                    var         retorno          = network.Classify(dataentradateste);
                    //Console.WriteLine(retorno + " ||| SetA: " + SetA + " | TempA: " + TempA + " ||| SetB: " + 20 + " | TempB: " + 0);
                    var tuple   = convertToXY(retorno, tamanho_X, tamanho_Y);
                    var array_v = arrayprint[tuple.Item1, tuple.Item2];
                    if (array_v == "  ")
                    {
                        string saida = " ";
                        if (TempA >= SetA)
                        {
                            if (Lista_1.Contains(retorno))
                            {
                                saida += "#";
                            }
                            else
                            {
                                Lista_0.Add(retorno);
                                saida += "0";
                            }
                        }
                        else if (TempA < SetA)
                        {
                            if (Lista_0.Contains(retorno))
                            {
                                saida += "#";
                            }
                            else
                            {
                                Lista_1.Add(retorno);
                                saida += "1";
                            }
                        }
                        else
                        {
                            saida += "#";
                        }

                        arrayprint[tuple.Item1, tuple.Item2] = saida;
                    }
                }
            }


            StringBuilder fileContents = new StringBuilder();

            for (int x = 0; x < tamanho_X; x++)
            {
                for (int y = 0; y < tamanho_Y; y++)
                {
                    fileContents.Append(arrayprint[x, y]);
                }
                fileContents.AppendLine("|");
            }
            File.WriteAllText(@"C:\Users\bredi\Documents\mapaneural.txt", fileContents.ToString());

            //////////////////////////////////////////////////////////
            ////salvar network:

            string path = Path.Combine(@"C:\Users\bredi\Desktop\TCC\TCC", "redeneural" + DateTime.Now.Ticks + ".txt");

            if (File.Exists(path))
            {
                File.Delete(path);
            }

            FileStream fs         = new FileStream(path, FileMode.CreateNew, FileAccess.Write);
            PersistSOM persistSOM = new PersistSOM();

            persistSOM.Save(fs, network);
            fs.Close();

            //////////////////////////////////////////////////////////
            //testes//////////////////////////////////////////////////////////
            DateTime datahora_atual = DateTime.MinValue;

            do
            {
                DateTime datahora = Simulation.Memory.Get().dmDateTime.DataHora;
                var      Dados_D  = Simulation.Input.Termostato_D();
                var      Dados_E  = Simulation.Input.Termostato_E();

                if (datahora >= datahora_atual.AddSeconds(.5))
                {
                    datahora_atual = datahora;
                    //double hora = Normalizacao.Norm_DataHoraSeg(datahora);

                    //BasicMLData dataentradateste = new BasicMLData(new double[] { hora, TempA, SetA, TempB, SetB });
                    //BasicMLData dataentradateste = new BasicMLData(new double[] { TempA, SetA, TempB, SetB });
                    BasicMLData dataentradateste = new BasicMLData(new double[] { Dados_D.TemperaturaNormalizado, Dados_D.SetPointNormalizado });

                    var retorno = network.Winner(dataentradateste);

                    if (Lista_0.Contains(retorno))
                    {
                        //desligar
                        Simulation.Output.DesligarAquecedor_D();
                        Simulation.Output.DesligarAquecedor_E();
                        Console.WriteLine(retorno + " | OFF | ");
                    }
                    else if (Lista_1.Contains(retorno))
                    {
                        //ligar
                        Simulation.Output.LigarAquecedor_D();
                        Simulation.Output.LigarAquecedor_E();
                        Console.WriteLine(retorno + " | ON | ");
                    }
                    else
                    {
                        Console.WriteLine(retorno + " | OUT | ");
                    }
                }
            }while (true);
        }
        /// <summary>
        /// Create a LMA trainer.
        /// </summary>
        ///
        /// <param name="method">The method to use.</param>
        /// <param name="training">The training data to use.</param>
        /// <param name="argsStr">The arguments to use.</param>
        /// <returns>The newly created trainer.</returns>
        public IMLTrain Create(IMLMethod method,
                               IMLDataSet training, String argsStr)
        {
            if (!(method is SupportVectorMachine))
            {
                throw new EncogError(
                          "Neighborhood training cannot be used on a method of type: "
                          + method.GetType().FullName);
            }

            IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr);
            var holder = new ParamsHolder(args);

            double learningRate = holder.GetDouble(
                MLTrainFactory.PropertyLearningRate, false, 0.7d);
            String neighborhoodStr = holder.GetString(
                MLTrainFactory.PropertyNeighborhood, false, "rbf");
            String rbfTypeStr = holder.GetString(
                MLTrainFactory.PropertyRBFType, false, "gaussian");

            RBFEnum t;

            if (rbfTypeStr.Equals("Gaussian", StringComparison.InvariantCultureIgnoreCase))
            {
                t = RBFEnum.Gaussian;
            }
            else if (rbfTypeStr.Equals("Multiquadric", StringComparison.InvariantCultureIgnoreCase))
            {
                t = RBFEnum.Multiquadric;
            }
            else if (rbfTypeStr.Equals("InverseMultiquadric", StringComparison.InvariantCultureIgnoreCase))
            {
                t = RBFEnum.InverseMultiquadric;
            }
            else if (rbfTypeStr.Equals("MexicanHat", StringComparison.InvariantCultureIgnoreCase))
            {
                t = RBFEnum.MexicanHat;
            }
            else
            {
                t = RBFEnum.Gaussian;
            }

            INeighborhoodFunction nf = null;

            if (neighborhoodStr.Equals("bubble", StringComparison.InvariantCultureIgnoreCase))
            {
                nf = new NeighborhoodBubble(1);
            }
            else if (neighborhoodStr.Equals("rbf", StringComparison.InvariantCultureIgnoreCase))
            {
                String str = holder.GetString(
                    MLTrainFactory.PropertyDimensions, true, null);
                int[] size = NumberList.FromListInt(CSVFormat.EgFormat, str);
                nf = new NeighborhoodRBF(size, t);
            }
            else if (neighborhoodStr.Equals("rbf1d", StringComparison.InvariantCultureIgnoreCase))
            {
                nf = new NeighborhoodRBF1D(t);
            }
            if (neighborhoodStr.Equals("single", StringComparison.InvariantCultureIgnoreCase))
            {
                nf = new NeighborhoodSingle();
            }

            var result = new BasicTrainSOM((SOMNetwork)method,
                                           learningRate, training, nf);

            if (args.ContainsKey(MLTrainFactory.PropertyIterations))
            {
                int plannedIterations = holder.GetInt(
                    MLTrainFactory.PropertyIterations, false, 1000);
                double startRate = holder.GetDouble(
                    MLTrainFactory.PropertyStartLearningRate, false, 0.05d);
                double endRate = holder.GetDouble(
                    MLTrainFactory.PropertyEndLearningRate, false, 0.05d);
                double startRadius = holder.GetDouble(
                    MLTrainFactory.PropertyStartRadius, false, 10);
                double endRadius = holder.GetDouble(
                    MLTrainFactory.PropertyEndRadius, false, 1);
                result.SetAutoDecay(plannedIterations, startRate, endRate,
                                    startRadius, endRadius);
            }

            return(result);
        }