public static Matriz operator *(Matriz c1, decimal escalar)
        {
            Matriz Resultado = new Matriz(c1.Linhas, c1.Colunas);

            Resultado.Map((valor, linha, coluna) =>
            {
                return(c1.Dados[linha, coluna] * escalar);
            });

            return(Resultado);
        }
        public static Matriz operator -(Matriz c1, Matriz c2)
        {
            Matriz Resultado = new Matriz(c1.Linhas, c1.Colunas);

            Resultado.Map((valor, linha, coluna) =>
            {
                return(c1.Dados[linha, coluna] - c2.Dados[linha, coluna]);
            });

            return(Resultado);
        }
Ejemplo n.º 3
0
        public static Matriz ArrayToMatriz(double[] arr, int rows)
        {
            var cols   = arr.Length / rows;
            var matriz = new Matriz(rows, cols);

            for (int i = 0; i < arr.Length; i++)
            {
                matriz.Dados[i / cols][i % cols] = arr[i];
            }

            return(matriz);
        }
Ejemplo n.º 4
0
        public static Matriz MapDerivedSigmoid(Matriz m)
        {
            for (int i = 0; i < m.Linhas; i++)
            {
                for (int j = 0; j < m.Colunas; j++)
                {
                    m.Dados[i][j] = DerivedSigmoid(m.Dados[i][j]);
                }
            }

            return(m);
        }
Ejemplo n.º 5
0
        // Função responsável por treinar a rede neural, utilizando backpropagation
        public void Train(int[] ArrayEntrada, int[] ArraySaida)
        {
            // Entrada para Oculta
            Matriz matrizEntrada = Matriz.ArrayToMatriz(ArrayEntrada);
            Matriz matrizOculta  = Matriz.Multiply(this.Pesos_EntradaOculto, matrizEntrada);

            matrizOculta = Matriz.Add(matrizOculta, this.BIAS_EntradaOculto);
            matrizOculta.MapSigmoid();

            // Oculta para Saida
            Matriz matrizSaida = Matriz.Multiply(this.Pesos_OcultoSaida, matrizOculta);

            matrizSaida = Matriz.Add(matrizSaida, this.BIAS_OcultoSaida);
            matrizSaida.MapSigmoid();

            // BackPropagation ->

            // Saida para Oculta
            Matriz matrizEsperada         = Matriz.ArrayToMatriz(ArraySaida);
            Matriz matrizErroSaida        = Matriz.Subtract(matrizEsperada, matrizSaida);
            Matriz matrizSaidaDerivada    = Matriz.MapDerivedSigmoid(matrizSaida);
            Matriz matrizOcultaTransposta = Matriz.Transpose(matrizOculta);

            Matriz matrizGradiente = Matriz.Hadamard(matrizSaidaDerivada, matrizErroSaida);

            matrizGradiente = Matriz.EscalarMultiply(matrizGradiente, this.TaxaAprendizado);

            // Ajustar a BIAS
            this.BIAS_OcultoSaida = Matriz.Add(this.BIAS_OcultoSaida, matrizGradiente);

            // Ajustar os Pesos
            Matriz matrizDeltaPesoOcultaSaida = Matriz.Multiply(matrizGradiente, matrizOcultaTransposta);

            this.Pesos_OcultoSaida = Matriz.Add(this.Pesos_OcultoSaida, matrizDeltaPesoOcultaSaida);

            // Oculta para Entrada
            Matriz matrizPesoSaidaOcultaTransposta = Matriz.Transpose(this.Pesos_OcultoSaida);
            Matriz matrizErroOculta        = Matriz.Multiply(matrizPesoSaidaOcultaTransposta, matrizErroSaida);
            Matriz matrizOcultaDerivada    = Matriz.MapDerivedSigmoid(matrizOculta);
            Matriz matrizEntradaTransposta = Matriz.Transpose(matrizEntrada);

            Matriz matrizOcultaGradiente = Matriz.Hadamard(matrizOcultaDerivada, matrizErroOculta);

            matrizOcultaGradiente = Matriz.EscalarMultiply(matrizOcultaGradiente, this.TaxaAprendizado);

            // Ajustar a BIAS
            this.BIAS_EntradaOculto = Matriz.Add(this.BIAS_EntradaOculto, matrizOcultaGradiente);

            // Ajustar os Pesos
            Matriz matrizDeltaPesoEntradaOculto = Matriz.Multiply(matrizOcultaGradiente, matrizEntradaTransposta);

            this.Pesos_EntradaOculto = Matriz.Add(this.Pesos_EntradaOculto, matrizDeltaPesoEntradaOculto);
        }
Ejemplo n.º 6
0
        // Multiplica uma matriz pela outra
        public static Matriz Hadamard(Matriz A, Matriz B)
        {
            var matriz = new Matriz(A.Linhas, A.Colunas);

            for (int i = 0; i < A.Linhas; i++)
            {
                for (int j = 0; j < A.Colunas; j++)
                {
                    matriz.Dados[i][j] = A.Dados[i][j] * B.Dados[i][j];
                }
            }

            return(matriz);
        }
