Exemplo n.º 1
0
        static void Main(string[] args)
        {
            //Tabla de verdad XOR
            int[,] xorentra = { { 1, 1 }, { 1, 0 }, { 0, 1 }, { 0, 0 } };
            int[] xorsale = { 0, 1, 1, 0 };

            int        numEntradas = 2; //Número de entradas
            int        capa0       = 4; //Total neuronas en la capa 0
            int        capa1       = 4; //Total neuronas en la capa 1
            int        capa2       = 1; //Total neuronas en la capa 2
            Perceptron perceptron  = new Perceptron(numEntradas, capa0, capa1, capa2);

            //Estas serán las entradas externas al perceptrón
            List <double> entradas = new List <double>();

            entradas.Add(0);
            entradas.Add(0);

            //Estas serán las salidas esperadas externas al perceptrón
            List <double> salidaEsperada = new List <double>();

            salidaEsperada.Add(0);

            //Ciclo que entrena la red neuronal
            int totalCiclos = 8000;             //Ciclos de entrenamiento

            for (int ciclo = 1; ciclo <= totalCiclos; ciclo++)
            {
                //Por cada ciclo, se entrena el perceptrón con toda la tabla de XOR

                //Cada 200 ciclos muestra como progresa el entrenamiento
                if (ciclo % 200 == 0)
                {
                    Console.WriteLine("Ciclo: " + ciclo.ToString());
                }

                for (int conjunto = 0; conjunto < xorsale.Length; conjunto++)
                {
                    //Entradas y salidas esperadas
                    entradas[0]       = xorentra[conjunto, 0];
                    entradas[1]       = xorentra[conjunto, 1];
                    salidaEsperada[0] = xorsale[conjunto];

                    //Primero calcula la salida del perceptrón con esas entradas
                    perceptron.calculaSalida(entradas);

                    //Luego entrena el perceptrón para ajustar los pesos y umbrales
                    perceptron.Entrena(entradas, salidaEsperada);

                    //Cada 200 ciclos muestra como progresa el entrenamiento
                    if (ciclo % 200 == 0)
                    {
                        perceptron.SalidaPerceptron(entradas, salidaEsperada[0]);
                    }
                }
            }

            Console.WriteLine("Finaliza");
            Console.ReadKey();
        }
Exemplo n.º 2
0
        static void Main(string[] args)
        {
            //El número "dibujado" en el reloj digital
            int[,] relojEntra = { { 1, 1, 1, 0, 1, 1, 1 },
                                  { 0, 0, 1, 0, 0, 1, 0 },
                                  { 1, 0, 1, 1, 1, 0, 1 },
                                  { 1, 0, 1, 1, 0, 1, 1 },
                                  { 0, 1, 1, 1, 0, 1, 0 },
                                  { 1, 1, 0, 1, 0, 1, 1 },
                                  { 1, 1, 0, 1, 1, 1, 1 },
                                  { 1, 0, 1, 0, 0, 1, 0 },
                                  { 1, 1, 1, 1, 1, 1, 1 },
                                  { 1, 1, 1, 1, 0, 1, 1 } };
            //El número en binario
            int[,] numeroEsperado = { { 0, 0, 0, 0 },
                                      { 0, 0, 0, 1 },
                                      { 0, 0, 1, 0 },
                                      { 0, 0, 1, 1 },
                                      { 0, 1, 0, 0 },
                                      { 0, 1, 0, 1 },
                                      { 0, 1, 1, 0 },
                                      { 0, 1, 1, 1 },
                                      { 1, 0, 0, 0 },
                                      { 1, 0, 0, 1 } };

            int        numEntradas = 7; //Número de entradas
            int        capa0       = 5; //Total neuronas en la capa 0
            int        capa1       = 5; //Total neuronas en la capa 1
            int        capa2       = 4; //Total neuronas en la capa 2
            Perceptron perceptron  = new Perceptron(numEntradas, capa0, capa1, capa2);

            //Estas serán las entradas externas al perceptrón
            List <double> entradas = new List <double>();

            entradas.Add(0);
            entradas.Add(0);
            entradas.Add(0);
            entradas.Add(0);
            entradas.Add(0);
            entradas.Add(0);
            entradas.Add(0);

            //Estas serán las salidas esperadas externas al perceptrón
            List <double> salidaEsperada = new List <double>();

            salidaEsperada.Add(0);
            salidaEsperada.Add(0);
            salidaEsperada.Add(0);
            salidaEsperada.Add(0);

            //Ciclo que entrena la red neuronal
            int totalCiclos = 8000;             //Ciclos de entrenamiento

            for (int ciclo = 1; ciclo <= totalCiclos; ciclo++)
            {
                //Por cada ciclo, se entrena el perceptrón con toda la tabla de XOR

                //Cada 200 ciclos muestra como progresa el entrenamiento
                if (ciclo % 200 == 0)
                {
                    Console.WriteLine("Ciclo: " + ciclo.ToString());
                }

                for (int conjunto = 0; conjunto < relojEntra.GetLength(0); conjunto++)
                {
                    //Entradas y salidas esperadas
                    entradas[0] = relojEntra[conjunto, 0];
                    entradas[1] = relojEntra[conjunto, 1];
                    entradas[2] = relojEntra[conjunto, 2];
                    entradas[3] = relojEntra[conjunto, 3];
                    entradas[4] = relojEntra[conjunto, 4];
                    entradas[5] = relojEntra[conjunto, 5];
                    entradas[6] = relojEntra[conjunto, 6];

                    salidaEsperada[0] = numeroEsperado[conjunto, 0];
                    salidaEsperada[1] = numeroEsperado[conjunto, 1];
                    salidaEsperada[2] = numeroEsperado[conjunto, 2];
                    salidaEsperada[3] = numeroEsperado[conjunto, 3];

                    //Primero calcula la salida del perceptrón con esas entradas
                    perceptron.calculaSalida(entradas);

                    //Luego entrena el perceptrón para ajustar los pesos y umbrales
                    perceptron.Entrena(entradas, salidaEsperada);

                    //Cada 200 ciclos muestra como progresa el entrenamiento
                    if (ciclo % 200 == 0)
                    {
                        perceptron.SalidaPerceptron(entradas, salidaEsperada);
                    }
                }
            }

            Console.WriteLine("Finaliza");
            Console.ReadKey();
        }
