static void Main(string[] args)
{
int data_size = 30;
double[,] input =
{
{ 0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 0, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 0, 0, 1, 0, 0,
0, 1, 1, 0, 0,
0, 0, 1, 0, 0,
0, 0, 1, 0, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 0, 0, 1, 1, 0,
0, 1, 0, 1, 0,
1, 0, 0, 1, 0,
1, 1, 1, 1, 1,
0, 0, 0, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 1, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 1, 0, 0,
0, 1, 1, 1, 0,
0, 0, 1, 0, 0 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0 },
//////////////////////////
{ 0, 1, 1, 1, 1,
0, 1, 0, 0, 1,
0, 1, 0, 0, 1,
0, 1, 0, 0, 1,
0, 1, 1, 1, 1 },
{ 0, 0, 1, 0, 0,
0, 1, 1, 0, 0,
0, 0, 1, 0, 0,
0, 0, 1, 0, 0,
0, 0, 1, 0, 0 },
{ 0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 1, 1, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0 },
{ 1, 1, 1, 1, 0,
0, 0, 0, 1, 0,
1, 1, 1, 1, 0,
0, 0, 0, 1, 0,
1, 1, 1, 1, 0 },
{ 0, 1, 0, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 1,
0, 0, 0, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 0, 0, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 1, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 1, 0, 0,
0, 1, 1, 1, 0,
0, 0, 1, 0, 0 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 0, 1, 0 },
///////////////////
{ 1, 1, 1, 1, 0,
1, 0, 0, 1, 0,
1, 0, 0, 1, 0,
1, 0, 0, 1, 0,
1, 1, 1, 1, 0 },
{ 0, 0, 1, 0, 0,
0, 0, 1, 0, 0,
0, 0, 1, 0, 0,
0, 0, 1, 0, 0,
0, 0, 1, 0, 0 },
{ 0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 1, 1, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 0, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 1,
0, 0, 0, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 0, 0, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 1, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 1, 0, 0,
0, 1, 1, 1, 0,
0, 0, 1, 0, 0 },
{ 0, 0, 1, 1, 1,
0, 0, 1, 0, 1,
0, 0, 1, 1, 1,
0, 0, 1, 0, 1,
0, 0, 1, 1, 1 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 0, 1, 0 }
};
double[,] res =
{
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }
};
int test_size = 10;
double[,] test =
{
{ 1, 1, 1, 0, 0,
1, 0, 1, 0, 0,
1, 0, 1, 0, 0,
1, 0, 1, 0, 0,
1, 1, 1, 0, 0 },
{ 0, 0, 1, 0, 0,
0, 0, 1, 0, 0,
0, 0, 1, 0, 0,
0, 0, 1, 0, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0,
0, 1, 1, 0, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 0, 0, 1, 1, 0,
0, 1, 0, 1, 0,
1, 0, 0, 1, 0,
1, 1, 1, 1, 1,
0, 0, 0, 1, 0 },
{ 0, 1, 1, 0, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 1, 1, 0 },
{ 0, 1, 1, 0, 0,
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 1, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 1, 0, 0,
0, 1, 1, 0, 0,
0, 0, 1, 0, 0 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 0, 1, 1, 0 },
};
Perceptron p = new Perceptron(25, 100, 10);
p.train(input, res);
//p.printR();
double[] my_res;
for (int i = 0; i < test_size; i++)
{
my_res = p.calculate(getrow(test, 25, i));
foreach (double d in my_res)
{
Console.Write("{0} ", d);
}
Console.WriteLine();
}
Console.WriteLine("testc");
double[] testc =
{
0, 1, 1, 1, 0,
0, 1, 0, 1, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
0, 1, 1, 1, 0
};
double[] sres = p.calculate(testc);
for (int i = 0; i < 10; i++)
{
Console.Write("{0} ", sres[i]);
}
Console.Write("\nмертвые {0} ", p.count_dead(input, data_size));
Console.ReadKey();
}
static void Main(string[] args)
{
//Lee los datos de un archivo plano
int MaximosRegistros = 2000;
double[] entrada = new double[MaximosRegistros + 1];
double[] salidas = new double[MaximosRegistros + 1];
//Qué valores de entrada se usarán para entrenamiento y cuáles para validación de "overfitting"
bool[] entraValida = new bool[MaximosRegistros + 1];
const string urlArchivo = "datos.tendencia";
int ConjuntoEntradas = LeeDatosArchivo(urlArchivo, entrada, salidas);
//Normaliza los valores entre 0 y 1 que es lo que requiere el perceptrón
double minimoX = entrada[0], maximoX = entrada[0];
double minimoY = salidas[0], maximoY = salidas[0];
for (int cont = 0; cont < ConjuntoEntradas; cont++)
{
if (entrada[cont] > maximoX)
{
maximoX = entrada[cont];
}
if (salidas[cont] > maximoY)
{
maximoY = salidas[cont];
}
if (entrada[cont] < minimoX)
{
minimoX = entrada[cont];
}
if (salidas[cont] < minimoY)
{
minimoY = salidas[cont];
}
}
for (int cont = 0; cont < ConjuntoEntradas; cont++)
{
entrada[cont] = (entrada[cont] - minimoX) / (maximoX - minimoX);
salidas[cont] = (salidas[cont] - minimoY) / (maximoY - minimoY);
entraValida[cont] = false;
}
//Marca al azar que valores usará para entrenar y cuáles para validar "overfitting"
int porcentaje = 20;
int totalValida = ConjuntoEntradas * porcentaje / 100;
int cuentaValida = 0;
Random aleatorio = new Random(100);
do
{
int pos = aleatorio.Next(ConjuntoEntradas);
if (entraValida[pos] == false)
{
entraValida[pos] = true;
cuentaValida++;
}
} while (cuentaValida < totalValida);
int numEntradas = 1; //Número de entradas
int capa0 = 5; //Total neuronas en la capa 0
int capa1 = 5; //Total neuronas en la capa 1
int capa2 = 1; //Total neuronas en la capa 2
Perceptron perceptron = new Perceptron(numEntradas, capa0, capa1, capa2);
//Estas serán las entradas externas al perceptrón
List <double> entradas = new List <double>();
entradas.Add(0);
//Estas serán las salidas esperadas externas al perceptrón
List <double> salidaEsperada = new List <double>();
salidaEsperada.Add(0);
//Ciclo que entrena la red neuronal
double anteriorAjuste = Double.MaxValue; //Para validar el "overfitting"
int ciclos = 0;
while (true)
{
ciclos++;
//if (ciclos >= 80000) break;
//Por cada ciclo, se entrena el perceptrón con todos los valores
for (int conjunto = 0; conjunto < ConjuntoEntradas; conjunto++)
{
//Si el valor es para validar no lo usa para entrenar
if (entraValida[conjunto] == true)
{
continue;
}
//Entradas y salidas esperadas
entradas[0] = entrada[conjunto];
salidaEsperada[0] = salidas[conjunto];
//Primero calcula la salida del perceptrón con esas entradas
perceptron.calculaSalida(entradas);
//Luego entrena el perceptrón para ajustar los pesos y umbrales
perceptron.Entrena(entradas, salidaEsperada);
}
//Valida el "overfitting"
double ajusteValidando = 0;
for (int conjunto = 0; conjunto < ConjuntoEntradas; conjunto++)
{
//Si el valor es para entrenar no lo usa para validar
if (entraValida[conjunto] == false)
{
continue;
}
//Entradas y salidas esperadas
entradas[0] = entrada[conjunto];
salidaEsperada[0] = salidas[conjunto];
ajusteValidando += perceptron.CalculaAjuste(entradas, salidaEsperada);
}
//Console.WriteLine("Ciclo: " + ciclos.ToString() + " Ajuste: " + ajusteValidando.ToString());
//Si el nuevo entrenamiento aleja la precisión entonces termina el entrenamiento
if (ajusteValidando > anteriorAjuste)
{
Console.WriteLine("Posible Overfitting en: " + ciclos.ToString());
break;
}
else
{
anteriorAjuste = ajusteValidando;
}
}
//Muestra el resultado del entrenamiento
for (int conjunto = 0; conjunto < ConjuntoEntradas; conjunto++)
{
if (entraValida[conjunto] == false)
{
continue;
}
//Entradas y salidas esperadas
entradas[0] = entrada[conjunto];
salidaEsperada[0] = salidas[conjunto];
//Calcula la salida del perceptrón con esas entradas
perceptron.calculaSalida(entradas);
//Muestra la salida
perceptron.SalidaPerceptron(entradas, salidaEsperada);
}
Console.WriteLine("Finaliza");
Console.ReadKey();
}