DESARROLLO DE UN SISTEMA DE DETECCIÓN DE SILLAS PARA ROBOTS DE...
50
1 Sistema para detección y rastreo de sillas en tiempo real para el robot de servicios Golem –II+ Memoria de proyecto Que para obtener el título en Ingeniero en Mecatrónica Presenta Guadalupe Antonio Castro García Cd. Obregón, Sonora; Diciembre de 2014
Transcript of DESARROLLO DE UN SISTEMA DE DETECCIÓN DE SILLAS PARA ROBOTS DE...
1
Sistema para detección y rastreo de sillas en
tiempo real para el robot de servicios Golem –II+
Memoria de proyecto
Que para obtener el título en
Ingeniero en Mecatrónica
Presenta
Guadalupe Antonio Castro García
Cd. Obregón, Sonora; Diciembre de 2014
2
Agradecimientos
A mi señora madre Hildelisa Garcia Herrera, que ha hecho hasta lo imposible para
que pudiera seguir adelante en el camino de la vida, por su apoyo y amor
incondicional que siempre me ha brindado. Porque ha sido y será un ejemplo a
seguir y espero siempre se sienta tan orgullosa de mi como yo siempre lo he
estado de usted. Gracias madre mía.
A mi hermano Alejandro con el que he compartido casi toda mi vida, gracias por
compartir tantos bueno y malos momentos conmigo, gracias por apoyarme cuando
lo he necesitado.
A mi pequeño hermano Cruz Alberto, por ser una persona tan noble, talentosa y
buen amigo. Recuerda que yo siempre estaré para ti cuando lo necesites pequeño
saltamontes.
A mis amigos de la universidad, David, Gildardo, José Luis, Héctor e Irving con los
que compartí grandes experiencias durante toda esta gran travesía. Por todas las
alegrías, pelas, risas, enojos y enseñanzas que vivimos juntos. Nunca los olvidaré
nenas.
A mi asesor el Maestro Jose Manuel Campoy Salguero que me apoyado y
motivado para concluir esta etapa de mi vida con éxito.
Por último pero no menos importante, al Dr. Ivan Vladimir Meza Ruiz y a todos mis
compañeros del verano de investigación Alfredo, Héctor, Rocela, Karla, Raúl,
Guillermo, Frine, Adrian, Fernando el grande y Fernando el chico con los cuales
aprendí y compartí buenos momentos desarrollando este proyecto, experiencias
que nunca olvidaré.
3
Índice Tabla de Figuras .................................................................................................................. 4
Capítulo I. Introducción ....................................................................................................... 6
1.1.- Antecedentes ........................................................................................................... 6
1.2.- Planteamiento del problema .................................................................................. 8
1.3.- Justificación .............................................................................................................. 9
1.4.- Objetivo ..................................................................................................................... 9
1.5.- Delimitaciones ........................................................................................................ 10
1.6.- Limitaciones ........................................................................................................... 10
Capítulo II. Método ............................................................................................................. 11
2.1.- Sujeto ...................................................................................................................... 11
2.2.- Materiales ............................................................................................................... 12
2.3.- Procedimiento ........................................................................................................ 13
2.3.1.- Estudio del estado del arte. .......................................................................... 14
2.3.2.- Recolección de la base de datos. ................................................................ 14
2.3.3.- Etiquetación de la base de datos. ............................................................... 14
2.3.4.- Creación de Modelos. .................................................................................... 15
2.3.5.- Pruebas. ........................................................................................................... 16
2.3.6.- Resultados. ...................................................................................................... 16
Capitulo III. Desarrollo ....................................................................................................... 17
3.1.- Recolección de base de datos para el aprendizaje del sistema detector. ... 17
3.2.- Etiquetación de la base de datos. ...................................................................... 24
3.3.- Creación de modelos. ........................................................................................... 35
Capitulo IV. Resultados ..................................................................................................... 43
Capítulo V. Conclusiones.................................................................................................. 47
Referencias Bibliográficas ................................................................................................ 49
iii
4
Tabla de Figuras
Figura 2 1. Procedimiento para la elaboración del proyecto....................................... 13
Figura 2 2. Diagrama del proceso de elaboración de modelos. ................................. 15
Figura 3 1. Fotografía con demasiada iluminación....................................................... 18
Figura 3 2. Fotografía borrosa. ........................................................................................ 19
Figura 3 3. Ninguna de las sillas muestra todas sus partes visibles en la fotografía.
.............................................................................................................................................. 19
Figura 3 4. La silla que esta al centro de la fotografía muestra todas sus partes. .. 20
Figura 3 5. Silla con todas sus partes y en diferentes ángulos. ................................. 20
Figura 3 6. De cuatro patas, asiento, respaldo y color café. ....................................... 21
Figura 3 7. De cuatro patas, asiento, respaldo, apoya manos y color azul. ............. 21
Figura 3 8. De rueditas, asiento, respaldo y color azul. ............................................... 22
Figura 3 9. De rueditas, asiento, respaldo, apoya manos y color azul. .................... 22
Figura 3 10. De rueditas, asiento, respaldo, apoya manos y color negro. ............... 22
Figura 3 11. Paredes y muebles del laboratorio. .......................................................... 23
Figura 3 12. Pasillos de las instalaciones. ..................................................................... 24
Figura 3 13. Personas en interacción con Golem. ....................................................... 24
Figura 3 14. Librerías utilizadas y argumentos de entrada del programa. ............... 25
Figura 3 15. Lectura de imágenes, modificación de características y
almacenamiento. ................................................................................................................ 26
Figura 3 16. Librerías utilizadas, lectura de imágenes y coordenadas. .................... 28
Figura 3 17. Movimiento de la etiqueta (mouse), salir del programa de etiquetación
(tecla escape o “q”). ........................................................................................................... 28
Figura 3 18. Adición del recuadro rojo y azul (tecla control izquierdo). .................... 29
Figura 3 19. Incremento (tecla space) y decremento (tecla Shift izquierdo) de la
etiqueta. ............................................................................................................................... 29
Figura 3 20. Recuadro de confirmación (tecla Alt izquierdo) y eliminación de
recuadro rojo y azul (tecla “x” y “s” respectivamente). ................................................. 30
Figura 3 21. Para avanzar o retroceder en las imágenes a etiquetar. ...................... 30
Figura 3 22. Almacenamiento de etiqueta y coordenadas de la misma (tecla enter).
.............................................................................................................................................. 31
Figura 3 23. Etiqueta para sillas de rueditas, asiento, respaldo y color azul. .......... 31
Figura 3 24. Para silla de cuatro patas, asiento, respaldo, apoya manos y color
azul. ...................................................................................................................................... 32
Figura 3 25. Etiqueta para silla de rueditas, asiento, respaldo, apoya manos y color
negro. ................................................................................................................................... 32
iv
5
Figura 3 26. Etiqueta para silla de rueditas, asiento, respaldo, apoya manos y color
azul. ...................................................................................................................................... 33
Figura 3 27. Etiqueta para silla de cuatro patas, asiento, respaldo y color café. .... 33
Figura 3 28. Etiquetación de fotografías negativas (1). ............................................... 34
Figura 3 29. Etiquetación de fotografías negativas (2). ............................................... 34
Figura 3 30. Configuración para el descriptor HOG de una imagen. ........................ 35
Figura 3 31. Configuración del SMV para un conjunto de objetos. ........................... 36
Figura 3 32. Librerías utilizadas y argumentos de entrada del programa. ............... 36
Figura 3 33. Se abren las etiquetas positivas y se calcula su descriptor HOG. ...... 37
Figura 3 34. Se abren las etiquetas negativas y se calcula su descriptor HOG. ..... 37
Figura 3 35. Entrenamiento y almacenamiento del modelo. ....................................... 38
Figura 3 36. Argumentos de entrada del programa y configuración del descriptor
HOG. .................................................................................................................................... 39
Figura 3 37. Se carga el modelo entrenado y se sincroniza con el descriptor HOG.
.............................................................................................................................................. 39
Figura 3 38. Se carga la imagen y se buscan las sillas con el barrido y reducción
de la imagen. ...................................................................................................................... 39
Figura 3 39. Se dibujan sobre la imagen rectángulos de las áreas localizadas. ..... 40
Figura 3 40. Ejemplo del modelo del sistema detector de sillas sin errores (1). ..... 40
Figura 3 41. Ejemplo del modelo del sistema detector de sillas sin errores (2). ..... 41
Figura 3 42. Ejemplo del modelo del sistema detector de sillas con errores. .......... 41
Figura 4 1. Modelo de detección aplicado al robot de servicios detectando
correctamente. .................................................................................................................... 44
Figura 4 2. Ejemplo del modelo con deficiencia al detectar sillas por la falta de
ejemplos (1). ....................................................................................................................... 45
Figura 4 3. Ejemplo del modelo con deficiencia al detectar sillas por la falta de
ejemplos (2). ....................................................................................................................... 46
v
6
Capítulo I. Introducción
1.1.- Antecedentes
En la actualidad la mayoría de los sistemas electrónicos o mecánicos que se
encuentran funcionando en el ámbito industrial como social, se busca que sean lo
más autónomos posibles, es decir, que sean capaces de responder de la manera
más idónea al tomar una decisión sin tener la necesidad de la intervención
humana. Conforme el avance de la tecnología continúa la independencia de estos
sistemas se hace cada vez más sólida, pero llegado a este punto se plantea la
siguiente pregunta ¿Las máquinas pueden llegar a ser lo suficientemente
inteligentes como los seres humanos?.
El científico y matemático Alan Turing en la década de los 50’s preguntó, ¿Una
máquina puede pensar?, quién apoyado de su artículo “Computing Machinery and
Intelligence” plantea la posibilidad de que una máquina pueda imitar el
comportamiento de la mente humana, en este mismo artículo se propone el
conocido “Test de Turing” orientado a demostrar si una determinada máquina es
7
inteligente o no, aportaciones que lo llevaron a ser reconocido como padre de la
inteligencia artificial.
Este artículo fue el catalizador que oriento el conocimiento acumulado con
anterioridad en otras disciplinas llevando al nacimiento de una ciencia, la
inteligencia artificial, pero no fue hasta el año de 1956 durante la conferencia
denominada “Dartmouth Summer Research Conference on Artificial Intelligence”
impartida por los investigadores Marvin L. Minsky, Claude E. Shannon, Herber
Simon y Allen Newell que esta nueva ciencia fuera bautizada con dicho nombre.
Una vez abierta la puerta a este nuevo campo de la tecnología el desarrollo e
investigación no se hizo esperar, pero debido a la época en que esto estaba
siendo planteado, se carecía de financiamiento, las capacidades computacionales
y conocimientos eran bastante escasos, los sistemas eran costosos de mantener e
incapaces de aprender cometiendo grandes errores, esto se mantuvo así por casi
cuatro décadas. A finales de los años 80´s y principios de los años 90´s se
presentaron los primeros avances significativos en la creación de algoritmos de
búsqueda, lenguaje natural, creación de máquinas capaces de conversar,
interpretar imágenes y razonamiento como seres humanos.
La propagación obtenida por la inteligencia artificial como aplicación ha sido tal
que ya se encuentra en ramas tan diversas como lo son robótica, procesamiento
de lenguaje natural, videojuegos, lingüística computacional, sistemas de apoyo de
decisión, prototipos informáticos, seguridad, procesos industriales e incluso
medicina.
Instituciones académicas también han incursionado en esta nueva rama de la
investigación. Tal es el caso de la Universidad Autónoma de México, la UNAM es
líder nacional en investigación, formación de recursos humanos y difusión en
computación realizando aportes teóricos y prácticos a las ciencias cognitivas e
inteligencia artificial, reconocimiento de patrones, vida artificial, diseños
8
combinatorios, sistemas complejos y procesamiento de imágenes. Estos avances
han sido realizados dentro del Departamento de Ciencias de la Computación en el
Instituto de Investigaciones de Matemáticas Aplicadas y de Sistemas (IIMAS) de la
UNAM donde se cuentan con laboratorios con el equipo necesario para el
desarrollo de nuevas tecnologías, uno de estos laboratorios es “Golem: Diseño y
construcción de robots de servicio” o “Grupo Golem” mismo nombre que posee el
robot de servicio de IIMAS, Golem.
Grupo Golem se enfoca en la investigación del modelado cognitivo de la
interacción humano-sistema computacional aplicado a los robots de servicio. Un
robot de servicio, según la Federación Internacional de Robótica (IFR) “es un robot
que opera de forma parcial o totalmente autónoma para realizar servicios útiles
para el bienestar de los humanos”. De acuerdo a esta definición el equipo de
trabajo de grupo Golem se centró en el desarrollo de habilidades domésticas y de
servicios de Golem obteniendo como resultado que este fuera capaz de mantener
conversaciones sencillas, entendimiento de comando, reconocimiento de voz en
español, y con sistemas de visión es capaz de dar una “visita guiada” a través de
carteles de los proyectos de investigación del departamento.
Se busca que Golem sea capaz de interactuar con el entorno físico de una manera
más natural aprendiendo de manera autónoma de la información constante que
recibe por los diferentes dispositivos de entrada que posee.
1.2.- Planteamiento del problema
Un robot de servicio tiene que interactuar con muchos cambios físicos en entornos
complejos, ya sean personas, objetos fijos, objetos móviles en habitaciones, zonas
urbanas, áreas verdes, etc. Elementos proporcionan información poco
estructurada y muy variante en el tiempo. En muchas situaciones, el robot debe
interactuar directamente con estos elementos, de los cuales tiene que aprender en
un corto periodo de tiempo mientras se realiza la interacción para poder después
identificarlos si así lo requiere la tarea.
9
Dentro del entorno de trabajo actual de Golem los principales elementos de
interacción que pudieran presentarse van desde el cruce de personas hasta
muebles como sillas o mesas de trabajo.
Por lo cual surge la interrogante ¿Qué se requiere hacer para crear un sistema
que ayude al robot de servicios Golem a identificar y seguir objetos de interés de
manera autónoma aprovechando los sistemas de visión que este posee?
1.3.- Justificación
El desarrollar un sistema que contribuya a la localización y rastreo de objetos
específicos para Golem conducirá a mejorar la interacción que el robot tiene con el
entorno, reducirá el tiempo de respuesta en la toma de decisiones una vez
encontrado con el elemento a interactuar, realizará en un tiempo menor las tareas
que se le planteen, se contará con un análisis visual más completo y robusto,
destacando el abrir la posibilidad para el desarrollo de nuevas habilidades del
robot.
La manera en que Golem se traslada dentro de las instalaciones de IIMAS se ve
fuertemente obstaculizada principalmente por sillas que por el hecho de ser un
laboratorio estos son los principales elementos que están en constante
movimiento, por lo tanto si el robot pudiera ver y seguir estos elementos buscaría
la manera de evadirlos o evitarlos.
Al no crear dicho sistema de localización y rastreo para el robot se verá
fuertemente afectada la interacción que tiene, llegando al punto de no realizar las
tareas que se planteen.
1.4.- Objetivo
Desarrollar un sistema de detección de sillas capaz de localizar y rastrear al objeto
mediante un sistema de visión y algoritmos computacionales para el robot de
servicios Golem-II+.
10
1.5.- Delimitaciones
El sistema en su última instancia será capaz de realizar las siguientes tareas:
I. Será capaz de detectar dentro del entorno visual que el robot de servicios
posea los diferentes tipos de sillas que existan en el laboratorio.
II. Las sillas que será capaz de identificar serán de las siguientes
características:
De cuatro patas.
De base con llantitas.
Con o sin apoyabrazos.
Color indistinto.
III. Una vez localizada la o las sillas, el sistema será capaz de seguir su cambio
de posición o ubicación hasta donde el campo de visión se lo permita.
1.6.- Limitaciones
Este proyecto fue realizado durante mi estancia de verano científico en el Distrito
Federal, se contó con poco tiempo para desarrollar un sistema confiable y robusto.
Además el robot de servicios es exclusivo del Instituto de Investigaciones de
Matemáticas Aplicadas de la Universidad Autónoma de México por lo que es poco
probable continuar con las pruebas del sistema desarrollado estando en el Instituto
Tecnológico de Sonora.
11
Capítulo II. Método
2.1.- Sujeto
El presente proyecto está dirigido a la comunidad científica que se encuentre
interesada en el tema, ya sea para investigación o estudio.
El responsable del proyecto es el Doctor Ivan Vladimir Meza Ruiz, Ingeniero en
Computación de la Facultada de Ingeniería – UNAM (1996), Maestro en Ciencias
Especialidad en Procesamiento de Lenguaje Natural en la Universidad de
Edimburgo (2003), Doctorado en Sistemas de Diálogo en la Universidad de
Edimburgo (2006) y cuyas líneas de investigación son:
- Inteligencia Artificial.
- Lingüística Computacional.
- Procesamiento de Lenguaje Natural.
- Aprendizaje Automático.
12
- Text Mining.
- Patrones de Reconocimiento.
- Recuperación de Información.
- Reconocimiento de Voz.
2.2.- Materiales
Los distintos elementos empleados para el desarrollo del presente proyecto se
mencionan a continuación:
1. Computadora portátil. Para el manejo de los programas requeridos. Algunas
características son: Laptop Dell, Procesador de Intel Core 5 de 1.60GHz, 6
Gb de memoria RAM, Disco duro de 685 Gb, Sistema operativo Windows 8
de 64 bits.
2. Cámara Digital. Para la captura de las fotos que son la base de datos.
3. Herramienta de programación Python 2.7. Software utilizado para la
elaboración de los programas necesarios para la creación del sistema de
localización y rastreo.
4. Bibliotecas extras para Python 2.7. (Pygame, OpenCV, Numpy, Matplotlib).
5. Robot de Servicios Golem. Principal elemento del proyecto el cual
ejecutaba los modelos creados para ver su comportamiento. Algunas
elementos que este contiene son: Arreglos de sonares con ocho sensores
cada uno, dos sensores IR (infrarrojos) al frente, arreglos de sensores al
tacto con cinco sensores cada uno, micrófonos y bocinas, computadora
interna VersaLogic EBX-12, una laptop Dell Precision M4600, LAIDETEC-
IIMAS brazos robóticos, Webcam QuickCam Pro 9000, Cámara Microsoft
Kinect.
13
6. Herramientas de apoyo. Acceso a internet, presentaciones del académicas
de IIMAS, vídeos.
7. Bibliografía. Se utilizó documentación de los manuales de programas y
libros referentes a la programación y anteriores proyectos de Golem para el
desarrollo de este proyecto.
2.3.- Procedimiento
El procedimiento llevado a cabo para el desarrollo del presente proyecto se
muestra a continuación:
Figura 2 1. Procedimiento para la elaboración del proyecto.
Inicio
Investigación del estado del arte.
Recolección de la base de datos.
Etiquetación de la base de datos.
Creación de Modelos
Pruebas
Resultados
Fin
14
2.3.1.- Estudio del estado del arte. Para empezar a trabajar con el desarrollo del
sistema detector de sillas para el robot de servicios Golem, primeramente fue
necesario hacer un reconocimiento del robot, así como las técnicas de
programación antes utilizadas para desarrollar las habilidades de esté.
Para ello se recurrió a hacer una investigación bibliográfica en los distintos
artículos, libros y tesis que IIMAS ha desarrollado en base a Golem para así
aprender tanto de la metodología del trabajo así como del software utilizado.
Posteriormente se plantearon problemáticas donde el tema principal es el
aprendizaje automático y cuyo principal objetivo fue crear códigos en el software
de programación Python que solucionan dichos problemas y nos familiarizamos
con el lenguaje que utiliza Python.
2.3.2.- Recolección de la base de datos. El método que se decidió utilizar para
programar a Golem fue aprendizaje automático, el cual consiste en que el sistema
tome decisiones en base a la “experiencia”, dicha experiencia la obtiene en base a
ejemplos dados como lo son las sillas en cada una de las fotografías, una vez
aprendido de los ejemplos tomara la decisión en un futuro de que es silla y que no
lo es.
Para ello se necesita una base de datos de fotos donde haya sillas (fotos
positivas) y una base de datos donde no haya sillas (fotos negativas), estas bases
de datos tienen que ser grande y considerando la mayor cantidad de posibles
casos en los que se podría encontrar el objeto a identificar por lo que se tomaron
alrededor de 5000 fotos tanto positivas como negativas.
2.3.3.- Etiquetación de la base de datos. Este proceso consiste en seleccionar
de manera manual en cada una de las fotos donde se encuentra la silla en cada
una de las fotografías, esto con el fin de indicarle dentro de la programación que
es silla de lo que no lo es y así pueda aprender el sistema. Una vez etiquetada la
15
silla se renombraba para mantener un estándar de las imágenes que el sistema
utilizaría.
2.3.4.- Creación de Modelos. Para la elaboración de los modelos se utilizó el
proceso mostrado en la Figura 2. Primero se tomaba un número establecido de las
etiquetas de la base datos (tanto positivas como negativas), se entrenaba al
sistema con el código de programación de Python y así obtener un modelo, se
hacían pruebas a los modelos para comprobar que cumpliera con el objetivo, de
no ser así se agregaban más etiquetas de la base de datos, positivas, negativas o
ambas para mejorar los modelos.
Figura 2 2. Diagrama del proceso de elaboración de modelos.
Número de etiquetas de la
base de datos.
Entrenamiento del modelo
Pruebas del modelo.
¿Cumple con el
objetivo?
Documentación
Si
No
16
2.3.5.- Pruebas. Al obtener un modelo lo suficientemente confiable, este pasaba a
ser aplicado a Golem para hacer las pruebas suficientes en tiempo real con el
mismo, buscando obtener de manera más concreta como es que el modelo se
comportaba y concluir si este funciona correctamente o es necesario mejorarlo
siguiendo los pasos anteriores.
2.3.6.- Resultados. Después de realizarse las pruebas y correcciones necesarias
para la obtención de un resultado satisfactorio, se procede a realizar la
documentación de cada modelo.
17
Capitulo III. Desarrollo
3.1.- Recolección de base de datos para el aprendizaje del sistema detector.
La base de datos que el sistema requiere consiste principalmente de dos tipos de
muestras, fotografías de las sillas ejemplo de las que el sistema aprenderá (fotos
positivas) y fotografías del entorno que rodean las sillas sin contener a las mismas
(fotos negativas).
La recolección de las fotos positivas es un paso bastante importante, ya que esto
es lo que define en gran medida la capacidad del sistema para detectar lo que es
una silla de lo que no lo es. Por ello, se propusieron ciertas características que
deberían de poseer las fotografías que contuvieran a las muestras y que se
mencionan a continuación:
No se toman en cuenta para la base de datos fotografías borrosas o con
demasiada iluminación que impedían ver con claridad a la silla.
18
La silla tiene que estar vacía para considerarse válida, si una persona u
objeto está sobre la misma no se toma en cuenta.
La silla no debe de abarcar más del 50% de la imagen total.
En caso de que dos o más sillas se sobreponían en una fotografía, se toma
en cuenta soló la silla que se visualizaba completamente.
La silla debe contener todas y cada una de sus partes visibles en la
fotografía (patas, asiento, respaldo, apoya brazos).
La silla no debe ser el único elemento contenido en la fotografía.
Las fotografías tomadas a las sillas deben ser de todos los ángulos y
posiciones posibles para cubrir la mayor cantidad de casos que estás
pudiesen presentar.
Ejemplos de una mala toma de fotografías para la base de datos se muestran en
las figuras 3.1, 3.2 y 3.3.
Figura 3 1. Fotografía con demasiada iluminación.
19
Figura 3 2. Fotografía borrosa.
Figura 3 3. Ninguna de las sillas muestra todas sus partes visibles en la fotografía.
Ejemplos de una buena toma de fotografías positivas para la base de datos se
muestran en las figuras 3.4 y 3.5.
20
Figura 3 4. La silla que esta al centro de la fotografía muestra todas sus partes.
Figura 3 5. Silla con todas sus partes y en diferentes ángulos.
Otro aspecto importante de la base de datos es la cantidad de muestras que debe
poseer. Por lo tanto, además de que las fotografías deben tener “calidad”
respetando las características antes mencionadas, también se busca que haya
cantidad de las mismas.
21
Como el objetivo del proyecto es que el robot de servicios “Golem” fuera capaz de
detectar las sillas que se encuentran en su entorno de trabajo, era necesario tomar
en cuenta cada una de ellas para la base de datos. Dentro de IIMAS se cuentan
con cinco tipos distintos de sillas. Las características que poseen cada una de
ellas entre sí, es muy similar pero con pequeñas variaciones, a continuación se
describe cada una de ellas, en las figuras 3.6, 3.7, 3.8, 3.9 y 310.
Figura 3 6. De cuatro patas, asiento, respaldo y color café.
Figura 3 7. De cuatro patas, asiento, respaldo, apoya manos y color azul.
22
Figura 3 8. De rueditas, asiento, respaldo y color azul.
Figura 3 9. De rueditas, asiento, respaldo, apoya manos y color azul.
Figura 3 103. De rueditas, asiento, respaldo, apoya manos y color negro.
23
Una vez definido cada ejemplo del cual el sistema tendría que ser capaz de
aprender se inició con la recolección de las muestras. Se hizo uso de cámaras
digitales o de celulares para la toma de las imágenes. Se tomaron
aproximadamente 1000 fotografías por cada una de las sillas con las
características antes mencionadas, por lo que al final la base de datos de fotos
positivas contó aproximadamente con una cantidad cercana a los 5000
ejemplares.
La recolección de la base de datos de fotos negativas no fue tan rigurosa como la
de fotos positivas, ya que simplemente se buscó que la imagen representase el
área de trabajo de Golem sin contener a los elementos de ejemplo a identificar,
siempre y cuando la imagen no estuviera borrosa o con demasiada iluminación.
Al igual que las fotos positivas fue necesario tener una gran cantidad de
ejemplares de fotos negativas principalmente para que el sistema poseyera un
contraste significativo entre lo que es o no una silla.
Ejemplos de fotografías negativas para la base de datos se muestran en las
figuras 3.11, 3.12 y 3.13.
Figura 3 11. Paredes y muebles del laboratorio.
24
Figura 3 12. Pasillos de las instalaciones.
Figura 3 13. Personas en interacción con Golem.
3.2.- Etiquetación de la base de datos.
La etiquetación de la base de datos consiste en hacer recortes exclusivamente de
las sillas dentro de las fotografías tomadas en el paso anterior, esto con el fin de
señalarle posteriormente al sistema las características que una silla posee y
aprenda a identificarla.
25
Pero antes de realizar lo antes mencionado fue necesario estandarizar tanto las
dimensiones como nombres de cada fotografía de la base de datos. Por lo tanto
se creó un programa en Python que hiciera esta tarea. Se propuso que las
dimensiones que deberían de tener las fotografías serían de 640 píxeles de ancho
por 480 píxeles de alto y que el nombre que tendrían sería “silla_(número
correspondiente)”.
Además de las librerías propias del software fue necesario hacer uso de librerías
externas como lo es OpenCV que se enfoca en el procesamiento de imágenes
para aplicaciones de tiempo real, estas mismas librerías fueron utilizadas para la
elaboración de los próximos programas del proyecto. Dicho programa quedó de la
manera como lo muestran las figuras 3.14 y 3.15.
Figura 3 14. Librerías utilizadas y argumentos de entrada del programa.
26
Figura 3 15. Lectura de imágenes, modificación de características y almacenamiento.
Una vez realizado lo anterior se procedió a realizar los recortes de las sillas de la
nueva base de datos. Para ello se hizo uso del programa de etiquetación de
imágenes que IIMAS ya poseía, cuyo autor es Rogelio Adrián Romero Cordero,
pero antes de ser aplicado a nuestro sistema fue necesario hacer breves
modificaciones y adaptarlo a nuestro proyecto.
El código funciona de la siguiente manera.
El programa lee la primera imagen contenida dentro de la carpeta con todas
las imágenes predispuestas a etiquetar y la muestra al usuario.
Una vez que usuario ve la imagen, este con el cursor del mouse se
posiciona sobre la silla a etiquetar.
Ya sobre la silla, se presiona la tecla espaciadora del teclado (Space) para
hacer crecer el rectángulo (color verde) de 48 por 96 pixeles de la etiqueta
hasta que este rectángulo rodee completamente a la silla sin haberse
excedido demasiado. En caso de que el rectángulo haya sido demasiado
grande, presionando la tecla Shift es posible decrecer el rectángulo de la
etiqueta, de igual manera si la posición de la etiqueta no fue el correcto
27
también se puede dar click sostenido sobre rectángulo verde y arrastrarlo a
la posición deseada. Solo hay que tener en cuenta que al presionar la tecla
Space o Shift para hacer crecer o decrecer el marco de la etiqueta esté lo
hará a partir de donde se encuentre el cursor del mouse ya que este le
indica el centro de la etiqueta.
Cuando el rectángulo de color verde es de las dimensiones deseadas, sin
mover el mouse se presiona la tecla control izquierdo (Left Ctrl) lo que
ocasiona que el rectángulo cambie de color verde a rojo, indicando la
posición preliminar de la etiqueta. En caso de haber ocurrido un error con el
posicionamiento con la etiqueta, al presionar la tecla “x” elimina el
rectángulo rojo.
Para confirmar que la etiqueta es correcta se presiona la tecla Left Alt, la
cual hace que se muestre de nueva cuenta el rectángulo verde pero con las
dimensiones que el rectángulo rojo ya posee. Posteriormente se presiona la
tecla Left Ctrl de nueva cuenta, lo que hará que el rectángulo cambie de
color azul. En caso de haber ocurrido un error con el posicionamiento con la
etiqueta, al presionar la tecla “x” elimina el rectángulo azul.
Cuando se tenga el rectángulo en color azul al presionar “enter” la imagen
que se encuentra dentro del rectángulo se almacena en la carpeta
especificada así como un documento de “.txt” con las coordenadas de la
misma imagen.
Una vez etiquetadas la o las sillas que se encuentren en la fotografía se
puede cambiar a la siguiente fotografía con las flechas del teclado y seguir
el procedimiento anterior para proseguir con las etiquetas de la base de
datos.
Para salir del proceso de etiquetación solo es necesario presionar la tecla
escape (esc) o la tecla “q” para terminar el proceso.
A continuación se muestran las partes más importantes del programa de
etiquetación en las figuras 3.16, 3.17, 3.18, 3.19, 3.20, 3.21 y 3.22.
28
Figura 3 16. Librerías utilizadas, lectura de imágenes y coordenadas.
Figura 3 17. Movimiento de la etiqueta (mouse), salir del programa de etiquetación (tecla escape o “q”).
29
Figura 3 18. Adición del recuadro rojo y azul (tecla control izquierdo).
Figura 3 19. Incremento (tecla space) y decremento (tecla Shift izquierdo) de la etiqueta.
30
Figura 3 20. Recuadro de confirmación (tecla Alt izquierdo) y eliminación de recuadro rojo y azul (tecla “x” y “s” respectivamente).
Figura 3 21. Para avanzar o retroceder en las imágenes a etiquetar.
31
Figura 3 22. Almacenamiento de etiqueta y coordenadas de la misma (tecla enter).
Algunos ejemplos de las sillas etiquetadas de las fotografías positivas son
mostradas en las figuras 3.23, 3.24, 3.25, 3.26 y 3.27.
Figura 3 23. Etiqueta para sillas de rueditas, asiento, respaldo y color azul.
32
Figura 3 24. Para silla de cuatro patas, asiento, respaldo, apoya manos y color azul.
Figura 3 25. Etiqueta para silla de rueditas, asiento, respaldo, apoya manos y color negro.
33
Figura 3 26. Etiqueta para silla de rueditas, asiento, respaldo, apoya manos y color azul.
Figura 3 27. Etiqueta para silla de cuatro patas, asiento, respaldo y color café.
Para la etiquetación de la base de datos de fotografías negativas se hizo uso del
mismo programa que el de etiquetación de sillas, pero con la diferencia de que en
34
esta ocasión soló era necesario realizar etiquetas donde se estuviera seguro que
no estuviera ninguna silla contenida.
Ejemplos de etiquetas de fotografías negativas se muestran en las figuras 3.28 y
3.29.
Figura 3 28. Etiquetación de fotografías negativas (1).
Figura 3 29. Etiquetación de fotografías negativas (2).
35
3.3.- Creación de modelos.
Una vez realizada la etiquetación de ambas base de datos el siguiente paso a
realizar fue la del entrenamiento de sistema con la finalidad de obtener modelos
con la capacidad para detectar sillas.
Para ello es necesario hacer uso de dos principales herramientas para el
procesamiento y clasificación de imágenes. El primero de ellos es el histograma
de orientaciones de gradientes (Hog) el cual es una técnica que se encarga de
extraer características básicas de la imagen en estudio, esto lo logra hacer al
transformar la imagen en componentes básicos que representen a la imagen
original con el objetivo de reducir la cantidad de información. Este proceso se logra
hacer directamente mediante una de las librerías contenidas dentro de OpenCV la
cual calcula el descriptor HOG de una imagen (figura 3.30).
Figura 3 30. Configuración para el descriptor HOG de una imagen.
Lo segundo es por medio de las máquinas de soporte vectorial (SVM) las cuales
son técnicas de aprendizaje automático que se especializan en aprender modelos
de dos diferentes clases de objetos o un conjunto de estas. Se caracteriza por
crear un trazado de línea que separa las dos diferentes clases de objetos desde la
máxima distancia dada por dos ejemplos de cada clase que no tengan elementos
en común entre ellos. A estos ejemplos se les conoce vectores de soporte, de ahí
el nombre de la técnica. En nuestro caso los ejemplos de las dos diferentes clases
son las etiquetas de las fotografías positivas y las etiquetas de las fotografías
negativas.
36
Igual que en el caso anterior, OpenCV posee una implementación de SVM que
puede utilizarse para el entrenamiento de los modelos (figura 3.31).
Figura 3 31. Configuración del SMV para un conjunto de objetos.
En conjunto con estas dos herramientas fue posible realizar la programación para
el entrenamiento del sistema y poder generar los modelos de detección de sillas.
Dichos modelos varían su efectividad y confiabilidad dependiendo del número de
ejemplos tanto de etiquetas positivas como negativas eran ingresadas al código.
Las partes más importantes son mostradas en las figuras 3.32, 3.33, 3.34 y 3.35.
Figura 3 32. Librerías utilizadas y argumentos de entrada del programa.
37
Figura 3 33. Se abren las etiquetas positivas y se calcula su descriptor HOG.
Figura 3 34. Se abren las etiquetas negativas y se calcula su descriptor HOG.
38
Figura 3 35. Entrenamiento y almacenamiento del modelo.
Una vez obtenido el modelo el siguiente y último paso para la detección de las
sillas fue hacer uso de la implementación de OpenCV que viene equipada con un
detector para la búsqueda de sillas en cualquier imagen la cual consiste de la
siguiente manera.
Se hace un barrido sobre la imagen con una ventana de las dimensiones del
descriptor HOG que ya poseemos (48 por 96 pixeles) hasta a completar con toda
la imagen y esperando que la ventana se tope con alguna silla a la cual detectar.
Esto no puede ser muy eficiente a la primera por lo que al hacer el segundo
barrido se reduce el tamaño de la imagen para repetir el proceso. Esto se repite
hasta que la ventana supere a la imagen donde se realiza la búsqueda.
La programación utilizada para la búsqueda y detección de las sillas fue la que se
muestra en las figuras 3.36, 3.37, 3.38 y 3.39.
39
Figura 3 36. Argumentos de entrada del programa y configuración del descriptor HOG.
Figura 3 37. Se carga el modelo entrenado y se sincroniza con el descriptor HOG.
Figura 3 38. Se carga la imagen y se buscan las sillas con el barrido y reducción de la imagen.
40
Figura 3 39. Se dibujan sobre la imagen rectángulos de las áreas localizadas.
Los primeros modelos creados tuvieron un entrenamiento con un número
aproximados de etiquetas positivas y negativas de entre 1500 a 2500 fotografías
arrojando los resultados que se muestran en las figuras 3.40, 3.41 y 3.42.
Figura 3 40. Ejemplo del modelo del sistema detector de sillas sin errores (1).
41
Figura 3 41. Ejemplo del modelo del sistema detector de sillas sin errores (2).
Figura 3 42. Ejemplo del modelo del sistema detector de sillas con errores.
Para el mejoramiento de los modelos preliminares detectores de silla se hicieron
dos principales cosas. La primera de ellas fue entrenar nuevamente el sistema con
un número mayor de ejemplos tanto de etiquetas positivas así como negativas. La
42
segunda y más importante fue agregar a los nuevos modelos las áreas de error tal
como se muestra en la Figura 3 38. Al hacer esto se agregan más negativos al
sistema reduciendo el error para los próximos modelos considerablemente. A este
nuevo ejemplo de negativos se le denominó, negativos duros. Por lo tanto ahora el
sistema estará siendo entrenado por tres diferentes tipos de ejemplos, Etiquetas
positivas, Etiquetas negativas y negativos duros.
43
Capitulo IV. Resultados
Los resultados obtenidos presentaron distintos niveles de confiabilidad de acuerdo
a los diferentes modelos creados por el equipo de trabajo. Los primeros modelos
creados presentaron errores bastantes notables, como ignorar sillas donde si
había y detectar como sillas figuras o sombras que aparentaban serlo. Los
modelos finales lograron ser mucho más robustos y eficientes eliminando errores
de modelos iniciales y detectando en la mayoría de los casos las sillas del
laboratorio (figura 4.1).
44
Figura 4 1. Modelo de detección aplicado al robot de servicios detectando correctamente.
En las implementaciones finales de los modelos se puede apreciar que algunas
sillas no eran posibles detectarlas por el limitado número de ejemplos presentados
en la base de datos de fotos positivas, lo que restringía hacer un buen trabajo de
detección del sistema (figuras 4.2 y 4.3).
45
Figura 4 2. Ejemplo del modelo con deficiencia al detectar sillas por la falta de ejemplos (1).
46
Figura 4 3. Ejemplo del modelo con deficiencia al detectar sillas por la falta de ejemplos (2).
47
Capítulo V. Conclusiones
La creación de sistemas capaces de detectar objetos mediante el método de
aprendizaje automático generaliza de manera muy completa la diversidad de
casos que pudiese presentar un fenómeno en específico lo que resulta ser un
método bastante bueno y confiable. El principal problema de este método de
aprendizaje radica en los ejemplos de los que el sistema tiene que aprender. La
cantidad de ejemplos tienen que ser bastante grande para que el sistema aprenda
de todos los casos posibles.
Dentro del proyecto realizado la presencia de los errores radica en eso, el sistema
requiere de muchos más ejemplos tanto de sillas como de no sillas para ser más
robusto. Esa conclusión se puede apreciar de manera sencilla de acuerdo en los
diferentes modelos realizados. Los primeros donde la base de datos fue pequeña
los errores fueron más latentes pero conforme el número de la base de datos era
mayor los errores se minimizaron.
48
Cabe aclarar que el sistema como todo sistema analógico también presenta una
curva de aprendizaje donde a pesar de poseer un número infinito de ejemplos no
aprenderá más que si poseyera 50,000 ejemplos (por decir un número). Esta
curva se puede obtener de manera manual agregan poco a poco ejemplos a la
base de datos y evaluar los resultados obtenidos. Cabe mencionar que esta curva
de aprendizaje nos puede indicar la cantidad de ejemplos positivos o negativos
que hay que agregar al sistema para ser más robusto los modelos.
49
Referencias Bibliográficas
Julio Villena Román (2011). Inteligencia de Redes de Comunicación:
Historia de la Inteligencia Artificial. Madrid. C.C. Autor.
Ciencias de la computación. Obtenida el 01 de Octubre de 2014, de
Instituto de Investigaciones de Matemáticas Aplicadas y de Sistemas de la
Universidad Autónoma de México (IIMAS-UNAM), página web institucional:
http://www.iimas.unam.mx/iimas/
Grupo Golem. Obtenida el 01 de Octubre de 2014, de Instituto de
Investigaciones de Matemáticas Aplicadas y de Sistemas de la Universidad
Autónoma de México (IIMAS-UNAM), página web institucional:
http://golem.iimas.unam.mx/
Rafael Barea (n.d.). Robótica de Servicios. Madrid. C.C. Autor.
Sumir Kumar Sahar (2008). Introduction to robotics (1ra ed.). India. Tata
McGraw-Hill.
International Organization for Standardization (2012) ISO 8373:2012 Robots
and robotic devices – Vocabulary.
Marcos Berreto. Applied ontologies and standards for service robots. [En
línea]. Robotics and Autonomous Systems, Volume 61, Issue 11, November
2013.
Sebastien Lechevalier. Diversity in patterns of industry evolution: How an
intrapreneurial regime contributed to the emergence of the service
robot industry [En línea]. Research Policy, Volume 43, Issue 10, December
2014.
50
¿Cómo ves? Obtenida el 20 de Octubre de 2014, Revista de Divulgación de
la Ciencia de la Universidad Autónoma de México, página web institucional:
http://www.comoves.unam.mx
Sekou L. Remy. How to teach a new robot new tricks: Interactive learning
freamwork applied to service robotics. Tesis (Doctor en Filosofía). U. E.,
Instituto de Tecnología de Georgia. (2009)
La Ciencia y el Hombre, Obtenida el 20 de Octubre de 2014, Revista de
Divulgación Científica y Tecnológica de la Universidad Veracruzana, página
web institucional: http://www.uv.mx
Aprendizaje Automático – Machine Learning. Obtenida el 21 de Octubre del
2014, Facultad de Ciencias Exactas y Naturales de la Universidad de
Buenas Aires, página web institucional: http://www.dc.uba.ar
Kamal Priyantha Ranaweera. Optimization, Artificial Intelligence and
Machine Learning in the Develpment of Image Processing Plans. Tesis
(Ingeniero en Ciencias). Londres., Universidad del Este de Ontario. (2007)
Grupo Golem. Obtenida el 21 de Octubre de 2014, de Instituto de
Investigaciones de Matemáticas Aplicadas y de Sistemas de la Universidad
Autónoma de México (IIMAS-UNAM), página web institucional:
http://golem.iimas.unam.mx/
Python. Obtenida el 22 de Octubre de 2014, de Tutorial de Python, página
web: http://docs.python.org.ar/tutorial/pdfs/TutorialPython2.pdf
