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;
}
