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.”

Antes de seguir revisa bién si tienes estos requisitos que son fundamentales y en cierto modo necesarios para que podamos continuar:

• Conocimiento aunque sea básica en la programación orientada a objetos (POO).
• Contar con el entorno de desarrollo de netbeans de preferencia la versión 6.0 (www.netbeans.org) correctamente instalado.
• Y lo que creo más importante… muchas ganas y deseos de aprender.

Empecemos entonces; siempre dije que los programadores nos encargamos de hacer algunas tareas se vuelvan más sencillas para el humano o lo que es igual  motivar a la humanidad a ser más floja, ahora me lo confirmo pues estos “señores”, los de netbeans, crearon ya en su entorno de desarrollo buenas utilidades para solucionar nuestro tedioso problema de escribir miles y miles de líneas de codigo (exagerando un poquito).  Y ahora nosotros haremos una calculadora que podrá ser implementada en tu movil: comodidad o tecnología, entiéndase como mejor se convenga.

Inicia netbeans y mientras carga vamos repasando algo de teoría que creo es útil lo sepas antes de seguir. Si esta es tu primera vez que crearás una aplicación para tu movil (una calculadora) te diré que lo que estás a punto de hacer es algo parecido a un applet pero de nombre MIDLET mira como lo describe el señor Alberto García Serrano (www.agserrano.com), él nos dice: ”Si estas familiarizado con la programación de applets, conoces las diferencias que tiene con respecto a una aplicación Java normal. La primera es que un applet se ejecuta sobre un navegador web. Otra importante es que, a diferencia de un programa Java estándar, un applet no tiene un método main(), además, un applet tiene que ser una subclase de la clase Applet, e implementar unos métodos concretos (init, start, stop, destroy). En este sentido, un MIDlet es más parecido a un applet que a una aplicación Java estándar. Un MIDlet tiene que ejecutarse en un entorno muy concreto (un dispositivo con soporte J2ME), y tampoco cuenta con un método main(). Un MIDlet tiene que heredar de la clase MIDlet e implementar una serie de métodos de dicha clase.”

Te preguntarás ¿qué es J2ME?, natural, en mi momento también lo hice; ésto no es mas que las iniciales de Java 2 Micro Edition  (Java 2 edición micro); si eres de los que les gusta leer aqui te pongo un link donde te empararás mas acerca de esto. Pero en resumidas palabras la plataforma J2ME es una familia de especificaciones que definen varias versiones minimizadas de la plataforma Java 2; estas versiones minimizadas pueden ser usadas para programar en dispositivos electrónicos; desde teléfonos móvil, en PDAs, hasta en tarjetas inteligentes, etc. Estos dispositivos presentan en común que no disponen de abundante memoria ni mucha potencia en el procesamiento, ni tampoco necesitan de todo el soporte que brinda el J2SE, (la plataforma estándar de Java usada en sistemas de escritorio y servidor) .  ¿Aún quieres conocer un poco de historia?, mirá que nos dicen en la ciberaula de java (dale click aqui).

Por el momento creo que esto es suficiente, vamos a crear ahora nuestra calculadora que por cierto en esta vez sólo hará operaciones básicas de suma, resta, multiplicación y división; en entradas posteriores te hablaré de algo más que esto. Vuelve a netbeans y crea un proyecto: File-> New Project; desplázate hasta llegar a Mobility y al seleccionar esto verás al lado derecho MIDP Aplication, seleccionado y dale siguiente. Pon el nombre que desees al proyecto, yo lo llame “CalculadoraBasica” es opcional que deshabilites el ‘Create Hello Midlet’ si no deseas que NetBeans cree automáticamente ya un midlet por nosotros, finaliza con esto la creación de un proyecto.

Empecemos a añadir un midlet, esto es, file->new file; ahi al vemos una ventana similar a la anterior (ver imagen arriba) y elejimos en la izquierda ’MIDP’ y a su derecha ‘Visual Midlet’ presiona siguiente y dale un nombre al nuevo midlet que estamos creando, ten en cuenta que este nombre es el que verás en el equipo móvil antes de  ejecutar. En mi caso le puse “CalculadorSimple”, presiona finish y apreciarás una ventana similar a la que te muestro.

A partir de eso podemos decir que en el lado derecho del IDE vemos varios componentes en la paleta: Displayables, Commands, Elements, Items, entre otros. En J2ME, un objeto Displayable contiene la información que va a ser visualizada, y son controlados por un objeto Display quien gestiona qué objeto Displayable se mostrará al usuario. En MIDP existen tres categorías de Displayable: Screen con estructura predefinida: Alert, List y TextBox, que encapsulan componentes de interfaz complejos y que las aplicaciones no pueden enriquecer con nuevos componentes. Screen genérica: Form, las aplicaciones pueden llenar este tipo de pantalla con texto, imágenes u otros componentes de interfaz de usuario. Canvas, las aplicaciones tienen control total sobre la aparición de componentes en el display y puede acceder directamente a eventos de bajo nivel. Por otro lado la clase Display proporciona los métodos que nos permiten controlar la visualización de los objetos Displayable y obtener propiedades del display (si soporta color o no, número de colores,…).

Agreguemos un ‘Displayable’ en nuestro midlet para esto arrastra un form desde la paleta al midlet o bien dentro del midlet dale clic derecho dentro de new/add elije form.

