INSTITUTO TECNOLÓGICO DE CHIHUAHUA DIVISIÓN DE ESTUDIOS DE POSGRADO E INVESTIGACIÓN
“AGENTE PIZARRÓN BASADO EN ONTOLOGÍAS PARA LA COMUNICACIÓN DE AGENTES ROBÓTICOS
INTELIGENTES”
TESIS
QUE PARA OBTENER EL GRADO DE
MAESTRO EN INGENIERÍA MECATRÓNICA
PRESENTA:
ING. RAÚL GILBERTO ANTONIO SÁNCHEZ RUIZ
DIRECTOR DE TESIS: M.C. PEDRO RAFAEL MÁRQUEZ GUTIÉRREZ
CHIHUAHUA, CHIH. , MEXICO, ENERO 2020
ii
iii
RESUMEN AGENTE PIZARRÓN BASADO EN ONTOLOGÍAS PARA LA COMUNICACIÓN DE
AGENTES ROBÓTICOS INTELIGENTES Raúl Gilberto Antonio Sánchez Ruiz Maestro en Ingeniería Mecatrónica
División de Estudios de Posgrado e Investigación del Instituto Tecnológico de Chihuahua
Chihuahua, Chih. Enero 2020. Director de Tesis: M.C. Pedro Rafael Márquez Gutiérrez
La robótica ha significado una revolución más de la automatización industrial,
hasta en la actualidad solo reemplazando a la fuerza humana en tareas altamente
repetitivas y simples donde prácticamente no se requiere pensar los movimientos a
realizar. Esta revolución no solo se quedara hasta el reemplazo de estas tareas
simples, en el futuro cercano la industria pondrá a los robots a realizar tareas más
complejas tanto en tamaño como en conocimiento en donde los robots involucren
cierta inteligencia y cooperación para completar sus objetivos, por lo que la forma y
la estrategia de comunicación se vuelve importante a la hora de cumplir el objetivo
de tener robots más inteligentes.
Con el propósito anterior se desarrolló un agente pizarrón el cual tiene la
función de manejar, distribuir y organizar todo el conocimiento para que sea visible y
esté al alcance cualquier robot dentro de sus sistema para su uso en la tarea que
tengo como objetivo realizar, proponiendo una estrategia centralizada de
comunicación. También se desarrolló este agente pizarrón para que representara
todo este conocimiento en ontologías, este cumpliendo el objetivo de tener una
forma de comunicación que sea entendida de la misma manera por todos los robots
involucrados en el sistema ya que las ontologías son una manera clara y organizada
de representar el conocimiento.
Se implementaron las funciones del agente pizarrón para el manejo de la base
de conocimiento tanto en JADE con Java como en SPADE (Python), la primera se
realizó debido a la madurez de la herramienta y la segunda se realizó con el fin de
probar la madurez de esta herramienta ya que Python podrá ser de gran ayuda para
su implementación en las futuras tecnologías robóticas inteligentes.
iv
ÍNDICE
1. INTRODUCCIÓN .................................................................................... 8
1.1 Uso de la robótica en la automatización ........................................... 8
1.2 Problema a resolver e hipótesis. .................................................... 10
1.3 Metodología. ................................................................................... 12
1.3.1 Investigación de áreas de interés y herramientas disponibles para
el desarrollo. ................................................................................................... 12
1.3.2 Diseño de agente pizarrón basado en ontologías. ....................... 12
1.3.3 Pruebas de funcionamiento de las herramientas. ........................ 12
1.3.4 Implementación de la comunicación entre agentes. ..................... 12
1.3.5 Implementación de la construcción de la base de conocimiento
basada en ontologías. .................................................................................... 13
1.4 Justificación. ................................................................................... 14
2. MARCO TEÓRICO ................................................................................ 15
2.1 Sistemas basados en conocimientos. ............................................ 15
2.1.1 Ontologías. .................................................................................... 16
2.1.1.1 Software para el desarrollo de ontologías .............................. 17
2.1.2 Sistema pizarrón. .......................................................................... 21
2.2 Sistemas basados en agentes. ....................................................... 22
2.2.1 Cooperación y colaboración de agentes ...................................... 22
2.2.1.1 Agentes .................................................................................. 22
2.2.1.2 Sistemas multi-agente ............................................................ 24
2.2.1.3 Comunicación en sistemas multi-agente ............................... 24
2.2.1.4 Software para el desarrollo de sistemas multi-agente ........... 26
v
3. DISEÑO DE AGENTE PIZARRÓN PARA SISTEMAS MULTI-ROBOT.
29
3.1 Definición de una base de conocimiento en común. ...................... 29
3.2 Definición de la comunicación de los agentes robóticos con el
agente pizarrón. ................................................................................................. 32
3.3 Descripción del funcionamiento del agente pizarrón en el sistema
multi-robot. 36
4. IMPLEMENTACIÓN DE AGENTE PIZARRÓN CON JADE ................. 39
4.1 Pruebas Iniciales: Implementación de traslado de mensajes. ........ 39
4.2 Ontologías con JADE. .................................................................... 42
4.3 Agente pizarrón con JADE. ............................................................ 46
5. IMPLEMENTACION DE AGENTE PIZARRON CON OWLREADY ...... 49
5.1 Construcción de una ontología con Owlready2 .............................. 49
5.2 Implementación del agente pizarrón en Owlready. ........................ 51
5.3 Comunicación de agente pizarrón con SPADE. ............................. 58
6. RESULTADOS, CONCLUSIONES Y TRABAJO A FUTURO .............. 65
6.1 Diseño de agente pizarrón. ............................................................. 65
6.2 Implementación de agente pizarrón con JADE .............................. 66
6.3 Implementación de agente pizarrón con Python ............................ 68
6.4 Conclusiones finales. ...................................................................... 70
ANEXO 1 ....................................................................................................... 72
BIBLIOGRAFÍA ............................................................................................. 73
vi
LISTA DE FIGURAS
Figura 2.1Puntos en común desde los datos a la sabiduría. ............................ 15
Figura 2.2 Pirámide del conocimiento .............................................................. 16
Figura 2.3Arquitectura general de Owlready propuesta en (Olszewska et al.,
2017) ......................................................................................................................... 20
Figura 2.4 Arquitectura de sistema pizarrón .................................................... 22
Figura 2.5 Esquema de funcionamiento de un agente. .................................... 23
Figura 2.6 Arquitectura de comunicación de agentes mediante pizarrón. ....... 25
Figura 3.1 Diferentes categorías de modelos para modelado de bases de
conocimiento. ............................................................................................................ 29
Figura 3.2 Modelo de comunicación de paso de mensajes entre agentes. ..... 33
Figura 3.3 Modelo de comunicación centralizado para el acceso a la base de
conocimiento. ............................................................................................................ 34
Figura 3.4 Modelo de comunicación modularizado. ......................................... 35
Figura 3.5 Funcionamiento de sistema multi-robot con un agente pizarrón para
crear un nuevo conocimiento. ................................................................................... 38
Figura 4.1 Esquema de funcionamiento de la primera implementación de paso
de mensajes con JADE. ............................................................................................ 40
Figura 4.2 Esquema de funcionamiento de paso de mensajes con agentes en
diferentes contenedores. ........................................................................................... 40
Figura 4.3 Interfaz generada por JADE con agentes en diferentes
contenedores. ........................................................................................................... 41
Figura 4.4 Mensajes impresos en consola de agentes en diferentes
contenedores. ........................................................................................................... 41
Figura 4.5 Estructura de ontología de ejemplo para la implementación de
ontologías con JADE ................................................................................................. 43
Figura 4.6 Diagrama UML de clases implementadas para ejemplo de uso de
ontologías con JADE. ................................................................................................ 44
Figura 4.7 Mensaje impreso en consola del resultado de la implementación de
ontologías con JADE en formato FIPA-SL (FIPA Semantic language). .................... 45
vii
Figura 4.8 Código implementado para la recepción de mensajes del agente
pizarrón en JADE. ..................................................................................................... 47
Figura 4.9 Código implementado para la recepción de mensajes del agente
pizarrón y transformación del mensaje a objeto en JADE ........................................ 48
Figura 5.1 Código de ontología implementada en Owlready. .......................... 50
Figura 5.2 Representación de dominio y rango de una relación en Owlready . 51
Figura 5.3 Formato para el contenido de los mensajes enviados al agente
pizarrón. .................................................................................................................... 52
Figura 5.4 Funcionamiento de preparador de mensajes del agente pizarrón. . 53
Figura 5.5 Código de implementación del método para el objeto preparador de
mensajes. .................................................................................................................. 54
Figura 5.6 Código de implementación del método de aportar conocimiento del
agente pizarrón. ........................................................................................................ 55
Figura 5.7 Código de implementación para los métodos que permiten checar y
eliminar el conocimiento. ........................................................................................... 56
Figura 5.8Código de implementación para los métodos que permiten checar y
eliminar el conocimiento. ........................................................................................... 57
Figura 5.9 Comparación de bibliotecas necesarias para el desarrollo del agente
pizarrón. .................................................................................................................... 58
Figura 5.10 Esquema de funcionamiento de implementación de Owlready +
SPADE. ..................................................................................................................... 60
Figura 5.11Codigo de implementación para el agente remitente. .................... 62
Figura 5.12 Código de implementación para el agente que realiza la función de
agente pizarrón. ........................................................................................................ 63
Figura 6.1Comunicación basada en conocimiento entre agentes robóticos. ... 71
8
1. INTRODUCCIÓN
1.1 Uso de la robótica en la automatización
En los años 60 en México comenzaron a aparecer zonas industriales que en su
mayoría eran del sector automotriz, petroquímico, industria metalmecánica y papel. Con esto
el papel de México pasó a ser el de un país con una fuerte industria manufacturera, lo cual
prevalece hasta la actualidad. México y el mundo en general se han ido adaptando conforme
al paso del tiempo a los cambios en la industria, por lo que el surgimiento de la
automatización ha formado parte de las mejoras de los procesos industriales desde que
sucedió este auge en la industria manufacturera en México.
La automatización sigue siendo una revolución en la industria, tanto en la mejora de
procesos como en la reducción de coste de operaciones. Es tal el impacto de la
automatización actualmente que en los próximos 5 años se espera que 1.54 millones de
empleos se vean afectados por la automatización y 7.19 millones en los próximos 5 y 15
años, representando en conjunto casi el 19% de todos los empleos en México solamente
(Emma Martinho-Truswell et al., 2018).
Claro que toda esta revolución de la automatización no ha sido gracias solamente a
una tecnología, si no que ha ido desde la implementación de motores eléctricos, neumática e
hidráulica, hasta el uso de tecnologías más sofisticadas como la electrónica, sensores, PLC,
computadoras, hasta una de las más importantes y modernas, la robótica. Hoy en día los
robots nos simplifican la realización de muchas tareas que son repetitivas, en las cuales son
mucho más eficientes que los humanos, por lo que ha permitido tener ahorros operativos
como en el caso de Amazon de hasta 20 % (Bhattacharya, 2016).
Por lo tanto, no es sorprendente decir que el uso de robots en la industria ha ido
creciendo en los últimos años, con densidades de 838 robots instalados por cada 10000
empleados sólo en el 2018 en Singapur (IFR, 2019) y en México en 2015 aumentó 6 veces el
número de robots adquiridos con respecto a 2010 (A3 México, 2017). La implementación de
automatización con robots en la industria ya es prácticamente un estándar y las estadísticas
apuntan a que así se mantendrá en los próximos años.
9
Uno de los últimos avances de la robótica para la industria que ha permitido ir de
utilizarlos para ejecutar tareas repetitivas, mecánicas y con casi un total grado de certeza en
las variables, a utilizarlos en trabajos donde se ejecutan tareas sofisticadas con un entorno
estocástico, muy cerca de la complejidad de trabajo que actualmente sólo desempeñan los
humanos, ha sido la integración de la inteligencia artificial (IA) y su subcampo el aprendizaje
automático (Machine Learning). La robótica en conjunto con la inteligencia artificial está
haciendo posible el avance de los sistemas con ejecución de un razonamiento simple, hacia
habilidades cognitivas como los seres humanos (Pérez et al., 2018). La inteligencia artificial
es el campo de la ciencia con el cual a las máquinas se les provee de capacidades de ejecutar
acciones lógicas, de razonamiento, planeación, aprendizaje y percepción.
Una de las definiciones recopiladas por (Russell et al., 2011) en un enfoque racional
dice que la inteligencia artificial es el estudio del diseño de agentes inteligentes que perciben
su entorno e interactúan con él, dejando también claro que la inteligencia de los agentes se
basa en la habilidad que tienes para completar objetivos. Algunos de los algoritmos más
conocidos de inteligencia artificial son (Mata et al., 2018):
• Algoritmos de toma de decisiones (Proceso de decisión de Markov).
• Modelos estadísticos (Redes bayesianas, filtro de Kalman, modelo oculto de
Markov).
• Teoría de juegos.
• Métodos de búsqueda y optimización (Algoritmos genéticos, inteligencia de
enjambre, etc.).
• Métodos basados en el conocimiento, razonamiento y planeación.
• Aprendizaje automático (Aprendizaje supervisado, Aprendizaje no
supervisado, aprendizaje reforzado).
Para ejemplificar cómo se ha hecho el uso de la robótica y la IA en conjunto, en (Ragi
& Chong, 2013) se presenta un algoritmo de planificación de ruta para guiar vehículos aéreos
no tripulados para rastrear múltiples objetivos terrestres basados en la teoría de procesos de
decisión de Markov parcialmente observables, donde el control de la aceleración, estabilidad
10
contra corrientes de viento, evasión de obstáculos y colisiones es hecha en tiempo real. En
Cui et al. (2013) se propone la asignación de tareas para múltiples robots aplicando el
enfoque de negociación basado en la teoría del juego. Pero uno de las ramas principales y
más estudiadas de la IA es el aprendizaje automático (Sadie Bennet, 2019), el cual también
ha aportado recientes avances en la robótica. Jin et al. (2018) presentó el control de un brazo
robótico con ayuda de redes neuronales, el cual aprovecha la característica de procesamiento
en paralelo de las redes neuronales para un control cercano al tiempo real. Una subrama del
aprendizaje automático con la cual se relacionan más la IA y la robótica es el aprendizaje
reforzado, el cual permite el aprendizaje del agente (en este caso robot) en tiempo de
ejecución y en un entorno poco controlado y dinámico como lo es un sistema multirobot
(Matarić, 1997). Long et al. (2018) proponen una política descentralizada de prevención de
colisiones a nivel de sensor para sistemas multirobot, donde cada robot genera su propio
recorrido sin observar el estado ni las acciones de los otros robots.
1.2 Problema a resolver e hipótesis.
El siguiente nivel de la robótica nos lleva a pensar que los robots deben de tener
capacidad para cooperar entre ellos, inteligencia, entre otras capacidades. Con el reciente
resurgimiento del área de la IA y el aprendizaje automático, se prevé que a los robots se les
dote, cada vez de más inteligencia (Nebot, 2018).
La combinación de los robots y la inteligencia puede ser de gran beneficio para la
industria, por ejemplo, dando oportunidad de construir sistemas de manufactura inteligentes
en donde lo sistemas robóticos puedan ser más eficientes, flexibles y reusables (Day, 2018).
La aplicación de estas tecnologías en conjunto también permitirá, como se describe
anteriormente, tener sistemas de múltiples robots trabajando de manera coordinada y
cooperando para cumplir con objetivos tanto individuales como en conjunto.
Otro aspecto que resulta importante destacar, es que los robots no sólo estarán hechos
con un propósito, es decir, no estarán específicamente diseñados para una sola tarea, ya que
con la ayuda de la IA también podrán contar con múltiples propósitos, sólo utilizando los
mismos recursos, así como los humanos pueden ser albañiles o mecánicos, los robots también
podrán tanto acomodar inventario, como ensamblar piezas en un automóvil o buscar
11
productos en un almacén.
Todas las características que un robot obtendrá al implementar IA y ejecutar tareas más
diversas y de manera distribuida se verá también aumentado en complejidad con la cual
trabajarán estos sistemas en un entorno real. Una de las primeras necesidades de estos
sistemas y la que importa a esta tesis es la manera de comunicarse. Los algoritmos de IA
trabajan abstrayendo un conjunto grande de información convirtiéndolo en un concepto
abstracto, por ejemplo, un algoritmo de red neuronal toma una imagen, la cual consiste en
miles de pixeles, cada uno con una cantidad de color rojo, verde y azul, y lo convierte a un
concepto el cual se trata del objeto que más se destaca en la misma imagen. Dado lo anterior,
los sistemas de comunicación actuales entre robots carentes de inteligencia, comunican
información cruda y sin procesar, hacen difícil el acoplamiento de estos sistemas a uno
inteligente en donde se comunica información a alto nivel. Uno de los problemas que aborda
esta tesis es el manejo de la información o conocimiento con los cuales estos agentes
inteligentes trabajan.
Actualmente existen esfuerzos por estandarizar el uso de las ontologías no solo para la
comunicación de robots, sino también para el manejo de tareas, cooperación y coordinación
en ambientes dinámicos (Olszewska et al., 2017), así como impactar en la manera en que los
robots intercambian información ya sea con otros robots o incluso con humanos y que entre
ellos exista un entendimiento que no sea ambiguo.
Con el crecimiento en la complejidad de los comportamientos que se espera que los
robots ejecuten, así como una colaboración entre robots y entre robots y humanos, la
necesidad de una bien definida representación del conocimiento se hace presente en los
actuales desarrollos de robots (Schlenoff et al., 2012).
Dado el problema, la hipótesis que se aborda en este trabajo es la siguiente:
“Utilizando ontologías para la representación de conocimiento que tiene un sistema
multirobot conformado por agentes robóticos inteligentes, se logra una comunicación a alto
nivel necesaria para los retos que representa la implementación de algoritmos de inteligencia
artificial en los robots”
12
1.3 Metodología.
Para la realización de esta tesis y para la validación de la hipótesis, se realizaron las
actividades descritas a continuación:
1.3.1 Investigación de áreas de interés y herramientas disponibles para el desarrollo.
Se realizó una investigación de las áreas que fueron relevantes para esta tesis para la
adquisición del conocimiento necesario y establecer el marco teórico. También se
investigaron los trabajos relacionados a estas mismas áreas que dieran una guía para el diseño
y las implementaciones de este trabajo.
1.3.2 Diseño de agente pizarrón basado en ontologías.
La revisión de los trabajos en las áreas relacionadas durante la etapa de investigación
ayudó a definir las características de un agente pizarrón basado en ontologías que ayudara en
la comunicación entre agentes robóticos en un sistema mutli-robot, además se definió qué
partes lo conformaron y se describió cómo funcionan en un sistema multi-robot.
1.3.3 Pruebas de funcionamiento de las herramientas.
En el desarrollo de este trabajo se ejecutaron pruebas con las herramientas con la
finalidad de verificar si su funcionamiento se adecuaba a las necesidades de diseño del agente
pizarrón, en los capítulos IV y V se presentan algunas pruebas de funcionamiento del manejo
de ontologías y de construcción de agentes para las bibliotecas utilizadas.
1.3.4 Implementación de la comunicación entre agentes.
Se realizó la implementación de la comunicación entre agentes con dos bibliotecas
diferentes, en JADE el enfoque del desarrollo del agente pizarrón fue el de crear un agente
como tal que desempeñara la labor de agente pizarrón gestionando el conocimiento, así que
13
se trató de desarrollar la comunicación del agente, implementándose como cualquier otro
agente, en donde el mismo agente pizarrón tenía un comportamiento que se encargaba de
recibir el mensaje y que recolectaba el conocimiento del contenido del mensaje y lo convertía
en objeto para colocarlo en la base de conocimiento. Se implementó de esa manera porque
resultó difícil implementarlo de manera modular dada la escasa documentación del
framework y se reflejó en el manejo de los objetos de la parte de construcción de ontologías
en JADE, ya que no resultaba tan sencillo como el manejo de los objetos en JAVA, aunque
una de las ventajas que tenía era que la comunicación estaba basada en el estándar FIPA
(Foundation for Intelligent Physical Agents en inglés). La parte de la comunicación de los
agentes en el lenguaje Python fue implementada con ayuda de la biblioteca SPADE (Smart
Python Agent Development Enviroment en inglés), esta implementación descrita en el
capítulo V, se realizó de manera modular al desarrollar la parte de comunicación, como una
prueba del módulo de manejo de ontologías y de conocimiento, por lo que al ser modular
puede formar parte de cualquier agente desarrollado con SPADE y cualquier agente robótico
puede realizar las funciones de agente pizarrón.
1.3.5 Implementación de la construcción de la base de conocimiento basada en ontologías.
La realización de este objetivo fue la principal aportación de este trabajo, ya que aquí
reside la mayor parte de la funcionalidad del agente pizarrón, en el manejo de las ontologías y
el conocimiento. Este se llevó a cabo con dos enfoques algo distintos a causa de la naturaleza
con la cual se pudo llevar a cabo el desarrollo en las dos diferentes bibliotecas utilizadas. Uno
de los enfoques fue el desarrollo con JADE, la cual es una de las más completas herramientas
para el desarrollo de agentes de software con manejo de ontologías, desarrollado en el
lenguaje Java, el enfoque fue desarrollar un agente pizarrón como se describe en 1.3.4, que
dentro de sus comportamientos tuviese el de manejar el conocimiento y las ontologías. El
otro enfoque fue el de desarrollar las funciones del agente pizarrón de manera modular, tal
que cualquier agente en el sistema multi-agente, pudiera ser un agente pizarrón. Esta
implementación fue abordada de esta manera porque Owlready (framework de desarrollo de
ontologías) tiene un manejo de ontologías orientado a objetos, el cual es más fácil de
implementar por las aplicaciones a las cuales está destinado este agente pizarrón. Además,
14
fue desarrollado en Python, uno de los lenguajes más utilizados para el desarrollo de
inteligencia artificial y aprendizaje automático.
1.4 Justificación.
Dentro de las limitaciones técnicas en la implementación masiva de robots en la
industria, Upchurch (2018) señala que aún si fueran resueltos los problemas de la difícil
implementación de los robots fuera de las actividades repetitivas y la falta de flexibilidad a la
hora de ejecutar diferentes tipos de tareas, la falta de plataformas o lenguajes para la
comunicación de las máquinas inteligentes sería también un problema, además del gran
ancho de banda que tendría que existir para el manejo de información que necesitan los
algoritmos de inteligencia artificial para ser útiles.
Estos problemas pueden ser solucionados creando canales de comunicación de
información más abstracta entre los robots, donde lo que se comunica entre las máquinas o
robots es conocimiento y no información a bajo nivel, incluso se podría solucionar el
problema del ancho de banda porque, al comunicarse los robots con conocimiento, pueden
abstraer grandes cantidades de información en tan solo 2 o más conceptos relacionados entre
sí.
.
Lo que nos permite este tipo de comunicación, también, es que habilitan una mayor
cantidad de aplicaciones que resuelvan problemas de manera distribuida aprovechando las
recientes ventajas que puede proporcionar la inteligencia artificial a los sistemas robóticos al
desempeñar tareas casi tan complejas como lo hace el ser humano.
15
2. MARCO TEÓRICO
2.1 Sistemas basados en conocimientos.
Los sistemas de inteligencia de artificial usan técnicas a través de las cuales logra un
nivel experto de competencia en la resolución de problemas de distintas áreas. Tales sistemas,
los cuales usan uno o más tipos de conocimientos para resolver problemas de un determinado
dominio, son llamados sistemas basados en conocimientos o sistemas expertos.
Los sistemas tradicionales de cómputo solo trabajan con datos y/o información
(Akerkar & Sajja, 2010). La figura 2.1 y 2.2 muestran la relación que existe entre los datos,
información, conocimiento y sabiduría.
Figura 2.1Puntos en común desde los datos a la sabiduría.
16
Como parte de los sistemas basados en conocimientos, la base de conocimiento sirve
como repositorio del conocimiento del dominio específico y contiene todo el conocimiento
necesario para la solución del problema. De manera conceptual la base de conocimiento
puede ser vista como una simple base de datos aumentada con reglas que especifican como
interpretar los datos de la base de datos. Una forma de representación del conocimiento que
es adoptada en el área de los agentes son las ontologías, en donde la forma de representar las
reglas antes mencionadas son las relaciones entre todos los conceptos de un dominio
específico.
2.1.1 Ontologías.
En los sistemas multi-agente es importante que todos los agentes que son parte del
sistema puedan comunicarse entre ellos para alcanzar los objetivos en los cuales trabajan de
manera colaborativa. Necesitan interactuar entre ellos para intercambiar necesidades,
resultados, etc., lo que genera la necesidad de que se comuniquen con un lenguaje en común
para el entendimiento mutuo entre los agentes. Es aquí donde las ontologías son usadas para
la comunicación efectiva entre diferentes agentes ya que estas especifican la terminología
Figura 2.2 Pirámide del conocimiento
17
usada y ayuda a establecer el significado de estos mismos términos dentro del conocimiento
de dominio específico (Hadzic et al., 2009).
Aunque el término tiene sus orígenes en las ciencias filosóficas, en el área de
inteligencia artificial y ciencias de la computación, la definición aceptada por la mayoría de
los investigadores del área es la siguiente combinación establecida por Studer et al. (1998) de
la propuesta por Gruber (1993) junto con el término “formal” agregado por Borst (1997):
“Una ontología es una especificación formal y explícita de una conceptualización
compartida“
Una “conceptualización” es una vista del mundo abstracta y simple que se pretende
representar con un propósito y debe ser compartida entre varias partes, de manera que exista
un consenso más que una visión individual. “Formal” se refiere a que la representación del
conocimiento puede ser leída por las máquinas y “explícita” se refiere a que expresa las
definiciones de conceptos y sus relaciones de manera clara y precisa.
Para comunicarse de manera efectiva entre agentes, deben tener una comprensión
común y compartida de los términos utilizados en la comunicación. Los términos deben tener
el mismo significado para todas las partes involucradas en la comunicación. Por ejemplo, la
palabra "metro" para un agente está asociado con el concepto unidad de medida, mientras que
para el otro agente este término está asociado con el concepto de medio de transporte. Se
necesita que todas las partes involucradas en la comunicación comparte la misma ontología y
tiene una comprensión común de todos los términos utilizados en la conversación.
2.1.1.1 Software para el desarrollo de ontologías
Protegé
Los desarrolladores de aplicaciones inteligentes en las diferentes áreas como
biomedicina, comercio electrónico y modelado organizacional enfrentan desafíos para
representar, administrar, compartir y reutilizar el conocimiento requerido por sus sistemas.
Muchos sistemas de razonamiento utilizan enfoques de resolución de problemas que son
18
computacionalmente ineficientes debido a los métodos de razonamiento complejos. Dichos
sistemas son difíciles de construir y mantener porque el conocimiento está contenido en las
ontologías de dominio, así como en el código de la aplicación. Se necesitan metodologías
integrales que integren el dominio y el conocimiento del razonamiento.
Protégé es un entorno de desarrollo de código abierto para ontologías y sistemas
basados en el conocimiento. Es una herramienta que apoya la construcción de ontologías y
también proporciona una plataforma de aplicación para sistemas basados en conocimiento y
bibliotecas para la creación de aplicaciones. Protégé se desarrolla en la Escuela de la
Universidad de Stanford. Es el editor de ontología más conocido con complementos que
admite OWL (Ontology Web Language por sus siglas en inglés).
OWL se ha convertido en un lenguaje estándar para representar el conocimiento en la
Web Semántica. OWL también se basa en lógicas de descripción y admite razonamiento
automatizado. Si una aplicación inteligente se puede plantear como una tarea de clasificación,
OWL proporciona la ventaja de un lenguaje de representación de conocimiento estándar que
puede codificar tanto el conocimiento de dominio como el conocimiento de razonamiento en
forma de axiomas y definiciones de clase.
Protégé OWL proporciona una variedad de características que lo hacen muy útil para
construir ontologías en OWL y aplicaciones inteligentes que usan esas ontologías las cuales
son las siguientes:
• Interfaz gráfica de usuario (GUI) y API. Protégé OWL se basa en el modelo de
conocimiento basado en el marco de Protégé y utiliza la GUI de Protégé para
editar clases, espacios (propiedades) e instancias (individuos). Proporciona una
API que permite a los desarrolladores integrar Protégé OWL en sus aplicaciones.
• Editor gráfico para expresiones lógicas OWL. Protégé OWL proporciona un
editor de expresiones cómodo que permite a los usuarios ensamblar expresiones
rápidamente con el mouse o el teclado. También utiliza una visualización gráfica
orientada a objetos de clases primitivas y definidas.
19
• Asistentes para agilizar tareas complejas. Hay asistentes para admitir patrones
comunes de ingeniería de ontología, como crear grupos de clases, hacer que un
conjunto de clases sea disjunto, crear una matriz de propiedades para establecer
muchos valores de propiedad y crear particiones de valores.
• Acceso directo a razonadores. Protégé OWL proporciona acceso directo a
clasificadores de alto rendimiento como Racer. La interfaz de usuario admite tres
tipos de razonamiento: (1) comprobación de coherencia, (2) clasificación
(subsunción) y (3) clasificación de instancia).
• Soporte para múltiples formatos de almacenamiento. Protégé OWL se puede
ampliar con back-end para formatos de archivo alternativos. Los formatos actuales
incluyen Clips, XML, RDF y OWL.
Owlready
Dado el problema de la dificultad del manejo de ontologías que presentan Olszewska
et al. (2017), estos diseñaron y desarrollaron un módulo para la programación orientada a
ontologías en el lenguaje Python que soporta ontologías en OWL, la cual se enfoca en dos
puntos: el primero es de proveer una sintaxis clara, concisa y fácil de usar, basada en las
notaciones del editor de ontologías de Protegé y la notación de punto que comúnmente es
usada en los lenguajes orientados a objetos. La segunda es proveer de elementos sintácticos
de alto nivel para facilitar la manipulación de clases y un simple algoritmo para un
razonamiento local y cerrado del mundo.
20
La arquitectura consiste en 5 componentes: (1) un grafo de base de datos cuádruple
implementada en una base de datos SQL almacenada tanto en memoria como en archivos en
disco de almacenamiento, (2) meta clases para las clases y constructores de OWL, (3)
archivos Python específicos de la ontología que definen métodos para insertar clases de
OWL, (4) razonador OWL HermiT para realizar clasificaciones automáticas,
La arquitectura consiste en 5 componentes: (1) un grafo de base de datos cuádruple
implementada en una base de datos SQL almacenada tanto en memoria como en archivos en
disco de almacenamiento, (2) meta clases para las clases y constructores de OWL, (3)
archivos Python específicos de la ontología que definen métodos para insertar clases de
OWL, (4) razonador OWL HermiT para realizar clasificaciones automáticas, (5) el motor
SPARQL del módulo de Python RDFlib. Owlready se encarga de importar las ontologías de
la base de datos, dinámicamente carga las sus entidades y las agrupa en los objetos de Python,
de importar los archivos fuente asociados a las ontologías y ejecutar el razonador. Owlready
presenta a los programadores una interfaz unificada, mezclando declaraciones de OWL con
declaraciones de Python. Esta arquitectura soporta grandes ontologías, almacenadas en la
optimizada base de datos cuádruple.
Figura 2.3 Arquitectura general de Owlready propuesta en (Olszewska et al., 2017)
21
2.1.2 Sistema pizarrón.
Un pizarrón se define como una base de datos global que es usada para la resolución
de problemas y es presentada usando la siguiente metáfora:
“Imagine un grupo de especialistas humanos sentados junto a un gran pizarrón. Los
especialistas están trabajando cooperativamente para resolver un problema, utilizando el
pizarrón como lugar de trabajo para desarrollar la solución.
La resolución de problemas comienza cuando el problema y los datos iniciales se
escriben en la pizarra. Los especialistas miran el pizarrón, buscando la oportunidad de
aplicar su experiencia a la solución en desarrollo. Cuando un especialista encuentra
información suficiente para hacer una contribución, registra la contribución en el pizarrón,
con la esperanza de que otros especialistas puedan aplicar su experiencia. Este proceso de
agregar contribuciones al pizarrón, continúa hasta que se resuelva el problema.”
La metáfora anterior menciona las características más importantes de los sistemas
pizarrón como lo son la independencia de las habilidades y de las formas de resolver de los
participantes en el sistema (fuentes de conocimiento), una flexible representación de la
información del pizarrón, un lenguaje de interacción en común, puede ser dividido por
secciones para una búsqueda eficiente y necesita de un control. Los componentes básicos de
un pizarrón son los mostrados en la figura 2.4.
• Las fuentes de conocimiento son módulos independientes que contienen el
conocimiento necesario para resolver el problema. Las fuentes de conocimiento
pueden ser muy diversas en técnicas de representación e inferencia.
• El pizarrón es una base de datos global que contiene datos de entrada, soluciones
parciales y otros datos que se encuentran en varios estados de resolución de
problemas.
• Un componente de control toma decisiones de tiempo de ejecución sobre el curso de
la resolución de problemas y el gasto de recursos para resolver problemas. El
22
componente de control está separado de las fuentes de conocimiento individuales. En
algunos sistemas de pizarra, se implementa el componente de control en sí utilizando
un enfoque de pizarrón.
2.2 Sistemas basados en agentes.
2.2.1 Cooperación y colaboración de agentes
2.2.1.1 Agentes
Un agente es cualquier cosa capaz de percibir su medio ambiente con la ayuda de
sensores y actuar en este medio usando actuadores como lo muestra la figura 2.5. Un agente
humano tiene ojos, oídos y otros órganos que funcionan como sensores y partes del cuerpo
como los dedos y los brazos para actuar. Un robot es un agente que capta información
mediante cámaras y sensores ultrasónicos, y actúa utilizando su brazo robótico o cualquier
Figura 2.4 Arquitectura de sistema pizarrón
23
actuador con el que cuente para cumplir su funcionalidad. Se puede decir que el agente
tomara decisiones de actuar dependiendo de las percepciones, este es el comportamiento de
un agente y en términos matemáticos es la función que representa a un agente, es decir, dado
que el agente percibió “X” su salida o acción será “Y”.
Un agente racional es el que busca la mejor función que le ayude a alcanzar un mejor
resultado en el cumplimiento de objetivos. Un agente también es considerado omnisciente
porque conoce el resultado de su acción y actúa de acuerdo con él, aunque en la realidad la
omnisciencia no es posible. Un agente también es programado con un conocimiento inicial y
a lo largo de su existencia recopila más conocimiento del cual aprende, pero si se apoya más
en este conocimiento inicial que en el aprendido se dice que carece de autonomía. Los
agentes ponen a prueba su racionalidad en entornos de trabajo con distintas propiedades para
las cuales los agentes están diseñados como lo son:
• Totalmente o parcialmente observables
• Determinista o no determinista
• Episódico o secuencial
• Estático o dinámico
• Discreto o continuo
• Agente individual o multiagente
Figura 2.5 Esquema de funcionamiento de un agente (V. Botti, 1999).
24
La estructura de un agente se compone de dos elementos los cuales son arquitectura y
programa. La arquitectura de un agente se refiere al lugar donde es alojado el agente, por
ejemplo, una computadora, un robot móvil o un automóvil. El trabajo de la inteligencia
artificial es diseñar el programa del agente que implemente la función de este. Los cuatro
tipos de programas básicos que un agente puede tener son:
• Agente reactivo simple
• Agente reactivo basado en modelos
• Agente basado en objetivos
• Agentes basados en utilidad
2.2.1.2 Sistemas multi-agente
Los sistemas multiagente son una extensión de las tecnologías de agentes donde un
grupo de agentes autónomos débilmente acoplados actúan en un ambiente para alcanzar
objetivos en común. Esto es realizado de manera cooperativa o competitiva, compartiendo o
no compartiendo conocimiento con los otros agentes. Estos sistemas han sido ampliamente
adoptados por las ventajas que ofrecen como el incremento de eficiencia debido a la
paralelización de la ejecución de las tareas, su escalabilidad y flexibilidad, costo reducido y
reusabilidad. Pero los sistemas multiagente también representan algunos desafíos. Uno de los
más importantes es que el ambiente en donde se desarrollan es modificado no solo por el
mismo agente, también es modificado por los demás, por lo que existe la necesidad de inferir
lo que los otros agentes han modificado.
2.2.1.3 Comunicación en sistemas multi-agente
La comunicación es uno de los componentes cruciales en los sistemas multiagente.
Una comunicación redundante o innecesaria puede incrementar el costo y causar
inestabilidad. Basado en la comunicación de información entre agentes, la comunicación de
los sistemas multiagente pueden clasificarse entre comunicación local o paso de mensajes y
comunicación en red o pizarrón.
25
La comunicación local no tiene lugar para almacenar la información y no hay medios
de comunicación intermedios presentes para actuar como facilitadores. El término
transmisión de mensajes se utiliza para enfatizar la comunicación directa entre los agentes.
En este tipo de comunicación, el flujo de información es bidireccional y crea una arquitectura
distribuida y reduce el cuello de botella causado por la falla de los agentes centrales.
Otra forma de intercambiar información entre agentes es a través de pizarrones (figura
2.6). En la comunicación pizarrón, un grupo de agentes comparte un depósito de datos que se
proporciona para el almacenamiento y la recuperación de los datos compartidos entre los
agentes. El repositorio puede contener tanto los datos del sistema como el conocimiento al
que pueden acceder los agentes. El tipo de datos a los que puede acceder un agente puede
controlarse mediante el uso de un mecanismo de control. Este mecanismo actúa como una
alarma que notifica al agente cuando hay datos relevantes disponibles en el repositorio. El
control se puede programar para establecer diferentes tipos de coordinación entre los agentes.
Figura 2.6 Arquitectura de comunicación de agentes mediante pizarrón.
26
2.2.1.4 Software para el desarrollo de sistemas multi-agente
JADE
La Fundación para Agentes Inteligentes Físicos (o FIPA por sus siglas en inglés) fue
creada en 1996 como una asociación internacional sin fines de lucro, con el objetivo de
producir una especificación estándar para la tecnología de agentes heterogéneos que
interaccionen entre sí y sistemas basados en agentes. El proyecto que llevó a la creación de
JADE, empezó a finales de 1998 propulsado por Telecom Italia como una implementación
que buscaba validar las especificaciones iniciales creadas por FIPA. Este proyecto se
distribuye bajo la licencia de código abierto LGPL (Lesser GNU Public License) en su
versión 2.1.
JADE es un framework de agentes móviles de software, ya que permite crear agentes
específicos para satisfacer las necesidades del usuario que lo utiliza. Además del framework
para el desarrollo de agentes, JADE ofrece una plataforma donde estos podrán ser ejecutados.
está compuesta por contenedores que pueden estar distribuidos en la red y proveen todos los
servicios necesarios para albergar y ejecutar los agentes. Los agentes son las entidades con
las cuales JADE representa a los agentes móviles de software. Existe un contenedor especial
conocido como el contenedor principal que representa el punto de inicio de la plataforma, es
decir, es el primer contenedor en ser lanzado y todos los demás contenedores que vayan a
pertenecer a la plataforma deben registrase con este.
Para la comunicación entre contenedores de la misma plataforma, JADE dispone de
un protocolo interno de transporte de mensajes (Internal Message Transport Protocol o
IMTP). Este es utilizado tanto para el envío de mensajes entre agentes, como también para el
de comandos internos necesarios para la administración de la plataforma distribuida y el
monitoreo del estado de los contenedores. Actualmente se ofrecen dos implementaciones de
IMTP con JADE, una que está basada en Java RMI y LEAP que utiliza un protocolo
propietario sobre conexiones TCP. JADE permite elegir al lanzar la plataforma cual IMTP se
utilizará y, además, ofrece un conjunto de configuraciones para ajustar el IMTP a las
características específicas de la red y dispositivos sobre los que se despliegue la misma.
27
En JADE, el concepto de agente de software se define como un proceso
computacional que habita una plataforma y, por lo general, ofrece uno o más servicios que
pueden ser publicados mediante una descripción del mismo. Un agente en JADE tiene las
siguientes propiedades:
• Identidad única entre todas las plataformas.
• Reside en un contenedor.
• Se compone de comportamientos que es la lógica con la que se ejecutan.
• La comunicación con otros agentes es asíncrona.
Cada agente cuenta con una casilla de mensajes (bandeja de mensajes) en la cual el
entorno de ejecución de JADE pone los mensajes enviados por otros agentes, quienes solo
deben indicar el identificador del destinatario y cuando un mensaje es puesto en la casilla de
mensajes, el agente destinatario es notificado de forma tal que pueda reaccionar al evento. Sin
embargo, dado que se trata de un modelo asincrónico, no está determinado cuando el receptor
manejará el mensaje e, incluso, puede no hacerlo, siendo esto solo determinado por la lógica
interna de dicho agente.
SPADE
SPADE es una plataforma de agentes basada en Python basada en el protocolo XMPP
que sigue el estándar de FIPA. La biblioteca proporciona un amplio conjunto de funciones
basadas en la comunicación, así como el procesamiento adecuado del agente asíncrono. Esta
plataforma es un muy buen ejemplo de sistema abierto de múltiples agentes que admite la
distribución y la posibilidad de ejecución paralela de agentes. Como los agentes SPADE
"existen" en servidores XMPP normales pueden interactuar sin ningún problema con
personas, así como con otros agentes.
El manejo del protocolo XMPP y la interacción asíncrona servidor-cliente son
administrado por la biblioteca de Python aioxmpp. La ejecución paralela del agente es
proporcionada por la biblioteca popular asyncio. El uso de estos paquetes está entrelazado
en la mayoría de las funcionalidades de SPADE: mensajería, facilitación de directorios
(manejo de la lista de agentes, sus identificadores únicos y proporcionar esta información a
pedido para otros agentes) y gestión de presencia.
28
Los comportamientos que forman la funcionalidad del agente son ejecutados en hilos
en paralelo y cada comportamiento tiene su bandeja de mensajes.
29
3. DISEÑO DE AGENTE PIZARRÓN PARA SISTEMAS MULTI-
ROBOT.
3.1 Definición de una base de conocimiento en común.
Ya que el uso de tecnologías de sistemas basados en conocimiento en su mayoría es
implementado en los sistemas basados en agentes de software, y los robots pueden ser
modelados como agentes, se optó por investigar tecnologías de manejo y modelado del
conocimiento en agentes de software, lo cual llevó a encontrar algunas diferentes opciones
para el manejo del conocimiento. En la investigación realizada por Bimba et al. (2016), se
estudiaron diferentes tecnologías para el manejo y modelado del conocimiento para sistemas
de software, los cuales dividieron en 4 diferentes categorías como lo muestra la figura 3.1.
Esta misma investigación presenta una evaluación y comparación entre las 4
categorías, donde se describe que la principal ventaja de la ontología es proveer de una
plataforma que facilite el compartir y reusar el conocimiento entre grupos de agentes. La
Figura 3.1 Diferentes categorías de modelos para modelado de bases de conocimiento.
30
ontología es una herramienta popular entre los sistemas de conocimiento para agentes ya que
tiene ventajas que ayudan al fácil manejo de conocimiento entre agentes (Sanz, 2007),
algunas son:
1. Ayudan a definir un vocabulario y una estructura clara del conocimiento
2. Ayudan a la escalabilidad de las bases de conocimiento
3. Proveen de una base para la interoperabilidad entre agentes
4. Permite compartir y reusar el conocimiento
Para ejemplificar cómo es que una base de conocimiento basada en ontologías puede
ayudar a la resolución de problemas de razonamiento de conceptos de alto nivel, Zhao et al.
(2016) presenta la implementación de un sistema de toma de decisiones para el control de
tráfico en intersecciones para vehículos autónomos, el cual realiza razonamiento en tiempo
real usando las leyes de tráfico y la información de la base de conocimiento basada en
ontologías, la cual es alimentada por los datos de los sensores de los autos. Para el caso de
este trabajo, un posible escenario en donde se tenga un sistema multi-robot podría ser los
robots móviles que ejecuten tareas de ensamblado de autos, pueden emplear un sistema
similar para convertir los datos de sus sensores en conocimiento que les ayude a tomar
decisiones en las tareas que tengan por cumplir, así como para comunicarse con los otros
robots usando como base ese mismo conocimiento, y lograr una comunicación a alto nivel
casi como la de los seres humanos.
De ese modo, se optó por implementar una base de conocimiento basada en
ontologías, para lo cual también se realizó una investigación en las tecnologías disponibles
para su implementación. Una de las más populares es Protegé, como se describe en el
capítulo II, es un editor de ontologías de código abierto. Protegé no fue de gran utilidad para
este trabajo ya que sólo es un editor de ontologías, las cuales sólo pueden ser creadas de
manera manual con el software que proporcionan sus creadores. Uno de los objetivos fue que
el agente pizarrón del sistema multi-robot pudiera manejar de manera dinámica la ontología
de la base de conocimiento, es decir, que pudieran agregar, eliminar y cambiar conceptos y
relaciones en la ontología. Una de las ventajas al tener la facultad de editar la ontología de la
base de conocimiento de manera dinámica es que los agentes pueden mejorarla o adaptarla de
acuerdo a sus necesidades, o si un agente robótico nuevo se integra al sistema multi-robot y
31
tiene más o distintos conocimientos, pueda agregarlos sin problema a la base de conocimiento
de todo el sistema multi-robot, para tener el sistema multi-robot mejor adaptado posible.
Otra de las desventajas de Protegé son las necesidades de las aplicaciones, descritas en
el capítulo I, para las cuales está dedicado este trabajo, puntualmente en la facultad que deben
de tener los agentes para fácilmente construir la ontología desde el software que se utiliza
para la aplicación misma. Con la finalidad de una fácil implementación del agente pizarrón
en las aplicaciones de los diferentes sistemas multi-robot en donde se desempeñe, se tiene
como un requisito que la aplicación del agente como tal sea totalmente compatible con la
aplicación del sistema multi-robot y buscar que todas las funcionalidades escritas en el
código del agente pizarrón puedan ser usadas por las aplicaciones del sistema. Esto con el fin
de ofrecer las funcionalides del agente pizarrón de manera sencilla al número creciente de
aplicaciones robóticas que usan algoritmos de inteligencia artificial, tales como
reconocimiento de objetos, aprendizaje reforzado, clasificación etc. Entonces se definió que
las funciones para el manejo de la ontología estuvieran implementadas en el mismo lenguaje
que las aplicaciones basadas en agentes. Para realizar esto también se investigaron diferentes
herramientas de software disponible que permitieran la construcción de ontologías. Las
tecnologías con documentación suficiente para el desarrollo de las funciones para el manejo
de ontologías fueron JADE (Telecom Italia SpA, 2019) y Owlready (LIMICS research lab,
2019).
En el caso de JADE, es definido como un framework para el desarrollo de agentes
implementado en lenguaje Java y es una de las más populares a la hora de desarrollar agentes
que manejen ontologías. También, cuenta con herramientas de comunicación de agentes las
cuales son el atractivo para este trabajo. JADE cumple con los estándares de la fundación de
agentes físicos inteligentes, FIPA, la cual define el formato de los mensajes para
comunicación de agentes. Dentro de este estándar uno de los parámetros del mensaje es la
ontología, la cual ellos describen sirve para la semántica del contenido del mensaje. Por lo
tanto, JADE al cumplir con los estándares de FIPA cuenta con herramientas para el uso de
ontologías.
Owlready es un poco diferente a JADE, se trata de una biblioteca para manipular
ontologías en formato OWL, RDF y N-Triples en lenguaje Python. Con Owlready se pueden
manipular clases e instancias como si fuesen objetos de Python. Se trata de una biblioteca
enteramente para el manejo de ontologías en los formatos más usados para este propósito,
32
esto mediante código escrito en lenguaje Python y su paradigma orientado a objetos. A
diferencia de JADE, Owlready no proporciona herramientas para la construcción de agentes,
pero si cumple con la facilidad de modificación de ontologías a través de código, por lo que
también fue considerado. Para resolver la falta de herramientas de construcción de agentes
por parte de Owlready, también se investigaron herramientas en el mismo lenguaje que
cumplieran con esas funciones y dentro de la búsqueda se encontró SPADE (Smart Python
Agent Development Environment en inglés). SPADE es una plataforma de construcción de
sistemas multiagente basada en mensajería instantánea con el protocolo XMPP y escrita en
Python. Esta plataforma también permite modelar agentes basado en comportamientos y
soporta el envío de mensajes con las especificaciones de FIPA, al igual que JADE.
En el capítulo III, se describe cómo es que se llevaron a cabo las implementaciones de
ontologías en JADE, así como qué cuestiones surgieron a la hora de integrarlo con el agente
pizarrón. En el capítulo IV se describen también las implementaciones con las herramientas
en lenguaje Python: Owlready y SPADE. Se decidió que en este trabajo se implementarían
las dos opciones para obtener también información de qué posibilidades, ventajas y
desventajas existen con los dos enfoques actualmente para el desarrollo de sistemas robóticos
basados en el conocimiento, descritos como parte del capítulo IV, ya que los recientes
grandes pasos de la inteligencia artificial nos podrían dar mejor toma de decisiones a la hora
de elegir tecnologías en comparación con hace algunos años.
3.2 Definición de la comunicación de los agentes robóticos con el agente pizarrón.
En el significado de comunicación del sistema multi-robot basado en el conocimiento,
existen dos tipos de comunicación las cuales son totalmente diferentes una de la otra en
cuanto al propósito, ya que uno de los tipos de comunicación es para el manejo de la base de
conocimiento como lo muestra la figura 3.3 y el otro es para el paso de mensajes entre los
agentes robóticos con el propósito de cumplir los objetivos individuales y en común entre los
mismos agentes, como se muestra en la figura 3.2.
Para lo que a este trabajo le compete, los esfuerzos solamente se enfocaron en el
desarrollo de la comunicación para el manejo de la base de conocimiento, pero como un buen
33
resultado de este mismo trabajo, la misma comunicación que se usó para el manejo de la base
de conocimiento también se podría usar para el paso de mensajes entre agentes, de hecho, las
primeras pruebas para la evaluación de la herramienta JADE descritas en el capítulo IV
también sirvieron de ejemplo para la comunicación con el agente pizarrón para el manejo de
la base de conocimiento.
Un agente que tenga la capacidad de manejar todo el conocimiento de un sistema
multi-robot fue el objetivo de este trabajo, este se encarga de recopilar el conocimiento
adquirido por cada uno de los agentes robóticos y convertirlo en una base de conocimiento.
Para que este agente lograra cumplir con este objetivo, una de las más importantes
características es que tuviese la facultad de poder comunicarse con cada uno de los agentes en
su entorno de trabajo.
Figura 3.2 Modelo de comunicación de paso de mensajes entre agentes.
34
Para ésto en las primeras etapas de la investigación de este trabajo se planeó el
desarrollo de un agente que centralizara totalmente la comunicación para la recopilación de
todo el conocimiento como es propuesto en la figura 3.3, es decir, todos los agentes del
entorno que quisieran trabajar de cualquier manera con la base de conocimiento, tendrían que
comunicarse directamente con este agente. Una de las ventajas de una comunicación
centralizada sobre un sistema de paso de mensajes entre agentes consiste en evitar los
conflictos que se pudiesen generar a la hora de comunicar el conocimiento, por ejemplo, si
dos agentes quisieran aportar a la base de conocimiento ideas que sean complementarias entre
sí al mismo tiempo, la toma de decisiones para saber cuál es el conocimiento verdadero sería
conflictiva.
La desventaja que representó este sistema centralizado es que su implementación en
agentes robóticos era un problema a la hora de que ocurriera una falla en el agente que lo
haga quedar fuera del sistema. Por ejemplo, si el agente robótico que tiene la función de
pizarrón por alguna razón deja de funcionar, todo el sistema de recopilación y la misma base
de conocimientos quedarían fuera a causa de la baja del agente encargado, lo que podría
ocasionar fallas en todo el sistema.
Figura 3.3 Modelo de comunicación centralizado para el acceso a la base de conocimiento.
35
Se podría decir que la anterior situación es similar cuando falla un servidor, si éstos
por alguna razón fallan, se cae el sistema completo, afectando todas las aplicaciones que
estaban alojadas en él. Pero para contrarrestar este problema, se creó un módulo que pudiese
implementar cualquier agente del sistema multi-agente, así en este caso se puede suplir la
función de agente pizarrón en caso de una falla del agente robótico que estuviese a cargo en
ese momento.
Este módulo como se muestra en la figura 3.4, proporciona una interfaz a través de la
implementación de los métodos del módulo y permite a cualquier agente dentro del sistema
tener la responsabilidad de realizar funciones como agente de pizarrón, quedando cubierto el
Figura 3.4 Modelo de comunicación modularizado.
36
problema de tener agentes de respaldo si por alguna razón el agente pizarrón a cargo deja de
funcionar.
En resumen, lo que se implementó fue un agente pizarrón que se encargara de recibir
los mensajes de todos los demás agentes robóticos para extraerlo el conocimiento del mensaje
y añadirlo a la base de conocimiento basada en ontologías. Además, el agente pizarrón
también tiene la función de responder a los agentes robóticos que necesiten hacer uso de la
base de conocimiento para comunicarse con otros agentes robóticos, ayudándose de la base
de conocimiento para construir el contenido de los mensajes.
El capítulo IV describe los pasos a detalle de cómo se llevó a cabo la implementación
del agente pizarrón con el framework JADE y el capítulo V describe también cómo se llevó a
cabo la implementación con la biblioteca Owlready.
3.3 Descripción del funcionamiento del agente pizarrón en el sistema multi-robot.
Para describir el funcionamiento del agente pizarrón, a continuación, se propone un
escenario de uso posible que se muestra en la figura 3.5. A un agente pizarrón se le sitúa en
un almacén donde trabajan n cantidad de agentes robóticos, los cuales tienen a cargo la
gestión del almacenamiento de productos. Dentro de las funciones realizadas por los agentes
robóticos está la de estar pendientes de qué zonas del almacén están vacías y disponibles para
almacenar productos que lleguen. Pero no sólo un agente robótico estará a cargo de esta
función, si no todo el equipo de robots, mientras realicen trabajos por todo el almacén, tienen
que estar pendientes de los espacios vacíos, como si de un trabajador humano se tratase.
Entonces uno de los agentes robóticos, por medio de algoritmos de visión detecta que todo un
estante está vacío y disponible para almacenar producto. Este mismo agente construye un
mensaje basado en la ontología que tengan para describir su ambiente, para enviárselo al
agente pizarrón y que éste ponga el conocimiento a disposición de los demás agentes
37
robóticos. En este punto es conveniente describir que hay varios tipos de funciones que puede
realizar el agente pizarrón según la intención del agente robótico interesado en interactuar
con el agente pizarrón y son:
• Aportar conocimiento: Esta función permite crear un nuevo conocimiento a
partir de la ontología con la que trabajen los agentes robóticos, creándose una
instancia en la base de conocimiento usando los conceptos necesarios para
describir el nuevo conocimiento a aportar.
• Checar conocimiento: Esta función permite comparar si un conocimiento en la
base de conocimiento del agente pizarrón está vigente, es decir, revisando si la
instancia de este conocimiento existe en el agente pizarrón.
• Eliminar conocimiento: Esta acción es requerida cuando se requiere eliminar
un concepto de la base de conocimiento, eliminando la instancia de la base de
conocimiento.
• Cambiar conocimiento: Para cambiar un conocimiento nuevo por uno ya
existente en la base de conocimiento, es usada esta función. Primero es
agregada la nueva instancia y después es eliminada la ya existente en la base
de conocimiento.
• Nuevo concepto: Esta función permite agregar un nuevo concepto a la
ontología creando un nuevo objeto en el código de la ontología.
• Nueva propiedad: Esta función permite agregar una nueva propiedad con la
cual se relacionan dos o más conceptos en la ontología, creándose también un
nuevo objeto representando esta propiedad.
• Eliminar concepto: Esta función permite eliminar un concepto de la ontología,
así como el objeto asociado a este.
• Eliminar propiedad: Esta función permite eliminar un concepto de la
ontología, así como el objeto asociado a esta propiedad.
Después de recibir el mensaje, el agente pizarrón lo convierte de formato cadena a
formato objeto para que sea almacenado en la base de conocimiento, la cual en este caso es la
memoria de la que hace uso el código.
38
Figura 3.5 Funcionamiento de sistema multi-robot con un agente pizarrón para crear un nuevo
conocimiento.
39
4. IMPLEMENTACIÓN DE AGENTE PIZARRÓN CON JADE
En este capítulo se describen las implementaciones realizadas con JADE, se inicia
presentando las primeras interacciones que se tuvieron con este framework, en donde primero
se prueba el simple paso de mensajes para revisar cómo es que sería la comunicación por
mensajes entre los agentes robóticos y el agente pizarrón, después se empieza a interactuar con
la parte de construcción de ontologías y cómo es realizada, así como la construcción de los
mensajes basados en las ontologías. Para finalizar se describen los resultados y conclusiones
obtenidos en la implementación del agente pizarrón.
4.1 Pruebas Iniciales: Implementación de traslado de mensajes.
Con el fin de probar el funcionamiento de la comunicación entre agentes de JADE se
realizó un primer ejemplo de comunicación entre dos agentes en un mismo contenedor como
se muestra en la figura 4.1. Se creó una clase Java representando al agente Thomas, en la cual
a su vez se creó una clase describiendo un comportamiento que se ejecuta de manera cíclica
que arma un mensaje y se lo envía al agente Manuel. De la misma manera se creó una clase
que representa al agente Manuel y que anida a otra clase que describe también un
comportamiento cíclico que está a la espera de cualquier mensaje recibido para imprimirlo en
consola.
40
Después se implementó otra prueba comunicando dos agentes desde dos contenedores
diferentes como se muestra en la figura 3.2. Este ejemplo, es el mismo que el anterior en
cuanto a las clases creadas, la única diferencia es que uno de los agentes se cambió de
contenedor.
Figura 4.1 Esquema de funcionamiento de la primera implementación de paso de mensajes con JADE.
Figura 4.2 Esquema de funcionamiento de paso de mensajes con agentes en diferentes contenedores.
41
Lo anterior fue implementado en una misma computadora, pero separando a los
agentes por contenedores, esto con el fin de poder tener la posibilidad de mudar a los agentes a
otra máquina. La figura 4.3 muestra la interfaz creada por JADE al separar los agentes por
contenedores y la figura 4.4 muestra los mensajes impresos por el agente 002 los cuales recibe
del agente 001.
Figura 4.3 Interfaz generada por JADE con agentes en diferentes contenedores.
Figura 4.4 Mensajes impresos en consola de agentes en diferentes contenedores.
42
4.2 Ontologías con JADE.
Después de las primeras pruebas realizadas se siguió con la implementación de
ontologías para representar el conocimiento que se iba a comunicar entre los agentes. Una de
las principales características en el desarrollo de ontologías con JADE, es que la ontología se
divide en dos partes: la primera en la cual se describe todo el vocabulario a través de todos los
conceptos posibles que sean necesarios para construir la ontología y la segunda es en donde se
definen las relaciones entre todos los conceptos definidos en la parte anterior, estas relaciones
definen la semántica y la estructura de la ontología.
El propósito principal del desarrollo de una ontología fue poder ir evaluando el
desarrollo que se hacía en el agente pizarrón, y ver cómo se comportaba el agente ante los
distintos cambios en la implementación, por lo que el área de la ontología fue meramente
complementaria para este trabajo, aunque con la intención de que cualquier persona en el área
de robótica pudiese relacionar el trabajo, se desarrolló una ontología tratando de imitar el
ambiente de uno de los sistemas robóticos con más impacto en la actualidad, el cual es el de
manejo de almacenes de la empresa Amazon. La ontología describe de manera simple, para
efectos prácticos de este trabajo, un almacén que está compuesto por estantes en donde son
almacenados los productos que los robots tienen que identificar, para posteriormente ejecutar
la acción de traerlos. La figura 3.5 ejemplifica cómo está estructurada la ontología de ejemplo.
43
Como se mencionó anteriormente, una de las partes de este desarrollo, es la
declaración del vocabulario de esta ontología. Todos los conceptos, acciones y predicados se
declararon en la misma clase “Almacén” y se inicializan en el constructor de esta misma clase,
así como otros conceptos que están relacionados al mismo concepto sin definir cuál es la
relación entre ellos. La parte en la cual se definen las relaciones entre cada uno de los
conceptos de la ontología consiste en crear un “Schema” de uno de los dos tipos diferentes de
relación, ya sea por un “ActionSchema” con el cual se definen las relaciones del tipo acciones,
por ejemplo, la acción de “Traer” relaciona al robot con el producto, o la otra opción sería por
“PredicateSchema” con el cual se definen las relaciones de tipo predicado, por ejemplo
“EstaEn” relaciona al producto y al estante. Una parte importante que se debe declarar en el
código de la ontología es el acceso a la modificación de los atributos de cada uno de los
conceptos y relaciones, para que los agentes puedan instanciar cada uno de los conceptos y
crear instancias específicas según su conveniencia, esto se logra a través de la declaración de
cada uno de los conceptos en una clase, la cual contiene los métodos necesarios para acceder a
Figura 4.5 Estructura de ontología de ejemplo para la implementación de ontologías con JADE
44
la modificación de cada uno de los atributos que formarán las instancias de cada uno de los
conceptos, que es lo que ya podrán comunicar cada uno de los agentes, entonces la declaración
de cada uno de los conceptos y relaciones de la ontología es un molde y este molde se va
llenando con las instancias y las relaciones entre estas para formar el mensaje que se comunica
al agente pizarrón, para que en teoría este agente lo tome y lo almacene en la base de
conocimiento. La estructura del código de la ontología en JADE se puede visualizar en la
figura 4.6
Figura 4.6 Diagrama UML de clases implementadas para ejemplo de uso de ontologías
con JADE.
45
Usando el mismo ejemplo de la figura 3.2 se implementó la comunicación, pero ahora
con ontologías, la diferencia ahora es que el contenido del mensaje se arma basado en la
ontología. En este ejemplo se armó un mensaje que comunicó que en el estante con número
2526 que se ubica en el área de producción, está un producto con el nombre de “libro”.
Primero, se creó un objeto de tipo estante al cual se le asignan los atributos de número y
ubicación. Luego se crea un objeto tipo producto y se le asignó el nombre, después a un objeto
del tipo “EstaEn” se le asignaron los dos atributos, el dominio (el cual es el producto), y el
rango (que es el objeto de tipo estante). Entonces, el mensaje final que quedó armado fue el
objeto “EstaEn”, que contenía a los otros objetos anidados. El envío del mensaje que resultó
de la ontología no puede realizarse como en el ejemplo de la figura 4.2, ya que no es una
cadena de caracteres, se trata de un objeto, por lo que para este tipo de mensajes, JADE
necesita de un manejador de contenido, que es un objeto de esta biblioteca que ayuda a armar
el mensaje, por lo que este mensaje ya después de asignar los otros parámetros como lo son la
performativa, el lenguaje, el nombre de la ontología, etc. se pasa como parámetro al objeto del
manejador de contenido, para después mandarlo a otro agente. Del lado del agente receptor se
recibió el mensaje de la misma manera que en el ejemplo de la figura 4.2, pero para abrir el
contenido, también se tiene que hacer uso del manejador de contenido. El contenido del
mensaje está en el formato que muestra la figura 4.7.
Figura 4.7 Mensaje impreso en consola del resultado de la implementación de ontologías con JADE en formato FIPA-SL (FIPA Semantic language).
46
4.3 Agente pizarrón con JADE.
La realización de el agente pizarrón fue hecha en el orden de las funciones que se iban a
ejecutar conforme el funcionamiento descrito en el capítulo anterior, por lo que primero se
implementó la funcionalidad que tenía que tener el agente pizarrón para recibir los mensajes
de los agentes robóticos. Los mensajes se reciben en formato ACL y su contenido está
construido en base a la misma ontología de ejemplo usada en secciones anteriores.
Para que el agente pizarrón tuviese la facultad de estar a la espera de mensajes de los
agentes robóticos se implementó un comportamiento que se dedicara sólo a este propósito,
esto traducido a código se realizó como se muestra en la figura 4.8.
El paso siguiente por realizar, fue el preparar el conocimiento contenido en el mensaje
para anexarlo en la base de conocimiento, por lo cual se procedió a convertir a objeto el
contenido para guardarlo en la memoria del programa. Este paso fue el que hizo evidente la
escasa documentación sobre el manejo de ontologías con JADE, ya que de alguna forma se
buscaba que cualquier concepto y cualquier relación basada en la ontología contenida en el
mensaje pudiese ser instanciada como objeto, el problema fue que lo que la documentación
(Bellifemine et al., 2007) y algunos ejemplos (Ambroise Ncho, 2003) encontrados sugirieron
que para convertir el mensaje a un objeto, ya se tenía que saber por anticipado de qué tipo o
clase eran los conceptos y relaciones que se reciben, por lo que esta parte de convertir de
manera dinámica el mensaje a objeto según el contenido del mensaje no pudo ser completada
con éxito. Para ejemplificar el cómo es que los ejemplos ejecutan esta acción de convertir el
mensaje a objeto se muestra la figura 4.9 en donde se muestran las ediciones realizadas al
código en la figura 4.8.
47
A partir de la línea 66 de la figura 4.9, se añadieron 4 líneas para que el contenido del
mensaje fuese convertido a objeto. Primero en la línea 66 el contenido sustraído por el
manejador de contenido es preconvertido a tipo predicado, después en la línea 67 el convertido
a el objeto que define la relación EstaEn. Después, en la línea 68 de la relación EstaEn se
obtiene el estante y se guarda en un objeto de tipo Estante, el cual representa el dominio y en
la línea 69 se obtiene el producto y se guarda en un objeto de tipo Producto. El problema con
lo anterior es que no se encontró una manera de tener una clase que definiera un concepto
genérico para convertir cualquier concepto y relación contenida en los mensajes a un objeto
para así poder guardarlo en la base de conocimiento.
Figura 4.8 Código implementado para la recepción de mensajes del agente pizarrón en JADE.
48
Dado lo anterior, la investigación se vio afectada por la escasa documentación del
framework JADE y por ende se buscaron otras alternativas para poder desarrollar la
implementación completamente. La siguiente parte de la investigación continuó con un
enfoque en el lenguaje de Python.
Figura 4.9 Código implementado para la recepción de mensajes del agente pizarrón y transformación del mensaje a objeto en JADE
49
5. IMPLEMENTACIÓN DE AGENTE PIZARRÓN CON OWLREADY
En este capítulo se describe la implementación del agente pizarrón en Python, como
consecuencia del cambio de enfoque por problemas antes descritos con la implementación en
JADE. De las primeras tareas realizadas al empezar la investigación de herramientas con el
lenguaje Python fue encontrar una que tuviese igual o mayor capacidad que JADE,
desafortunadamente el desarrollo de herramientas para el manejo de agentes y ontologías en
una misma herramienta en Python no fue fructífero. Dado lo anterior se optó por buscar por
separado, es decir, se investigaron herramientas exclusivamente para desarrollar agentes y
herramientas para el manejo de ontologías. Bajo esta metodología se encontró un artículo
(Lamy, 2017) que proponía una biblioteca o módulo a alto nivel para el manejo de ontologías
en formato OWL, la cual integra el modelo del formato OWL al formato de manejo de objetos
de Python.
5.1 Construcción de una ontología con Owlready2
Para realizar las pruebas de funcionalidad de Owlready se empezó por construir una
pequeña ontología para realizar pruebas al igual que en el capítulo IV donde se desarrolló
también una ontología para hacer pruebas de funcionalidad al framework JADE. Entonces
siguiendo la pequeña introducción en la documentación disponible de Owlready, se declararon
los conceptos y las relaciones de la ontología de la manera en que se muestra en la figura 5.1.
En la línea 1 se importa la biblioteca completa y en la línea 4 se obtiene una ontología vacía de
prueba pasándole por parámetro el IRI (Internacionalized Resource Identifier) de la ontología,
este IRI es el que está disponible por defecto para pruebas.
50
En la línea 6 se trabaja con el archivo que contiene a la ontología y es accesado para que
a partir de la línea 7 a la 25 se declaren los conceptos y relaciones de la ontología. Para crear
un concepto en la ontología se declaró una clase vacía con el nombre del concepto como
nombre de la clase, existen opciones en Owlready para que el nombre en el archivo de la
ontología y el nombre del concepto no sean iguales que la clase para casos en donde el
Figura 5.1 Código de ontología implementada en Owlready.
51
concepto o relación tenga más de una palabra. En la declaración de las relaciones como por
ejemplo esta_en es necesario declarar el dominio y el rango como es representado en la figura
5.2. Cabe destacar, que tanto en el rango representado en la clase como el atributo range, como
el dominio representado con el atributo domain, pueden existir más de un concepto, por lo que
los atributos son declarados como listas de objetos.
De la misma manera en la relación contiene_a se declara el dominio y el rango
intercambiándolos de la misma forma en que fueron declarados en esta_en ya que son
relaciones que son inversas entre sí y para que se declare en la ontología a cualquiera de las
dos clases se le añade el atributo inverse_property con el concepto inverso, esto ayuda a que
quede implícito que, si se declara una relación, la relación inversa sea implícita sin ser
estrictamente declarada.
5.2 Implementación del agente en Owlready.
Basado en la descripción hecha en el capítulo III sobre el agente pizarrón, se
implementó el manejo de la base de conocimiento del agente pizarrón con ayuda de la
biblioteca Owlready. Se decidió implementarlo como un objeto que pudiese ser llamado por
cualquier agente y dentro del objeto codificar los métodos necesarios para el manejo de la base
Figura 5.2 Representación de dominio y rango de una relación en Owlready
52
de conocimiento como es descrito en el apartado 3.3.
Lo primero a tomar en cuenta es el formato con el cual será recibido el contenido de
los mensajes, el caso de JADE, el mismo framework ya tenía un formato definido por FIPA, el
cual es FIPA-SL, pero para el caso de la biblioteca SPADE, la cual está encargada del
transporte de mensajes entre los agentes para esta implementación del agente pizarrón, no está
definido y queda abierto a cualquier lenguaje que se quiera usar. Para reducir la complejidad
en implementar el lenguaje FIPA-SL en SPADE, se optó por hacerlo de la manera más simple
con el formato mostrado en la figura 5.3.
El mensaje está conformado por cinco variables separadas por una diagonal para
simplificar la separación de las cinco variables. La primera variable en la cadena es el
concepto que es el dominio, la segunda es el nombre de la instancia del dominio, la cual se
utiliza para el conocimiento que es guardado en la base de conocimiento. La tercera se trata
del nombre de la relación entre la instancia de dominio y la instancia de rango. La cuarta se
trata del concepto que representa el rango y la quinta es la instancia del rango.
Figura 5.3 Formato para el contenido de los mensajes enviados al agente pizarrón.
53
El manejo de los conceptos de la ontología por parte de los agentes robóticos se lleva a
cabo en formato de objetos, ya que es más fácil a nivel código de Python para las aplicaciones
de los agentes robóticos el manejo de los conceptos. Se implementó como parte del módulo
del agente pizarrón un objeto preparador de mensajes ilustrado en la figura 5.4, para que los
agentes robóticos hagan uso del mismo y les ayude en la tarea de convertir el conocimiento en
forma de objeto a formato de cadena para su envío al agente pizarrón. El código implementado
para el preparador de mensajes se muestra en la figura 5.5
Figura 5.4 Funcionamiento de preparador de mensajes del agente pizarrón.
54
El único método de este objeto es el que realiza la conversión de objetos a mensajes, se
trata de prep_msj y tiene como parámetros el dominio, la relación la cual es manejada con el
nombre de propiedad en Owlready por eso el nombre prop de la variable y el rango. En la
línea 113 (en la fig. 5.5, se muestra cómo) se sustrae la clase del dominio del arreglo
is_instance_of, el cual es un arreglo de las clases de la que es instancia esa clase, después se
obtiene el nombre de la misma clase en la línea 115 y éste es guardado en la cadena tal y como
se muestra en la línea 124, esta cadena, que será la que retorne el método prep_msj. En las
líneas 117 y 118 se realiza el mismo procedimiento, pero para obtener el valor del rango para
la cadena. Ya en las líneas 121 a 123 se obtiene también el nombre de los demás valores como
lo son las instancias de dominio y rango, así como la relación o propiedad.
Dentro de los primeros métodos desarrollados del agente de pizarrón, está el que ayuda
a crear un nuevo conocimiento, el código es mostrado a continuación en la figura 5.6.
Figura 5.5 Código de implementación del método para el objeto preparador de mensajes.
55
En la figura 5.6, línea 4, se muestra como en la línea 4 se declara la clase del agente
pizarrón y en la línea 66 se define un constructor vacío como requisito necesario para la clase
en Python. El primer método implementado fue