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!