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