Practica 5 de Neuronales salidas

aquí dejo unas cuantas salidas, al ser con pesos iniciales aleatorios, obviamente cada vez que se ejecuta da valores distintos:
Tambien tener en cuenta que aproximadamente 1 de cada 20 no itera en 10000 iteraciones:

Practica 5 de Neuronales otros sitios de interes

Números aleatorios:

• Función rand() La función rand genera números enteros aleatorios entre 0 y 32767.
• Random Number Generation Utilizando la función rand para distintos intervalos.

Back-Propagation

El sistema de entrenamiento mediante back-propagation consiste en:

• Empezar con unos pesos sinápticos cualquiera (generalmente elegidos al azar).
• Introducir unos datos de entrada (en la capa de entradas) elegidos al azar entre los datos de entrada que se van a usar para el entrenamiento.
• Dejar que la red genere un vector de datos de salida (propagación hacia delante).
• Comparar la salida generada por al red con la salida deseada.
• La diferencia obtenida entre la salida generada y la deseada (denominada error) se usa para ajustar los pesos sinápticos de las neuronas de la capa de salidas.
• El error se propaga hacia atrás (back-propagation), hacia la capa de neuronas anterior, y se usa para ajustar los pesos sinápticos en esta capa.
• Se continua propagando el error hacia atrás y ajustando los pesos hasta que se alcance la capa de entradas.

BackPropagation en la wikipedia

BackPropagation bien explicada

Código util en c++

Practica 5 de Neuronales

Modificar la práctica p4 añadiendo una capa oculta, de esta forma tendremos una red de tres capas que debe ser capaz de poder entrenar y aprender el comportamiento de un XOR u otro problema no linealmente separable.

El número de neuronas en la capa oculta será una constante en el programa.

Deben inicializarse los pesos de forma aleatoria, con valores comprendidos entre -pesoinicial y +pesoinicial donde pesoinicial será una constante en el programa, con valor 0.5

Estos valores iniciales deberán ser además distintos cada vez que se ejecute el programa.

Ejemplo: XOR, con dos neuronas en la capa oculta, ganancia de aprendizaje 0.6, momento 0.4, error máximo 0.01 y pesos iniciales entre -0.5 y +0.5. Ciclos máximos 10000.

Debe tardar entre 1000 y 5000 ciclos, lo más frecuente serán valores alrededor de 1000. En algunas ocasiones (pocas, quizás una entre diez o una entre veinte) puede no entrenar.

NOTA:
utilizar primero pesos iniciales:

0.00
0.01
0.02
...

para poder comprobar resultados (Pesos a usar para depuracion y pruebas), y luego hacer que sean aleatorios.

Practica 4 de Neuronales salidas y archivos de entrada

Aquí estan las salidas que deben salir de la práctica 4 con los archivos que entrenan, uno con los valores 0 y 1, y el otro con los valores 0.05 y 0.95, y el que no entrena...


Archivos de entrada:

ENTRENA (0,1)
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
1 1 1 0 1

ENTRENA(0.05, 0.95)
0.05 0.05 0.05 0.05 0.05
0.05 0.05 0.95 0.95 0.05
0.05 1 0.05 0.95 0.05
0.95 0.95 0.95 0.05 0.95

NO ENTRENA
0 0 0 0 0
0 0 1 1 0
1 1 0 1 0
1 1 1 0 1

Practica 4 de Neuronales

0 0 0 0 0
0 1 1 0 1
1 0 1 0 1
1 1 1 1 0

El número de salidas será una constante dentro del programa.

En el ejemplo de arriba la red tendrá 3 entradas y dos salidas si la constante vale 2.

Serán constantes también el error máximo permitido (0.001) calculado como:

error límite = error cuadrático total / (patrones * salidas),

la ganancia de aprendizaje (0.6), el momento (0.9) y el número máximo de ciclos (10000).

Finalizado el aprendizaje se mostrarán los resultados como una tabla con:

x1,x2,x3,s1,y1,s2,y2,s3,y3 ...

Ejemplo que entrena (184 ciclos, 108 si se usa 1->0.95 y 0->0.05):

0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
1 1 1 0 1

