IMPLEMENTACIÓN DE UNA RED NEURONAL UTILIZANDO SOFTWARE TLEARN

En este Post voy a enseñar como diseñar una red neuronal Feedforward de dos capas.

Vamos a implementar una red neuronal que permita reconocer escrituras de dígitos (0 - 9). Presentemos la red como una malla 3x5, que contiene un dibujo binario del digito.

Cantidad de neuronas de entrada:

La cantidad de neuronas de entrada serán 3x5 = 15 neuronas de entrada.

Esta cantidad se escogió puesto que representa un mejor manera de dibujar el digito en la matriz, y además para no complicar en demasía la estructura de la red.

Cantidad por capas ocultas:

La cantidad de capas ocultas corresponderá a una, la cual contiene 6 neuronas en el nivel intermedio, esto puesto que un nivel intermedio demasiado grande extenderá drásticamente el número de iteraciones requerido para probar la red y reducirá la fiabilidad de la rellamada.

Cantidad de neuronas de salida:

El nivel de salida debe tener 4 neuronas, para darnos la salida de 4 bits, esto porque a los dígitos 8 y 9 le corresponden 4 bits, para poder representarlos de forma binaria.

Estructura de datos utilizada para la neurona:

Construimos red neuronal feedforward multicapas para que cada nivel esté completamente conectado al siguiente. Cada neurona en un nivel mandará su salida a cada neurona del siguiente nivel.

Configuración de la red:

Para configurar la red utilizamos el archivo RED.CF, donde definimos los valores de la red neuronal. En el ejemplo se puede apreciar 10 nodos, 15 patrones de entrada, 4 neuronas de salida definida entre los nodos del 7 al 10.

Las conexiones la establecemos en la etiqueta CONNECTIONS, donde definimos las conexiones de las 15 neuronas de entrada con las 6 neuronas de la capa intermedia y así mismo de las neuronas intermedias a las neuronas de salida.

NODES:

nodes = 10

inputs = 15

outputs = 4

output nodes are 7-10

CONNECTIONS:

groups = 0

1-6 from i1-i15

7-10 from 1-6

SPECIAL:

selected = 1-6

weight_limit = 1.0

Diagrama de red neuronal:

Entrenamiento de la red:

Para configurar la red neuronal utilizamos los archivos DATA y TEACH, que nos permitirán ingresar a la red neuronal los valores de entrada y salida respectivamente.

Configuración archivo DATA:

Para cada digito representado se eligieron 5 ejemplos para el entrenamiento seleccionados de forma aleatoria, cada ejemplo tuvo una distorsión de 1 ó 2 bits como máximo, donde el primer ejemplo de cada digito representa el digito original.

0	1
111101101101111 111101000101111 111101100101111 111101101101110 011101101101111	010110010010010 010110010000010 010010010010010 000110010010010 001011001001001
2	3
111001111100111 111001111100110 111001111000111 011001111100111 111001011100111	111001011001111 011001011001111 111001010001111 101001011001111 110001011001111
4	5
101101111001001 000101111001001 001101111001001 101101101001001 101101111000001	111100111001111 111100111001101 111100111001110 011100111001111 111100110001111
6	7
111100111101111 111100111101101 111100111101110 110100111101111 111100111101011	111001010010010 111001011010010 011001011010010 111001010000010 111001000010010
8	9
111101111101111 111101111101111 101101111101111 111101010101111 111101110101111	111101111001111 111101111001011 011101111001111 111111111001111 111101110001111

Ejemplo de representación grafica de cada digito:

Configuración archivo TEACH:

Cada digito se represento de forma binaria, esto para poder realizar los 5 ejemplos de entrenamiento para cada digito.

0 0 0 0 = 0

0 0 0 1 = 1

0 0 1 0 = 2

0 0 1 1 = 3

0 1 0 0 = 4

0 1 0 1 = 5

0 1 1 0 = 6

0 1 1 1 = 7

1 0 0 0 = 8

1 0 0 1 = 9

Resultado del entrenamiento:

Una vez configurados los archivos DATA y TEACH se procede al entrenamiento de la red, en este caso realizamos entrenamientos de 10000 y 20000 iteraciones, obteniendo como resultado las siguientes graficas y valores correspondientes.

Para el caso de los entrenamientos vamos a considerar los valores arrojados de la siguiente forma: Para valores mayores 0,6 lo consideraremos como valor 1 y para valores menores a 0.6 lo consideraremos 0.

• Entrenamiento de la red con 10000 iteraciones:

Output activations

using red-10000.wts and red.data (Training Set)

0.074 0.000 0.012 0.005

0.035 0.000 0.007 0.062