Ejemplo n.º 7
0
        // Multiplica todos os valores da matriz pelo valor escalar
        public static Matriz EscalarMultiply(Matriz A, double escalar)
        {
            var matriz = new Matriz(A.Linhas, A.Colunas);

            for (int i = 0; i < A.Linhas; i++)
            {
                for (int j = 0; j < A.Colunas; j++)
                {
                    matriz.Dados[i][j] = A.Dados[i][j] * escalar;
                }
            }

            return(matriz);
        }
Ejemplo n.º 8
0
        public static Matriz ArrayToMatriz(int[] array)
        {
            var matriz = new Matriz(array.Length, 1);

            for (int i = 0; i < matriz.Linhas; i++)
            {
                for (int j = 0; j < matriz.Colunas; j++)
                {
                    matriz.Dados[i][j] = array[i];
                }
            }

            return(matriz);
        }
Ejemplo n.º 9
0
        // Faz a transposição da matriz de horizontal para vertical
        public static Matriz Transpose(Matriz A)
        {
            var matriz = new Matriz(A.Colunas, A.Linhas);

            for (int i = 0; i < A.Linhas; i++)
            {
                for (int j = 0; j < A.Colunas; j++)
                {
                    matriz.Dados[j][i] = A.Dados[i][j];
                }
            }

            return(matriz);
        }
        public decimal[] ConverterParaArray()
        {
            decimal[] resultado = new decimal[this.Dados.LongLength];
            Matriz    temp      = this;
            int       k         = 0;

            for (int i = 0; i < this.Dados.GetLength(0); i++)
            {
                for (int j = 0; j < this.Dados.GetLength(1); j++)
                {
                    resultado[k++] = this.Dados[i, j];
                }
            }

            return(resultado);
        }
        public static Matriz operator *(Matriz c1, Matriz c2)
        {
            Matriz Resultado = new Matriz(c1.Linhas, c2.Colunas);

            Resultado.Map((valor, linha, coluna) =>
            {
                decimal operacao = 0;
                for (int i = 0; i < c1.Colunas; i++)
                {
                    decimal Valor1 = c1.Dados[linha, i];
                    decimal Valor2 = c2.Dados[i, coluna];
                    operacao      += Valor1 * Valor2;
                }
                return(operacao);
            });

            return(Resultado);
        }
Ejemplo n.º 12
0
        public static Matriz Add(Matriz A, Matriz B)
        {
            var matriz = new Matriz(A.Linhas, A.Colunas);

            // // int Linhas = A.Linhas;

            //  if (A.Linhas > B.Linhas)
            //      Linhas = B.Linhas;

            for (int i = 0; i < A.Linhas; i++)
            {
                for (int j = 0; j < A.Colunas; j++)
                {
                    matriz.Dados[i][j] = A.Dados[i][j] + B.Dados[i][j];
                }
            }

            return(matriz);
        }
Ejemplo n.º 13
0
        // Função responsável por retornar uma predição do aprendizado da rede neural
        public double[] Predict(int[] ArrayEntrada)
        {
            // Entrada para Oculta
            Matriz matrizEntrada = Matriz.ArrayToMatriz(ArrayEntrada);

            Matriz matrizOculta = Matriz.Multiply(this.Pesos_EntradaOculto, matrizEntrada);

            matrizOculta = Matriz.Add(matrizOculta, this.BIAS_EntradaOculto);
            matrizOculta.MapSigmoid();

            // Oculta para Saida
            Matriz matrizSaida = Matriz.Multiply(this.Pesos_OcultoSaida, matrizOculta);

            matrizSaida = Matriz.Add(matrizSaida, this.BIAS_OcultoSaida);
            matrizSaida.MapSigmoid();

            double[] ArraySaida = Matriz.MatrizToArray(matrizSaida);
            return(ArraySaida);
        }
Ejemplo n.º 14
0
        public RedeNeural(int Entrada, int Oculto, int Saida)
        {
            this.Entrada = Entrada;
            this.Oculto  = Oculto;
            this.Saida   = Saida;

            this.BIAS_EntradaOculto = new Matriz(this.Oculto, 1);
            this.BIAS_EntradaOculto.Randomize();
            this.BIAS_OcultoSaida = new Matriz(this.Saida, 1);
            this.BIAS_OcultoSaida.Randomize();

            this.Pesos_EntradaOculto = new Matriz(this.Oculto, this.Entrada);
            this.Pesos_EntradaOculto.Randomize();

            this.Pesos_OcultoSaida = new Matriz(this.Saida, this.Oculto);
            this.Pesos_OcultoSaida.Randomize();

            this.TaxaAprendizado = 0.1;
        }
