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); }
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); }
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); }
// 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); }
// 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); }
// 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); }
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); }
// 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); }
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); }
// 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); }
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; }
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); }
// 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); }
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(); } } }
public void SetPesoOcultoSaida(Matriz Peso) { this.Pesos_OcultoSaida = Peso; }
public void SetPesoEntradaOculto(Matriz Peso) { this.Pesos_EntradaOculto = Peso; }