Código Entrenamiento Supervisado Red Neuronal

Programas, sistemas, condiciones, filtros...
Responder
Avatar de Usuario
juanknito
11
11
Mensajes: 584
Registrado: Dom 20 Mar, 2016 12:16 pm
Ubicación: Tenerife

Código Entrenamiento Supervisado Red Neuronal

Mensaje por juanknito »

Saludos,

sé que hace años se estudió el tema por varios foreros, y que existe interés en ésta disciplina de la Inteligencia Artificial, y su aprendizaje para mejorar su potencia y/o capacidad de analizar información.

Aquí dejo un articulo para iniciarse en la Inteligencia Artificial, y concretamente aplicado a la Quiniela, una de sus posibles aplicaciones:

http://naukas.com/2015/12/09/acertando- ... euronales/

aquí adjunto un código en C+, para ver la posibilidad de traducción a QBasic o Visual Basic, para mejor entendimiento y utilización.

Si alguien lo puede traducir, aprovechar, y mejor aún, si lo comparte.
(éste código es compartido por su autor, que no soy yo),

es éste:

es una red neuronal de aprendizaje supervisado, esto trabaja con dos capas de neuronas una oculta mas una de salida

using System;
namespace OldPar
{
/// <summary>
/// Clase que contiene los metodos de creacion, prueba y entrenamiento de la red
/// </summary>
public class perceptron
{
public perceptron()
{
//
// TODO: agregar aquí el código del constructor
//
}
public void hace_red(int entradas, int salidas, int ocultas)
{
en = new double[entradas];
sa = new double[salidas];
ocu = new neurona[ocultas];
sal = new neurona[salidas];
for (i=0; i < ocu.Length;i++)
{
ocu = new neurona();
ocu.dimensiona_pesos(entradas);
}
for (i=0; i < sal.Length;i++)
{
sal = new neurona();
sal.dimensiona_pesos(ocultas);
}
}
public void aleatorios(int entradas, int salidas, int ocultas)
{
Random r = new Random();
for (i=0;i<ocu.Length;i++)
{
for (j=0;j<entradas;j++)
{
ocu.pesos[j] = (double)((r.NextDouble() * 2) - 1);
}
ocu.peso_bias = (double)((r.NextDouble() * 2) - 1);
}
for (i=0; i<sal.Length;i++)
{
for (j=0; j<ocultas;j++)
{
sal.pesos[j] = (double)((r.NextDouble() * 2) - 1);
}
sal.peso_bias = (double)((r.NextDouble() * 2) - 1);
}
}
/////////////////////////
public void muestra_pesos_red(System.Windows.Forms.ListBox lista, int vn1, int vn2, bool entrada)
{
int n1,n2;
String cad, cad1 = "";
lista.Items.Clear();
for (n1 = 0; n1 < vn1; n1++)
{
for (n2 = 0; n2 < vn2; n2++)
{
cad = "";
cad1 = "";
if (entrada)
{
cad1 = System.Convert.ToString(ocu[n2].pesos[n1]);
cad = "P" + System.Convert.ToString(n1) + "," + System.Convert.ToString(n2) +
" =" + cad1.Substring(0,6);
lista.Items.Add((Object)cad);
}
else
{
cad1 = System.Convert.ToString(sal[n2].pesos[n1]);
cad = "P" + System.Convert.ToString(n1) + "," + System.Convert.ToString(n2) +
" =" + cad1.Substring(0,6);
lista.Items.Add((Object)cad);
}
}
}
}
///////////////////////////
private double Activacion(double su)
{
su = (double)((1.0) / (1.0 + Math.Exp(su * -1)));
return su;
}
////////////////// el backpro by jesus benigno contreras UFT ///////////
public void entrena(int ocultas, int lugar)
{
double suma;
// calculo del valor de las ocultas
for (i = 0; i < ocultas; i++)
{
suma = 0;
for (j = 0; j < 27; j ++)
{ // sumatoria de entradas por salidas
suma = suma + en[j] * ocu.pesos[j];
}
suma = suma + ocu.peso_bias; // se le suma el peso de la bias la entrada siempre es 1
ocu[i].valor = Activacion(suma);
}
// ahora los valores de las neuronas de salida
for (i = 0; i < 9; i++)
{
suma = 0;
for (j = 0; j < ocultas; j ++)
{
suma = suma + ocu[j].valor * sal[i].pesos[j];
}
suma = suma + sal[i].peso_bias;
sal[i].valor = Activacion(suma);
}
// ahora calculamos el error de cada neurona a la salida tambien llamado delta
// que viene dado por la rediravada * el error
for (i = 0; i < 9; i++)
{ // derivada de la funcion // // error = deseado - obtenido de aca pueden tomar para hacer las graficas pero el tema se pone muy lento
sal[i].delta = sal[i].valor * (1 - sal[i].valor) * (System.Math.Abs(sa[i]) - sal[i].valor);
}
// ahora los deltas de las ocultas como se ve estos dependen de los de salida
// de alli la verga esa del backpropagation
for (i = 0; i < ocultas; i ++)
{
suma = 0;
for (j = 0; j < 9; j ++)
{
suma = suma + sal[j].pesos[i] * sal[j].delta;
}
error = System.Math.Abs(suma);
ocu[i].delta = ocu[i].valor * (1 - ocu[i].valor) * suma;
}
// ahora el ajuste de los pesos de las neuronas de salida
for (i = 0; i < 9; i++)
{
for (j = 0; j < ocultas; j++)
{
sal[i].pesos[j] = sal[i].pesos[j] + aprendizaje * ocu[j].valor * sal[i].delta;
}
sal[i].peso_bias = sal[i].peso_bias + aprendizaje * sal[i].delta;
}
// ahora los pesos de las neuronas de entrada
for (i = 0; i < ocultas; i++)
{
for (j = 0; j < 27; j++)
{
ocu[i].pesos[j] = ocu[i].pesos[j] + aprendizaje * en[j] * ocu[i].delta;
}
ocu[i].peso_bias = ocu[i].peso_bias + aprendizaje * ocu[i].delta;
}
} // fin del back pro
////////////////////////////////////////////////////
public String prueba(int ocultas)
{
double suma = 0;
String cadena = "";
for (i = 0; i < ocultas; i++)
{
for (j = 0; j < 27; j++)
{
suma = suma + en[j] * ocu[i].pesos[j];
}
suma = suma + ocu[i].peso_bias;
ocu[i].valor = Activacion(suma);
suma = 0;
}
for (i = 0; i < 9;i++)
{
for (j = 0; j < ocultas; j++)
{
suma = suma + ocu[j].valor * sal[i].pesos[j];
}
suma = suma + sal[i].peso_bias;
sal[i].valor = Activacion(suma);
if (sal[i].valor > 0.6)
{
cadena = cadena + "1";
}
else
{
cadena = cadena + "0";
}
suma = 0;
}
return cadena;
} // fin del metodo prueba
////////////////////////////////////////////////////
int i,j;
public double[] en;
public double[] sa;
public neurona[] ocu, sal;
public double aprendizaje = 0;
public double error = 1;
}
}
V

el Karma Instantáneo existe, REPARTE con los que COMPARTEN.
Avatar de Usuario
Mirlo
14
14
Mensajes: 6241
Registrado: Lun 20 Jun, 2016 10:34 am

Re: Código Entrenamiento Supervisado Red Neuronal

Mensaje por Mirlo »

Demasiado complicado para mi intelecto.
Pero es interesante :ok:
Responder