Ejemplo n.º 1
0
        static void Main(string[] args)
        {
            /*Perceptron p = new Perceptron(2, 0.1, 1000);
            p.Treinar(new double[] { 0, 0 }, 0);
            p.Treinar(new double[] { 1, 0 }, 0);
            p.Treinar(new double[] { 0, 1 }, 0);
            p.Treinar(new double[] { 1, 1 }, 1);*/

            double[] um = new double[] {
                0, 0, 1, 0,
                0, 0, 1, 0,
                0, 0, 1, 0,
                0, 0, 1 ,0,
                0, 1, 1, 0};
            double[] saidasum = new double[] {
                1,0,0,0};

            double[] dois = new double[] {
                1, 1, 1, 1,
                0, 0, 0, 1,
                1, 1, 1, 1,
                1, 0, 0 ,0,
                1, 1, 1, 1 };
            double[] saidasdois = new double[] {
                0,1,0,0};

            Camada camada = new Camada(4, 20, 0.5, 1000, new FuncaoDegrau());
            camada.Treinar(um, saidasum);
            camada.Treinar(dois, saidasdois);

            Console.ReadLine();
        }
Ejemplo n.º 2
0
        public void ConfiguraCamada(int index, int quantNeuronios)
        {
            int qtdEntradas;
            if (index == 0)
                   qtdEntradas = numEntradas;
            else{
                   qtdEntradas = camadas[index - 1].NumeroNeuronios;
                }

            camadas[index] = new Camada(quantNeuronios, qtdEntradas,
            taxaAprendizado, 1000, ativacao);
        }
Ejemplo n.º 3
0
        public void ConfiguraCamada(int index, int quantNeuronios)
        {
            int qtdEntradas;

            if (index == 0)
            {
                qtdEntradas = numEntradas;
            }
            else
            {
                qtdEntradas = camadas[index - 1].NumeroNeuronios;
            }

            camadas[index] = new Camada(quantNeuronios, qtdEntradas,
                                        taxaAprendizado, 1000, ativacao);
        }
Ejemplo n.º 4
0
        static void Main(string[] args)
        {
            /*Perceptron p = new Perceptron(2, 0.1, 1000);
             * p.Treinar(new double[] { 0, 0 }, 0);
             * p.Treinar(new double[] { 1, 0 }, 0);
             * p.Treinar(new double[] { 0, 1 }, 0);
             * p.Treinar(new double[] { 1, 1 }, 1);*/


            double[] um = new double[] {
                0, 0, 1, 0,
                0, 0, 1, 0,
                0, 0, 1, 0,
                0, 0, 1, 0,
                0, 1, 1, 0
            };
            double[] saidasum = new double[] {
                1, 0, 0, 0
            };

            double[] dois = new double[] {
                1, 1, 1, 1,
                0, 0, 0, 1,
                1, 1, 1, 1,
                1, 0, 0, 0,
                1, 1, 1, 1
            };
            double[] saidasdois = new double[] {
                0, 1, 0, 0
            };

            Camada camada = new Camada(4, 20, 0.5, 1000, new FuncaoDegrau());

            camada.Treinar(um, saidasum);
            camada.Treinar(dois, saidasdois);

            Console.ReadLine();
        }
Ejemplo n.º 5
0
        public void Treinar(int numPadroes, double[,] conjTreinamento, double[,] saidasEsperadas)
        {
            int contEpocas = 0;

            while (erroGlobal > nivelErro && contEpocas < maxEpocas)
            {
                for (int padrao = 0; padrao < numPadroes; padrao++)
                {
                    double[] x       = new double[numEntradas];
                    double[] entrada = new double[numEntradas];

                    for (int tmp = 0; tmp < numEntradas; tmp++)
                    {
                        x[tmp]       = conjTreinamento[padrao, tmp];
                        entrada[tmp] = conjTreinamento[padrao, tmp];
                    }

                    double[] saidas = new double[numSaidas];
                    for (int tmp = 0; tmp < numSaidas; tmp++)
                    {
                        saidas[tmp] = saidasEsperadas[padrao, tmp];
                    }

                    double erro          = 1;
                    int    contIteracoes = 0;
                    while (erro > nivelErro) // && contIteracoes < maxEpocas*5)
                    {
                        contIteracoes++;

                        /*
                         * FASE FORWARD
                         */
                        x = new double[numEntradas];
                        entrada.CopyTo(x, 0);

                        foreach (Camada camada in camadas)
                        {
                            x = camada.Gerar(x);
                        }

                        /*
                         * FASE BACKWARD
                         */

                        // Calcula o erro global
                        erro = 0;
                        String outStr = "";
                        for (int saida = 0; saida < numSaidas; saida++)
                        {
                            double e = saidas[saida] - x[saida];
                            outStr += " " + x[saida];
                            erro    = erro + Math.Abs(e);
                            //erroGlobal = erroGlobal + ((e * e)/2);
                        }
                        erroGlobal = erroGlobal + (erro * erro) / 2;
                        erroGlobal = erroGlobal / 2;

                        Console.WriteLine("Epoca:" + contEpocas + "\tIteração:" + contIteracoes + "\tPadrao:" + padrao + "\t\tErro:" + erro + " " + outStr);

                        //Atualiza pesos da última camada

                        if (numCamadas > 1)
                        {
                            camadas[numCamadas - 1].CorrigePesos(camadas[numCamadas - 2].Saida, saidas);
                        }
                        else
                        {
                            camadas[numCamadas - 1].CorrigePesos(entrada, saidas);
                        }

                        // Atualiza pesos das camadas intermediárias

                        for (int indiceCamada = numCamadas - 2; indiceCamada >= 0; indiceCamada--)
                        {
                            Camada   camada         = camadas[indiceCamada];
                            Camada   camadaAnterior = camadas[indiceCamada + 1];
                            double[] entradaCamada;
                            if (indiceCamada != 0)
                            {
                                entradaCamada = camadas[indiceCamada - 1].Saida;
                            }
                            else
                            {
                                entradaCamada = entrada;
                            }

                            for (int neuronio = 0; neuronio < camada.NumeroNeuronios; neuronio++)
                            {
                                double err = 0;
                                for (int neuronioAnt = 0; neuronioAnt < camadaAnterior.NumeroNeuronios; neuronioAnt++)
                                {
                                    err = err
                                          + (camadaAnterior.Neuronios[neuronioAnt].Erro
                                             * camadaAnterior.Neuronios[neuronioAnt].Pesos[neuronio]);
                                }

                                err = ativacao.Derivada(camada.Neuronios[neuronio].Net) * err;

                                camada.Neuronios[neuronio].CorrigePesos(entradaCamada, err);
                            }
                        }
                    }
                }

                contEpocas++;
            }
        }