documento proyecto de grado - uniandes
TRANSCRIPT
DOCUMENTO PROYECTO DE GRADO
APLICACIÓN DE DEEP LEARNING EN ROBÓTICA MÓVIL PARA EXPLORACIÓN Y
RECONOCIMIENTO DE OBJETOS BASADOS EN IMÁGENES
Autor: Javier Stevenson Contreras Rojas
Diciembre 2015
Ingeniería de Sistemas y Computación Universidad de los Andes
Bogotá, Colombia
Profesor Asesor: Mario Fernando De la Rosa Rosero
1
Tabla de contenido
Capítulo 1. Introducción ................................................................................................................. 4
Capítulo 2. Descripción general ..................................................................................................... 5
2.1 Objetivo General ............................................................................................................. 5
2.2 Objetivos Específicos ............................................................................................................. 5
2.3 Antecedentes ........................................................................................................................ 6
2.4 Identificación del problema y de su importancia .......................................................... 10
Capítulo 3. Diseño y especificaciones .......................................................................................... 12
3.1 Definición del problema ................................................................................................ 12
3.2 Especificaciones............................................................................................................. 12
3.3 Restricciones ....................................................................................................................... 15
Capítulo 4. Desarrollo del diseño ................................................................................................. 16
4.1 Red Neuronal convolucional para reconocimiento de imágenes ....................................... 16
4.2 Deep learning ...................................................................................................................... 17
4.3 Arquitectura del robot móvil neuronal ............................................................................... 21
Capítulo 5. Implementación ......................................................................................................... 24
5.1 Descripción de la implementación ................................................................................ 24
5.2 Resultados esperados ................................................................................................... 30
Capítulo 6. Validación ................................................................................................................... 33
6.1 Métodos ........................................................................................................................ 33
6.2 Validación de resultados ............................................................................................... 33
Capítulo 7. Conclusiones .............................................................................................................. 42
7.1 Discusión ....................................................................................................................... 42
7.2 Trabajo futuro ............................................................................................................... 42
Capítulo 8. Referencias ................................................................................................................. 43
2
Tabla de Figuras
FIGURA 1 RED NEURONAL CONVOLUCIONAL[8] ............................................................................... 17
FIGURA 2 MODELO RED NEURONAL[8] .......................................................................................... 18
FIGURA 3 OPTIMIZACIÓN GRADIENTE DE DESCENSO[8] ..................................................................... 19
FIGURA 4 MODELO DEL ALGORITMO BACKPROPAGATION[8] ............................................................. 21
FIGURA 5 ARQUITECTURA GENERAL DEL SISTEMA ............................................................................. 23
FIGURA 6 CÁMARA WEB LOGITECH ............................................................................................... 31
FIGURA 7 ROBOT P3-DX……………………………………………………………………………………………………….32
FIGURA 8 SENSOR URG…………………………………………………………………………… .............................. 32
FIGURA 9 MOBILESIM …………………………………………………………………………………………………………..32
FIGURA 10 JOYSTICK GENIUS F-16U ............................................................................................. 32
FIGURA 11 (IZQUIERDA) APRENDIZAJE NAVEGACIÓN (DERECHA) APRENDIZAJE ESTRUCTURAS. .................. 34
FIGURA 12 APRENDIZAJE FINAL NAVEGACIÓN ................................................................................. 35
FIGURA 13 APRENDIZAJE FINAL NAVEGACIÓN ................................................................................. 35
FIGURA 14 RE APRENDIZAJE NAVEGACIÓN 1 .................................................................................. 36
FIGURA 15 RE APRENDIZAJE NAVEGACIÓN 2 .................................................................................. 36
FIGURA 16 RE APRENDIZAJE FALLIDO NAVEGACIÓN ......................................................................... 36
FIGURA 17 RE APRENDIZAJE FALLIDO NAVEGACIÓN ......................................................................... 37
FIGURA 18 VISTA SUR DEL MAPA………………………………………………………………………………………………37
FIGURA 19 PATRÓN DE CALLEJÓN CERRADO………………………………………………………………………………..37
FIGURA 20 VISTA NORTE DEL MAPA ............................................................................................. 37
FIGURA 21 VISTA GENERAL DEL MAPA ............................................................................................ 37
FIGURA 22 APRENDIZAJE FINAL IMÁGENES 1 .................................................................................. 39
FIGURA 23 APRENDIZAJE FINAL IMÁGENES 2 .................................................................................. 39
FIGURA 24 APRENDIZAJE FINAL IMÁGENES 3 .................................................................................. 40
FIGURA 25 IMÁGENES DE PUERTAS DE ASCENSOR ............................................................................ 40
FIGURA 26 IMÁGENES DE ESCALERAS ............................................................................................. 41
FIGURA 27 IMAGEN DE CORREDOR ESTRECHO ................................................................................. 41
FIGURA 28 IMAGEN DE CORREDOR AMPLIO .................................................................................... 41
3
Capítulo 0. Resumen
Deep Learning es una técnica de aprendizaje de máquina utilizada para un robot móvil,
con el objetivo de reconocer estructuras como escaleras, ascensores o corredores, por
medio de una cámara web y establecer acciones de movimiento para su exploración a
través de un sensor láser. Esta tarea es compleja, debido a que la red neuronal tiene que
analizar los datos de la imagen y del sensor para establecer patrones de las estructuras y
comportamientos de movimiento, de esta manera lograr un aprendizaje detallado y más
preciso sobre la información. Esto requiere una implementación eficiente y un buen
procesamiento computacional para el proceso de entrenamiento. Luego de un apropiado
entrenamiento, por medio de imágenes supervisadas y datos de proximidad de un sensor
láser, con sus respectivas acciones de movimiento, se redirige a dos redes neuronales
independientes que lograran que el robot en tiempo real explore y reconozca las
estructuras conforme a lo que se le enseñó.
Palabras Clave - Deep Learning, Robótica móvil, Procesamiento de imágenes, red
neuronal, sensor láser, aprendizaje, reconocimiento, exploración.
4
Capítulo 1. Introducción
El aprendizaje de las máquinas se ha ido desarrollando en las últimas décadas con el fin de
no hacer un programa específico para cada situación. Nuevas técnicas como Deep
Learning (basado en redes neuronales) han surgido para tratar de simular en una máquina
la forma en el que un cerebro funciona y aprende. La técnica de Deep Learning consiste en
desfragmentar en profundidad diferentes características de un elemento y de esta manera
aprender en detalle, por medio de diferentes filtros, patrones que no son evidentes de
reconocer para una máquina. Dentro de las aplicaciones de esta técnica se encuentra
reconocimiento de imágenes o video en tiempo real, reconocimiento de voz y
reconocimiento de texto. En el campo de la robótica móvil, esta técnica podría ser muy
útil para un mejor entendimiento y relación entre los sensores como cámaras, micrófonos,
GPS, láser entre otros, y de esta forma tomar mejores decisiones sobre el entorno para las
tareas que tengan que ejecutar.
El tema de estudio del proyecto desarrollado consiste en utilizar Deep Learning para
aprender a explorar y reconocer estructuras físicas (tipo escaleras, corredores,
ascensores), siendo interesante debido a que este tipo de aprendizaje es basado en el
funcionamiento del cerebro humano y acerca a los computadores a una inteligencia más
natural.
El documento está estructurado de la siguiente forma: El capítulo 2 presenta una
descripción general objetivos y estado del arte, el capítulo 3 trata sobre el diseño y
especificaciones del proyecto, el capítulo 4 muestra el diseño desarrollado del sistema, el
capítulo 5 describe la implementación y resultados esperados, el capítulo 6 muestra los
métodos a utilizar para los resultados y los resultados del proyecto, el capítulo 7 trata de
las conclusiones y trabajo a futuro.
5
Capítulo 2. Descripción general
2.1 Objetivo General
Diseñar, implementar, probar y documentar la aplicación del método Deep Learning por
medio de un robot móvil para realizar un reconocimiento de estructuras físicas y
navegación al interior de espacios cerrados. El objetivo del robot es explorar el terreno
para identificar tipos de estructuras físicas (corredores, ascensores, escaleras, etc.) que lo
componen. Por medio de reconocimiento de imágenes y sensores láser, analizar su
navegabilidad en el ambiente. Para ello una red neuronal clasificará las diferentes
estructuras que la cámara y los sensores obtengan y de esta manera lograr mostrar a los
interesados el efectivo reconocimiento y exploración en las que puedan incurrir una
edificación o terreno.
2.2 Objetivos Específicos
Realizar una revisión bibliográfica con respecto al tema de interés y preparar un
estado del arte. Destacar las características de los trabajos más importantes para
poder hacer una diferenciación con respecto a la propuesta realizada en este
trabajo.
Diseñar una arquitectura de solución identificando el(los) método(s) de solución de
sus componentes.
Diseñar escenarios de pruebas para ambiente en simulación y plataforma
experimental.
Implementar los componentes de la arquitectura y realizar las pruebas diseñadas.
Integrar las componentes en la arquitectura y realizar sus pruebas diseñadas.
Documentar el proceso de la realización del proyecto.
6
2.3 Antecedentes
2.3.1 Landing Zone Detection[1]
3D Convolutional Neural Networks for Landing Zone Detection from LiDAR es un proyecto
el cual desarrolló un sistema de detección de obstáculos en un terreno con vegetación. En
este proyecto implementaron una técnica de Deep Learning la cual utiliza una red
neuronal convolucional para calcular la región más adecuada en la que un helicóptero
pueda hacer un aterrizaje satisfactorio. Esta red reduce la cantidad de parámetros a
aprender para lograr mayor eficiencia en el reconocimiento de imágenes aprovechando la
estructura espacial de una imagen.
El proceso de este proyecto empieza con la obtención de la información, para ello
utilizaron un sensor LiDAR el cual puede obtener la estructura tridimensional de un
terreno; luego dividieron el mapa obtenido en una malla de un metro cuadrado para
predecir la región más segura a aterrizar, se hizo mediante la evaluación de cada
subregión en la red neuronal y a través de las diferentes capas se entrenó para reconocer
estructuras como planos, esquinas y la densidad del terreno, de esta manera determinar si
hay un obstáculo que pueda afectar el proceso de aterrizaje.
El proceso de aprendizaje utilizó una regresión logística a los parámetros de la red
convolucional y se implementó utilizando la librería Theano para hacer los cálculos sobre
GPU para acelerar el procesamiento en tiempo real por medio del cálculo en paralelo.
Por último se entrenó en simulación la red neuronal, con objetos en 3D diseñados
virtualmente y se midió que tan acertado el sistema predecía donde aterrizar. Luego se
utilizó información real para hacer pruebas en campo, aunque a futuro ellos plantean
realizar pruebas más extensivas incorporando mayor cantidad de modelos en 3D y objetos
reales para entrenar mejor la red neuronal, también como trabajo a futuro poder
incorporar más sensores para hacer más precisa la información del terreno.
7
2.3.2 Door recognition for visual based robot navigation[2]
Este trabajo planteó el problema de demostrar que se puede reconocer de manera
acertada las puertas de un sitio cerrado mediante la técnica de Deep Learning y que esta
es adecuada para la robótica móvil.
En sitios cerrados, es necesario que el robot pueda reconocer las diferentes posiciones y
ángulos de una puerta cuando está recorriendo un sitio, de esta manera puede crear un
plan de ruta en base a las puertas que va reconociendo. Primero se recolectan muchas
imágenes de puertas en diferentes posturas e imágenes de falsos positivos para que la red
neural se pueda entrenar. Al igual que el anterior proyecto, para mayor eficiencia la red
neuronal se ejecuta sobre una tarjeta gráfica de 960 núcleos que pueden trabajar en
paralelo. Esta red convolucional se entrenó con 20500 imágenes durante 8 horas.
Durante los resultados se obtuvo que los errores ocurrían sobre las muestras positivas por
un factor de omisión, lo cual es un error aceptable para un robot móvil ya que
continuamente está recolectando nuevas imágenes.
Como trabajo a futuro en este proyecto, ellos esperan investigar la influencia de las
muestras de entrenamiento en la red neuronal para mejorar la rata de error en la
detección de puertas de un robot autónomo móvil.
2.3.3 Pedestrian detection[3]
Este trabajo propuso el proyecto Long-Range Pedestrian Detection using Stereo and
Cascade of Convolutional Network Classifiers, el cual es un sistema detector de personas
en una combinación de detección estéreo, clasificación por red neuronal y en cascada
especializada en reducir falsos positivos y carga computacional.
Para este proceso fue necesario calibrar las cámaras estéreo, para que la información que
le llegue a la red neuronal sea acertada, luego se computó la información de las cámaras
para posicionar la información en un plano cartesiano tridimensional. Por último, se
8
entrenó la red con muestras positivas y negativas de personas, y se hizo varias
clasificaciones para personas que se encuentran tanto lejos como cerca de la detección.
En las pruebas del sistema, se utilizaron secuencias de video de ambientes externos como
parqueaderos, áreas abiertas con edificios, vegetación y bosque por un periodo de 10
meses. Lograron demostrar el reconocimiento de personas a diferentes distancias incluso
en rangos que típicamente no se habían intentado en trabajos anteriores. La primera
parte clasificadora reconoció en las imágenes lo que podía ser una persona y en la
segunda parte se filtró considerablemente el número de falsos positivos. La parte de
Deep Learning fue utilizada para no tener que rediseñar nuevas características que se
pudieran presentar de las personas, sino que en el proceso de optimización el sistema
aprendiera a reconocerlas.
Como trabajo a futuro propusieron utilizar sensores más precisos y combinación de
nuevos métodos para lograr reconocer personas de una forma precisa, también que esta
técnica podría ser de ayuda para el campo de robótica móvil.
2.3.4 Mobile robot control[4]
Se presenta un sistema de navegación para un robot móvil que utiliza dos algoritmos: el
primero es una red neural de auto aprendizaje sobre la planeación de los movimientos
para un robot, el segundo algoritmo es un control de colisión con una heurística neuro-
borrosa.
El sistema robótico es controlado remotamente por una estación de comando la cual
contiene la red neuronal y obtiene toda la información de los sensores para luego manejar
los actuadores del robot. La primera parte del proceso fue comunicar el robot con la
estación y entender el funcionamiento de los diferentes sensores del robot. Luego se
utilizó un acercamiento a la heurística neuro-borrosa, la cual analiza las formas que
obtiene de un sonar y de esta manera determinar la velocidad de las llantas. Dependiendo
9
de la distancia a la que se encuentre de un obstáculo determinara que tan rápido se
moverá el robot.
Con la red neuronal se construirá sobre un ambiente bidimensional la cual cada espacio de
la grilla del mapa equivaldrá a una neurona, y la activación de cada neurona determinara
el camino por donde el robot deberá moverse.
Los resultados del experimento mostraron que para sitios amplios el error de navegación
era mínimo, pero para sitios cerrados con objetivos de navegación cortos el error era
considerable, estos errores aumentaron cuando se colocaron obstáculos en el camino,
estáticos y dinámicos.
2.3.5 Motion planning in mobile robotics [5]
El proyecto Hierarchical reinforcement Learning approach for motion planning in mobile
robotics presenta una forma de navegación robótica desde un punto inicial a un punto
objetivo mediante la generación de una ruta sin colisiones, con un resultado de
aprendizaje el cual puede ser aplicado satisfactoriamente en ambientes desconocidos.
Aplicando la técnica de Q-learning, un método de aprendizaje por refuerzo, el cual por
medio de la una función de optimización, una acción en un determinado estado obtiene
una recompensa la cual es evaluada para determinar el próximo movimiento con cierta
probabilidad, de esta manera, el conjunto de acciones del robot no recae en ciclos sin
salida, sino que para poder optimizar la función objetivo, puede caer en un estado que no
la mejore y así lograr salir de un óptimo local y lograr llegar al óptimo global.
Los resultados obtenidos en simulación fueron satisfactorios ya que el robot logro en poco
tiempo llegar a su objetivo; por otra parte los resultados sobre el robot físico fueron
menos acertados, ya que lo errores acumulados que tiene un robot físico afectan la
navegación y por esto tuvo que recorrer más pasos para lograr llegar a su objetivo.
Como trabajo a futuro se propone crear una red neuronal en el sistema de aprendizaje
para aproximarse a la función de optimización y de esta manera no tener que recorrer
10
todos los pares de acciones-estados de un ambiente, aunque implica investigar que la red
se ajuste este problema de planeaciones de movimiento.
2.3.6 Análisis de los trabajos relacionados
Estos trabajos, inspiran este proyecto, en el sentido que muestran las técnicas que fueron
favorables para el caso de estudio presentado en este documento. Por ejemplo, el cómo
entrenar una red neuronal, mostrándole diferentes puntos de vista del objeto a
reconocer; los métodos de red neuronal convolucional que mejoran la eficiencia del
análisis de patrones de imágenes; las aplicaciones que una red neuronal puede tener con
la navegación y planeación de rutas; y la optimización de obtener logros por medio de
técnicas como aprendizaje por refuerzo. Todas estas opciones, se intentaran implementar
en este proyecto para generar un aprendizaje robusto y completo.
2.4 Identificación del problema y de su importancia
Más de mil millones de personas viven en el mundo con alguna forma de limitación, esta
cifra representa casi el 15% de la población mundial. Alrededor de 200 millones presentan
dificultades considerables en su funcionamiento corporal. Así mismo, las naciones han
intentado regularizar por medio de leyes, las arquitecturas en todo el mundo, para que
tengan en cuenta el bienestar y movilidad de las personas con algún tipo de discapacidad.
Se considera una persona con limitación funcional, la que teniendo una o más deficiencias
mentales o físicas, sea por causa sensorial, psíquica o intelectual, por carácter temporal o
permanente, al movilizarse por alguna construcción, se ve restringida de navegar plena y
efectivamente[6].
Las nuevas y grandes construcciones, en su diseño moderno ya tienen en cuenta el
generar espacios accesibles para todas las personas. Por otro lado, las construcciones
pequeñas, presupuestadas y planeadas para estratos de bajos recursos económicos, con
cierto grado de antigüedad, normalmente presentes en países subdesarrollados o en los
suburbios de los desarrollados, no se preocupan por este 15% de la población. El lograr
reparar y reconstruir a futuro esta mayoría de construcciones en el mundo, determinará
un impacto social considerable en el bienestar y calidad de vida para todas las personas y
11
más aún para estas personas con limitaciones funcionales, que se encuentran marginadas
en la sociedad, de esta manera se podría brindar un poco más de autonomía para que
puedan desarrollar sus actividades diarias.
12
Capítulo 3. Diseño y especificaciones
3.1 Definición del problema
Antes de reparar o reconstruir una construcción, es necesario entender que es lo que se
tiene que cambiar, para ello se necesita analizar y reconocer los diferentes aspectos de la
construcción, como iluminación, espacios amplios y alternativas de caminos, que
determinan la facilidad de desplazamiento para todas las personas. De esta manera,
encontrar las falencias, que pueden no ser intuitivas para las personas, sobre una
edificación, por ejemplo, si una persona de edad necesita desplazarse de un punto A al B
pero en el trayecto se topa con obstáculos como escaleras o corredores estrechos, la
construcción debería presentar alternativas alrededor de estos obstáculos, como lo son
rampas, ascensores o corredores alternativos de mejor movilidad.
En este proyecto se desea que un robot móvil logre analizar estos espacios, para ello se
investigó anteriormente que la bio-inspiración en el cerebro humano a través de las redes
neuronales, permitirán que las máquinas, puedan aprender sin necesidad de tener que
programar las posibles situaciones que puedan encontrar, cosa que se vuelve muy tedioso
para el mundo real, ya que hay demasiadas variables que una función no puede calcular
de forma completa o se tardaría mucho en ejecutar a través de un computador. A la luz de
esta problemática, una red neuronal, le permitirá al robot identificar y generalizar los
objetos obtenidos de una cámara digital por medio de patrones y así mismo razonar y
relacionar los datos obtenidos con su objetivo principal.
3.2 Especificaciones
3.2.1 Requerimientos Funcionales
3.2.1.1 Descomposición de una imagen en varios aspectos (Convolución).
Para un mejor análisis de la imagen es necesario generar un sistema de filtrado para
obtener diferentes características de la misma imagen y de esta manera especializar el
entrenamiento de cada neurona en la red.
13
La entrada de este requerimiento es una matriz de datos en el que cada tres posiciones
equivalen a un pixel de la imagen, estas tres posiciones pertenecen a la intensidad de
color del rojo verde y azul, más conocido como RGB[7]. Estas imágenes serán varios
objetos de una construcción, decisivos para determinar la comodidad de navegación,
estos son corredores anchos y estrechos, escaleras, ascensores y rampas. Con cada uno de
estos objetos se obtendrán imágenes desde el punto de vista del robot y en tres
diferentes ángulos de observación al objeto: frontal, izquierdo y derecho; esto permitirá
un mejor reconocimiento sin importar la posición.
La salida es a partir de una imagen, un conjunto de imágenes descompuestas,
normalmente esta descomposición termina en un énfasis en los bordes de la imagen que
se está analizando.
3.2.1.2 Reducción de cada imagen descompuesta
Para una mayor eficiencia en el procesamiento de los datos de una imagen, es necesario
implementar una reducción de la resolución de la imagen, sin alterar el brillo. De esta
manera el tiempo de procesamiento disminuye considerablemente sin afectar el
reconocimiento de la imagen.
La entrada de este requerimiento es una parte de la imagen convolucionada, y de esta se
computa un área de pixeles a un pixel único, reduciendo así la resolución. Luego, la salida
es la imagen ya procesada con una cantidad de datos menor.
3.2.1.3 Reconocimiento de la estructura en sus diferentes aspectos.
Para que se tenga un reconocimiento correcto de los objetos de la construcción, es
necesario obtener y entrenar el sistema con la mayor cantidad de imágenes posibles.
Las entradas son las diferentes imágenes filtradas y reducidas, para que el sistema pueda
analizarlas por independiente. Así mismo, la salida, será un vector que determinará que
objeto reconoció y así se comparará con el objeto esperado y ver su grado de acertitud.
3.2.1.4 Navegación autónoma por un terreno
Para la navegación del robot, como entrada, se obtendrá el arreglo de distancias que el
sensor láser detecte en tiempo real. El sistema razonara sobre estos puntos obtenidos y
14
reconocerá que dirección y movimiento es necesario ejecutar. El resultado retorna una
probabilidad, esta estará asociada al grado de rotación en la dirección reconocida, por
ejemplo si obtiene la neurona de dirección derecha con probabilidad de 1, significará una
rotación al máximo grado de inclinación, pero si la probabilidad es cercana a cero, su giro
será mínimo.
3.2.1.5 Análisis y decisión de los resultados de reconocimiento en tiempo real.
Dependiendo de las salidas de lo que inspeccionó el sistema, este requerimiento tendrá
como objetivo examinar y relacionar los objetos reconocidos, y creará unos objetivos
primarios y secundarios que intentará ejecutar dependiendo de su prioridad, como por
ejemplo si encuentra unas escaleras, se disparará un sub-objetivo de buscar un ascensor o
rampa cercana. Como salida se obtendrá un conjunto de órdenes de movimiento al robot
y la persistencia de los datos obtenidos junto con su nivel de confianza, con el fin que al
final del recorrido se genere un informe detallado de la calidad de navegación de la
construcción analizada.
3.2.2 Atributos de Calidad
3.2.2.1 Latencia
Es importante, que la latencia de procesamiento entre la obtención de los datos del
sensor y la ejecución de movimiento, generación de objetivos y reportes, sean en tiempo
real. Es crítico que la parte de navegación, sea una exploración libre de colisión. Es por
esto que la red neuronal del sensor láser, debe ejecutarse con mayor prioridad y de forma
eficiente.
3.2.2.2 Interoperabilidad
Ya que para manejar el robot se utiliza la librería Aria, pero para la ejecución de la red
neuronal se manejará una librería que soporte procesamiento sobre GPU, es necesario
crear un sistema general que logre conectar, varias tecnologías y protocolos de
comunicación.
En conclusión, será aceptable si hay perdidas de conexión, o latencias en el procesamiento
de imágenes, no es crítico, en el sentido que la supervivencia del robot no dependerá de
15
lograr detectar estos objetos, ya que son solamente para reportar y analizar la
construcción, sin embargo es ideal, que esta tarea se ejecute en el menor tiempo posible.
3.3 Restricciones
El ambiente de pruebas del robot, se podrá ejecutar en las áreas cercanas al laboratorio,
ya que estos robots pertenecen a una red privada con poca cobertura. Las características
computacionales, afectaran el rendimiento del procesamiento del sistema. Las diferentes
partes del robot, como láser y cámara, se utilizaran de los recursos de la universidad.
16
Capítulo 4. Desarrollo del diseño
Para el proceso de aprendizaje de las diferentes estructuras de construcción, como
paredes, escaleras, corredores, ascensores, se propone implementar un sistema de red
neuronal convolucional eficiente, escoger con cuidado los datos y la cantidad de datos de
entrenamiento, ya que esto dependerá la calidad de aprendizaje que la máquina tendrá.
Una red neuronal es sensible a la parametrización que se le defina, si se utilizan valores
exagerados, puede sobrentrenarse, haciendo que no se adapte ante situaciones nuevas, o
si sucede el caso contrario, no podrá realizar con éxito el reconocimiento.
Así mismo, después de lograr un reconocimiento óptimo, el robot necesita explorar el
lugar a reconocer, para ello se utilizará una red neuronal que aprenderá a predecir hacia
qué dirección y la velocidad para moverse. A continuación presentaremos una descripción
detallada de cómo implementar estas soluciones.
4.1 Red Neuronal convolucional para reconocimiento de imágenes
Las redes neuronales convolucionales (CNN) fueron propuestas en el año 1990, y se
demostró que tenían excelente desempeño para la clasificación de imágenes como
rostros, letras manuscritas y objetos visuales en general. Este método está compuesto
básicamente por tres procesos principales: capa de extracción de características a partir
de la imagen, capa reductora de resolución y luego las capas de conexión completa para
clasificación.
La parte de obtención de características de la imagen, llamada convolución, intenta
resaltar bordes, esquinas de la imagen, con el objetivo de resaltar el objeto en esencia,
para ello se aplican una serie de filtros que son vistas como capas. Es decir cada capa de la
convolución comparte los mismos pesos, y convierte la imagen a color a escala de grises,
reduciendo la cantidad de datos por pixel. Luego sigue el proceso de reducción de la
imagen que es básicamente es reducir un área de la imagen compuesta por varios pixeles
a un pixel por medio de máximos o medias. Por último, este mapa de imágenes entran a
17
las capas de conexión para terminar en la capa de salida activando una de sus neuronas la
cual cada una significara un reconocimiento diferente, véase figura 1.
Figura 1 Red neuronal convolucional[8]
4.2 Deep learning
La activación de cada neurona se determinara por una función sigmoidea equivalente, que
será eficiente para los cálculos sobre GPU, esta función tendrá como entrada la matriz de
pesos y los pixeles originales o convolucionada, estas dimensiones tienen que ser
coherentes para una efectiva multiplicación. Al inicio la imagen comenzará con 480X640
pixeles, se convierte a un arreglo de 370200 valores, de esta manera cada valor se
multiplicaría con un peso y se sumaría de la siguiente manera 𝑦 = 𝜃1 ∗ 𝑥1 + 𝜃2 ∗ 𝑥2 … +
𝜃𝑛 ∗ 𝑥𝑛 , este valor resultante se escalará entre 0 y 1 mediante la función sigmoidea antes
mencionada la cual se define como:
𝑔(𝑋, 𝜃′) =1 +
tanh((𝑋 ∗ 𝜃′) + 𝑏)2
2
Con 𝑋 𝑅1 𝑥 𝑛𝑢𝑚_𝑝𝑖𝑥𝑒𝑙𝑒𝑠, 𝜃 𝑅𝑛𝑢𝑚𝑝𝑖𝑥𝑒𝑙𝑒𝑠 𝑥 𝑛𝑢𝑚_𝑛𝑒𝑢𝑟𝑜𝑛𝑎𝑠 , al tener esta escala nos dará una
probabilidad de activación que estos valores X sean el valor esperado Y 𝑃(𝑦 = 𝑖|𝑥, 𝜃, 𝑏) ,
donde 𝑏 es el vector de parcialidad o corte con 𝑦 definida por la fórmula lineal 𝑌 = 𝜃𝑥 + 𝑏
18
Luego de esta capa la salida, será la entrada para la siguiente capa determinada con
𝑋 𝑅1 𝑥 𝑛𝑢𝑚_𝑛𝑒𝑢𝑟𝑜𝑛𝑎𝑠𝑐𝑎𝑝𝑎−1 y el siguiente 𝜃𝑐𝑎𝑝𝑎 𝑅𝑛𝑢𝑚_𝑛𝑒𝑢𝑟𝑜𝑛𝑎𝑠𝑐𝑎𝑝𝑎−1 𝑥 𝑛𝑢𝑚_𝑛𝑒𝑢𝑟𝑜𝑛𝑎𝑠𝑐𝑎𝑝𝑎 , para
el caso de los 𝜃𝑠 de la capa de salida sus dimensiones se determinaran por el número de
objetos a clasificar 𝜃𝑜𝑢𝑡 𝑅𝑛𝑢𝑚_𝑛𝑒𝑢𝑟𝑜𝑛𝑎𝑠𝑐𝑎𝑝𝑎−1 𝑥 𝑛𝑢𝑚_𝑜𝑏𝑗𝑒𝑡𝑜𝑠𝑐𝑎𝑝𝑎, el modelo en general se
visualiza en la figura 2
Figura 2 Modelo red neuronal[8]
4.2.1 BackPropagation
Para el proceso de entrenamiento y aprendizaje de la red neuronal, se usará el algoritmo
de BackPropagation, el cual a partir del resultado obtenido de una imagen o valor de
entrada se genera un error con respecto al valor esperado y de esta manera, se retrocede
por la red ajustando todos los pesos con respecto a este error global. Teniendo esto en
mente, es necesario calcular la función de costo regularizada, que representa el costo o la
diferencia entre el resultado de la función de activación ℎ𝜃(𝑥(𝑖))𝑘 y el valor esperado
𝑦𝑘(𝑖), por medio de una función logística que tiene en cuenta el número de imágenes a
entrenar m y la cantidad de unidades(neuronas de una capa):
19
𝐽(𝜃) =1
𝑚 ∑ ∑[−𝑦 log ((ℎ𝜃(𝑥(𝑖)))
𝑘− (1 − 𝑦)log (1 − (ℎ𝜃(𝑥(𝑖)))
𝑘)]
𝐾
𝑘=1
𝑚
𝑖=1
+𝜆
2𝑚[∑ ∑ ∑(Θ𝑗,𝑘
(𝜃))2
𝐼
𝑘=1
𝑁
𝑗=1
𝜃
𝜃=1
]
Siendo y un número binario 0 o 1 donde 1 significa un valor positivo para el objeto que se
está entrenando, por ejemplo si se quiere clasificar correctamente la imagen de una
escalera, el conjunto de entrenamiento tendrá imágenes de escaleras y de lo que no son
escaleras, de esta manera cada imagen estará asociado a un 𝑌 que será 1 o 0
determinando si es o no una escalera.
Luego de tener esta función de costo es necesario hallar el gradiente, que básicamente es
la derivada de esta función, véase figura 3, lo que nos determinara que tan óptimo es esta
función de costo, entonces una vez calculado el gradiente se puede entrenar la red
neuronal, minimizando la función de costo con el algoritmo optimizador de gradiente, lo
que hace es por medio del gradiente bajar por la pendiente de la función hasta lograr un
mínimo local o global.
Figura 3 Optimización Gradiente de descenso[8]
20
Este gradiente es hallado después de ejecutar el algoritmo de BackPropagation, ya que si
se hace de la forma matemática usual (hallando la derivada), para muchas entradas es
ineficiente y costoso de calcular para una máquina, mientras que BackPropagation
optimiza este cálculo.
El proceso de entrenamiento de las redes neuronales empieza, inicializando de forma
aleatoria y simétrica los parámetros (𝜃), ya que es una estrategia efectiva generar valores
aleatorios en un rango [−𝜖𝑖𝑛𝑖𝑡, 𝜖𝑖𝑛𝑖𝑡] donde 𝜖𝑖𝑛𝑖𝑡 =√6
√𝐿𝑖𝑛+𝐿𝑜𝑢𝑡 donde 𝐿𝑖𝑛 =
𝑛ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑠(𝑝𝑖𝑥𝑒𝑙𝑒𝑠) y 𝐿𝑜𝑢𝑡 = 𝑛ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑛𝑒𝑢𝑟𝑜𝑛𝑎𝑠 𝑑𝑒 𝑙𝑎 𝑝𝑟𝑖𝑚𝑒𝑟𝑎 𝑐𝑎𝑝𝑎, de
esta manera se define los pesos como∶
𝑊 = 𝑟𝑎𝑛𝑑(𝐿𝑜𝑢𝑡, 1 + 𝐿𝑖𝑛) ∗ 2𝜖𝑖𝑛𝑖𝑡 − 𝜖𝑖𝑛𝑖𝑡
Luego para ejecutar este algoritmo hacia atrás se empieza ejecutado el algoritmo hacia
adelante “Forward Pass” a partir del conjunto de entrenamiento (𝑥(𝑡), 𝑦(𝑡)), de esta
forma se calcula todas las activaciones a través de la red neuronal incluyendo los valores
de salida ℎΘ(𝑥), En este punto, se quiere calcular el error 𝛿𝑗(𝑙)
por cada neurona 𝑗 en la
capa 𝑙 , le asigna a cada neurona un grado de responsabilidad en el error que se obtuvo en
la salida. Para cada salida en la neurona 𝑘 se obtiene el error mediante 𝛿𝑘(𝑜𝑢𝑡)
= (𝑎𝑘(𝑜𝑢𝑡)
−
𝑦𝑘) donde 𝑦 como ya habíamos visto es {0,1} donde 1 es la clasificación deseada y 0 una
clasificación falsa al elemento a entrenar. Para las capas ocultas este error se calcula como
𝛿(𝑙) = (Θ(𝑙))𝑇𝛿𝑙+1 ∗ 𝑔′(𝑧(𝑙)) donde 𝑔′(𝑧) es la derivada de la función sigmoidea 𝑔′(𝑧) =
𝑔(𝑧)(1 − 𝑔(𝑧))
Calculado los errores se acumula en un delta mediante Δ(𝑙) = Δ(𝑙) + 𝛿(𝑙+1)(𝑎(𝑙))𝑇
Y por último la derivada del costo de función se obtiene como
𝑑
𝑑Θ𝑖𝑗(𝑙) 𝐽(Θ) =
1
𝑚Δ𝑖𝑗
(𝑙) +𝜆
𝑚Θ𝑖𝑗
(𝑙) Para 𝑗 ≥ 1 donde 𝑗 ∈ 𝑁𝑒𝑢𝑟𝑜𝑛𝑎, 𝑖 ∈ 𝑒𝑛𝑡𝑟𝑎𝑑𝑎, 𝑙 ∈ 𝑐𝑎𝑝𝑎
21
Teniendo la función de costo y su derivada se ejecuta el algoritmo de optimización de los
parámetros para minimizar el costo, es decir que el gradiente hallado por el algoritmo de
BackPropagation tienda a 0.
Figura 4 Modelo del algoritmo BackPropagation[8]
Para finalizar, un aspecto a resaltar es la regularización que ya se tiene en cuenta, la cual
funciona para evitar problemas de overfiting, que básicamente es sobre entrenamiento
de la red neuronal, lo cual tiene como desventaja, el fallo de clasificación ante imágenes
nuevas, porque únicamente se adapta a los patrones de imágenes del conjunto de
entrenamiento.
4.3 Arquitectura del robot móvil neuronal
Teniendo en cuenta el diseño de la red neuronal se plantea tener dos redes neuronales,
una convolucional para el reconocimiento y aprendizaje de las estructuras (escaleras,
ascensores, etc.) y la otra para la planeación de navegación del robot. Las dos redes
estarán ejecutándose en paralelo, pero la red de navegación dependerá del
reconocimiento que se haga de las imágenes, para establecer diferentes objetivos
específicos dependiendo del objeto que se reconozca. Así mismo, la Red Convolucional
tiene como entradas imágenes con el propósito de reconocer estructuras físicas mientras
22
que la Red Neural (Normal) tiene como entradas las lecturas de distancia de un sensor
laser para definir la navegación del robot en el espacio.
Como se aprecia en la figura 5, el paquete de ImageProcessor será el encargado de
obtener la imagen por medio de una cámara web (640x480 pixeles color RGB) y generara
las capas convolucionales y reductoras de resolución sobre la imagen a 12 Frames por
segundo. Este proceso está encargado ImageDriver el cual es creado por NeuralDriver,
clase principal creadora de las redes neuronales, inicializadora de los modos online y de
entrenamiento. Con NeuralDriver se conectará las imágenes obtenidas en tiempo real con
la red neuronal. Por la parte de navegación y exploración del robot, el paquete
RobotSystem obtendrá el buffer de datos del sensor láser del Robot el cual NeuralDriver
los utilizara en conjunto al objeto reconocido por la convolución a la red neuronal de
navegación. Como resultado la red de reconocimiento de objetos generará un reporte
sobre los resultados obtenidos, como son el índice de confianza del reconocimiento de
estructuras en el edificio; y el de navegación generará un conjunto de acciones que
RobotDriver utilizará para mover el robot.
23
Figura 5 Arquitectura general del sistema
24
Capítulo 5. Implementación A continuación se presenta el funcionamiento básico del sistema:
Para la implementación del sistema se empezó por crear NeuralDriver, el controlador
principal que inicializaría la persistencia, obtención de la cámara web, conexión con el
robot y una creación básica de dos redes neuronales, las cuales si ya existen son
reemplazadas por las ya entrenadas.
En un ambiente sin interfaz gráfica, la consola de Python establece la comunicación con el
usuario para configurar y parametrizar el modo que se quiere que el sistema adopte
(training, online). Si está en modo Training el sistema realiza un conjunto de preguntas
para establecer si se desea entrenar un conjunto de datos ya almacenados o si se quiere
tomar una nueva muestra; luego se selecciona el elemento a entrenar y se pasa a un
estado de toma de datos. Al final de este proceso el usuario determina cuando parar, para
pasar al proceso de aprendizaje, en este proceso la instancia Training, inicializa y define las
funciones necesarias y a partir de la red neuronal generar un aprendizaje supervisado de
los datos.
En modo online, el sistema automáticamente empieza a utilizar las redes ya entrenadas
usando en tiempo real los datos de la cámara y del sensor, para luego establecer acciones
al robot y reportes. Se utilizó un robot diferencial con un portátil, el cual obtiene los datos
de la cámara web y realiza los procesos de las redes neuronales ya entrenadas.
5.1 Descripción de la implementación
Como se mencionó anteriormente el sistema cuenta con una instancia controladora de
todos los componentes “NeuralDriver”, la cual a su vez nos menciona las etapas de
implementación del sistema (Para todas la instancias a mencionar se pueden validar en el
diseño del sistema con la Figura5).
25
5.1.1 Manejador de persistencia
Debido a que es necesario que las redes neuronales mantengan su estado una vez
entrenadas, se implementó el controlador TargetManager para persistirlas, los archivos se
guardan en formato PKL utilizando la librería cPickle especializada en persistir arreglos y
matrices. También se crearon métodos complementarios para guardar los elementos y
acciones que las redes neuronales van a aprender y reconocer.
Este manejador es llamado cuando se termina de obtener los datos para guardarlos, ya
que si los datos a aprender (imágenes, distancias) eran tomados desde un portátil, se
podrían trasladar fácilmente a un computador más poderoso para realizar los aprendizajes
(véase 5.2.1 herramientas empleadas). Al igual que cuando termina de aprender la red
neuronal, ya sea la de reconocimiento de imágenes o la de exploración, esta era persistida
para que se pudiera utilizar y probar en un ambiente virtual o real.
Se crearon restricciones y checkpoints para informar al usuario el estado de carga y
guardado de los datos, por ejemplo, si no se encontraba una red neuronal persistida, el
sistema sabía que no podía intentar restablecer el estado de esa red neuronal inexistente
y se le informaba al usuario que el sistema iba a entrenar una nueva.
5.1.2 Creación de Elementos
Los elementos a crear no influían en el estado de la red neuronal, ya que como se vio
anteriormente (véase 4.2 Deep learning), una red neuronal retorna un vector del tamaño
de elementos a reconocer con uno de ellos en 1 y el resto en 0. Teniendo esto en cuenta,
la posición de este 1 en el vector determinaba la posición en el que se encuentra
elemento en el arreglo de elementos y de esta manera asociar su cálculo con el caso de
estudio. A medida que se iba entrenando cada estructura, se creaba el elemento nuevo y
los datos a aprender se iban acumulando. Para cada red se creó un arreglo de elementos
independiente.
26
5.1.3 Procesador de imágenes
En el controlador “ImageDriver” se inicializa la captura de video de la cámara web y el
proceso de filtrado y reducción de resolución de la imagen (convolución). Este controlador
únicamente toma un frame de la cámara, la escala a un rango de 0-255 y ejecuta las
transformaciones para que se pueda ingresar a la red neuronal, esto incluye convertir la
imagen a escala de grises para no tener que utilizar los tres colores básicos de la imagen
porque lo importante es identificar el patrón de la estructura no sus diferentes colores,
esto permite una generalización del objeto sin importar la iluminación y aspecto. Luego es
transformada utilizando los métodos de convolución y transformada de matriz a arreglo.
Al convertirla en arreglo no afecta el procesamiento ya que lo que se quiere es analizar
pixel por pixel sin importar la estructura, y es más eficiente recorrerlos en forma de
arreglo que en matriz, lo importante es que siempre se transforme en el mismo orden
para que se mantenga la relación matriz-arreglo.
5.1.4 Conexión Robot
Para la conexión con el robot se utilizó las librerías compatibles a Python. Al iniciar el
sistema se intenta conectar ya sea a robot virtual o al físico, es de aclarar que si se quiere
conectar al real es necesario proporcionarle la IP y puerto, a menos que se encuentre en la
misma red. La conexión incluye configuración del sensor láser y de la tele operación. Se
crearon métodos para que cuando el sistema lo requiera el robot le proporcione el buffer
de distancias del láser. Este láser entrega un arreglo de 229 datos en el que los primeros
114 datos se refieren a cada grado de la zona izquierda del sensor, un dato que se refiera
el grado cero o frontal del sensor y los otros 114 que son cada ángulo del lado derecho, es
decir que por cada ángulo este sensor nos devuelve un punto x, y relativo a su posición
con el que podemos calcular su distancia absoluta (véase 5.2.1 herramientas empleadas).
27
Por otro lado, se pueden obtener y establecer las acciones del robot, ya que la el
entrenamiento de la exploración los datos del láser son asociados al valor esperado de la
acción del robot. Se estableció tres tipos de acción: izquierda, derecha, centro. Debido a
que del robot se obtiene una velocidad de rotación y general entre 0 y 255, se estableció
que cuando esta velocidad de rotación sea mayor o menor a 15 y -15 mm/s se establece
una acción de izquierda / derecha respectivamente. Si están en el rango intermedio se
establece una acción central, esto se debió a que por motivos de error con el joystick, no
siempre se podía dirigir el robot exactamente hacia adelante (véase 5.2.1 herramientas
empleadas). Para establecer la acción del robot, la red neuronal devuelve la posición del
elemento reconocido y una probabilidad de confianza (véase 4.2 Deep learning),
dependiendo de esta confianza se establece la cantidad de velocidad que se le establecerá
a la acción resultante, de esta manera si está muy inseguro de la acción a tomar su
velocidad se reducirá en el trayecto y mantendrá la seguridad del robot.
Para cada entrenamiento utilizando el modo tele operación, se configuró para obtener
2000 muestras en lapsos de 500 milisegundos (corresponde a 1000 segundos, equivalente
a 16.666 minutos de entrenamiento), automáticamente se implementó la activación y
desactivación de este modo, al inicio y finalización del proceso de entrenamiento.
5.1.5 Inicialización redes Neuronales
Se implementó un sistema de redes neuronales generalizado, en el que se puede crear
varias instancias con parámetros diferentes. Para la red de reconocimiento de imágenes el
tamaño de la entrada es la imagen ya tratada anteriormente en el controlador
ImageDriver con 5 capas de 100 neuronas conectadas entre sí y una capa de salida de 5
neuronas relacionadas cada una con escaleras, corredores anchos y estrechos, ascensores
y un objeto de control. Las dimensiones se definen a continuación:
(𝑐𝑎𝑝𝑎𝐼𝑛[𝑖𝑛𝑝𝑢𝑡𝑎𝑟𝑟𝑒𝑔𝑙𝑜_𝑝𝑖𝑥𝑒𝑙𝑒𝑠, 100],
𝑐𝑎𝑝𝑎2[100,100], 𝑐𝑎𝑝𝑎3[100,100], 𝑐𝑎𝑝𝑎 4[100,100], 𝑐𝑎𝑝𝑎5[100,100],
28
𝑐𝑎𝑝𝑎𝑂𝑢𝑡[5,100])
Para la red neuronal de navegación se establece la siguiente configuración:
(𝑐𝑎𝑝𝑎𝐼𝑛[𝑖𝑛𝑝𝑢𝑡𝑎𝑟𝑟𝑒𝑔𝑙𝑜_𝑠𝑒𝑛𝑠𝑜𝑟 + 𝑜𝑏𝑗𝑒𝑡𝑜𝑅𝑒𝑐𝑜𝑛𝑜𝑐𝑖𝑑𝑜, 25],
𝑐𝑎𝑝𝑎2[25,25], 𝑐𝑎𝑝𝑎3[25,25],
𝑐𝑎𝑝𝑎𝑂𝑢𝑡[3,25])
Como se puede observar para la entrada se agrega un valor además del buffer del sensor y
es el objeto reconocido, aquí se intenta implementar una dependencia entre redes en la
que la red de navegación dependiendo del objeto reconocido establece una navegación
diferente de esta manera se le agrega un factor más inteligente a la decisión de acción a
tomar para moverse. Por ejemplo si está en un corredor estrecho se podría mover más
seguro que si está en un corredor amplio.
De esta manera se maneja la estructura de Deep learning en el que tiene un inputLayer,
hiddenLayer y outputLayer respectivamente (véase 4.2 Deep learning). Estos parámetros
pueden variar, como se puede ver las capas ocultas manejan las mismas dimensiones lo
cual permite implementar recurrencia en el código y el número de entradas, salidas y
neuronas se establecen al principio antes de crear las matrices con rangos aleatorios como
lo recomienda Deep Learning entre un épsilon dependiente de sus parámetros (véase
4.2.1 BackPropagation).
Finalizando, este proceso de creación se ejecuta en la instancia NeuralNetwork, la cual es
la encargada de conectar las funciones de generación inicial de una red.
5.1.6 Modo Training
En esta instancia se establece el objeto que se desea entrenar, y se genera el
procedimiento necesario para la obtención de la información a medida que se va
entrenando. Dependiendo si son imágenes o sensores, en las imágenes se muestra la
29
imagen obtenida y se responde con 1 o 0 si la imagen es o no el objeto que se quiere
reconocer.
Para el sensor como ya se mencionó antes, se entrena el robot por un lapso de 2000
muestras con lapsos de 500 milisegundos, dando como resultado un tiempo de 16
minutos por sesión, en este tiempo se usa el joystick para controlar el robot y manejarlo
en un ambiente virtual, de esta manera obtiene las acciones relacionadas con el buffer de
datos.
Luego se pasa al aprendizaje de la red que en conjunto con el framework Theano (véase
5.2.1 herramientas empleadas). Primero se calcula un punto inicial y es el porcentaje de
acierto hacia los elementos a aprender, en principio debería ser muy bajo debido a que no
sabe nada. Después de esto, se definen las funciones de aprendizaje de Deep Learning, ya
que Theano primero pre compila una función simbólica, no importa la complejidad, para
que en tiempo de ejecución sea más eficiente y se pueda ejecutar sobre diferentes
tecnologías como la GPU.
Teniendo la red compilada con sus funciones de aprendizaje, se recorre los elementos
guardados en el entrenamiento usándolos en la función de aprendizaje, y de esta manera
actualizar la red en simultaneo para minimizar el error (costo) que tiene la red al clasificar
un elemento. Este proceso de aprendizaje tiene diferentes restricciones, para evitar sobre
entrenamientos, o entrenamientos innecesarios, es decir, cuando llega a un promedio de
seguridad de todos los datos mayor a 97% el sistema termina de aprender al igual que si
este promedio se queda estancado en el mismo porcentaje durante mil iteraciones. De
esta manera el sistema ante las eventualidades más comunes es automático a la hora de
aprender.
Finalizando, después que ha terminado se guarda la red neuronal y se calcula de nuevo
que tan acertado es con los elementos, para saber si en principio tuvo un buen
aprendizaje. En este momento la red está lista para usarse en modo Online, el tiempo de
aprendizaje depende del poder computacional (si se usa CPU o GPU), la cantidad de datos,
la tasa de aprendizaje y la cantidad de neuronas.
30
5.1.7 Modo Online
Para el modo Online básicamente es un ciclo continuo de obtención del frame de la
cámara, para ingresarlo en la red entrenada de reconocimiento de estructuras y
generación del reporte. Como segundo paso, obtención y unificación del buffer de datos
con el objeto reconocido para introducirlo a la red de navegación, para que esta genere la
acción de movimiento al robot virtual o real.
Cuando se desee frenar la ejecución se oprime una letra configurada y el sistema
retornara al inicio en donde le preguntará qué modo utilizar o si quiere terminar la
ejecución.
5.2 Resultados esperados
Se espera que al implementar el entrenamiento respectivo de los elementos, en tiempo
real el sistema reconozca de forma correcta con al menos un 90%.
Así mismo con la red neuronal de navegación se espera que realice una exploración del
90% del lugar de prueba. La expectativa de la diferencia entre el simulador y el robot no
debería variar demasiado, aunque podría fallar en lugares donde las paredes son de
vidrio, ya que el láser se puede comportar diferente ante estas estructuras en donde
posiblemente los rayos pueden traspasar la estructura generando una distancia errónea.
A continuación se presentan las tecnologías utilizadas para la implementación del sistema.
31
El lenguaje utilizado para el sistema fue Python 2.7 ya que esta versión es compatible con
las demás tecnologías a utilizar en el sistema, el ambiente instalado fue Anaconda[9] ya
que incluye bastantes librerías de apoyo a Python, y el IDE de desarrollo fue PyCharm[10].
Para la obtención de los datos de la imagen de una cámara web Logitech c210[11] de
640x480 pixeles se usó Opencv[12] para Python, de esta manera se obtuvo la matriz de
datos de los pixeles de la imagen a 30 frames por segundo.
Figura 6 Cámara Web Logitech
Se utilizó el framework Theano[13] hecho para Python, especializado en definir, optimizar
y ejecutar expresiones matemáticas para arreglos multidimensionales. Con Theano se
pudo ejecutar los diferentes cálculos de la red neuronal sobre GPU, ya que esta ejecuta los
cálculos de las matrices en paralelo haciéndola más eficiente. Es de resaltar que para
poder utilizar la GPU es necesario tener una tarjeta gráfica NVIDIA con el toolkit CUDA[14]
instalado y visual Studio 2012[15] o superior.
Para la conexión con el robot P3-DX[16] con un sensor láser URG[17], la librería de esta
marca es Aria[18], la cual cuenta con una versión Python, lo cual facilitó el trabajo en un
mismo lenguaje. Así mismo, se utilizó el simulador MobileSim[19] de la compañía creadora
del robot “MobileRobots”[16], para el entrenamiento y pruebas. En la tele operación del
robot se usó un Joystick Genius F-16U[20], el cual facilitó el entrenamiento.
32
Figura 7 Robot P3-DX Figura 8 Sensor URG
Figura 9 MobileSim Figura 10 Joystick Genius f-16U
Ya que el sistema tiene dos estados básicos, modo entrenamiento y modo Online, se
dispuso para el entrenamiento un computador Windows 10 con procesador i7 de 12 CPUs
3.2GHz, memoria RAM de 16 GB y una tarjeta gráfica (GPU) MSI GTX 980 de 4GB RAM.
Por otra parte el modo online, se utilizó un portátil Windows 7 AMD de 2 CPUs 2GHz con
memoria RAM de 4GB, con GPU integrada la cual no es compatible con Theano.
33
Capítulo 6. Validación
6.1 Métodos
Para que al final aprendiera conjuntamente de todos los elementos, era necesario
entrenar todo completo ya que si aprende uno por uno ocurría un desbalanceo en la red,
ocasionando que al final generara un resultado único sobre el último elemento entrenado
independientemente de la imagen o dato del sensor mostrado.
Para validar los resultados es necesario obtener el conjunto de probabilidades de
confianza y el costo que la red neuronal retorna al comparar el resultado con el valor
esperado en cada iteración. De esta manera visualizar que tan bien entrenada esta la red.
Se debe utilizar diferentes tasas de aprendizaje y cantidad de muestras para entender el
comportamiento de aprendizaje de las redes neuronales.
Por otra parte es necesario tomar los tiempos de entrenamiento para hacer
comparaciones entre la diferencia de ejecución sobre CPU y GPU.
Por último, se debe estimar con pruebas reales que tan acertado es ante nueva muestras
de imágenes, y con la exploración visualizar y evaluar la cantidad de terreno evaluado que
a su vez al generar una toma de datos tele operado, calcular el acierto ante las acciones
esperadas.
6.2 Validación de resultados
Esta sección va a presentar las gráficas de aprendizaje que se obtuvo con el
reconocimiento de imágenes y de exploración. Las gráficas nos mostrarán como la red
neuronal se comportó durante el aprendizaje de los datos, mostrándonos su costo y
confianza sobre el número de iteraciones que le llevó.
6.2.1 Resultados intermedios
34
Durante el proceso de aprendizaje, se reportó su comportamiento, mostrando su
porcentaje de confianza con respecto al número de iteraciones con las que se repitió el
aprendizaje con respecto a los datos que se tomaron, tanto en imágenes, como distancias
(las siguientes gráficas manejan la misma estructura y nomenclatura que en la figura 11).
Para la red neuronal de navegación 1000 muestras de 242 distancias. Para la red neuronal
de imágenes se utilizó 345 imágenes.
Navegación Reconocimiento de estructuras
Confianza
Costo
# Iteraciones # Iteraciones
Figura 11 (Izquierda) Aprendizaje navegación (Derecha) Aprendizaje estructuras.
Para las primeras fases de entrenamiento, como se visualiza en las gráficas anteriores, no
se logró un aprendizaje apropiado, ya que se estaba probando su tasa de aprendizaje, y en
esta prueba se utilizó una tasa de 0.1 lo cual es muy alta, para la información utilizada, al
presionar la red a aprender rápidamente muchos datos, esto puede terminar que su
función de minimización sobrepase el mínimo local y no converja, haciendo que los
valores y pesos de la red tiendan a infinito. Como se puede ver en la gráfica de navegación
anterior, su porcentaje de confianza máximo fue de 90%, el cual detalla que se quedó
estancado en su aprendizaje hasta que en la iteración 1100 sus valores dejaron de
converger. Así mismo, en la red de reconocimientos de estructuras, se obtuvo un
aprendizaje mucho mejor aunque en la iteración 70 sobrepaso la minimización y dejó de
converger.
35
6.2.2 Resultados Finales Navegación
Para estas dos redes, una vez fallida su convergencia, quedan inservibles y se tiene que
volver a entrenar. Después de esto, se tomaron muestras mayores para la navegación,
incluyendo 1500 muestras del sensor, con una tasa de aprendizaje de 0.001.
Figura 12 Aprendizaje Final Navegación
En este caso se obtuvo un entrenamiento satisfactorio con una confianza de 94.16% y
acertando un 92.34% en las imágenes aprendidas, después del proceso de aprendizaje.
Luego de realizar diversos entrenamientos en la navegación, ajustando las tolerancias del
robot, para determinar la acción esperada. En este proceso se pudo observar que algunas
veces su aprendizaje primero tenía una reducción de su confianza, y luego un aumento de
ella, como si estuviera retrocediendo su aprendizaje anterior para aprender algo nuevo.
Navegación
Confianza
Costo
Iteraciones
Figura 13 Aprendizaje Final Navegación
36
Se realizaron 6 redes neuronales independientes con entrenamientos diferentes en la
navegación, en algunas impulsando la curiosidad del robot y otras manteniendo la
seguridad con las siguientes gráficas de aprendizaje.
Figura 14 Re Aprendizaje Navegación 1
Figura 15 Re Aprendizaje Navegación 2
Figura 16 Re Aprendizaje Fallido Navegación
37
Figura 17 Re Aprendizaje Fallido Navegación
Luego de probarlas en simulación y ambiente real, se obtuvo una red funcional, que se
comportó muy bien en simulación, presentando 5 colisiones en todo el recorrido,
explorando el 60% del terreno aproximadamente:
Figura 18 Vista sur del mapa Figura 19 Patrón de callejón cerrado Figura 20 Vista Norte del Mapa
Figura 21 Vista general del mapa
38
Las zonas amarillas fue los lugares donde el robot colisionó, y la señal azul es donde se
redirigió hacia el corredor estrecho, el resto de lugares el sistema lo exploro
automáticamente.
Los resultados con el robot real, no fueron satisfactorios, ya que solo pudo recorrer un
40% del lugar, con 5 colisiones y muchas indecisiones al moverse. Esto se debió a que el
robot físico tiene errores considerables comparados con lo que se simuló. En primera
instancia el rango máximo que tiene el sensor en el simulador es de 5 metros, mientras
que en el robot es de 4,096 metros, esto influye directamente en la red neuronal para
tomar la decisión, porque es como si existiera una pared en frente en todo momento. En
segunda instancia, el tiempo de cálculo del portátil es más lento que el del computador
entrenador, por estos motivos las decisiones no las puede tomar con tanta precisión,
afectando el movimiento acertado del robot, y por último el ambiente virtual contiene
paredes y objetos ideales geométricos, mientras que con el robot real, tuvo objetos en
movimiento como personas y el terreno no es perfecto en su forma, además de la
imprecisión del láser físico. Las colisiones en el ambiente real se presentaron, debido a la
falta de entrenamiento en estos casos, en el que el sensor presentaba un rango de
distancias corto, por este motivo la red neuronal generaba acciones perjudiciales para su
exploración.
6.2.3 Resultados Finales Imágenes
Para el reconocimiento de imágenes no se presentaron muchos problemas después de
ajustar los parámetros con tasa de aprendizaje de 0.001, al obtener un reconocimiento de
imágenes de las estructuras.
En principio se utilizaron 500 imágenes, la cual la red neuronal aprendió después de 1343
iteraciones con un porcentaje del 94.9% de confianza.
39
Figura 22 Aprendizaje Final Imágenes 1
Pero al probarlo en el ambiente real se percibió que la cantidad de reconocimientos
acertados hacia la escaleras y ascensores era muy bajo, entonces se tomó más fotos para
estos objetos y se reentrenó para una siguiente prueba. En esta gráfica, se observa que al
tener más elementos, el sistema necesito más iteraciones para llegar al mismo nivel de
confianza.
Figura 23 Aprendizaje Final Imágenes 2
Después, de esto se siguieron presentando inconsistencias con los reconocimientos de
ascensores, entonces se tomó más fotos, para un total de 843 fotos, incluyendo todos los
objetos.
40
Figura 24 Aprendizaje Final Imágenes 3
Para este aprendizaje, se necesitó 2999 iteraciones y se entrenó a un 100% de confianza,
esto genero un reconocimiento acertado de 80% de los objetos mostrados en tiempo real,
de esta manera se logró que la red neuronal funcionara establemente mientras que el
robot se movía.
Debido a que la exploración no tuvo el mismo resultado satisfactorio, se tuvo que tele
operar con un joystick, para hacer los test respectivos en el reconocimiento de imágenes.
Los objetos mostrados al sistema fueron:
Figura 25 Imágenes de puertas de Ascensor
41
Figura 26 Imágenes de Escaleras
Figura 27 Imagen de Corredor Estrecho Figura 28 Imagen de Corredor Amplio
Para el caso de los corredores anchos y estrechos, a veces ocurrían ambigüedades, dado a
que un corredor estrecho lo es dependiendo de su perspectiva, es por esto que el nivel de
confianza bajaba a un 80%, ya que es muy parecido a un corredor amplio.
42
Capítulo 7. Conclusiones
7.1 Discusión
Se investigó sobre los métodos de aprendizaje actuales, utilizando uno de los más
recientes como lo es Deep Learning de manera supervisada, es decir enseñándole
únicamente los objetos de interés para el caso de estudio. Se diseñó una arquitectura,
pensada en conectar todas las tecnologías necesarias para utilizar redes neuronales,
robots de la referencia disponible y cámara web. Esta arquitectura fue pensada para
poder utilizar distintos equipos físicos, portátiles, robots, servidores, dependiendo de la
necesidad a la hora de la toma y aprendizaje de datos. Se probó de diferentes maneras y
con diferentes datos y se llegó a la conclusión que la red neuronal se implementó de
manera correcta, y las fallas presentadas se debieron a que se necesita un buen
entrenamiento, es decir es necesario enseñarle de manera adecuada los objetos, si no hay
una muestra que en conjunto logre definir de manera correcta el objeto, las fallas
aumentaran considerablemente.
Se presentaron limitaciones en el poder de procesamiento de cálculo para el robot móvil,
ya que se utilizó un portátil con niveles bajos de eficiencia de cálculo, lo que influyo en la
toma rápida de decisiones en la red neuronal para la navegación. Se debió hacer una
investigación más profunda sobre la diferencia entre el sensor del simulador y el real, para
que el entrenamiento hubiera sido más cercano al ambiente a probar y de esta manera
haber obtenido mejores resultados.
7.2 Trabajo futuro
Para futuro, se debería incluir más sensores, para la exploración y reconocimiento, ya que
solo un sensor laser o cámara independiente, que toma una muestra en dos dimensiones
no es suficiente. Para un reconocimiento más acertado se podría utilizar una cámara
infrarroja que escanee el terreno tridimensionalmente, permitiendo que se pueda
explorar y reconocer objetos de forma precisa. La falla que tienen los sensores
bidimensionales, es que su margen de error se eleva debido a que no perciben el
ambiente de forma completa.
43
Capítulo 8. Referencias
[1] Daniel Maturana y Sebastian Scherer, «3D Convolutional Neural Networks for Landing Zone Detection from LiDAR», 2015 IEEE Int. Conf. Robot. Autom. IC(International Conference on Robotics and Automation), may 2015.
[2] W. Chen, T. Qu, Y. Zhou, K. Weng, G. Wang, y G. Fu, «Door recognition and deep learning algorithm for visual based robot navigation», en 2014 IEEE International Conference on Robotics and Biomimetics (ROBIO), 2014, pp. 1793-1798.
[3] Z. Kira, R. Hadsell, G. Salgian, y S. Samarasekera, «Long-Range Pedestrian Detection using stereo and a cascade of convolutional network classifiers», en 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 2012, pp. 2396-2403.
[4] S. A. Vukosavljev, D. Kukolj, I. Papp, y B. Markoski, «Mobile robot control using combined neural-fuzzy and neural network», en 2011 IEEE 12th International Symposium on Computational Intelligence and Informatics (CINTI), 2011, pp. 351-356.
[5] A. Buitrago-Martinez, R. F. De La Rosa, y F. Lozano-Martinez, «Hierarchical Reinforcement Learning Approach for Motion Planning in Mobile Robotics», en Robotics Symposium and Competition (LARS/LARC), 2013 Latin American, 2013, pp. 83-88.
[6] «OMS | 10 datos sobre la discapacidad», WHO. [En línea]. Disponible en: http://www.who.int/features/factfiles/disability/es/. [Accedido: 16-sep-2015].
[7] «RGB», Wikipedia, la enciclopedia libre. 15-ago-2015. [8] «Convolutional Neural Networks (LeNet) — DeepLearning 0.1 documentation». [En
línea]. Disponible en: http://deeplearning.net/tutorial/lenet.html. [Accedido: 12-ene-2016].
[9] «Download Anaconda now!», Continuum. [En línea]. Disponible en: https://www.continuum.io/downloads. [Accedido: 17-nov-2015].
[10] «Python IDE & Django IDE for Web developers : JetBrains PyCharm». [En línea]. Disponible en: https://www.jetbrains.com/pycharm/. [Accedido: 17-nov-2015].
[11] «webcam-c210-gsw.pdf». [En línea]. Disponible en: http://www.logitech.com/assets/33983/webcam-c210-gsw.pdf. [Accedido: 17-nov-2015].
[12] «OpenCV | OpenCV». [En línea]. Disponible en: http://opencv.org/. [Accedido: 17-nov-2015].
[13] «Welcome — Theano 0.7 documentation». [En línea]. Disponible en: http://deeplearning.net/software/theano/. [Accedido: 17-nov-2015].
[14] «CUDA Zone», NVIDIA Developer. [En línea]. Disponible en: https://developer.nvidia.com/cuda-zone. [Accedido: 17-nov-2015].
[15] «Visual Studio - Herramientas para desarrolladores de Microsoft». [En línea]. Disponible en: https://www.visualstudio.com/. [Accedido: 17-nov-2015].
[16] «Mobile Robots | Robotic Control Platforms and Applications». [En línea]. Disponible en: http://www.mobilerobots.com/Mobile_Robots.aspx. [Accedido: 17-nov-2015].
44
[17] «Scanning range finder URG-04LX | Photo sensor | PRODUCTS | HOKUYO AUTOMATIC CO.,LTD.» [En línea]. Disponible en: https://www.hokuyo-aut.jp/02sensor/07scanner/urg_04lx.html. [Accedido: 19-nov-2015].
[18] «ARIA - MobileRobots Research and Academic Customer Support». [En línea]. Disponible en: http://robots.mobilerobots.com/wiki/ARIA. [Accedido: 17-nov-2015].
[19] «MobileSim - MobileRobots Research and Academic Customer Support». [En línea]. Disponible en: http://robots.mobilerobots.com/wiki/MobileSim. [Accedido: 17-nov-2015].
[20] «Joystick USB de ordenador con Turbo». [En línea]. Disponible en: http://www.geniusnet.com/Genius/wSite/ct?xItem=19497&ctNode=1309. [Accedido: 17-nov-2015].