Exemplo n.º 3
0
        static void Main()
        {
            //Lee los datos de un archivo plano
            int MaximosRegistros = 2000;

            double[]     entrada          = new double[MaximosRegistros + 1];
            double[]     salidas          = new double[MaximosRegistros + 1];
            const string urlArchivo       = "datos.tendencia";
            int          ConjuntoEntradas = LeeDatosArchivo(urlArchivo, entrada, salidas);

            //Normaliza los valores entre 0 y 1 que es lo que requiere el perceptrón
            double minimoX = entrada[0], maximoX = entrada[0];
            double minimoY = salidas[0], maximoY = salidas[0];

            for (int cont = 0; cont < ConjuntoEntradas; cont++)
            {
                if (entrada[cont] > maximoX)
                {
                    maximoX = entrada[cont];
                }
                if (salidas[cont] > maximoY)
                {
                    maximoY = salidas[cont];
                }
                if (entrada[cont] < minimoX)
                {
                    minimoX = entrada[cont];
                }
                if (salidas[cont] < minimoY)
                {
                    minimoY = salidas[cont];
                }
            }

            for (int cont = 0; cont < ConjuntoEntradas; cont++)
            {
                entrada[cont] = (entrada[cont] - minimoX) / (maximoX - minimoX);
                salidas[cont] = (salidas[cont] - minimoY) / (maximoY - minimoY);
            }

            int        numEntradas = 1; //Número de entradas
            int        capa0       = 5; //Total neuronas en la capa 0
            int        capa1       = 5; //Total neuronas en la capa 1
            int        capa2       = 1; //Total neuronas en la capa 2
            Perceptron perceptron  = new Perceptron(numEntradas, capa0, capa1, capa2);

            //Estas serán las entradas externas al perceptrón
            List <double> entradas = new List <double>();

            entradas.Add(0);

            //Estas serán las salidas esperadas externas al perceptrón
            List <double> salidaEsperada = new List <double>();

            salidaEsperada.Add(0);

            //Ciclo que entrena la red neuronal
            int totalCiclos = 10000;             //Ciclos de entrenamiento

            for (int ciclo = 1; ciclo <= totalCiclos; ciclo++)
            {
                //Por cada ciclo, se entrena el perceptrón con todos los valores
                for (int conjunto = 0; conjunto < ConjuntoEntradas; conjunto++)
                {
                    //Entradas y salidas esperadas
                    entradas[0]       = entrada[conjunto];
                    salidaEsperada[0] = salidas[conjunto];

                    //Primero calcula la salida del perceptrón con esas entradas
                    perceptron.calculaSalida(entradas);

                    //Luego entrena el perceptrón para ajustar los pesos y umbrales
                    perceptron.Entrena(entradas, salidaEsperada);
                }
            }

            Console.WriteLine("Entrada normalizada | Salida esperada normalizada | Salida perceptrón normalizada");
            for (int conjunto = 0; conjunto < ConjuntoEntradas; conjunto++)
            {
                //Entradas y salidas esperadas
                entradas[0]       = entrada[conjunto];
                salidaEsperada[0] = salidas[conjunto];

                //Calcula la salida del perceptrón con esas entradas
                perceptron.calculaSalida(entradas);

                //Muestra la salida
                perceptron.SalidaPerceptron(entradas, salidaEsperada);
            }

            Console.WriteLine("Finaliza");
            Console.ReadKey();
        }