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:

https://github.com/JonathanAlvarado/kinect_control_interfaz.git

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.

•  Simulación de presionado de teclado (keypressed) para poder asociar las salidas a una combinación de teclas que mueva entre escritorios (no implementado debido a salidas incorrectas, cabe destacar que no desarrollé este código, desconocía de este tema). Liga específica: https://github.com/JonathanAlvarado/kinect_control_interfaz/blob/master/Teclas.py
• Detección de errores de las neuronas, son funciones que sirvieron de base para integrar funciones más completas al programa final. Liga específica: https://github.com/JonathanAlvarado/kinect_control_interfaz/blob/master/Triana02.py
• Intento de implementación de detección de errores en nuestro código principal (fase1.py, en este solo aporte una porción mínima de código). Liga directa: https://github.com/JonathanAlvarado/kinect_control_interfaz/blob/master/fase1.py

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!

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!

 

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!

.

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!