lunes, 19 de noviembre de 2012

Reporte individual final

Reporte individual, fin del proyecto

Hola, en esta entrega final del proyecto las siguientes actividades por hacer era pasar las coordenadas en tiempo real a python para que sirvieran como entradas a la red neuronal (si recuerdan antes las entradas las tomaba de un txt previamente generado con processing, y cada movimiento que se hacia con la mano, la red tardaría en procesarlo porque primero processing generaría el txt, luego se determinaría hacia donde fue el movimiento, en fin, eran pasos inecesarios). Otra  de las actividades a realizar era agregar capas a nuestra red, esto con el fin de filtrar nuestras entradas y que fuera más fácil procesarlas para poder tomar una respuesta de salida mejor.

Bien mediante Back-propagation nosotros estuvimos calculando errores y también recalculando pesos en cada iteración del proceso de la red neuronal.
Lo que más costó trabajo fue pasar las coordenadas en "tiempo real" a python para así procesar directamente los valores de entrada (en esto casi no metí mano, por no decir que nada). Lo segundo que nos costó más trabajo fue programar  el cálculo de los errores en cada F (neurona de la red), esta actividad se me asignó a mi y al compañero osvaldo, estuvimos trabajando buen rato, al principio iba trabajando bien en esto, pero al compañero osvaldo le quedó mucho mejor el programa y ya solo fuimos sumando ideas entre los 2 para realizar una mejor red (mis aportes los pueden encontrar en la siguiente liga:






Otra cosa que realicé (pero que no implementaremos en el proyecto) yo, fue buscar la manera de realizar en python una simulación de combinación de teclas, para que cuando la red aviente su respuesta (con la entrada del movimiento de la mano) esta se pueda asociar a un evento en el escritorio de Gnome (la combinación de teclas en específico que buscabamos implementar es: Ctrl + Alt + Flecha derecha, izquierda, arriba, abajo, esto con el fin de movernos por los escritorios de ubuntu)



En general estas fueron las 3 cosas en las que pude apoyar a mis compañeros.
Y la liga hacia todo el repertorio general (again): https://github.com/JonathanAlvarado/kinect_control_interfaz

Por último les dejo nuestra presentación.





Cualquier duda o aclaración pueden dejarla en comentarios. 


Saludos!



martes, 9 de octubre de 2012

Reporte individual

Reporte individual del proyecto
Hola, para esta entrega de del proyecto de redes neuronales, nosotros debiamos mostrar las entradas (de dónde las obteniamos, cómo las pre-procesabamos, etc), un 15% de la construcción de la red neuronal y una interface de salida (para la interface de salida, nostros solamente imprimimos direcciones de movimiento en la consola: izquierda - derecha).
Bien, para los que no lo recuerdan, nuestro proyecto trata sobre mover las ventanas de un sistema operativo (ubuntu en específico) con acciones realizadas por las manos o los dedos (detecta lo más próximo). Las acciones que se realizarían en las ventanas sería, minimizar, maximizar, y mover de lugar algunas ventanas (todavía estamos pensando eso).

Lo que utilizamos para detectar los movimientos de la mano es el kinect, y mediante processing obtuvimos las coordenadas de cada movimiento de la mano, las coordenadas obtenidas fueron las de los ejes x y y, y estás coordenadas están dadas por pixeles.

Bien, tuvimos bastantes opiniones y discusiones entre los miembros del equipo sobre cómo obtener o elegir nuestros valores de comparación, para saber si la salida obtenida era la correcta o la que buscabamos.

Las primeras opciones que pensamos era en dividir por rangos el largo y ancho de la cantidad de pixeles totales. Lo que yo propuse después era que de pre-procesamiento hicieramos la diferencia de un punto final menos un punto inicial, así de esa manera, mediante la diferencia obtendriamos un valor negativo o uno positivo, es decir, si mi mano comenzo a moverse desde el pixel 20 (eje x) y finalizó en el pixel 200, haríamos 200 - 20 y el resultado sería positivo, y viceversa si comenzamos  a movernos desde el pixel 20 otra vez pero ahora avanzamos hacía el pixel 5, pués la diferencia ahora será 5 - 20, y el resultado sería un negativo (diciéndonos que ha movido hacía la izquierda), obviamente en un futuro se ocuparían más capaz para filtrar el movimiento por sí en vez de moviemientos rectos se hacen arcos, o algo por el estilo.

Después de varias discusiones optamos por "partir" la ventana en regiones para obtener rangos de comparación.

La primer cosa o el primer paso para realizar nuestro proyecto (ya habiendo pensado en la manera de desarrollarlo, después de lo antes mencionado), fue obtener las entradas, para lo cual guardamos todas las coordenadas que se producen al relizar un movimiento, chequé cómo trabajar con ficheros en Processing y agregamos esa funcionalidad al código que ya teniamos preparado con las coordenadas.

La idea es que ya teniendo las entradas almacenadas en un txt por processing, ahora python entrara a leer el archivo y sacará cada uno de los vectores que se compone de ubicación y x y ubicación en y, además de su respectivo -1 en cada vector claro.

Miren, un ejemplo de un movimiento horizontal es representado por las siguientes coordenadas de la imagen:


Este txt es el que les digo que entra python para formar los vectores de entrada.

Ya obteniendo estos valores, se procede a obtener las sumatorias de los pesos(random) por las entradas, así como lo hicimos en tareas anteriores.

Al obtener una salida, decidimos por compararla con un valor esperado que en nuestro caso lo definimos como 320 ya que es exactamente la mitad que divide al eje x (320 es la cantidad en pixeles), por el momento lo realizamos así, obteniendo si el movimiento realizado fue a la izquierda o a la derecha, pero no filtra movimientos como por ejemplo arcos o parábolas (estos movimientos los deberá interpretar, aprendiendo que es lo que quiere dar a entender el usuario).

Aquí les muestro una imagen que sacó el compañero jonathan de cuando se van calculando las coordenadas con el movimiento de la mano. Y pensamos que lo adecuado era que después de realizar el movimiento, las coordenadas dejaran de calcularse, para cortar el movimiento y así la entrada de la red no se llenara con información basura, porque por default, después de hacer el movimiento, seguía tirando coordenadas, aunque fueran las mismas (estando en el mismo lugar o posición la mano)

Esta es una imagen de lo antes explicado:



En la parte de abajo en la izquierda están las coordenadas obtenidas, y esas mismas se graban en el txt, para formar parte de los vectores de entrada, luego cuando se finaliza el movimiento, las coordenadas dejan de calcularse. Y al realizar un nuevo movimiento después se vuelven a calcular las coordenadas y se sobreescriben en el txt previamente creado, para ahora calcular salidas con el otro movimiento.


Para arrancar el processing desde python propuse usar la librería os, importamos os y así usamos la función system para mandar llamar el pde y que generara el txt, luego de generarlo, el python entra a ese archivo y saca los vectores de entrada.

Las partes de ese código las agregué a los códigos iniciados que tenía el compañero Jonathan en su repositorio de Gist.
Aquí les dejo la liga hacia mi repositorio, debido a que no pude agregar algunos códigos al repo de Jonathan, aunque si hice algunos commits editando parte de su código (arranque de Processing mediante python).-
https://github.com/eddypre/Neuronales_kinect 

La liga hacia el repositorio de Jonathan es el siguiente, ahí también hice commit en un python (fase1): https://github.com/JonathanAlvarado/kinect_control_interfaz.git

Para la próxima entrega pensamos agregar más capas para así filtrar cualquier error que se pudiera malinterpretar, debido a que debemos contar con que no siempre el movimiento será totalmente en línea recta. De hecho en las pruebas que hicimos con el Kinect, era muy dificil tratar de dibujar una línea semi-recta.

Las demás capaz también nos servirán para obtener más salidas, para que la red pueda interpretar más movimientos y así agregar más funcionalidades. 

Pero por ahora la idea era solo los movimientos de izquierda a derecha y viceversa.

Presentación del equipo:



Cualquier duda o comentario pueden dejarla en comentarios.

Saludos!


 

lunes, 20 de agosto de 2012

Creando una red Neuronal

Iniciando una red neuronal en Python


Hola, para esta tarea la Doctora Elisa nos encargó iniciar la construcción de una red neuronal, decidí usar Python por "simpleza" y limpieza del código, además que lo vi como una área de oportunidad para aprender este lenguaje (solo conozco lo básico, muy básico).

Bueno para agarrar el hilo, lo que nos explicó la Dra. es que tendríamaleatoriaos una cadena de entradas binarias (0110), esta cadena la tomaría como entradas la red neuronal y además la cadena tiene que ser aleatoria.

Lo siguiente es que cada entrada tendría un peso asignado de manera aleatoria, y los pesos serían numeros entre -1 y 1, por ejemplo:  -.5, .7, .3, etc.

Después multiplicariamos cada entrada binaria aleatoria por su respectvo peso y sumariamos todos los resultados, por ejemplo, para una cadena binaria: 0101 con pesos de .1, .5, .7, .3 respectivamente sería: Sumatoria = 0(.1) + 1(.5) + 0(.7) + 1(.3) = 0 + .5 + 0 + .3 = .8.

Al final esa sumatoria se compararía con un valor númerico (obviamente) predefinido umbral, si la sumatoria es menor al umbral la salida sería un binario 1, si sucede lo contrario la salida sería un binario 0.

En realidad la condición para determinar la salida se diseña dependiendo de la aplicación y propósito de la red neuronal, por ejemplo podría ser que si sumatoria es mayor a umbral la salida arroje 1, o que si la sumatoria es 2 veces el umbral arroje 1, esto repito, depende del propósito para el cual estamos construyendo la red neuronal.

Bien, a continuación les dejo el código que desarrollé:



También les dejo una captura de pantalla del programa corriendo:

Para esta ejecución del programa se puede apreciar que la cadena binaria se llenó aleatoriamente con: (0111), y los pesos para cada entrada salieron negativos cada uno, debido a eso, la suma total salió = -2.30934844622.

Si recuerdan en el código que puse arriba, el umbral lo definí en 0.7, y como suma  (-2.30934844622) es menor a 0.7 la salida arrojó un 1, de lo contrario hubiera arrojado un 0.





Aquí les dejo otra ejecución del programa con salida = 0, debido a que la suma (0.869347482808) resulto mayor a 0.7





Cualquier aclaración o duda pueden dejarla en comentarios.

Saludos!


.

martes, 7 de agosto de 2012

Redes Neuronales Artificiales

Proyecto de Redes Neuronales 


Hola, la idea de mi proyecto es aplicar las redes neuronales para poder "descifrar" o resolver los captchas que nos piden algunos servidores de datos, o páginas de películas como Cuevana (los contra spybots). Lo que quiero hacer es primeramente que el programa te de la oportunidad de seleccionar el área donde se encuentran los caracteres que va a descifrar, luego ya por medio de una red neuronal obtener la salida correcta de los caracteres de una manera que nosotros podamos copiar y pegar, o en su defecto solo transcribir. La siguiente imagen es la solicitud de captcha que les comento: 





La entrada de la red neuronal sería la imagen con los caracteres a "descifrar" y la salida serían los mismos caracteres descifrados. Mi idea es que aparezca para solo copiar y pegar, pero algunos captchas no aceptan el copy-paste, en ese caso tendriamos que transcribirlo.


Cualquier aclaración o comentario pueden dejarlo en comentarios.

Saludos!



lunes, 16 de mayo de 2011

PROGRAMACIÓN ORIENTADA A OBJETOS

Resumen de mi proyecto.


Mi proyecto trata sobre una cuenta para poder ahorrar, retirar, o transferir dinero.
Tiene una ventana inicial que te pide tu usuario y contraseña para tener acceso a tu cuenta, tambien tiene distintas ventanas para hacer las funciones antes mencionadas.

Patrones de diseño:

Patrones de diseño incorporados en Java.

Recordar que un patrón de diseño es una solución estándar para un problema común de programación.

Yo usé dos patrones de diseño: Subclase(herencia) y Excepciones

El patrón subclase se usa para no hacer repeticiones de código(ahorrar código) ya que esta actividad es muy propensa a errores y confusiones.
Utilicé este patrón en mi clase Gráficos, heredé de la clase JFrame.

El patrón excepciones, es usado cuando una parte de código es propensa a errores, este patrón lo usamos para controlar el flujo "normal" de ejecución.
En caso de que se presente una irregularidad o falla en nuestro sistema, este saltará ese pedazo de código, mostrando un mensaje de Error.

Aclaro que estos patrones de diseño que he mencionado ya vienen incorporados en Java.

Eventos:

Los únicos eventos que ocurren en mi programa son al hacer click sobre los diferentes botones, por ejemplo en la ventana inicial (acceso) vienen 2 botones "Aceptar" y "Crear cuenta" con obvios eventos que cuando damos click en Aceptar y si el usuario y contraseña son correctos se abre la ventana de meus, y cuando presionamos el "Crear cuenta" si el usuario ingresado no existe ya en la base de datos, se crea la nueva cuenta.

Otros eventos son cuando estoy en la ventana de menu , para seleccionar una opción solo se oprime un botón y te lleva a esa función por ejemplo ahorrar, transferir, retirar, eliminar cuenta.

Todos los eventos de mi programa se manejan por medio de botones.

Excepciones y errores:

Las excepciones y errores que yo manejo es en mi clase "BaseDatos" cuando se hace de forma erronea una consulta a la base de datos el catch avienta un mensaje de error: "Error al realizar la consulta".

En la misma clase tambien cuando intento conectarme a la base de datos, puse un try y en el catch puse que mostrara un mensaje de error con la leyenda: "Error en la conexión"

Pruebas unitarias:

En cuanto a pruebas unitarias yo como la mayoría de mis compañeros hice el tipo de prueba de caja negra porque algunos compañeros probaron mi sistema, unos me dijeron que no tenía suficiente información para el usuario pero las pruebas fueron que ponian cierto tipo de caracteres raros en mis JTextField y después mi sistema no respondía, para eso puse excepciones y errores, que el sistema solo debia aceptar el tipo de datos que estaba declarando en mis atributos, de manera que cuando hacian lo mismo de poner caracteres extraños, mi sistema mandaba un error en la acción que queria que se llevara acabo.


Interfaz gráfica:

En la interfaz gráfica batallé mucho porque es la primera vez que hago un proyecto con interfaz gráfica (ya las había usado antes pero fue un ejercicio muy secillo).

Mi proyecto cuenta con 6 ventanas:

1. Ventana de acceso.
2. Ventana de creación de cuentas.
3. Ventana de ahorro.
4. Ventana de retiro.
5. Ventana de transferencias
6. Ventana de eliminación de cuenta.

Para hacer todas estas ventanas heredé de JFrame, para acomodar los elementos de las ventanas utulicé FlowLayout porque tuve muchos problemas con setBounds.

La mayoría de mis ventanas tienen componentes como JButton, JTextField y JLabel.
Mi programa abría ventanas cada que hacía una función y al final quedaban muchas ventanas abiertas, para solucionar eso, antes abrir otra ventana puse un setVisible(false) para ocultar la ventana pasada.

Sistemas distribuidos:

En caso de que mi sistema quiera ser subido a la red y tuviera muchas consultas, se necesitaría de una computadora (servidor) que pueda responder a las peticiones de los usuarios, pero para poder realizar ese trabajo se necesita buen hardware en una máquina, además si se tuviera mi sistema en una sola máquina, si falla esa máquina pues fallaría todo el servicio.
Para evitar problemas de acceso a mi sistema desde la red, se necesitaría un Sistema distribuido en el cuál se puede instalar partes de mi sistema, y que todas las máquinas trabajen en conjunto, así si falla una máquina se puede seguir dando el servicio, no con la misma calidad pero seguiría estable, sería como un Cluster.
Lo que quiero decir es que conviene más para mi sistema que el trabajo se haga distribuido y no centralizado, para que el control de mi sistema no dependa de un solo punto y pueda presentar fallas solo por causa de una computadora (en la que está alojado).

Estos son los videos(explicación y ejecución de mi sistema) que subí a YouTube del Taller de Programación Orientada a Objetos:







Es todo en esta entrada, cualquier corrección pueden dejarla en comentarios.
Saludos!

jueves, 24 de marzo de 2011

PROGRAMACIÓN ORIENTADA A OBJETOS

Ejercicio.

  • Detección de eventos, errores y excepciones de mi proyecto.
El evento que he usado hasta ahorita en mi proyecto es:
  1. Hacer click sobre un botón.
Todas las consultas que haga a mi base de datos, además de los logins , serán accesadas por medio de botones. Cada ventana tendrá un botón a excepción de la ventana de Login que tendrá 2 botones, el botón para accesar a la cuenta y el botón para crear una nueva cuenta.

Los errores que pudiera tener mi proyecto son:
  1. Usuarios con el mismo nombre en mi tabla de base de datos.
  2. Asignación o ahorro de dinero con más cifras de las que se dispone.

  • ¿Cómo los voy a manejar?
Bueno los errores que mencione que pudieran salir son fáciles de manejar, porque en el atrbuto de la cifra del ahorro puedo limitarlo hasta cierto número.

viernes, 18 de marzo de 2011

TALLER DE PROGRAMACIÓN ORIENTADA A OBJETOS

Herramienta BOUML.

Acá está el diagrama de clases que hicimos en clase de Taller de Programación Orientada a Objetos con la herramienta BOUML.

Este fue solo un ejemplo que nos puso la Dra. Sara, luego subiré el diagrama de clases de mi proyecto.

(Hacer click sobre la imagen para verla más grande)




Cualquier duda pueden ponerla en los comentarios.
Saludos;)