0.084 0.000 0.009 0.005

0.058 0.001 0.012 0.022

0.075 0.000 0.007 0.032

0.013 0.029 0.000 0.997

0.025 0.002 0.000 0.977

0.041 0.015 0.045 1.000

0.036 0.003 0.000 0.978

0.095 0.000 0.066 0.919

• Entrenamiento de la red con 20000 iteraciones:

Output activations

using red-20000.wts and red.data (Training Set)

0.031 0.001 0.019 0.000

0.031 0.001 0.022 0.001

0.039 0.001 0.014 0.001

0.037 0.001 0.017 0.001

0.039 0.001 0.013 0.001

0.007 0.026 0.000 1.000

0.032 0.001 0.000 1.000

0.000 0.019 0.019 1.000

0.027 0.001 0.000 1.000

0.024 0.017 0.002 0.974

Prueba y verificación del entrenamiento:

Cada digito fue distorsionado de una forma diferente al entrenamiento que fue realizado, esto para verificar si su aprendizaje.

Para el digito cero 111101101101111, se aplico la siguiente nueva configuración:

111101101101100

Obteniendo como resultado los siguientes valores para 10000 y 20000 iteraciones:

Output activations

using red-10000.wts and red.data (Training Set)

0.184 0.007 0.026 0.003

Output activations

using red-20000.wts and red.data (Training Set)

0.009 0.007 0.009 0.004

Lo cual refleja los valores de las cuatro neuronas de salida representan el numero binario: 0 0 0 0 = 0, esto demuestra que para este ejemplo la red neuronal pudo reconocer el digito a pesar de la distorsión impuesta.

Para nuestro 2 ejemplo se utilizo el digito uno, 010110010010010 y se aplico la siguiente nueva configuración:

010110000010010

Obteniendo como resultado los siguientes valores para 10000 y 20000 iteraciones:

Output activations

using red-10000.wts and red.data (Training Set)

0.002 0.010 0.002 1.000

Output activations

using red-20000.wts and red.data (Training Set)

0.013 0.030 0.000 1.000

Lo cual refleja los valores de las cuatro neuronas de salida representan el numero binario: 0 0 0 1 = 1, esto demuestra que para este ejemplo la red neuronal pudo reconocer el digito a pesar de la distorsión impuesta.

De manera similar se realizaron pruebas para los siguientes dígitos obteniendo equivalentes resultados.

IMPLEMENTACIÓN DEL SOFTWARE

Interfaz del Software:

El Software implementado presenta una interfaz, la cual presenta una grilla de entrada, que permite ingresar el digito a evaluar, a su costado presenta la cadena de bit del digito ingresado que representa los valores de los patrones de entrada de la neurona.

Una vez ingresados los datos de entrada y al presionar el botón Reconocer, automáticamente se generan los datos de salida correspondiente al digito evaluado, esto es en la grilla salida.

Código del Software:

Los valores que ocupa el programa se guardaran en las siguientes estructuras

Los valores de entrada se guardan en un vector entrada (1 to 10).

Ls valores de la neuronas se guardaran en una matriz llamada cap1(10,15) , donde el primer índice representa la neurona y el segundo índice representa los pesos de entrada

Estos valores se rescatan del archivo red-20000.wts ingresándolo de la siguiente forma:

' datos entrada neurona 1

cap1(1, 0) = -1.0992292166

cap1(1, 1) = 0.2268614322

cap1(1, 2) = 3.3533549309

‘datos entrada neurona 2.

El cálculo de los valores de las neuronas se realiza mediante la suma de la multiplicación del valor de entrada por el peso de la neurona + el peso del bias

‘sumatoria del las entradas de la neurona

For i = 0 To 6

For j = 1 To 15

valor(i) = valor(i) + cap1(i, j) * entrada(j)

Next j

Next i

‘ suma del bias que se encuentra en la posición 0 del la matriz cap1()

valor(1) = cap1(1, 0) + valor(1)

valor(2) = cap1(2, 0) + valor(2)

valor(3) = cap1(3, 0) + valor(3)

valor(4) = cap1(4, 0) + valor(4)

valor(5) = cap1(5, 0) + valor(5)

valor(6) = cap1(6, 0) + valor(6)

Finalmente se le aplica la función sigmoidea para la salida de cada neurona

For i = 1 To 6

valor(i) = sigmoidea(valor(i))

Next i

Para las neuronas de salida es la suma de la multiplicación de el valor de salida de la capa escondida por el peso de la neurona

For i = 7 To 10

For j = 0 To 6

valor(i) = valor(i) + cap1(i, j) * valor(j)

Next j

Next i