Max Hernandez

Laberinto - Ejemplo de Canvas en HTML5
Mostrando las entradas con la etiqueta Redes neuronales artificiales. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Redes neuronales artificiales. Mostrar todas las entradas

martes, 20 de noviembre de 2012

Reporte entrega final de redes neuronales

Esta publicación esta dedicada a ser un reporte para la entrega final de la clase de redes neuronales con una explicación de mi aportación al proyecto de la red neuronal para controlar el brazo robótico.

Nuestro proyecto

Componentes
1.- El brazo robótico es el siguiente (Link) esta la compramos en Steren, este tiene cinco motores de directa, para utilizarlo desarmamos el dispositivo y controlamos utilizando un Arduino cada motor por separado para mapear cada uno con una salida de nuestra red neuronal.


[Imagen obtenida de: http://www.steren.com.mx/_imgs/prod/grande/k-682.jpg]

2.-  Electroencefalograma del juguete The Star Wars Force Trainer el cual es un sensor que mide la actividad electrica del cerebro.


[Image obtenida de: http://cdn2-b.examiner.com/sites/default/files/styles/image_content_width/hash/e2/93/e293a53f702510273b7481b9ce4d9462.jpg]



3.- Dos Arduinos , la idea es utilizarlo como interfaz de las señales recibidas del sensor y también para las señales mandadas al brazo robótico controlando cada motor del brazo mecánico.

[Imagen obtenida de:http://arduino.cc/en/uploads/Main/arduino_uno_test.jpg]


Funcionamiento
La idea es que utilizando el electroencefalograma como entrada  ala red, esta sea capaz de mapear pensamientos específicos como arriba, abajo izquierda y derecha a movimientos del brazo robótico directamente relacionados como moverse a esas direcciones.

Mi aportación

Algoritmo heurístico para configurar la red neuronal
Una vez teniendo una red capaz de entrenarse para el proyecto nos dimos cuenta que escoger una configuración de conexiones para la red neuronal era algo complicado y que necesitábamos un análisis minucioso sobre los valores de entrada  ala red para poder elegir una configuración correcta, pero dado que tardamos mucho tiempo en elegir un aparato que nos diera señales de entrada decidimos implementar un algoritmo heurístico que buscara la configuración con el menor error posible para no tener que preocuparnos por la configuración de la misma.

Algoritmo voraz 

El algoritmo voraz fue el seleccionado para configurar la red debido a su simplesa, el algoritmo genera grafos aleatorios y utiliza el error del entrenamiento de una red como función objetivo, es decir entrena n cantidad de veces la red neuronal y el error en n cantidad de entrenamientos finales es el valor de salida en la función objetivo.

Una vez teniendo definido esto solo se crean diferentes redes aleatorias y se modifican seleccionando siempre la que reduzca mas el error.

Esta es una gráfica del programa minimizando el error de una red neuronal

Aquí se muestra una red óptima generada por el programa:



Una nueva red mas flexible

Para que el programa heurístico pudiera minimizar el error de entrenamiento necesitábamos una  red neuronal mas flexible que fuera capaz de evaluar y entrenar una red neuronal con las características ya mencionadas por lo cual tuvimos que implementar una nueva red neuronas, utilizando Backpropagation otra vez como algoritmo de entrenamiento de entrenamiento.

El algoritmo funciona como una búsqueda de profundidad BFS, para evaluar empieza con las neuronas de la capa de entrada, después busca las neuronas con las que tiene conexión y visita las mismas, evalúa las salidas para las mismas y pasa  alas siguientes mas cercanas cuidando no volver a visitar neuronas que ya han sido visitadas antes.

Para el backpropagation utiliza la misma lógica pero esta vez empieza a visitar a las neuronas desde la capa de salida.

Exor
Como prueba para el algoritmo empezamos creando una red para un exór y entrenándola para lo cual esta fue el resultado: 
 
Salidas

[0, 0] (0.08847382273808657, [-0.42065145367176987])
[0, 1] (0.003901019389583797, [0.9116708497767153])
[1, 0] (0.0031196995578053406, [0.9210101328295162])
[1, 1] (0.039653499234460134, [-0.2816149826783374])
Error:  0.346610025801

Entrenando la red con entradas del EGG
Una vez teniendo la red, empezamos a entrenar la red con valores que habiamos tomado del egg con anterioridad, los valores fueron tomados.
Para mandar los valores a la red se creo un parser muy sencillo y se metieron todas las entradas en un vector junto con su salida esperada y se dieron com entrada a la red.

def cargar_archivos(archivos):
    muestras = list()

    for i in range(len(archivos)):
        fl = open(archivos[0])
        for j in fl:
            temp = j.split(",")
            for h in range(len(temp)):
  temp[h] = int(temp[h])
            muestras.append([temp, [i]])
        fl.close()

    random.shuffle(muestras)

    return muestras

El resultado de la red fue el siguiente:

Debido a un problema con la red neuronal, las entradas no siempre se entrenan de forma correcta y eso provoca que el algoritmo heuristico funcione mal y lanze males valores.

La gráfica del entrenamiento es la siguiente:

La red optima que me lanzo es la siguiente:


Programa
El programa se encuentra para descargar en Github desde el siguiente enlace:

https://github.com/SaulG/redesNeuronales

Con las versiones mas estables del programa.

Pero para modificar directamente y mantener una copia automática en tiempo real de lo que modificaba utilice mi cuenta de Dropbox para la cual por cuestiones de seguridad solo daré permiso de acceder a la doctora que imparte la clase.

Esta es la dirección del Dropbox
https://www.dropbox.com/sh/nsn458htcnvcoqo/ydTh4nYjc0

En esta página se puede ver el registro de actividades
https://www.dropbox.com/events?ns=160486657&n=1&d

lunes, 8 de octubre de 2012

Reporte de avances intermedios

Buen día

En esta publicación voy a hablar de mis aportes en el proyecto de el brazo robótico para redes neuronales. Primero voy hacer remembranza del proyecto en el cual me toco trabajar.

El proyecto

La ìdea es utilizar una red neuronal para como función interfaz para poder controlar una red neuronal utilizando un sensor como entrada. Los dispositivos del proyecto son los siguientes:

1.- El brazo robótico es el siguiente (Link) esta la compramos en Steren, este tiene cinco motores de directa, para utilizarlo desarmamos el dispositivo y controlamos utilizando un Arduino cada motor por separado para mapear cada uno con una salida de nuestra red neuronal.


[Imagen obtenida de: http://www.steren.com.mx/_imgs/prod/grande/k-682.jpg]

2.- Sensor de movimiento del brazo (link) este nos ayudara a medir los movimientos de un brazo real para poder pasarlos como entrada a la neurona que trata de hacer que el brazo imite el mismo movimiento de un brazo real.


[imagen obtenida de: https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhl3PMf1bDWHkKt8Tnupif7EdCvaUsBeONZOA0indBV8K8lloWW-XgaKWUjMNGVh30bzAaiU7-UIftsFiSX9gf4HYzJ5R27-57G1ZApleHYeGeQGTWux5bKVIbCcc_h5IggcEtkBdLY9_-F/s1600/Advancer+Technologies+Muscle+Sensor+v2.jpg]

3.- Dos Arduinos para controlar cada motor de la neurona y también la idea es utilizarlo como interfaz de las señales recibidas del sensor y también para las señales mandadas al brazo robótico.

[Imagen obtenida de:http://arduino.cc/en/uploads/Main/arduino_uno_test.jpg]

4.- Mouse como entrada que nos podría servir para pruebas principalmente o como dispositivo de entrada secundario si tenemos problemas con el sensor de movimiento.

Mis aportaciones en el proyecto

Durante estas semanas de trabajo yo me he centrado en la red neuronal en sí mis aportes han sido los siguientes:

1.- Un perceptrón que sabe realizar una operación lógica AND a partir de N cantidad de entradas.


[Imagen obtenida de http://www.bcp.psych.ualberta.ca/~mike/Software/Images/GIFS/Perceptron.gif]

Este es el perceptrón corriendo en la terminal:

kalavera@kalavera-AOD270:~/Dropbox/neuralNetworks/perceptron$ python perceptron.py 
Ronda: 10
[Entradas]-> (Salida, Error)
[0,0,0]-> (0, 0)
[0,0,1]-> (0, 0)
[0,1,0]-> (0, 0)
[0,1,1]-> (0, 0)
[1,0,0]-> (0, 0)
[1,0,1]-> (0, 0)
[1,1,0]-> (0, 0)
[1,1,1]-> (1, 0)
Porcentaje de error:  0.0
Ronda: 20
[Entradas]-> (Salida, Error)
[0,0,0]-> (0, 0)
[0,0,1]-> (0, 0)
[0,1,0]-> (0, 0)
[0,1,1]-> (0, 0)
[1,0,0]-> (0, 0)
[1,0,1]-> (0, 0)
[1,1,0]-> (0, 0)
[1,1,1]-> (1, 0)
Porcentaje de error:  0.0
Ronda: 30
[Entradas]-> (Salida, Error)
[0,0,0]-> (0, 0)
[0,0,1]-> (0, 0)
[0,1,0]-> (0, 0)
[0,1,1]-> (0, 0)
[1,0,0]-> (0, 0)
[1,0,1]-> (0, 0)
[1,1,0]-> (0, 0)
[1,1,1]-> (1, 0)
Porcentaje de error:  0.0
Ronda: 40
[Entradas]-> (Salida, Error)
[0,0,0]-> (0, 0)
[0,0,1]-> (0, 0)
[0,1,0]-> (0, 0)
[0,1,1]-> (0, 0)
[1,0,0]-> (0, 0)
[1,0,1]-> (0, 0)
[1,1,0]-> (0, 0)
[1,1,1]-> (1, 0)
Porcentaje de error:  0.0
Ronda: 50
[Entradas]-> (Salida, Error)
[0,0,0]-> (0, 0)
[0,0,1]-> (0, 0)
[0,1,0]-> (0, 0)
[0,1,1]-> (0, 0)
[1,0,0]-> (0, 0)
[1,0,1]-> (0, 0)
[1,1,0]-> (0, 0)
[1,1,1]-> (1, 0)
Porcentaje de error:  0.0




En la gráfica se puede ver como hasta el porcentaje de errores disminuye conforme avanzan el número de entrenamientos.

2.- Identificar cuales sería el formato de las entradas y salidas de la red neuronal para poder conectarla con las demás partes del proyecto.

Las salidas de la red neuronal serán cinco valores de -1 a 1 donde cada salida es un motor de el brazo a controlar, el signo representa la dirección hacia donde gira el motor y la magnitud es el porcentaje de la potencia que se le dara como entrada a cada motor para su movimiento en un momento dado.

La entrada de la red son valores de 0 a 1 donde en el mouse serìan cinco entradas con tres valores boolean(dos para mapear el desplazamiento en el eje "Z" y uno para controlar si la mano esta abierta o cerrada) y otros dos valores de cero a uno que representan la magnitud de movimiento en los ejes "X" y "Y".

3.- Una red neuronal con que utiliza un backpropagation que es capaz de entrenar una operación lógica XOR.


[Imagen obtenida de: http://upload.wikimedia.org/wikipedia/en/7/7b/XOR_perceptron_net.png]

Esta capaz de recibir N cantidad de entradas, N cantidad de salidas y N cantidad de capaz ocultas con una cantidad indicada de neurona por cada.

Resultado de la red neuronal funcionando:

kalavera@kalavera-AOD270:~/Dropbox/neuralNetworks/backpropagation$ python backpropagation.py 
Entrenamiento  200
[Entradas]->([Salidas], Error de la entrada)
[0, 0]-> ([0.474495271915521], 0.1125728815350921)
[0, 1]-> ([0.37505126707208475], 0.1952804593941034)
[1, 0]-> ([0.5823535611422921], 0.08721427394526257)
[1, 1]-> ([0.5220702129331823], 0.13627865361604918)
Error total: 0.532447443769
Entrenamiento  400
[Entradas]->([Salidas], Error de la entrada)
[0, 0]-> ([0.1322986224502954], 0.008751462751122902)
[0, 1]-> ([0.8394889161833453], 0.012881904013998573)
[1, 0]-> ([0.8793040698303914], 0.007283753779753512)
[1, 1]-> ([0.11724811917898809], 0.006873560725505097)
Error total: 0.0363892840677
Entrenamiento  600
[Entradas]->([Salidas], Error de la entrada)
[0, 0]-> ([0.05913700738077921], 0.0017485928209771675)
[0, 1]-> ([0.9307148291442338], 0.00240021745025636)
[1, 0]-> ([0.9415353481256814], 0.0017090577593926325)
[1, 1]-> ([0.05386406206351596], 0.0014506685909911497)
Error total: 0.00733992070545
Entrenamiento  800
[Entradas]->([Salidas], Error de la entrada)
[0, 0]-> ([0.04290168974228023], 0.0009202774913714363)
[0, 1]-> ([0.9499122257362397], 0.0012543925653487054)
[1, 0]-> ([0.9569983854337117], 0.0009245694276538073)
[1, 1]-> ([0.039291967229676726], 0.0007719293443889948)
Error total: 0.00388046980583
Entrenamiento  1000
[Entradas]->([Salidas], Error de la entrada)
[0, 0]-> ([0.035094804595055304], 0.0006158226547825574)
[0, 1]-> ([0.959063671610146], 0.0008378914910209811)
[1, 0]-> ([0.9646043401326987], 0.0006264263687208423)
[1, 1]-> ([0.03222230809688534], 0.0005191385695453013)
Error total: 0.00260358975226
Entrenamiento  1200
[Entradas]->([Salidas], Error de la entrada)
[0, 0]-> ([0.030329170362382255], 0.0004599292874352031)
[0, 1]-> ([0.964631056127485], 0.0006254810953285579)
[1, 0]-> ([0.9692976693002945], 0.00047131655519703987)
[1, 1]-> ([0.02788793831394172], 0.0003888685517011093)
Error total: 0.00194805307916
Entrenamiento  1400
[Entradas]->([Salidas], Error de la entrada)
[0, 0]-> ([0.027048462181108093], 0.00036580965318141735)
[0, 1]-> ([0.9684571007012248], 0.0004974772480863361)
[1, 0]-> ([0.972549861633694], 0.0003767550481646738)
[1, 1]-> ([0.02489620547440081], 0.00030991052351179245)
Error total: 0.00155153147387
Entrenamiento  1600
[Entradas]->([Salidas], Error de la entrada)
[0, 0]-> ([0.02461914725176058], 0.00030305120570193523)
[0, 1]-> ([0.9712874505768887], 0.0004122052471873045)
[1, 0]-> ([0.9749689348255783], 0.0003132771118830725)
[1, 1]-> ([0.02267685184578588], 0.0002571198048178612)
Error total: 0.00128674992658
Entrenamiento  1800
[Entradas]->([Salidas], Error de la entrada)
[0, 0]-> ([0.022729827787687135], 0.0002583225356289571)
[0, 1]-> ([0.9734873478545911], 0.000351460361891727)
[1, 0]-> ([0.976856568607479], 0.0002678092083101621)
[1, 1]-> ([0.02094851916507799], 0.00021942022760481996)
Error total: 0.0010978166042
Entrenamiento  2000
[Entradas]->([Salidas], Error de la entrada)
[0, 0]-> ([0.021207694303121406], 0.00022488314882732405)
[0, 1]-> ([0.9752590320475286], 0.000306057747612608)
[1, 0]-> ([0.9783812886752716], 0.00023368433967096928)
[1, 1]-> ([0.01955464950192206], 0.00019119215857151033)
Error total: 0.000956431642298


Gráfica del error de la red respecto al número de entrenamientos:


4.- Un script que manda valores del mouse a la red neuronal

Ya que es facilmente conectable con el brazo robótico este script utilizando el trabajo hecho por Saul en arduino puede servir como un demo funcional para poder probar el entrenamiento de la red o como entrada para el proyecto en caso de tener problemas con el sensor.

Script funcionando:

Lanzar neurona 
 Entrada: [1, 0, 0, 0.0, -0.00390625, -1.0] 
 Salida de la neurona: [0.48522782273394494, 0.46528791920646234, 0.5080086717829049, 0.47842463725639695, 0.3257708187603702]
Lanzar neurona 
 Entrada: [1, 0, 0, 1.0, -1.0] 
 Salida de la neurona: [0.48278577383442495, 0.46450789670091625, 0.5040649848787113, 0.4757326538389182, 0.32530698069301456]
Lanzar neurona 
 Entrada: [1, 0, 0, 0.00390625, -0.00390625, -1.0] 
 Salida de la neurona: [0.4852507257970186, 0.46530789612111967, 0.5080626634104084, 0.47847761475644773, 0.3257815217253954]
Lanzar neurona 
 Entrada: [1, 0, 0, 1.0, -1.0] 
 Salida de la neurona: [0.48278577383442495, 0.46450789670091625, 0.5040649848787113, 0.4757326538389182, 0.32530698069301456]
Lanzar neurona 
 Entrada: [1, 0, 0, 0.00390625, -0.00390625, -1.0] 
 Salida de la neurona: [0.4852507257970186, 0.46530789612111967, 0.5080626634104084, 0.47847761475644773, 0.3257815217253954]
Lanzar neurona 
 Entrada: [1, 0, 0, 1.0, -2.0] 
 Salida de la neurona: [0.47490840060670253, 0.4586456080429631, 0.48683150501808015, 0.4597414567647642, 0.3221387170017972]
Lanzar neurona 
 Entrada: [1, 0, 0, 0.00390625, -0.0078125, -1.0] 
 Salida de la neurona: [0.4852180545680131, 0.465284781840049, 0.5079928777280113, 0.47841383024354855, 0.32576895427644487]
Lanzar neurona 
 Entrada: [1, 0, 0, 1.0, -2.0] 
 Salida de la neurona: [0.47490840060670253, 0.4586456080429631, 0.48683150501808015, 0.4597414567647642, 0.3221387170017972]
Lanzar neurona 
 Entrada: [1, 0, 0, 0.00390625, -0.0078125, -1.0] 
 Salida de la neurona: [0.4852180545680131, 0.465284781840049, 0.5079928777280113, 0.47841383024354855, 0.32576895427644487]
Lanzar neurona 
 Entrada: [1, 0, 0, 2.0, -3.0] 
 Salida de la neurona: [0.47268561743692933, 0.4578659896865551, 0.4831443981393224, 0.4571462140479316, 0.32168335354092753]
Lanzar neurona 
 Entrada: [1, 0, 0, 0.0078125, -0.01171875, -1.0] 
 Valor de la neurona: [0.48520828720331255, 0.46528164447127085, 0.5079770845865935, 0.47840302355804754, 0.3257670898189717]


Cada que se recibe señal del mouse el script procesa los datos y lanza la neurona dándole como entrada los datos procesados, en este ejemplo la red neuronal debería ser capaz de enviar sus salidas al brazo robótico.
En este ejemplo la red neuronal no ha sido entrenada así que los valores de salida no son correctos pero se puede observar los valores tomados del mouse y normalizados usados como entrada para la red neuronal que son cinco(tres booleans y dos de magnitud) y la salida de la red neuronal que son los cinco porcentajes de potencia para cada motor del brazo robótico.

Por ultimo aquí dejo la liga al repositorio del proyecto donde se muestran mis aportaciones al mismo:
https://github.com/SaulG/redesNeuronales/tree/red

Referencias:
http://www.steren.com.mx/catalogo/prod.asp?p=2091&desc=
https://docs.google.com/file/d/0B8Wy2qiwirwyWnBkM09JT29LaXM/edit

martes, 7 de agosto de 2012

Idea de proyecto - Bots que juegue video juegos

Buen día.

Mi idea es entrenar la red neuronal para identificar de manera gráfica la posición de un personaje en un momento dado en un vídeo juego y como este interactúa con el ambiente u otros personajes, esto con el fin de tomar decisiones de manera inteligente.


[imagen obtenida de "http://www.thedirectorfiles.com/assets/photos/downloads/pacman.gif" ]


Algunos de las cosas que podría realizar el Bot:

  • Detectar gráficamente barras de salud , estamina, mana, etc, 
  • Detectar personajes hostiles y su posición.
  • Detectar personajes amigables y su posición.
  • Detectar objetos con los que es posible interactúar.
Una vez teniendo las posiciones puedo utilizar un algoritmo heuristico para que el Bot tome decisiones en el juego.

Redes neuronales artificiales

Hola