Пример #1
0
        private static void prtNeuEntrada(RedNeuronal rn, int tamaño_entrada)
        {
            Console.WriteLine("########################## ENTRADA ##########################");

            for (int i = 0; i < tamaño_entrada; i++)
            {
                Console.WriteLine("Valor de la neurona {0}: " + rn.getEntrada()[i], i + 1);
            }
        }
Пример #2
0
        public static void wea()
        {
            double[] calar = new double[]  { 0, 1, 1, 1, 0,
                                             1, 0, 0, 0, 1,
                                             1, 0, 0, 0, 1,
                                             0, 1, 1, 1, 1,
                                             0, 0, 0, 0, 1,
                                             0, 0, 0, 0, 1,
                                             0, 1, 1, 1, 0 };
            Random random = new Random();

            setBD();
            RedNeuronal rn             = new RedNeuronal(bd[0]);
            int         tamaño_entrada = rn.getEntrada().Length;
            int         tamaño_oculta  = rn.getOculta().Length;
            int         tamaño_salida  = rn.getSalida().Length;


            Console.WriteLine("Hora de inicio: " + DateTime.Now);
            train(rn, bd);
            Console.WriteLine("Entrenamiento terminado: " + DateTime.Now);

            //rn.feedForward(calar);



            //rn.feedForward(bd[0]);

            //prtNeuEntrada(rn, tamaño_entrada);

            //prtNeuOculta(rn, tamaño_oculta);

            //prtNeuSalida(rn, tamaño_salida);

            //prtPesos1(rn);

            //prtPesos2(rn);

            //Console.WriteLine("Error: " + obtenerError(rn.feedForward(bd[0])[0], 0, 0));

            //for (int i = 0; i < rn.feedForward(bd[0]).Length; i++)
            //{
            //     obtenerError(rn ,rn.feedForward(bd[0])[i], i, 0);
            //}

            double[] prueba = new double[] { 1, 1, 1, 1, 1,
                                             1, 0, 0, 1, 0,
                                             0, 0, 1, 0, 0,
                                             0, 0, 1, 0, 0,
                                             0, 0, 1, 0, 0,
                                             0, 1, 0, 0, 0,
                                             1, 0, 0, 0, 0 };

            Console.WriteLine("Es un " + especular(prueba));
        }
Пример #3
0
        public static void ajustarPesosBP(RedNeuronal rn, double error, int neuSalida)
        {
            double[] oculta        = rn.getOculta();
            int      tamaño_oculta = oculta.Length;

            double[] WD       = new double[tamaño_oculta];
            double[] SOD      = new double[tamaño_oculta];
            double[] PesosDWD = new double[rn.getPesosE().Length];

            double[] entrada = (double[])rn.getEntrada().Clone();
            double[,] PreChanges = (double[, ])rn.getPesosSCopia().Clone();
            double[] ocultaSP = rn.getOcultaSP();

            for (int i = 0; i < WD.Length; i++)
            {
                WD[i] = oculta[i] * error;
            }

            double[,] pesos2 = rn.getPesosS();

            for (int i = 0; i < WD.Length; i++)
            {
                pesos2[i, neuSalida] = WD[i];
            }
            double pesoPrimerCapa = 0;

            for (int i = 0; i < WD.Length; i++)
            {
                pesoPrimerCapa  = PreChanges[i, neuSalida] * error;
                pesoPrimerCapa *= ocultaSP[i];
                SOD[i]          = pesoPrimerCapa;
            }

            for (int i = 0; i < oculta.Length; i++)
            {
                for (int j = 0; j < entrada.Length; j++)
                {
                    rn.pesosE[j, i] += SOD[i] * entrada[i];
                }
            }
        }