Ejemplo n.º 15
0
        public static double[] MatrizToArray(Matriz matriz)
        {
            double[] array = new double[matriz.Linhas * matriz.Colunas];

            int max = matriz.Linhas * matriz.Colunas;
            int k   = 0;

            for (int i = 0; i < matriz.Linhas; i++)
            {
                for (int j = 0; j < matriz.Colunas; j++)
                {
                    if (k < max)
                    {
                        array[k++] = matriz.Dados[i][j];
                    }
                    else
                    {
                        break;
                    }
                }
            }

            return(array);
        }
Ejemplo n.º 16
0
        // Multiplica a matriz por coluna
        public static Matriz Multiply(Matriz A, Matriz B)
        {
            var matriz = new Matriz(A.Linhas, B.Colunas);

            double Soma = 0;

            for (int i = 0; i < A.Linhas; i++)
            {
                for (int j = 0; j < A.Colunas; j++)
                {
                    for (int k = 0; k < B.Colunas; k++)
                    {
                        double Elmt1 = A.Dados[i][j];
                        double Elmt2 = B.Dados[j][k];

                        Soma += Elmt1 * Elmt2;

                        matriz.Dados[i][k] = Soma;
                    }
                }
            }

            return(matriz);
        }
Ejemplo n.º 17
0
        static void Main(string[] args)
        {
            bool       Train = true;
            RedeNeural rn    = new RedeNeural(2, 3, 1);
            Random     rand  = new Random();

            if (File.Exists("rede.txt"))
            {
                StreamReader sr = new StreamReader("rede.txt");

                string[] ArrayString = new string[2];
                int      Count       = 0;

                while (sr.EndOfStream != true)
                {
                    ArrayString[Count++] = sr.ReadLine();
                }

                var temp   = ArrayString[0].Split(';');
                var Array1 = Array.ConvertAll <string, double>(temp, double.Parse);

                temp = ArrayString[1].Split(';');
                var Array2 = Array.ConvertAll <string, double>(temp, double.Parse);

                Matriz m1 = Matriz.ArrayToMatriz(Array1, 3);
                m1.Print();
                Matriz m2 = Matriz.ArrayToMatriz(Array2, 1);
                m2.Print();

                rn.SetPesoEntradaOculto(m1);
                rn.SetPesoOcultoSaida(m2);

                sr.Close();
            }

            int[] ArrayEntrada = new int[2] {
                0, 0
            };
            int[] ArrayEsperado = new int[2] {
                1, 0
            };

            // XOR Problem
            int[,] datasetEntrada = new int[4, 2]
            {
                { 1, 1 },
                { 1, 0 },
                { 0, 1 },
                { 0, 0 }
            };

            int[,] datasetEsperado = new int[4, 1]
            {
                { 0 },
                { 1 },
                { 1 },
                { 0 }
            };

            while (Train == true)
            {
                for (int i = 0; i < 10000; i++)
                {
                    int   Linha        = rand.Next(0, 4);
                    int[] entradaArray = new int[2];
                    entradaArray[0] = datasetEntrada[Linha, 0];
                    entradaArray[1] = datasetEntrada[Linha, 1];

                    int[] esperadoArray = new int[1];
                    esperadoArray[0] = datasetEsperado[Linha, 0];

                    rn.Train(entradaArray, esperadoArray);
                }

                double[] predict1 = rn.Predict(ArrayEntrada);
                double[] predict2 = rn.Predict(ArrayEsperado);

                Console.WriteLine("Predict 1: " + predict1[0] + " - Predict 2: " + predict2[0]);

                if (predict1[0] < 0.04 && predict2[0] > 0.98)
                {
                    Train = false;
                    Console.WriteLine("Terminou!");

                    rn.GetPesoEntradaOculto().Print();
                    rn.GetPesoOcultoSaida().Print();

                    double[] PesoEntradaOculto = Matriz.MatrizToArray(rn.GetPesoEntradaOculto());
                    double[] PesoOcultoSaida   = Matriz.MatrizToArray(rn.GetPesoOcultoSaida());

                    StreamWriter sm = new StreamWriter("rede.txt");

                    for (int i = 0; i < PesoEntradaOculto.Length; i++)
                    {
                        if (i == PesoEntradaOculto.Length - 1)
                        {
                            sm.Write(PesoEntradaOculto[i]);
                        }
                        else
                        {
                            sm.Write(PesoEntradaOculto[i] + ";");
                        }
                    }

                    sm.WriteLine();

                    for (int i = 0; i < PesoOcultoSaida.Length; i++)
                    {
                        if (i == PesoOcultoSaida.Length - 1)
                        {
                            sm.Write(PesoOcultoSaida[i]);
                        }
                        else
                        {
                            sm.Write(PesoOcultoSaida[i] + ";");
                        }
                    }

                    sm.Close();
                }
            }
        }
Ejemplo n.º 18
0
 public void SetPesoOcultoSaida(Matriz Peso)
 {
     this.Pesos_OcultoSaida = Peso;
 }
Ejemplo n.º 19
0
 public void SetPesoEntradaOculto(Matriz Peso)
 {
     this.Pesos_EntradaOculto = Peso;
 }