En la parte superior del midlet veremos tres fichas: Source, Screen, Flow y Analizer; nos interesa las tres primeras ya que al habilitar Source estaremos viendo todo el código que va generando el IDE, dentro de Screen vemos el displayable en su totalidad; y pues Flow es el estado en que vemos en la imagen y no es nada mas que como una visualización “resumida” de los diferentes displayables que estamos haciendo uso, en nuestro caso es solo uno pues el primero que viste solo es el midlet propiamente dicho.

Ok, ahora que ya tenemos un form dentro nuestro primer midlet solo debemos arrastar con el mouse desde el midlet el comando Started hasta nuestro form, con esta acción estamos diciendo que en cuanto arranque el midlet debe de ir directamente al form. Dirígete al form agregado y añade un Comand ( clic derecho sobre form new/add -> exitCommand) y realizamos la misma acción que inicimos con Started pero esta vez en sentido contrario, le diremos al form que cuando el usuario diga salir vaya directamente al inicio del midlet.  Por esta vez omitiré cuales son los estados en los que se encuentra un midlet pues al inicio dijimos que son como los applet’s pero no indicamos a detalles cuales son éstos pero ya vamos conociendo a dos estados (Started, Resumed).

Selecciona el form y habilita la pestaña Screen o simplemente dale doble clic a nuestro displayable form, te encontrarás con una pantalla similar a la que te muestro en la siguiente imagen.

Es aqui donde el usuario final vera y operará para poder realizar la tarea por la que iniciamos esta entrada.

A mi se me ocurre que el usuario solo tendrá dos operandos que nos dará como dato y nosotros le devolvemos en otro lado de la misma ventana el resultado de la operación, siempre y cuando no haya sucedido ningún error. Es asi que arrastraré tres componentes de la paleta que se llaman textField de la opción Items.

Ahora en la parte inferior de la paleta podemos ver las propiedades de cada componente según hayamos seleccionado, por ejemplo, cambiaré el título del form que el usuario verá; para esto me voy a su propiedad title y ahora procedo a cambiar algunas propiedades de los textfield como ser: label (titulo) y su propiedad Input Constraint pues le diremos que solo acepte números decimales y así controlamos posibles errores que como siempre el usuario aunque sea intencionalmente los comete (esto es: sumar dos letras, introducir nombres como dato, etc); hacemos todos los cambios a decimal de todos los textField excepto para el textField del resultado que lo dejaremos en su propiedad por defecto, ANY (ANY permite escribir cualquier dato sea número o letra). Ahora le pongamos opciones para que pueda hacer las 4 operaciones básicas pero de una en una, así que añádele 4 okCommand’s a nuestro form y cambiemosle a cada uno de ellos su propiedad label e Instance Name por Suma y sumaComando respectivamente; hazlo para cada comando que añadiste.

Si hiciste todo correctamente verás algo similar a la imagen que te muestro.

Hasta ahora lo único que hicimos fue arrastrar y soltar casi ni tocamos el teclado solo para algunas pequeñas cositas pero te preguntarás a que hora escribimos el código, pues veamos todo lo que ya hizo por nosotros el entorno de desarrollo. Habilita la ficha Source y revisa de arriba hacia abajo, ¿te parece mucho?.

Bien, ahora vámonos a escribir código nosotros mismos y programemos esos comandos que añadimos arriba. ¿Estas en Source verdad?, verás a tu izquierda todos los métodos implementados hasta el momento los que por su puesto los escribió NetBeans; existen ciertas líneas de código que no se nos permite modificar así que busquemos el método ‘commandAction(Command command, Displayable displayable)‘ dale doble click y te llevará directo al método que modificaremos para nuestra calculadora. Te muestro una imagen.

Antes que nada necesitamos dos variables en las cuales almacenar los operandos que nos de el usuario. Luego según sea el comando hacemos la operacion de suma, resta, multiplicación o división; no olvides programar también para cuando haya una división de controlar las excepciones pues puede que el usuario intente dividir entre cero (como generalmente sucede). Te muestro como quedo el mío:

double valor1= Double.parseDouble(this.textField.getString());
double valor2= Double.parseDouble(this.textField1.getString());
if (displayable == form) {

if (command == divideComando) {try { this.textField2.setString(String.valueOf(valor1/valor2)); }
catch (Exception io){ this.textField2.setString(io.getMessage());}}
else if (command == exitCommand) {exitMIDlet();}
else if (command == multiplicaComando) {textField2.setString(String.valueOf(valor1*valor2));}
else if (command == restaComando) {textField2.setString(String.valueOf(valor1-valor2));}
else if (command == sumaComando) {textField2.setString(String.valueOf(valor1+valor2));}
}

Esto fué todo compila el código (F9) si hay errores corrígelo luego ejecuta (F6) que ya todo está listo!! xD. Verifica todos los eventos que escribiste, esto lo lograrás intentando escribir letras por ejemplo, o caracteres especiales u otros como dato; verás que esto está controlado, así como también la división entre cero.

Ya finalizando esta entrada resumidos los siguiente (para mal o para bien):

1.  NetBeans y su IDE nos facilita muchas tareas a la hora de hacer aplicaciones para celular.
2. La programación sigue siendo un arte.
3. Los programadores hacemos floja a la humanidad.

Espero haber sido lo más claro posible en esta primera entrada, cualquier consulta acerca del contenido del mismo remítela a joseluiszelaya@gameplayart.com o déjame tu comentario en este post, te espero en la próxima!.

Aqui tienes el proyecto completito pero mejor si lo haces vos mismo. Descargar proyecto desde aqui calculadorabasica