Ejemplo que no entrena:

0 0 0 0 0
0 0 1 1 0
1 1 0 1 0
1 1 1 0 1

Se empleará para cálculo de los incrementos de los pesos las expresiones vistas en clase de retropropagación del gradiente.

Practica 3 de Neuronales

La práctica de neuronales que menos tiempo me ha llevado... ;)



Pues nada... solo hay que cambiar la función de Y para que en vez de ser la anterior (0 si x<=0 y1 si x>0) sea la sigmoide(1/1+e^(-p)) teniendo en cuenta que anteriormente tenemos que admitir n entradas... :)

un saludo

Practica 3 de Neuronales

Modificar p2 para que emplee varias entradas y para que use una sigmoide como función de activación. Máximo de entradas: 20, el número de entradas se obtendrá del fichero de patrones y será el número de columnas menos la última que es la salida.

Ejemplo que entrena (225 ciclos):

0 0 0 0
0 0 1 0
0 1 0 0
1 1 1 1

Ejemplo que no entrena:

1 0 0 0
1 0 1 1
0 1 0 1
0 1 1 0

Practica 2 de Neuronales salidas y archivos de entrada

Aquí estan las salidas que deben salir de la práctica 2, con las entradas and, or y xor respectivamente...

and en 6 iteraciones, or en 4 y xor nunca converge.

Entradas:

AND
0 0 0
0 1 0
1 0 0
1 1 1

OR
0 0 0
0 1 1
1 0 1
1 1 1

XOR
0 0 0
0 1 1
1 0 1
1 1 0

Practica 2 de Neuronales otros sitios de interes

Para la lectura del archivo, al pasarlo al array en floats necesitaremos estas 2 funciones:
la función para dividir un String en trozos
la función para convertir una cadena en un float

y posteriormente, en la funcion y = F(p) nos vendra muy bien la función exponencial...
la función exponencial en c++

PD: aun sigo peleandome con la practica...

Practica 2 de Neuronales

Iniciada la Practica 2 de Neuronales:

Debido a que la Practica 1 no estaba todabía en perfecto estado para cumplir todos los requerimientos de la practica 2, decidí arreglarla antes de ponerme con la practica 2...

Hasta ahora he hecho la parte de importar de un archivo, para lo cual me resulto muy util la página de Programación en C/C++ por Virgilio Gómez Negrete

Practica 1 de Neuronales

Acabada la practica 1:

Repetir el entrenamiento hecho el primer día de clase para:

x1 x2 so
0 0 1
1 1 0

con una delta = 0.2


Para la realización de la practica 1 utilizaba las variables globales:

const int x0 = 0;
const int x1 = 1;
const int x2 = 2;
const int s0 = 3;
const int w0 = 4;
const int w1 = 5;
const int w2 = 6;
const int P = 7;
const int Y = 8;
const int D = 9;

const float variacion = 0.2;
const int n = 150;

float valores[n][10];
float variaciones[n][3];
int finIteraciones = n;

Lo cual hacia bastante incomodo ampliar el numero de entradas en cada patrón...



Esa es la salida que generaba en la primera versión de la practica... una vez dado el guión de la 2ª practica decidí rediseñar el codigo de la practica 1... quedando asi:

// maximo numero de patrones de entrenamiento
#define maxpat 1000
// maximo numero de entradas
#define maxent 20
// error maximo permitido
#define epsilon 0.001
// numero maximo de ciclos de entrenamiento permitidos
#define maxciclos 10000
// constante de aprendizaje
#define delta 0.25


const int ment = maxent;
const int mpat = maxpat;

const float variacion = 0.2;

float x[mpat][ment];
float s[mpat];
float w[mpat][ment];
float p[mpat];
float y[mpat];
float d[mpat];

float variaciones[mpat][ment];

de esta forma saldria esta salida (decidí en esta ocasión dejar las variaciones del problema)



sin variaciones sería asi: que es como se tiene que entregar...



Aunque la salida sea la misma, lo que es normal, ya que el problema es el mismo... el código ha sido remodelado entero para que sirva para todas las entradas que queramos (siempre que sea menor que "maxent", en este caso 20).