Antecedentes

La primera red neuronal conocida, fue desarrollada en 1943 por Warren McCulloch y Walter Pitts. La red tipo Perceptrón fue inventada por el sicólogo Frank Rosenblatt en el año 1957 y el primer modelo de Perceptrón fue desarrollado en un ambiente biológico imitando el funcionamiento del ojo humano. El fotoperceptrón: era un dispositivo que respondía a señales ópticas.

Regla de Aprendizaje

El Perceptrón es un tipo de red de aprendizaje supervisado, es decir necesita conocer los valores esperados para cada una de las entradas presentadas; su comportamiento está definido por pares de esta forma:

Cuando pj es aplicado a la red, la salida de la red es comparada con el valor esperado tj

• Se Suma de las señales de entrada, multiplicadas por unos valores de pesos escogidos aleatoriamente.
• La entrada es comparada con un patrón preestablecido para determinar la salida de la red.
• Si en la comparación, la suma de las entradas multiplicadas por los pesos es mayor o igual que el patrón preestablecido la salida de la red es uno (1), en caso contrario la salida es cero (0).

Procedimiento general:

El procedimiento de aprendizaje de la red (ajuste de los pesos) se resume en aplicar cada objeto de la muestra a la red y ajustar los pesos en caso de que la salida de la red no sea correcta, de acuerdo a las fórmulas ya explicadas:

WN = WA + e * p                                               UmbralN = UmbralA + e

Donde
e = t-a
t = valor real del objeto
a = valor calculado por la Red
WN = Peso nuevo
WA = Peso anterior

por ejemplo sea estos datos nuestra bateria de Prueba. Utilizaremos cuatro puntos para el aprendizaje de la RNA
P1 = ( 2,  1)         R1 = 1  (clase A)
P2 = ( 0, -1)        R2 = 1  (clase A)
P3 = (-2,  1)       R3 = -1 (clase B)
P4 = ( 0,  2)        R4 = -1 (clase B)

Partimos de cualquier valor (aleatorios) para los pesos y el umbral:
W = ( -0.7, 0.2 )  umbral = 0.5

Paso 1.

Objeto P1 = (2,1)   R1 = 1
W = ( -0.7, 0.2 )     Umbral = 0.5

Aplicamos la Red para P1

a=(P1.Peso)+Umbral = -0.7*2 + 0.2*1 + 0.5 = -0.7
(a <0) ?  Si  a=-1 en otro caso a=1

R1 = 1     es igual a…    a = -1  (NO)

Por tanto es necesario ajustar los pesos:
e = R1 – a = 1 – (-1) = 2

W = W + e*P1 = (-0.7,0.2) + 2*(2,1)= (3.3, 2.2)
Umbral = Umbral + e = 0.5 + 2 = 2.5

Paso 2.

Objeto P2 = (0,-1)   R2 = 1
W = ( 3.3, 2.2 )        Umbral = 2.5

Aplicamos la Red para P2

a=(W.P2)+Umbral = 3.3*0 + 2.2*-1 + 2.5 = 0.3
(a <0) ?  Si  a=-1 en otro caso a=1

R2 = 1  es igual a…  a = 1  (SI)

Por tanto NO es necesario ajustar los pesos

Paso 3.

Objeto P3 = (-2,1)     R3 = -1
W = ( 3.3, 2.2 )    Umbral= 2.5

Aplicamos la Red para P3

a=(W.P3)+Umbral  = 3.3*-2 + 2.2*1 + 2.5 = -1.9
(a <0) ?  Si  a=-1 en otro caso a=1

R3 = -1  es igual a…  a = -1

Por tanto NO es necesario ajustar los pesos

Paso 4.

Objeto P4 = (0,2)   R4 = -1
W = ( 3.3, 2.2 )    Umbral = 2.5

Aplicamos la Red para P4

a=(W.P4)+Umbral = 3.3*0 + 2.2*2 + 2.5 = 6.9
(a <0) ?  Si  a=-1 en otro caso a=1

R4 = -1  es igual a…  a = 1 (NO)

Por tanto es necesario ajustar los pesos:
e = R4 – a = -1 – (1) = -2

W = W + e*P4 = (3.3,2.2) + -2*(0,2) = (3.3, -1.8)
Umbral = Umbral + e = 2.5 + (-2) = 0.5

Entonces nuestro vector de pesos (W) queda del siguiente modo W=(3.3,-1.8)  y el Umbral=0.5

Cualquier punto que le demos al algoritmo, éste sin necesidad de volver a evaluar nos dará la respuesta que es correcta pues lo que conseguimos con esto es que el algoritmo a base de la bateria de pruebas pueda establecer una línea de separación entre los puntos que introdujimos. Ten en cuenta que este tipo de algoritmo solo resuelve dos estados para un punto dado, esto es: o es de la clase A (1) o es de la clase B (-1).

Ahora al código

Para mejor entendimiento descarga el programa que con mucho entusiasmo cree para poder ver el funcionamiento de este algoritmo. Dentro de la clase main modifica los vectores de variablesX y variablesY con los datos que tienes (tu bateria de prueba) recuerda que todas las cordenadas x van en el vector de variablesX y las de y pues en su correspondiente y en la de resultados escribe a que clase pertenece cada dato. Por ejemplo si queremos que nuestra bateria de pruebas sea esta:

P1 = ( 2,  1)          R1 =   1   (clase A)
P2 = ( 0, -1)         R2 =   1   (clase A)
P3 = (-2,  1)         R3 = -1   (clase B)
P4 = ( 0,  2)          R4 = -1   (clase B)

Debemos de cambiar los vectores en:

….
float[] variableX ={2,0,-2,0};
float[] variableY={1,-1,1,2};
float[] resultado={1,1,-1,-1};
….

Ahora dicho esto ejecutalo (F6) y sigue los pasos que te dirá por consol.

Prueba el conocimiento del percetrón inventandote un punto cualquiera para probar la destreza de su conocimiento, por ejemplo yo me invente el punto de prueba PP=(-1,4)  y se sabe por el mapa cartesiano (ultima figura mostrada) que este estará dentro de la clase B porque está junto a los otros.

Como era de esperar el programa te dará el mismo resultado. Bien, ahora te toca divertirte, puedes hacer que el algoritmo cuando se encuentre confundido nos pida añadir a la bateria de pruebas el dato que acabamos de darle, no está dificil, te invito a que lo hagas si te encuentras perdido buscamos que estaremos para orientarte en lo poco que aún conocemos; recuerda la mejor forma de aprender es practicando.

Conclusiones

A todo esto añado lo siguiente He aqui alguna de mis curiosidades en respecto a este algoritmo, aunque tenga función limitada el mismo no está demás darle importancia. Mis inquietudes son:

1).- Como puedo medir el nivel de aprendizaje que está teniendo mi algoritmo. ¿Acaso es la variable error (en el programa) de mi ejemplo?
2).- Cuales son las recomendaciones para que algoritmos de este tipo tengan correcto desenvolvimiento en su área (RNA) pues sucede que debems de darle valores iniciales de peso y umbral, pero si lo hacemos aleatoriamente… ¿tendremos iguales resultados?.
3).- En este ejemplo en sí, ¿qué es lo que el algoritmo aprende?. Pues yo solo veo que éste es capáz de encontrar un Vector de Pesos y el Umbral solamente.
4).- Como experiencia de este trabajo me llevo gran sorpresa al saber que un algoritmo de Perceptrón solamente es un algoritmo mecánico como cualquier otro, pero con distinto nombre, espero estar equivocado y haya algo más en esto que le haga diferenciar al resto de los algoritmos que hasta ahora he ido construyendo.

En el último punto puedo decir que vi como el algoritmo fue capaz de encontrar su propio vector de pesos y así también el Umbral (sesgo), entonces yo concluí que un algoritmo perceptron demuestra su capacidad de aprendizaje por que es autónomo en encontrar una recta que permita divividir a los puntos en cuestión que son evaluados según sus resultados de ’1′ (clase A) contra los de resultado ‘-1′ (clase B) (en el ejemplo que adjunto la recta encontrada es el vector de pesos y su umbral); pero… para sorpresa mía todo esto lo hizo de manera mecánica, como cualquier otro algoritmo, es entonces que me pregunto: ¿he sido capaz de desarrollar un algoritmo inteligente?, ¿existe la inteligencia artificial?, o la inteligencia artificial solo lo trae de nombre ya que pareciera que Inteligencia Artificial es un ‘charle’ solamente (en el lenguaje común). Vaya que estoy recontra confundido.

En fin… el estudio nos liberará de esto, si tienes algún aporte ayúdanos a aprender cada día más. Ahora a practicar se dijo, ah!, casi me olvido aquí teneís el link de descarga Algoritmos Inteligentes: Perceptrón para poder ver todo el código fuente creado en Netbeans 6.0 recuerda darme crédito cuando presentes esto o enseñes a alguién más : ) Hasta la próxima.

José Luis Zelaya          Escríbele por correo

Si deseas estudiar la teoría de la que me guié para construir todo esto descargate desde Descargar Teoría

“Crear cuesta mucho… agradecer no cuesta nada.”