Tesis ISC Jesus

INSTITUTO TECNOLÓGICO DE CD. MADERO DEPARTAMENTO DE SISTEMAS Y COMPUTACIÓN

DISEÑO DE UN ASISTENTE VIRTUAL CON DIÁLOGO EMOCIONAL

TESIS Para obtener el Titulo de

Ingeniero en Sistemas Computacionales

Presenta

Jesús Raymundo Domínguez Martínez Numero de Control

05070788 Director de Tesis

Dra. María Lucila Morales Rodríguez

CD. MADERO, TAMAULIPAS

MAYO 2011

Declaración de Originalidad Declaro y prometo que éste documento de tesis es producto de mi trabajo original y que no infringe los derechos de terceros, tales como derechos de publicación, derechos de autor, patentes y similares. Además, declaro que en las citas textuales que he incluido (las cuales aparecen entre comillas) y en los resúmenes que he realizado de publicaciones ajenas, indico explícitamente los datos de los autores y las publicaciones. Además, en caso de infracción de los derechos de terceros derivados de éste documento de tesis, acepto la responsabilidad de la infracción y relevo de ésta a mi director y codirectores de tesis, así como al Instituto Tecnológico de Cd. Madero y sus autoridades.

Mayo 2011, Cd. Madero, Tamps.

C. Jesús Raymundo Domínguez Martínez

DEDICATORIAS A mi madre por brindarme siempre el apoyo necesario, y dar todo para verme triunfador, y darme la fuerza necesaria para querer salir adelante en esta vida, y así lograr uno más de mis objetivos, y a mis hermanos que los quiero mucho por su apoyo. A mis amigos que me enseñaron el significado de la amistad, y que siempre estuvieron ahí apoyándome en cada uno de los momentos que vivimos juntos y siempre me extendieron su mano amiga, gracias por todos esos momentos que compartimos.

AGRADECIMIENTOS A Dios, por guiarme día a día, por darme las fuerzas necesarias de seguir adelante y ayudarme a culminar uno de mis objetivos planteados hace algunos años. A mis padres; Rosalía y José. A mi hermana y hermano; Abigail y Miguel. A mi abuelita; Rosalía. A mi Directora de Tesis la Dra. María Lucila Morales Rodríguez por el apoyo y los consejos que me brindó durante el desarrollo de éste proyecto, por tenerme paciencia, y compartir su conocimiento. Gracias por su dedicación y por su tiempo. Mi más sincero agradecimiento a los miembros del comité tutorial de ésta tesis: Dr. Juan Javier González Barbosa, Dra. Laura Cruz Reyes, Rubén Basáñez Castro y la Dra. Ma. Lucila Morales Rodríguez. Agradezco al Instituto Tecnológico de Ciudad Madero por las facilidades proporcionadas para la realización de éste proyecto, así como a los profesores que contribuyeron a mi formación académica humana. Gracias a mis amigos de la ingeniería por la amistad, compañerismo y apoyo prestado. Por todos los momentos que pase con ellos, en especial a Victoria, Blanca Teresa, Rosario, y muchos más que saben que están incluidos aquí, aunque no esté su nombre muchas gracias por todo.

RESUMEN Este trabajo de investigación se origina a partir de un proyecto realizado en la institución relacionado con un agente conversacional corpóreo, ya que actualmente el uso de los Agentes Conversacionales Animados ha ido creciendo. Estos suelen ser una herramienta utilizada en ciertas funciones en las cuales pueden servir como guías, maestros, ayudantes, etc. La problemática que abordamos en éste documento, es la implementación de un agente conversacional capaz de expresar diálogos creíbles en lenguaje natural, expresando en sus diálogos rasgos de personalidad, emociones y su intensidad. Para la generación de diálogos creíbles, proponemos utilizar la extensión que se le hizo al lenguaje AIML (Artificial Intelligence Markup Language), utilizando la nueva estructura para los archivos de la base de conocimientos basados en AIML, mediante diálogos creíbles, es capaz de crear escenarios más reales para que el aspirante disperse sus dudas con relación a la Maestría en Ciencias en Ciencias de la Computación, manteniendo una conversación simulada por el agente conversacional. Para esto se presentó una metodología para organizar y diseñar la estructura de los diálogos de un Agente Conversacional Animado capaz de expresar emociones en su diálogo. Resultando de éste trabajo un Asistente Virtual con Diálogo Emocional que proporciona información sobre la Maestría en Ciencias en Ciencias de la Computación del ITCM.

TABLA DE CONTENIDO Capítulo 1. Introducción ................................................................................................................ 1 1.1 Antecedentes ........................................................................................................................ 1 1.1.1 Creación de una base de conocimientos en AIML para un Agente Conversacional........... 1 1.1.2 Agente Conversacional que utiliza AIML para integrar procesos de personalidad. ........... 2 1.1.3 Metodología para la simulación de expresiones no verbales de una recepcionista virtual 2 1.2 Objetivos ............................................................................................................................... 3 1.2.1 Objetivo General............................................................................................................. 3 1.2.2 Objetivos específicos....................................................................................................... 3 1.3 Problemática ......................................................................................................................... 3 1.4 Justificación ........................................................................................................................... 3 1.5 Hipótesis................................................................................................................................ 4 1.6 Alcances y Limitaciones ......................................................................................................... 4 1.7 Estructura del documento ..................................................................................................... 4 Capítulo 2. Concepción de Agentes Conversacionales...................................................................... 6 2.1 Agente Conversacional .......................................................................................................... 6 2.1.1 Características de los Agentes Conversacionales ............................................................. 7 2.1.2 Aplicaciones.................................................................................................................... 7 2.1.3 Agentes Conversacionales Animados .............................................................................. 8 2.1.4 Humanos Virtuales Creíbles ............................................................................................ 9 2.2 Asistentes Virtuales Creíbles ................................................................................................ 10 2.2.1 Estado de Arte de los Asistentes Virtuales..................................................................... 11 2.2.2 Áreas de Aplicación....................................................................................................... 13 2.2.2 Rol de los Asistentes Virtuales....................................................................................... 14 2.2.3. Implementaciones de Asistentes Virtuales ................................................................... 17

2.3 Base de Conocimientos de los Agentes Conversacionales .................................................... 18 Capítulo 3. Análisis de la comunicación......................................................................................... 19 3.1 Interacción cara-a-cara ........................................................................................................ 19 3.2. Análisis de la conversación.................................................................................................. 21 3.3. Análisis del Discurso............................................................................................................ 22 3.4.1. Actos del habla............................................................................................................. 23 3.4.2. Sistemas de Diálogo ..................................................................................................... 24 Capítulo 4. Programación de diálogo en Agentes Conversacionales ............................................... 26 4.1 AIML.................................................................................................................................... 26 4.1.1 Características............................................................................................................... 27 4.1.2 Etiquetas....................................................................................................................... 27 4.1.3 Algoritmo de Coincidencia de Patrones ......................................................................... 35 4.2 Extensión Emocional AIML................................................................................................... 36 4.3 Python y PyAIML.................................................................................................................. 40 4.3.1 Características de PYAIML. ............................................................................................ 40 4.3.2 Características de Python .............................................................................................. 40 4.3.3 MySQLdb ...................................................................................................................... 42 Capítulo 5. Diseño de un Asistente Virtual con Diálogo Emocional ................................................ 43 5.1 Arquitectura General ........................................................................................................... 43 5.2 Metodología a seguir para organizar la estructura de los diálogos ....................................... 46 5.3 Análisis de la Información para organizar la estructura de los diálogos................................. 51 5.4. Requerimientos del Sistema ............................................................................................... 53 Capítulo 6. Caso Aplicativo: Asistente Virtual de la Maestría en Ciencias en Ciencias Computacionales........................................................................................................................... 55 6.1 Caso de Aplicación............................................................................................................... 55 6.2 Diseño del diálogo ............................................................................................................... 56

6.2.1 Aplicación de la Metodología ........................................................................................ 56 6.2.2 Definición de la Estructura del diálogo .......................................................................... 58 6.2.3 Caracterización de locuciones ....................................................................................... 60 6.2.4 Reorganización de la base de conocimientos................................................................. 65 6.3 Desarrollo del Prototipo....................................................................................................... 66 Capítulo 7. Experimentación y Resultados ..................................................................................... 76 7.1 Descripción de la Experimentación ...................................................................................... 76 7.1.1. Resultados de seguir la metodología respecto al código AIML. ..................................... 76 7.1.2. Resultado de la conversación con el asistente virtual. .................................................. 80 Capítulo 8. Conclusiones y trabajos futuros ................................................................................. 81 8.1 Conclusiones........................................................................................................................ 81 8.2 Aportaciones ....................................................................................................................... 81 8.3 Trabajos Futuros.................................................................................................................. 81 Bibliografía.................................................................................................................................... 82 Anexos .......................................................................................................................................... 84 Anexo A: Creación de Interfaz Gráfica............................................................................................ 84 Anexo B: Integración de la base de conocimientos a la interfaz gráfica .......................................... 90 Anexo C: Creación de ejecutable de la interfaz gráfica ................................................................... 93

LISTA DE FIGURAS Figura 1. Usos de los Asistentes Virtuales ...................................................................................... 14 Figura 2. Ejemplos de Asistentes Sociales ...................................................................................... 15 Figura 3. Ejemplos de Asistentes Educacionales............................................................................. 15 Figura 4. Ejemplos de Asistentes Orientados a Servicios ................................................................ 16 Figura 5. Ejemplos de Asistentes Virtuales(Lun, 2010a).................................................................. 16 Figura 6. Ann asistente virtual de la aseguradora Aetna................................................................. 17 Figura 7. Jenn asistente de Alaska Airlines ..................................................................................... 17 Figura 8. Alex asistente de Continental Airlines ............................................................................. 17 Figura 9. Amy ................................................................................................................................ 18 Figura 10. SGT STAR del Ejercito de los Estados Unidos.................................................................. 18 Figura 11. Spike experto virtual de la Universidad Gonzaga ........................................................... 18 Figura 12. Proceso de Comunicación básica................................................................................... 22 Figura 13. Jerarquía de Etiquetas en AIML ..................................................................................... 28 Figura 14. Estructura propuesta para los archivos AIML de la base de conocimientos.................... 38 Figura 15. Arquitectura del Asistente Virtual ................................................................................. 44 Figura 16. Modulo de Generación de locución del Asistente.......................................................... 45 Figura 19. Interacción con el usuario. ............................................................................................ 56 Figura 20. Prototipo final............................................................................................................... 67 Figura 21. Importación de librerías. ............................................................................................... 69 Figura 22. Acceso a la BD paginas .................................................................................................. 69 Figura 23. Creación del objeto k, en este caso es como si fuera el cerebro del bot. ....................... 70 Figura 24. Código generado por la herramienta VisualWx.............................................................. 70 Figura 25. Función pregunta. ......................................................................................................... 70 Figura 26. Objeto edit text............................................................................................................. 71

Figura 27. Definición de la función pregunta.................................................................................. 71 Figura 28. Código para obtener el id de la pagina a mostrar........................................................... 72 Figura 29. Botón Enviar. ................................................................................................................ 73 Figura 30. Código del botón enviar. ............................................................................................... 73 Figura 31.- Std-startup.xml ............................................................................................................ 74 Figura 32. Carga de archivos aiml. ................................................................................................. 74 Figura 33. Interfaz gráfica para simular un bot conversacional....................................................... 75 Figura 34. Interacción con el bot, creado en VisualWx Python ....................................................... 75 Figura 37 . Elegir color de fondo del Frame.................................................................................... 85 Figura 38 . Escribir texto en una etiqueta (Static Text) ................................................................... 86 Figura 39 .Cambiar Fuente (Font) .................................................................................................. 86 Figura 40. Cambio de texto en la etiqueta. .................................................................................... 87 Figura 41. Inserción de Edit Text y Edit Text Multilínea. ................................................................. 87 Figura 42. Asignar nombre al botón............................................................................................... 88 Figura 43.objeto panel................................................................................................................... 88 Figura 44. Código para hacer ejecutable ........................................................................................ 93 Figura 45. Línea de comandos o símbolo del sistema..................................................................... 93 Figura 46. Directorio python25...................................................................................................... 94 Figura 47 .Python prueba.py py2exe (instrucciones que hacen el ejecutable) ................................ 94 Figura 48. Compresión de librerías. ............................................................................................... 95 Figura 49. Fin de la compilación y compresión de librerías............................................................. 95 Figura 50. Carpetas dist y build...................................................................................................... 95 Figura 51. Directorio build. ............................................................................................................ 96 Figura 52. Directorio dist. .............................................................................................................. 96

LISTA DE TABLAS Tabla 1. Bot en línea...................................................................................................................... 12 Tabla 2. Características de Python ................................................................................................. 41 Tabla 3. Etapas de la construcción de la base de conocimientos .................................................... 51 Tabla 4. Registros de la BD paginas................................................................................................ 68

CAPÍTULO 1. INTRODUCCIÓN En la actualidad el uso de los Agentes Conversacionales Animados ha ido creciendo, ya que son una herramienta muy útil y fácil de usar para ciertas tareas. Estos pueden fungir como guías, maestros, ayudantes, y pueden brindar ayuda en la búsqueda de información sobre un tema, hasta pueden llegar a mantener una conversación de cualquier tema en específico. Los agentes son entidades capaces de percibir su entorno, los cuales pueden procesar lo que perciben y tener una reacción, es decir una respuesta o actuar en su entorno de manera racional. En esta tesis, se presenta una metodología para organizar y diseñar la estructura de los diálogos de un Agente Conversacional Animado capaz de expresar emociones en su diálogo. Resultado de éste trabajo se diseña e implementa un Asistente Virtual con Diálogo Emocional que proporciona información sobre la Maestría en Ciencias en Ciencias de la Computación del ITCM.

1.1 Antecedentes Actualmente en la Maestría en Ciencias en Ciencias de la Computación del ITCM se están sentando las bases para el desarrollo de una línea de investigación enfocada al desarrollo de Interacción Hombre-Máquina, usando Agentes Conversacionales Animados. Esto con la finalidad de construir herramientas de simulación para fines ludo-educativos y profesionales, que permitan enseñar de una manera más eficaz. Los Agentes Conversacionales, tienen la finalidad de interactuar con el usuario, para realizar tareas de una forma muy natural, para lo cual, no basta con que su apariencia sea muy realista, sino que, además deben comportarse y comunicarse como lo haría un humano (Morales, 2007). A continuación, se mencionarán algunos trabajos realizados en el ITCM relacionados con esta tesis.

1.1.1 Creación de una base de conocimientos en AIML para un Agente Conversacional. En este trabajo de residencias, se revisó material acerca de la sintaxis y estructura del lenguaje AIML, el cual permite definir una serie de patrones y respuestas, para así crear una base de conocimientos, la cual contiene categorías ordenadas por contextos. Se creó una base conocimientos 1

para que el agente contestará preguntas acerca de la Maestría en Ciencias en Ciencias de la Computación, mostrándole al usuario una página Web con la información pertinente acerca de lo que le pregunte el usuario. Además se creó una BD para almacenar links de páginas con información de las diferentes secciones de la página Web de la Maestría en Ciencias en Ciencias de la Computación para mostrarlas como información complementaria. En este trabajo se programó un prototipo de una interfaz gráfica con una imagen de un personaje virtual, con el fin de probar el funcionamiento de la base de conocimientos, la cual representa emociones a través del diálogo.

1.1.2 Agente Conversacional que utiliza AIML para integrar procesos de personalidad. En el trabajo de tesis de (Florencia, 2010), Agente Conversacional que utiliza AIML para integrar procesos de personalidad,

se creó una propuesta de agente corpóreo conversacional (ECA,

Embodied Conversational Agents) que implementa emociones en el proceso de gestión de diálogo con un usuario. Este trabajo incorporó emociones en un ECA, extendiendo el lenguaje AIML, incorporándole etiquetas que toman en cuenta la intensidad y los tipos de emociones universales. Para incorporar las emociones se implementó el modelo emocional de (Morales, 2007), desarrollándose un Framework que permite la interrelación de las bases de conocimientos de AIML y el modelo comportamental de (Morales, 2007).

1.1.3 Metodología para la simulación de expresiones no verbales de una recepcionista virtual En el trabajo de (Coca & Ángel, 2009), se buscó formalizar las pautas para aumentar la credibilidad de las expresiones de los personajes por medio de la implementación de un autómata finito determinista que permitiría la selección de expresiones de interacción social y emocional no verbales asociadas al contexto. Para este trabajo se realizó un estudio acerca del análisis de la comunicación, interacción, conversación, expresión y discurso. Para lo cual, se analizaron videos para la comprensión de las gesticulaciones.

2

1.2 Objetivos 1.2.1 Objetivo General Definir una metodología para organizar la estructura de los diálogos de un agente conversacional que exprese emociones, y así diseñar un asistente virtual con diálogo emocional.

1.2.2 Objetivos específicos •

Crear una arquitectura general para el desarrollo de Asistentes Virtuales con diálogo emocional que puedan interactuar con el usuario a través de una interfaz gráfica.

•

Establecer las consideraciones que se deben tomar en cuenta para la organización de la estructura de los diálogos utilizando la extensión emocional del Lenguaje AIML para así diseñar un asistente virtual que exprese un comportamiento emocional en su diálogo.

•

Diseñar un personaje (asistente virtual) en iClone PRO.V4.1, que sea capaz de representar emociones por medio de expresiones faciales.

•

Crear un prototipo de la arquitectura para diseñar el diálogo del asistente virtual en el contexto de la Maestría en Ciencias en Ciencias de la Computación del ITCM.

1.3 Problemática La problemática en el desarrollo de asistentes virtuales con diálogo emocional radica en cómo representar emociones por medio del diálogo, además de sus expresiones faciales. Para este problema, se pretende analizar las conversaciones, identificar patrones en los diálogos en los que se puedan representar emociones, de acuerdo a la conversación con el usuario. Se evaluarán las conversaciones, de tal forma que se pueda estructurar la base de conocimiento del diálogo y saber, que tipo de diálogos representan cierta emoción.

1.4 Justificación Para elaborar formas de interacciones por medio de una computadora, más naturales y herramientas de simulación que permitan una instrucción eficaz, es necesario que el usuario del sistema esté sumergido en una situación virtual similar a la realidad. Para ello, no es suficiente reunir imágenes y sonidos realistas, es también importante que los personajes virtuales manifiesten comportamientos emocionales y de interacción social mediante expresiones no verbales (Coca & Ángel, 2009), (Morales, 2007). El diseñar un asistente virtual con diálogo emocional, a la semejanza del ser 3

humano como parte de las interfaces entre hombre-máquina dará un enfoque más interesante a éstas. Además, de poder mantener una conversación en la cual se podrá dar la información pertinente al usuario. Para lo cual se establecerá una metodología estándar para la organización de la estructura de los diálogos que representen emociones. Además, se diseñará un asistente virtual, el cual podrá expresar facialmente emociones.

1.5 Hipótesis En esta tesis se busca facilitar la representación de emociones de un agente conversacional por medio del diálogo. Existen una serie de problemáticas para lograrlo, ya que una misma frase puede ser expresada transmitiendo diferentes emociones, así como una emoción puede expresarse usando diferentes frases. Basándose en dicha afirmación, se quiere determinar si es posible diseñar una metodología para el diseño de las bases de conocimiento de AIML, considerando la expresión de emociones de acuerdo al contexto y así facilitar el diseño de un asistente virtual capaz de expresar diálogo emocional.

1.6 Alcances y Limitaciones El alcance de este proyecto está limitado a definir una metodología para la organización de la estructura del diálogo emocional utilizando la extensión del lenguaje AIML desarrollada por (Florencia, 2010). El caso aplicativo de esta metodología, será un asistente virtual, que proporcione información sobre la Maestría en Ciencias en Ciencias de la Computación del ITCM. El diseño del asistente virtual será en el software ICLONE4 PRO, y la implementación se creará con Python, haciendo uso de una base de datos creada en MySQL, por lo que se requerirá que esté instalado éste manejador de Base de Datos.

1.7 Estructura del documento En esta sección, se presenta la forma en que está organizada esta tesis: Capítulo 1. Introducción, en este capítulo se presenta de manera clara y precisa lo relacionado a la tesis, para que el lector se interese en seguir leyendo sobre el tema. Capítulo 2. Concepción de Agentes Conversacionales, en este capítulo se presenta la teoría para entender conceptos relacionados con agentes conversacionales. 4

Capítulo 3. Análisis de la comunicación, en este capítulo se presenta teoría para fundamentar los actos involucrados en la comunicación. Capítulo 4. Programación de diálogo en Agentes Conversacionales, en este apartado se presenta la literatura relacionada con la programación de la base de conocimientos. Capítulo 5. Diseño de un Asistente Virtual con Diálogo Emocional, en este apartado se describe como diseñar un asistente virtual. Capítulo 6. Caso Aplicativo: Asistente Virtual de la Maestría en Ciencias en Ciencias Computacionales, en esta sección se presenta el desarrollo del caso aplicativo en esta Maestría. Capítulo 7. Experimentación y Resultados, en este capítulo se presentan la experimentación y los resultados llevados a cabo. Capítulo 8. Conclusiones y Trabajos Futuros, se presenta la conclusión del trabajo, se mencionan los posibles trabajos futuros que permiten darle seguimiento a este proyecto.

5

CAPÍTULO 2. CONCEPCIÓN DE AGENTES CONVERSACIONALES En este capítulo se presentan los conceptos relacionados con el proceso de construcción de agentes conversacionales, su interacción social, y sus diálogos que están contenidos en la base de conocimientos, además de la tecnología necesaria para llevar a cabo su desarrollo.

2.1 Agente Conversacional Según (Marcelo & P, 2007) hacen mención que el término agente fue empleado por primera vez por Minsky en su obra "The Society of Mind". Según (Nwana, 1996) dice que un Agente es “aquel componente de software o hardware que es capaz de actuar en forma precisa para llevar a cabo una tarea en beneficio de su usuario”. Los agentes de software son sistemas informáticos que se puede encontrar en múltiples plataformas, y que usando técnicas de resolución de problemas, ejecutan acciones de forma flexible y autónoma, para alcanzar sus objetivos, lo cual los puede llevar a cambiar su entorno (Monroy, 2008). Existen diferentes tipos de agentes, los agentes conversacionales son uno de ellos. El término “agente conversacional” está compuesto por dos palabras “agente” y “conversacional”. La palabra agente tiene su raíz antes del siglo XV y significa: “el que actúa” y del Latín “agentem” (nominativo: Agens, el género: Agentis) (Lun, 2010). La palabra “conversacional” significa, que tiene la característica de una conversación o del lenguaje coloquial empleado en ella (wordreference, 2005). Un agente conversacional es una entidad viviente artificial diseñada para tener conversaciones con seres humanos reales. Estas conversaciones se pueden expresar vía texto, de forma oral o incluso una conversación no verbal. Los agentes conversacionales también son conocidos como chatbots (Lun, 2010), pueden encontrarse en pantallas, mundos virtuales, pero también en el mundo real, a

6

través de proyecciones (por ejemplo con proyección holográfica) o físicamente hablando y respondiendo como marionetas, juguetes y robots (Lun, 2010b). En esta tesis se definirá una metodología para organizar la estructura de los diálogos de un agente conversacional que exprese emociones, y así diseñar un asistente virtual con diálogo emocional. Los agentes conversacionales deben tener una base de conocimientos, mediante la cual podrán contestar y hacer preguntas al usuario.

2.1.1 Características de los Agentes Conversacionales Los agentes conversacionales tienen las siguientes características, las cuales hacen estos que se distingan de los diferentes tipos de agentes: •

Autonomía: Los agentes deben de tener la capacidad de respuesta de acuerdo a los conocimientos que le permitan alcanzar el objetivo que tenga planteado.

•

Proactividad: Los agentes tienen la capacidad de tomar la iniciativa ya sea mediante sugerencias o acciones que les ayude para alcanzar su objetivo.

•

Sociabilidad: esto quiere decir que un agente debe de tener: o Comunicación. o Cooperación. o Negociación.

•

Personalidad: Los agentes tienen un comportamiento dado al objetivo que buscan (Monroy, 2008).

•

Expresan emociones y tener comportamiento no verbal (Kopp, 2009).

Modelar con agentes tiene ventajas en el sentido de que este paradigma es más cercano a nuestra manera de ver el mundo, porque muchas organizaciones se definen con un conjunto de roles y relaciones entre ellos, aún así, es necesario disponer de métodos y herramientas para el desarrollo de los sistemas basados en agente (Monroy, 2008).

2.1.2 Aplicaciones Ahora en día, los agentes conversacionales son de mucha utilidad, tal que se pueden encontrar en diversas áreas, realizando funciones como: •

Wizards, en aplicaciones de escritorio.

•

Asistentes, en sitios web de comercio electrónico, negocios y otros dominios.

7

•

Tutores, en Educación, (por ejemplo. para aprender y practicar un idioma) (Kopp, 2009).

•

Herramienta de entretenimiento.

•

Herramienta de recuperación de información.

2.1.3 Agentes Conversacionales Animados Existen diferentes tipos de Agentes Conversacionales, uno de ellos son los ECA’s (Embodied Conversational Agents por sus siglas en inglés), en español se han conocidos como Agentes Conversacionales Corpóreos o Agentes Conversacionales Animados. Estos Agentes son interfaces gráficas con la capacidad de utilizar modos de comunicación verbal y no verbal para interactuar con usuarios en ambientes virtuales. Estos agentes algunas veces son sólo un rostro parlante animado, pueden desplegar expresiones faciales simples, pueden utilizar síntesis de voz con algún tipo de sincronización labial, y algunas veces tienen sofisticadas representaciones gráficas en 3D con movimientos corporales y expresiones faciales complejos. Según (Cassell, Tim Bickmore, Campbell, Vilhjálmsson, & Yan, 2000) un ECA debe tener las siguientes habilidades: •

Reconocer y responder a entradas verbales y no verbales por parte del usuario.

•

Generar salidas verbales y no verbales.

•

Realizar funciones conversacionales (por ejemplo turno de la palabra, retroalimentación, etc.)

•

Dar señales que indiquen el estado de la conversación así como contribuir con nuevas proposiciones.

Para desarrollar un ECA con las habilidades antes descritas, se requieren varios componentes, que en base a su función en el flujo de la información de la interacción con los usuarios, se pueden dividir en las siguientes categorías: •

Fase de entrada. Los ECA’s deben estar preparados para recibir diferentes tipos de entrada de información por parte del usuario, incluyendo las modalidades verbales y no verbales.

•

Fase de deliberación. Es la parte central del ECA, la cual determina su comportamiento en respuesta a las entradas y al contexto. Un ECA sin emociones ni expresiones faciales no se ve creíble, por lo tanto se debe incorporar emociones, personalidad, cultura y

8

modelos de rol social en un ECA para lograr credibilidad en la comunicación con los usuarios. •

Fase de salida. Es necesario que el ECA posea un cuerpo expresivo, tanto en los canales de comunicación verbal como en los no verbales. En lugar de robots y personajes animados, los ECA’s son preferidos por los investigadores por su libertad de expresión.

En una serie de estudios, investigadores en el paradigma de “computadoras como actores sociales” han demostrado la posibilidad de manipular las relaciones del usuario con la computadora utilizando una amplia gama de comportamientos. Reeves & Nass demostraron que los usuarios prefieren más a las que los halagan. Morkes, Kernal & Nass demostraron que agentes computacionales que utilizan el humor son clasificados como amables, competentes y cooperativas Moon demostró que una computadora que utiliza estrategias de reciprocidad y profundidad en la conversación con el usuario, son clasificadas como más afectivas y el usuario llega a comprar un producto de la computadora. En un paradigma diferente, Mark y Becker estudiaron cómo las convenciones sociales pueden afectar las relaciones interpersonales entre los usuarios que se encuentren reunidos en un ciberespacio. Éstos son ejemplos de técnicas de persuasión empleadas con la finalidad de cambiar las creencias, sentimientos y pensamientos de los usuarios (Cassell & Timothy Bickmore, 2002).

2.1.4 Humanos Virtuales Creíbles Construir ECA’s es una tarea multidisciplinaria, ya que reúne problemas tradicionales de la inteligencia artificial con las ciencias sociales. Los ECA’s deben actuar y reaccionar en sus ambientes simulados, basándose en las disciplinas de razonamiento automático y planeación. Para mantener una conversación, se debe explotar la gama de investigaciones realizadas sobre lenguaje natural, reconocimiento de voz y comprensión del lenguaje natural para la generación de síntesis del habla, así como visualmente tener un cuerpo humano con movimientos reales, tal como los de un ser humano real. La representación visual más común de los ECA’s son los personajes humanoides virtuales que son representaciones digitales en un ambiente virtual. La construcción de personajes virtuales creíbles requiere un enfoque multidisciplinario que tome en cuenta las cuestiones psicológicas, sociológicas y filosóficas. La consideración de estos temas permite dotar a los humanos virtuales de un comportamiento no verbal capaz de transmitir la personalidad y las emociones. Varios autores dicen que el uso de humanos virtuales como herramientas para la interacción puede enriquecer la interacción humano-computadora, por lo que hace más agradable y aumenta la motivación del usuario (Gratch, et al., 2002). 9

Algunas de las características de los humanos virtuales son: utilizar síntesis de voz con algún tipo de sincronización labial y tener sofisticadas representaciones gráficas en 3D con movimientos corporales y expresiones faciales complejos. Hay varias ideas acerca de lo que les puede dar credibilidad a los personajes virtuales. Según (Bates, 1994). Un personaje creíble se define, como un personaje que puede proporcionar la ilusión de vida y permite al público suspender su incredulidad. El grado de credibilidad de su ilusión se encuentra en el acoplamiento y reproducción de dos dimensiones principales: Antropomorfismo y el comportamiento. La realización permite más multimodalidad, por lo tanto haciendo la interacción más natural y robusta. De acuerdo a unos comentarios sobre la apariencia física y especialmente la falta de fluidez de las animaciones de agentes, también pueden causar menor credibilidad. Por lo tanto la apariencia física y los factores sociales tienen que tomarse en cuenta en forma conjunta para crear agentes más creíbles capaces de mantener una interacción con los usuarios.

2.2 Asistentes Virtuales Creíbles Un Asistente Virtual es una herramienta informática, que bajo la apariencia de un personaje virtual, es capaz de poner atención a los visitantes de un determinado sitio web. Es, por lo tanto, una herramienta fundamental para reducir los costes de atención, mientras que se incrementa la calidad de esta atención. Los Asistentes Virtuales permiten responder, de forma automática, las necesidades de información de sus usuarios. De este modo podrá tanto aportar en todo momento, la información que estos precisan, como también encauzar la conversación de la forma más provechosa para su organización o institución (dTinf, S.L., 2008). Los asistentes virtuales creíbles son una mezcla de agentes autónomos y personajes por computadora basados en las artes, como lo son la animación, películas o literatura. Son una extensión, tanto en la investigación de agentes autónomos en la ciencia de la computación y la idea de los asistentes virtuales creíbles de las historias tradicionales. Los asistentes virtuales creíbles son una versión de los agentes autónomos. Aunque los agentes creíbles están basados en los personajes creíbles, estos son diferentes en que ambos son interactivos y basados en computadora. El hecho que son basados en computadora significa que un autor no depende de un actor humano que le da muchas de las cualidades necesarias de credibilidad al agente, por ejemplo, en una película o en teatro. Para un agente creíble su personalidad debe ser creada completamente. Estos siempre son una abstracción de la realidad, 10

conservando sólo los elementos de realismo que contribuyen a transmitir la personalidad. Los asistentes virtuales creíbles son personajes interactivos, quienes parecen estar vivos, expresan emociones y personalidad (Loyall, Bates, & Mitchell, 1997). Según (Loyall, Bates, & Mitchell, 1997) los requerimientos para los asistentes virtuales creíbles son que deben mostrar: personalidad, emociones, automotivación, capacidad de adaptación, relaciones sociales, expresión de consistencia e ilusión de vida.

2.2.1 Estado de Arte de los Asistentes Virtuales “Eliza” fue el primer agente conversacional desarrollado, podía seguir una conversación sobre un tema concreto. Era un chatbot que dominaba el tema de la psicología, fue creado en 1980 por Joseph Weizenbaum, con el objetivo de sustituir a un psicólogo real en sus conversaciones con los pacientes. Eliza, sirvió de inspiración para casi todos los chatbots actuales, ya que todos se basan principalmente en la creación de patrones que simulen el comportamiento humano. PARRY, otro bot que tenía como objetivo, simular a un paciente paranoico. A este bot se le evaluó en sus conversaciones con tres pacientes que realmente tenían dicha enfermedad y enfrentándolos a un medico de verdad. En 1995, el Dr. Richard Wallace escribió A.L.I.C.E., en su primera versión, uso SETL, un lenguaje basado en lógica matemática, pero se quedo en un experimento. A partir de este primer intento se desarrollo el “Program A” que fue la primera versión de A.L.I.C.E., esta versión se desarrollo usando AIML y Java. El siguiente paso de este bot fue el “Program B” en el que ya intervinieron alrededor de 300 desarrolladores y donde se sustituyó AIML evolucionó a algo parecido a XML, y fue con esta versión con la que se ganó el Loebner Prize en 2000. A partir de aquí se crearon otras dos versiones de A.L.I.C.E., el “Program C” (que se desarrollo usando C/C++) y el “Program D” (basado en la tecnología Java2). A partir de aquí se creo, en 2001 “The A.L.I.C.E. AI Foundation” para distribuir, promocionar, desarrollar y mantenimiento de Alicebot y de la tecnología AIML. Otro trabajo a destacar lo encontramos en TinyMud, un entorno ideal para probar bots de charla ya que consistía en una especie de mundo virtual donde los usuarios hablaban sobre sus asuntos y problemas. La prueba consistía en que el bot se confundiera con los usuarios reales. El bot Julia es una evolución de un bot que se probó en este entorno con muy buenos resultados. El proyecto “Spence's Virtual Bar” se trata de un IRC que simula un bar donde los clientes pueden conversar y en el que hay una camarera. “Erin”, un bot cuyo tema de conversación es el Rock & Roll.

11

Otros bots que se han desarrollado son algunos como “Theresa” cuyo tema de conversación es la música y la cultura griega, “Mimic” que aprende mientras hablas con él, “Brian” que ganó el tercer puesto en el Loebner Prize de 1998 y otros muchos. La mayoría de los bots están diseñados para hablar en inglés. A pesar de la supremacía de los chatbots en idioma inglés, también cabe destacar algunos chatbots desarrollados para hablar en español. Por ejemplo: Dr. Abuse que es uno de los mejores chatbots escritos en español en la actualidad. Este bot toma la personalidad de un psiquiatra al que visitamos para que resuelva nuestros problemas, pero es capaz de seguir casi cualquier tipo de conversación. Sus conversaciones tienen algunos toques de humor y los autores han conseguido dotarle de una personalidad definida. Otro chatbot escrito en español es Zebal. La principal característica de Zebal, es su gran capacidad para interactuar con el exterior mediante una conexión al IRC lo que le permite aprender de interlocutores humanos que no saben que están hablando con un bot. Además, Zebal se puede conectar remotamente a bases de datos, lo que le aporta acceso a un gran diccionario de 30000 palabras o incluso puede recoger información de Internet. Por el contrario, Zebal no sigue conversaciones tan bien como el resto de Bots. Por último cabe destacar que existen chatbots que conversan en otros idiomas, como ejemplo de esto, tenemos a “Eloisa” que mantiene charlas en italiano. Muchos de estos Bot son de carácter general, es decir que no están especializados en ningún tema en particular, mientras que otros si lo están. En la Tabla 1 se muestra una relación de algunos de los Bots que se encuentran en línea, en la cual se especifica la temática que tratan, su idioma y su Url (Marcelo & P, 2007). Nombre Eliza A.L.I.C.E. Zebal Julia Erin Mitbolel Mimic Brian Dr. Abuse Theresa Eloisa Alice-espX Eva Inés

Tema Psicología General General General Rock & Roll General General General Psicología Música General Relaciones Afectivas

Empresa indisys Ibanesto

Idioma Ingles Ingles Español Ingles Ingles Ingles Ingles Ingles Español Ingles Italiano Español Español Español

Url http://www.manifestation.com/neurotoys/eliza.php3 http://www.alicebot.net http://www.espasoft.net/fichas/zebal.shtm http://www.lazytd.com/lti/julia/ http://www.extempo.com/webbar/index.html http://www.romahi.com/yazann/Mitbolel/Mitbolel.html http://www.thespoon.com/mimic/ http://www.strout.net/info/science/ai/brian/ http://www.ctv.es/USERS/jboronat/drabuse.html http://www.oz.com/ov/agents/main_index.html http://web.tin.it/eloisa/ http://aurora.esi.uem.es/∼ivinas http://www.indisys.es/ http://asistentevirtual.ibanesto.com/ibanesto/ibanesto.jsp

Tabla 1. Bot en línea 12

2.2.2 Áreas de Aplicación Las áreas de aplicación de los asistentes virtuales pueden ser: Industrial, Comercial, en la Educación, en la Medicina, etc. De las cuales, se pueden destacar dos áreas de aplicación, la industrial y la comercial. Por otro lado, también está siendo empleado en aplicaciones comerciales, sobre todo a nivel de aplicaciones de red, tanto en Internet como en redes corporativas, entre las que podemos distinguir: •

Gestión de información: Como ejemplo de la gestión de información el agente puede filtrar correos, noticias o recopilar información que se encuentre en la red. También puede realizar tareas como almacenar, aprender, y manejar las preferencias del usuario, así como sus modificaciones. Podría también ser una agenda personal, como si se contara con una secretaria o asistente personal.

•

Comercio electrónico: En este caso la tecnología se aplicaría para crear el entorno virtual en donde se llevaran a cabo transacciones como compras, ventas de algún producto o hacer búsquedas de productos para comprobar la existencia o precios de estos automáticamente.

•

Monitorización: En esta aplicación el agente da información al usuario acerca de lo que sucede, si se actualiza información, elimina o se mueve. También indican al usuario que página o páginas han sido modificadas, y desde cuando sucedió.

•

Mediador de diferentes fuentes de información: En esta aplicación aun se está trabajando actualmente, para que los agentes operen entre diferentes fuentes de información independientemente del sistema en que se haya creado.

Otra área de interés son las aplicaciones médicas, donde la idea es disponer de agentes que realicen de forma autónoma tareas que pueden ser automatizadas en un hospital, como por ejemplo: la monitorización de pacientes en cuidados intensivos, estos sistemas se encargarían de seguir el tratamiento de un paciente controlando todos los aspectos relativos a la enfermedad que tenga el mismo. También es posible encontrar aplicaciones dentro del área del entretenimiento como pueden ser juegos (la aplicación de esta tecnología en juegos permite disponer de juegos más sofisticados, con características inteligentes donde se pueden incorporar personajes virtuales que pueden funcionar de forma casi autónoma) y el teatro interactivo y cine, donde se permite a un usuario interpretar el papel de un personaje en una obra donde el resto de los personajes pueden ser virtuales (Botti, 2000). 13

Finanzas, banca y seguros

Seguridad, industria y logística

AA, PP, Sanidad y Turismo

Portales Web financieros con asistencia AVI como guía - Cajeros automáticos. Ayuda a personas con problemas de accesibilidad.

- Sistemas de SV (Speaker Verification) o de huella de voz. Funciones de autentificación/ identificación.

- Banca UMTS. Consulta de saldos y cuentas mediante asistente virtual en móvil.

- Portales Web de logística del estado de las entregas .Preguntas técnicas.

- Kioscos autoservicio guía en aeropuertos, estaciones, etc. – Paneles informativos centros médicos, aeropuertos. - Doctor virtual. Portal Web de atención sanitaria, cita previa.

Telecomunicaciones - Aplicaciones de servicios telefónicos 3G. - Campañas publicitarias MMS en móvil. Servicio contestador. - Información TDT.

Ocio, utilidades y enseñanza - Paneles informativos en comercios, - Videojuegos de fidelización. Acercan a usuarios. No e-Generation a Recomendador de productos. Empresa. - Portales Web de e-learning Profesor virtual.

Figura 1. Usos de los Asistentes Virtuales

2.2.2 Rol de los Asistentes Virtuales De forma general los asistentes virtuales pueden ser de 3 tipos: asistentes virtuales sociales, asistentes virtuales educacionales y asistentes virtuales orientados al servicio, los cuales se describen a continuación. Asistentes Virtuales Sociales: Su propósito es conversar libremente acerca de algo con cualquier usuario, así como lo haría con un amigo. Son usados en línea para entretenimiento. Ver figura 2. Asistentes Virtuales Educacionales: Su propósito es ayudar a aprender acerca de algo, como un nuevo lenguaje, historia, geografía, etc. Son usados en las escuelas. Ver figura 3. Asistentes Virtuales Orientados a Servicios: Estos generalmente son utilizados por empresas que ofrecen servicios en línea. Su propósito es ayudar a los clientes a encontrar el camino en el sitio web, así como contestar preguntas acerca de sus productos y servicios. Ver figura 4 (Jenkins, 2010).

14

Figura 2. Ejemplos de Asistentes Sociales

Figura 3. Ejemplos de Asistentes Educacionales

15

Figura 4. Ejemplos de Asistentes Orientados a Servicios

Figura 5. Ejemplos de Asistentes Virtuales(Lun, 2010a)

El rol de los asistentes es muy importante, ya que puede un simple asistente que proporcione información, aunque también podría realizar tareas más complejas, si está programado para realizarlas. A continuación una descripción de algunos roles importantes: •

Representación virtual. Se comunican en lenguaje natural y suplen a los comerciales.

•

Como asistentes personales. Nos ayudan como lo haría un ayudante.

16

•

Negociador en mercados electrónicos. Localiza una subasta en Internet, aprende cómo va la oferta y realiza una compra por nosotros.

•

Agente de búsqueda de información o rastreador. Rastrean en las redes de ordenadores en busca de información solicitada. Son parametrizables por el usuario aprenden de sus hábitos, rastrean la red e informan por correo electrónico de novedades que consideran pueden ser de interés para el usuario.

•

Agente secreto o espía. Monitorizan una página Web identificada previamente por el usuario e informan cuando se producen cambios en dicha página (Takeyas, 2005).

2.2.3. Implementaciones de Asistentes Virtuales Ejemplos de algunas empresas que se dedican al desarrollo de asistentes virtuales, son: ATOS ORIGIN, Response, Artificial Solutions Iberia, The Reuse Company, INBENTA, Intuit MyProSeries, CAJA MADRID y Next IT. A continuación se presentan algunos de los asistentes virtuales realizados Next IT (Next IT Corporation, 2010): Aetna compañía aseguradora de salud de los Estados Unidos lanzó su asistente Ann a principios del año 2010. Lo que ha ocasionado una reducción del 29% en las llamadas a su servicio de asistencia técnica de los clientes. Figura 6. Ann asistente virtual de la aseguradora Aetna

Jenn, es un experto virtual del servicio a clientes de Alaska Airlines, que entró en operación desde febrero de 2008. Figura 7. Jenn asistente de Alaska Airlines

Alex, la experta virtual de Continental Airlines inició en Julio de 2009. En su primer mes respondió a más de un millón de preguntas, y actualmente atiende a más de 60.000 preguntas por día. Figura 8. Alex asistente de Continental Airlines

17

Amy, la experta virtual para Comunicaciones Shaw, ayuda a mejorar la interacción en su sitio web el cual anteriormente fue percibido como torpe y con servicios difíciles de ubicar. Figura 9. Amy

Lanzado en 2006, el SGT STAR ha aumentado la duración de la sesión promedio y ha respondido a más de 4 millones de preguntas en el sitio web del Ejercito de los Estados Unidos. Figura 10. SGT STAR del Ejercito de los Estados Unidos

Con el fin de ayudar al alumnado, estudiantes, y proporcionar información relevante del sitio web de la escuela, la Universidad Gonzaga colaboró con Next IT y en 2004 puso en marcha su experto virtual “Spike”. Figura 11. Spike experto virtual de la Universidad Gonzaga

2.3 Base de Conocimientos de los Agentes Conversacionales Para poder mantener un diálogo con coherencia es necesario que el agente cuente con una base de conocimientos. Esta puede estar formada por una serie de archivos .aiml los cuales contienen una gran cantidad de reglas que definen la respuesta del bot en base a la información de entrada. Las bases de conocimientos deben manejar diferentes niveles de conocimiento, y tener una estructura organizada por contextos, puede ser definida para un tema en particular o se puede hacer general. El diseño de una base de conocimiento que apoye la generación de un diálogo requiere de realizar análisis de la comunicación cara a cara que se realiza en el contexto que se desea simular. En los siguientes capítulos se presentan los fundamentos teóricos necesarios para diseñar e implementar una base de datos de conocimiento para un agente conversacional.

18

CAPÍTULO 3. ANÁLISIS DE LA COMUNICACIÓN El análisis de la comunicación se basa en dos enfoques principales: El análisis del discurso que tiene por fundamento la teoría de los actos del habla y el análisis conversacional que se basa en la Etnometodología, que tiene como objetivo identificar las normas y principios que sustentan el funcionamiento de las conversaciones y los diferentes tipos de intercambios que se producen en la interacción comunicativa (Morales, 2007). Este capítulo permite comprender el backgroud de la estructura detrás del diseño de la conversación de un asistente virtual.

3.1 Interacción cara-a-cara La conversación cara-a-cara involucra la expresión de comportamientos no-verbal y de lenguaje. Los comportamientos durante la conversación no solo funcionan en paralelo, sino interdependiente. Una conversación cara-a-cara es una actividad en la que las sincronización entre los participantes parece ocurrir de manera natural. Esto se ve facilitado por el número de canales o modalidades que tenemos a nuestra disposición para transmitir información. Estos canales incluyen las palabras, la entonación de la voz, gestos, expresión facial, la postura, la orientación y la mirada. La coordinación de los comportamientos conversacionales no verbales y verbales para humanos virtuales requiere la reunión de los desafíos interrelacionados. Como el habla, la entonación, la mirada y los movimientos de la cabeza, que le dan sentido en conjunto, los patrones de su coocurrencia en la conversación, y que tipos de objetivos son alcanzados por los diferentes canales, todos son igualmente importantes para comprender la construcción de humanos virtuales. Los comportamientos no verbales y del habla no siempre manifiestan la misma información, sino lo que ellos transmiten es siempre compatible virtualmente. En muchos casos, las diferentes modalidades sirven para reforzar de una a otra gracias al significado de la redundancia. En otros casos, los 19

mensajes de los atributos de la pragmática y la semántica se distribuyen a través de las modalidades. La compatibilidad de significado entre los gestos y el discurso destituye la interacción de palabras y gráficos en las presentaciones multimodales. Los comportamientos no verbales y verbales, las arquitecturas computacionales para humanos virtuales deben controlar tanto las estructuras proposicional y de interacción. La construcción de un humano virtual que pueda participar eficazmente en una conversación cara a cara requiere una arquitectura de control con las siguientes características: E/S multimodal, retroalimentación en tiempo real, entendimiento y síntesis de la información de interacción y proposicional, así como también un modelo de función conversacional (Gratch, et al., 2002). La tendencia en interacción Hombre-Máquina (IHM) se enfoca en el uso de técnicas que permiten que el usuario se comunique, y así relacionarse, con las computadoras de manera más natural. El uso de lenguaje natural no basta, se necesitan añadir diversos aspectos emocionales, es decir, interacción emocional para que al tener una conversación con el usuario se mejore la comunicación. Las emociones son parte de la interacción social y de nuestra capacidad para tomar decisiones. Con el fin de entender el papel del comportamiento emocional en una interacción Máquina-Humano es necesario entender los aspectos fundamentales de la emoción misma (Pedro Branco, 2003). La teoría cognitiva de la emoción es la más adaptada en la computación, en particular la teoría de la valoración de la emoción. De acuerdo con esta teoría, los resultados de las respuestas emocionales a partir de una evaluación dinámica de las necesidades, creencias, objetivos, inquietudes, demandas ambientales que puedan resultar, consciente o inconscientemente. Uno de los modelos más implementados es el modelo OCC que proporciona un esquema de clasificación de etiquetas de emoción basadas en una reacción de valencia para eventos y objetos en los objetivos del agente, normas y actitudes. La interacción social, es el fenómeno básico mediante el cual se establece la influencia social que recibe todo individuo. El diálogo es la forma más simple de la interacción humana en situaciones de cooperación. Según (Morales, 2007) el diálogo puede verse como un juego, en el que cada participante juega disparos con los actos del habla para lograr su objetivo. El diálogo es el resultado de las interacciones (acciones y operaciones) para resolver subobjetivos. Los diálogos se suelen describir en tres fases: la primera es el comienzo de la conversación, la segunda fase es el intercambio de turnos para hablar y la tercera finaliza la conversación.2.5 Les

20

3.2. Análisis de la conversación El análisis de la conversación se interesa por analizar la acción humana, entendida como un sistema que permite que las personas actúen en múltiples ocasiones de la vida cotidiana de forma regular, utilizando “métodos” que les permiten dar sentido a las estructuras sociales. Se considera que el habla es un vehículo para la acción social y también uno de los principales medios con que se construye y se mantiene mutuamente la organización social en la interacción entre las personas. Según (Goodwin & Duranti, AÑO), proponen cuatro dimensiones que abarcan los elementos no lingüísticos presentados en una conversación: •

La localización Marco socioespacial (escena psicosocial) Deixis (de persona, de tiempo, de lugar, textual y social).

•

El comportamiento no verbal Oral (vocalizaciones, Kinesia, proxemia) Escrito (soporte, formato, tipografía, lo icónico).

•

La lengua como contexto o marcas de cohesión (relaciones. fónicas, conexión...) o géneros discursivos o (proto), tipos textual/es o variedad/es lingüística/s o intertextualidad.

•

El contexto extrasituacional aclara la estructura de las presuposiciones (conocimiento previo) guiones (secuencias cognitivas) Así pues, tanto lo lingüístico como lo no lingüístico se articulan para crear el contexto particular en que se desarrolla un intercambio comunicativo; contexto que se va negociando y que puede cambiar a lo largo de una conversación.

El análisis de la conversación nos permite darnos cuenta de cómo las formas, tanto lingüísticas como no lingüísticas en la interacción social crean y dan sentido a nuestras actividades cotidianas. Teniendo como objetivo el poder entender cómo se construyen, se negocian y reproducen determinados papeles sociales. A través del análisis conversacional y partiendo de las formas

21

lingüísticas en uso, al analizar cómo se va modulando una conversación con elementos no lingüísticos, se crea sentido y se descubren los signos sociales que emergen en una conversación.

3.3. Análisis del Discurso Tanto el discurso hablado como el discurso escrito (texto), se consideran hoy en día como una forma de interacción contextualmente situada. Si queremos entender en su totalidad los mensajes que nos transmiten, es necesario hacer un análisis de lo que nos dicen, es decir, tomar cada parte de esos mensajes y saber cuál es su significado, conocer que se obtiene de la unión de todo lo que una persona habló o escribió de cualquier tema; de esa manera tendremos la certeza de conocer el trasfondo de lo que se está diciendo. Por otra parte, si nos quedamos únicamente con la transmisión de información1, sin comprender a fondo lo que se nos está comunicando, solamente obtendremos lo explícito del mensaje, (lo que escuchamos, lo que leemos) dejando de lado lo implícito (lo que está entre líneas, lo que no se dice claramente) del mensaje, por lo que nos quedamos con la mitad de la información (V)

Figura 12. Proceso de Comunicación básica

En un proceso de comunicación básico, un emisor transmite mensajes (actos del habla) por medio de un canal, ya sea escrito, hablado, o por medio de símbolos (escritura) que son recibidos por un interlocutor o receptor, quien descodifica los mensajes enviados, es decir los interpreta, los entiende y los procesa para después retroalimentar a quien transmite la información, esto se evidencia en la figura 12.

22

3.4.1. Actos del habla La teoría de actos del habla es iniciada por John L. Austin en 1962 y desarrollada posteriormente por John R. Searle en 1969. Por actos del habla se refieren a los momentos en los que los enunciados se producen en el acto comunicativo, dentro de un contexto dado, es decir, los tipos de enunciados que existen, identificándose 3 tipos de Actos: locutivos, ilocutivos y perlocutivos. El acto locutivos es el que se realiza al decir aquello que se dice, el ilocutivo es la intención o finalidad que se tiene al decir algo, el acto perlocutivo es el efecto que se produce en el oyente por haber dicho algo. Austin fue el primer autor en presentar la idea del acto de habla como una unidad funcional en la comunicación. Austin, menciona que, cuando una persona dice o enuncia algo, lo dicho puede tener dos significados: el significado literal, o locutivo, y el significado ilocutivo, para él, el decir es actuar. Searle, se basó en las ideas de Austin y analizando los actos ilocutivos, clasificó los actos de habla en cinco grupos: •

Encomendativos (promesas o amenazas).Ej.: «La recepcionista te llamará para hacer una cita».

•

Declarativos (enunciados que se usan para declarar un cambio en el estado de las cosas). Ej.: «Le declaro el cirujano jefe del hospital».

•

Representativos (afirmaciones, reclamaciones e informes). Ej.: «Sus niveles de colesterol son altos».

•

Expresivos (disculpas, quejas y otras expresiones de sentimientos y actitudes hacia algo). Ej.: «No me gusta cómo me trató el Dr. Agnew».

•

Directivos (sugerencias, peticiones y mandados). Ej.: «Túmbese encima de la cama» (directo); « ¿Por qué no se sienta encima de la cama?» (Indirecto). (dicho no es lo que creen que has dicho, Jacobson 2001)

La teoría de los actos del habla permite caracterizar las locuciones que serán expresadas por un agente conversacional como parte de un sistema de diálogo.

23

3.4.2. Sistemas de Diálogo Los sistemas de diálogo, también conocidos como sistemas conversacionales, se han convertido hoy en día en una herramienta esencial para el desarrollo de servicios de atención al cliente, banca telefónica o de venta de productos. La tendencia actual de esta tecnología esté orientada a desarrollar sistemas para dominios de aplicación restringidos, los cuales permiten utilizar información acerca de las posibles palabras, tipos de frases e intenciones de los usuarios. Los sistemas de diálogo desarrollados han sido aplicados principalmente a tareas como las siguientes: información y reserva de viajes en avión o en tren, información meteorológica, control de terminales telefónicos, compra de productos, ayuda a la comunicación entre personas que hablan distintos idiomas, acceso al correo electrónico o mensajes telefónicos, etc. Algunos de los principales problemas que se deben resolver para lograr que estos sistemas sean más "amigables" y efectivos para los usuarios son los siguientes: 1. Reconocimiento robusto del habla. 2. Extracción de la información semántica de las frases. 3. Gestión del diálogo. El éxito de un sistema de diálogo depende mucho del cuidado que se tenga con el diseño de la interacción, considerar que esta permita cubrir las limitantes usuales de la tecnología del reconocimiento del habla. Supuestamente esta tecnología no está garantizada por completo, así que se necesita mejorar los métodos empleados para prevenir, detectar, y recuperar los errores que se puedan producir durante la interacción. Normalmente un gestor de diálogo cumple cuatro funciones principales: •

Actualizar el contexto del diálogo

•

Proveer de contexto en el que basara las interpretaciones.

•

Coordinar el resto de los módulos.

•

Decidir qué información dar al usuario y cuando hacerlo. Para que así de información pertinente.

•

Por lo tanto, el gestor de diálogo puede consultar distintas fuentes de información, tales como resultados del procesamiento del lenguaje natural, resultados de consultas a bases de datos, conocimiento acerca del dominio de aplicación, conocimiento acerca de los usuarios y la historia del diálogo. La complejidad dependerá de la tarea y flexibilidad e iniciativa del diálogo. 24

4. Generación de respuestas y síntesis de voz. A fin de ser aceptados por los usuarios finales, los sistemas de diálogo deben generar mensajes con un alto nivel de inteligencia y naturalidad, y así de esta manera programar un diálogo entre humano-maquina, es decir un agente conversacional y el usuario (Libro Blanco de las Tecnologias del Habla).

25

CAPÍTULO 4. PROGRAMACIÓN DE DIÁLOGO EN AGENTES

CONVERSACIONALES En este capítulo se describe el lenguaje AIML para poder entender el funcionamiento de cada una de las etiquetas que se utilizan en éste, y de esta forma programar la base de conocimientos del asistente virtual la cual permitirá dar respuestas al usuario, y así establecer un diálogo.

4.1 AIML Para poder mantener un diálogo de texto coherente con el usuario en lenguaje natural, en el módulo de gestión del diálogo de ésta investigación, se hará uso del lenguaje AIML. AIML (Artificial Intelligence Markup Language, Lenguaje) es un lenguaje compatible con XML que es fácil de aprender, y nos permite crear una base de conocimientos. Esta base de conocimiento utiliza un conjunto de categorías con las cuales un agente conversacional podrá dar respuesta a preguntas, asociándoles patrones (personalizados o enfocadas a un tema en específico). AIML fue desarrollado por la comunidad de software libre durante el periodo 1995-2000. AIML describe una clase de objetos de datos llamados objetos AIML. Los objetos AIML están formados por unidades llamadas categorías y temas. La unidad básica de conocimiento en AIML son las categorías indicadas con la etiqueta . Cada categoría se compone de una pregunta de entrada, una respuesta de salida y un contexto opcional. La pregunta o estimulo se llama patrón y se señala con la etiqueta , el patrón debe de estar en mayúsculas y debe coincidir con lo que un usuario pueda dar como entrada. . La respuesta se llama plantilla y está especificada por la etiqueta (Bush, 2001).

26

4.1.1 Características A continuación se presentan las características que tiene el lenguaje AIML, como lo es su simplicidad y su flexibilidad, en particular este lenguaje tiene dos problemas que se presentan a continuación el primero de ellos es la rigidez, en la exactitud que tiene, es decir el usuario debe ingresar exactamente la frase que se tiene previamente en la base de conocimientos. Solo permite el uso de comodines * y _ en una parte de la frase y no soporta ninguna variante de estos, como podría ser; cualquier palabra que tenga diez letras, solo si es un digito, solo si es un signo, etc. Tampoco permite obtener el valor ingresado. Por ejemplo: en la palabra “HOLA” relaciona solamente una palabra idéntica de las frases (“Hola”), y “HOLA *” relaciona cualquier frase de dos o más palabras iniciando con “Hola” (Ej. “Hola ¿como estas?”). El segundo problema que tiene AIML, es que ningún intérprete cumple con todo lo que está en la especificación. Según AIML debería poder ejecutar sentencias java script o invocar scripts de otro lenguaje como puede ser BASH, incluso HTML. Sin embargo estas funcionalidades no están implementadas. [por que no aiml]

4.1.2 Etiquetas Esta sección describe las etiquetas de AIML más utilizadas en la composición de un archivo .aiml que forma parte de la base de conocimiento de un agente conversacional. En la figura 13 se muestra la jerarquía de las etiquetas en AIML. Cada etiqueta que se abre tiene asociada una etiqueta que se cierra por ejemplo y . Son 4 las etiquetas básicas que se utilizan en la construcción de, la etiqueta se utiliza para iniciar y termina un documento AIML. La etiqueta , marca el inicio de una "unidad de conocimiento" que contiene a una pregunta (patrón), sus respuestas

y un contexto opcional

(etiquetas that y topic). Los patrones se definen por la etiqueta , las posibles respuestas al patrón están definidas por la etiqueta . A continuación se describen las etiquetas ilustradas en la figura 13.

27











. . . Categorías Relacionadas a un Tema. . .



/aiml

Figura 13. Jerarquía de Etiquetas en AIML

Dependiendo de la configuración de los y , se pueden considerar que hay 3 tipos de categorías: Atómicas, Default y Recursivas. Las Categorías Atómicas son las que tienen patrones atómicos, por ejemplo; el patrón que no contenga “*” o “_”, son las más fáciles y simples para añadir en AIML. Un ejemplo es el siguiente: QUE ES LA MAESTRIA Es un programa de estudios que esta dedicado a la Investigacion. Se profundiza en problemas que por su complejidad, requieren de encontrar soluciones óptimas, mediante los nuevos métodos de computación inteligente (redes neuronales, métodos heurísticos, algoritmos genéticos, entre otros)

Las Categorías default, son aquellas que en su patrón tiene un “*” o “_”. La última categoría default es la que tiene un *, la cual se relaciona con cualquier entrada. Esas respuestas default son a menudo llamadas por que generalmente se componen de preguntas diseñadas dirigidas a enfocar al cliente de temas que conoce. Categorías predeterminadas muestran 28

que la escritura AIML es un arte y una ciencia. Las categorías default más comunes tienen patrones combinados con unas pocas palabras y un símbolo comodín (Ringate, Wallace, Taylon, Baer, & Daniels, 2001). Por ejemplo la categoría “¿QUE ES *?”, es un claro ejemplo de una categoría default. ¿QUE ES *? Es un programa de estudios que está dedicado a la Investigación y Se profundiza en problemas que por su complejidad, requieren de encontrar soluciones óptimas, mediante los nuevos métodos de computación inteligente (redes neuronales, métodos heurísticos, algoritmos genéticos, etc.).

Las Categorías Recursivas son aquellas que “mapean” entradas a otras entradas, ya sea para simplificar el lenguaje o a identificar patrones de sinónimos. Muchas entradas de sinónimos tienen la misma respuesta. Esto se logra con la etiqueta recursiva (Ringate, Wallace, Taylon, Baer, & Daniels, 2001). Un ejemplo de esta categoría podría ser un saludo como el siguiente “BUEN “BUEN

DIA *”,

DIA”,

estas frases pueden tener varias formas de sinónimos en la forma de responder, como

los que siguen: “Que tal, como te va”, “Hey, como estas”, etc. Para mapear esas entradas a la misma salida para “HOLA” se usan categorías como las siguientes: BUEN DIA HOLA BUEN DIA * HOLA

HOLA Hola. ¿Cómo te llamas? Que tal, como te va Hey, Como te va ¡Hola !

La simplificación o reducción de patrones de entrada complejos es otra aplicación común de categorías recursivas. La pregunta “Que es X” podría ser preguntada de muchas formas diferentes: 29

"Sabes tú que es X?", "Háblame sobre X", "Describe X", "Que puedes tu decirme sobre X?", y "¿X es qué?" son algunos ejemplos. Usualmente se intenta almacenar conocimiento en la manera más concisa o común. La función asigna a todas estas formas a la forma básica: SABES QUE ES * QUE ES

La etiqueta sustituye el valor relacionado con un “*”, antes la recursividad llama a la etiqueta . Esta categoría transforma “¿Sabes que es un circulo?” a “¿Que es un circulo?”, y entonces encuentra la mejor relación para la entrada transformada. Otra aplicación muy común de las categorías recursiva es lo que podría denominarse "análisis", excepto que AIML no analiza el lenguaje natural. Un mejor término podría ser "partición", porque estas categorías AIML descomponen la entrada en dos (o más) partes, y luego se combinan las respuestas y nuevamente se juntan. Si una frase comienza con "Hola..." no importa lo que viene después de la palabra en primer lugar, en el sentido de que el robot puede responder a "Hola" y lo que esta después de "..." es independiente. Ejemplo “Hola mi nombre es Carlos” y “Hola como estas” son bastante diferentes, pero muestran como la entrada puede ser partida en dos partes. A continuación se muestran unos ejemplos que sirven para ilustrar la idea que se plantea. Lleva a cabo la partición de entrada respondiendo a "HOLA" con HOLA , a cuanto coincide con "*" con . La respuesta es el resultado de las dos respuestas parciales anexas juntas.

HOLA * HOLA HOLA QUE ONDA HEY COMO ESTAS QUE TAL QUE PASO HEY

30

Con el fin de especificar el “estimulo” o “entrada” del usuario, se hace uso de la etiqueta . El patrón es una expresión en un lenguaje formal que se compone de: •

Palabras de lenguaje natural en MAYÚSCULAS.

•

El símbolo “*” el cual relaciona cualquier relación de una o más palabras.

•

El símbolo “_” el cual es lo mismo que un “*” excepto que si viene después de la Z en orden lexicográfico.

La etiqueta , es la que se sustituye a la hora de cargar el bot con el nombre del bot. (Ringate, Wallace, Taylon, Baer, & Daniels, 2001). Las expresiones de AIML en el lado del patrón(PSAE), que pueden aparecer en la etiqueta , , o , y las expresiones de AIML en el lado de la plantilla(TSAE) que pueden aparecer dentro de la etiqueta . Note hay diferencias entre el patrón “HOLA” y “HOLA *”. Como se puede observar en la sección 4.1.2.1 se muestra la sintaxis de un patrón. Etiquetas La etiqueta topic permite elegir las propias respuestas que tienen que ver con el tema actualmente discutido. Es decir, cuando el programador decidió que un tema sea un topic, se pueden crear categorías las cuales podrían contener ciertas respuestas específicas sobre el topic. Esto mantiene una conversación de actualidad y aún se tiene la habilidad para moverse de un tema a otro. Esta etiqueta también permite tener patrones duplicados en diferentes contextos (temas) permitiendo tener diferentes respuestas para el mismo patrón de entrada dependiendo del tema. Por ejemplo, primordial el patrón “*” de los distintos temas. Hay la etiqueta para referirse al tema en tus declaraciones de salida (template). Las etiquetas topic se colocan alrededor de una o más categorías que serian asociadas con el topic definido. El nombre del tema seria dado por una propiedad “name” en el inicio de la etiqueta. Una vez que el tema es asignado, cuando el usuario teclea una frase para encontrar una respuesta, las categorías definidas en las etiquetas se relacionan con el tema actual, si no hay una relación con la categoría definida en el tema actual, entonces cualquiera de las categorías que no están definidas en las etiquetas topic son buscadas. Como se menciono anteriormente, podemos crear categorías con frases o patrones idénticos en diferentes temas, cada uno con distintas repuestas que necesite el tema actual. Por ejemplo, si el bot fuera colocado en un sitio Web y una persona hablara acerca de perros una entrada muy útil podría ser desplegada.

31

* Los perros son una de las mascotas mas populares para tener ¿Conoces un Chihuahua, no te gusta? Que mas sabes sobre perros? Tienes alguna otra pregunta acerca de los perros? . . .

Normalmente habrá muchas entradas en un tema, pero en este ejemplo, simplificamos las entradas por default “*”. En este caso, si la persona dice algo que el bot no tiene una respuesta especifica programada, podría aun responder inteligentemente en el tema actual. (Nota: Todo esto es suponiendo que no son categorías que podría definir el tema actual “PERROS”). Aunque también los temas pueden solamente tener un nombre, pueden contener los caracteres comodines “*” ó “_” como un patrón. Asimismo, si bien la continuidad de los criterios del patrón, solamente un carácter es permitido por nombre. Esto permitiría temas como “CUIDANDO PERROS” o “ASEANDO PERROS” puede ser también en el tema “_PERROS”. Al igual que los patrones, los temas mas específicos ganarían preferencia sobre el tema comodín. Esto significa que si el tema es actualmente “ASEANDO PERROS” y aun no hay una respuesta programada para la entrada en la categoría, entonces “_PERROS” sería verificada. Etiquetas La etiqueta de AIML se refiere a la respuesta anterior del bot. Hay dos formas de la etiqueta : una forma pareja … aparecen en una categoría, y una forma atómica siempre apareciendo en una plantilla de respuesta. A menudo podemos usar para encontrar una oportunidad para crear una categoría con . Una de las respuestas para la entrada “QUE TAL” es “Genial, como te va”.

32

A continuación se presenta un ejemplo de cómo crear un that: QUE TAL Genial, ¿Como estas tu? * como estas tu Ya sabes

Este estilo de análisis conversacional no presupone que sabemos cuando el usuario diría “Que tal”; más bien se observa que regresa a identificar casos donde apareció uno del siguiente “Como estas tu” de las declaraciones del bot. Teniendo identificado el punto de la conversación, el diseñador del bot crea una nueva categoría. Etiquetas Una Template es la respuesta o parte de la salida de una categoría AIML. El caso más simple se compone de un sencillo texto sin marcar. AIML provee funciones de marcado para confeccionar las respuestas para cada entrada individual y de usuario. La función de marcado por ejemplo inserta el nombre del cliente en la respuesta. El template puede llamar al patrón relacionado recursivamente usando las etiquetas y . Muchos templates son reducciones simples simbólicas que una frase de mapa para formar a otro, por ejemplo “Sabes que es X?” transformamos a “Que es X” con la categoría: SABES QUE ES * QUE ES

La etiqueta template se supone que también puede contener otras etiquetas incrustadas de HTML y XML.

33

En el siguiente fragmento de código, se aprecia cómo se asigna un topic, en un template elegido por el programador. MAESTRIA Maestria Recuerda que puedes formularme tus dudas acerca de la Maestría en Ciencias de la Computación. Mi función es ayudarte con tus dudas acerca de la Maestría en Ciencias de la Computación. Si tienes alguna duda sobre la Maestría en Ciencias de la Computación., aquí estoy para ayudarte Si estas interesado en la Maestría en Ciencias de la Computación, puedes preguntarme lo que quieras. ¿Estas interesado en la Maestría en Ciencias de la Computación? Como ya te he dicho, mi función es informarte sobre la Maestría en Ciencias de la Computación.

Este código permite ilustrar la forma en que se asigna un topic, dentro de un template. Cabe mencionar que las categorías asociadas al topic pueden ser diferentes o iguales a las que se tiene en la base de conocimientos aiml. Como se puede apreciar las categorías del topic asignado se encierran entre la etiqueta topic y también tiene su etiqueta de cierre como cualquier otra. ¿QUE ES? Es un programa Investigación. QUE ES Es un programa .

de

de

estudios

estudios

que

esta

que

está

dedicado

dedicado

a

la

a

la

Investigación

Este lenguaje permite tener en una categoría un solo patrón, aunque dato curioso puedes tener varias respuestas, como salida. Etiquetas o Esta etiqueta tiene muchos acrónimos (“Inteligencia Artificial de Reducción Simbólica”, “Inteligencia Artificial de Recursividad Simple”, “Inteligencia Artificial de Estimulo-Respuesta”). La etiqueta siempre aparece en la respuesta, pero siempre trae como respuesta lo que se encuentre en el patrón que se escribe entre esta. El bot busca en su base de conocimientos y 34

encuentra la mejor respuesta. La única parte difícil es que la respuesta puede estar contenida dentro de más etiquetas . La mejor forma de entender la acción recursiva de la etiqueta de AIML es con un ejemplo Por ejemplo: HOLA SALUDOS

SALUDOS Que tal

En este caso si el usuario dice HOLA, el asistente dará la respuesta que está contenida en el template del patrón SALUDOS.

4.1.3 Algoritmo de Coincidencia de Patrones AIML carga el contenido de los archivos AIML en una estructura de datos llamada Graphmaster. Esta estructura se compone de una colección de nodos llamados Nodemappers. Esos Nodemappers controlan las ramas de cada nodo. Las ramas son palabras simples o símbolos (comodines). El número de hojas grafo es igual al número de categorías, y cada nodo hoja contiene una etiqueta . Los pasos del algoritmo de coincidencia de patrones son: •

Verificar si el Nodemapper contiene el símbolo “_”, si es así, buscar en el subgrafo correspondiente. Intentar todos los sufijos siguientes “X” para ver si uno coincide. Si no se encuentra coincidencia, intentar;

•

Verificar si el Nodemapper contiene el símbolo “X”, si es así, buscar en el subgrafo correspondiente, utilizando la cola de la entrada (el sufijo de la entrada con “X” removido). Si no se encuentra coincidencia, intentar:

•

Verificar si el Nodemapper contiene el símbolo “*”, si es así, buscar en el subgrafo correspondiente. Intentar todos los sufijos siguientes “X” para ver si uno coincide. Si no se encuentra coincidencia, regresar al padre de éste nodo, y colocar “X” en el inicio de la entrada.

•

Para terminar, si la entrada es nula (es decir, no hay más palabras) y el Nodemapper contiene la palabra , indica que se ha encontrado una coincidencia. Detener la búsqueda y regresar el nodo coincidente.

•

Si el Nodemapper contiene el símbolo “*” y es un nodo hoja, entonces el algoritmo garantiza encontrar una coincidencia. 35

En cada nodo, el símbolo “_” tiene prioridad primero, luego una palabra y posteriormente, el símbolo “*”. Los patrones son ordenados de manera en que el símbolo “_” se encuentre antes de cualquier palabra y el símbolo “*” posterior a cualquier palabra. La coincidencia se realiza palabra por palabra, no categoría por categoría. El algoritmo combina el patrón de entrada y las etiquetas y en un sólo patrón: PATTERN THAT TOPIC y trata los tokens y como palabras ordinarias. El algoritmo es una versión limitada de una búsqueda en profundidad y está basado en los algoritmos backtracking.

4.2 Extensión Emocional AIML En esta sección se presenta la estructura de la extensión de AIML desarrollada por (Florencia, 2010) que integra etiquetas que permiten caracterizar la expresión de rasgos de personalidad, emoción y su intensidad en los actos del habla de una base de conocimientos AIML. En la figura 14 se presenta la nueva estructura general de archivos los AIML que integran las nuevas etiquetas que permiten expresar emociones en el diálogo. Esta estructura considera el contexto y 3 atributos del modelo emocional de Morales [Morales, 2007] (personalidad, emoción y su intensidad) para filtrar los posibles diálogos emocionales contenidos dentro de la etiqueta . El atributo contexto se agregó a la etiqueta . En éste atributo se especifica el contexto del tema conversacional asociado al patrón de entrada del usuario. Dentro de la etiqueta , se agregó la etiqueta , cuya finalidad es filtrar los diálogos emocionales de acuerdo a la personalidad especificada, es decir, si la personalidad indicada es Personalidad 2, los diálogos emocionales de Personalidad 1 no son considerados en el proceso de selección de diálogos de AIML. Para cada personalidad, se agregaron las etiquetas emocionales de , , , , , , , y . Dependiendo de la emoción actual determinada por el módulo emocional, éstas etiquetas emocionales son utilizadas para filtrar los diálogos de respuesta al usuario, es decir, si la emoción actual fuera “enojo”, sólo los diálogos correspondientes a ésta emoción serían considerados en el proceso de selección de diálogos de AIML. Asociada a cada etiqueta de la emoción se agrega la etiqueta , el uso de este atributo permite asociar una Intensidad de la emoción al texto de respuesta proporcionado por la etiqueta Template. La intensidad se define como un número que está en el rango de 0-9, el cual representaría 36

qué tan fuerte es la emoción. Este atributo permite incorporar varios rangos de intensidad dentro de cada una de las emociones. Los rangos de intensidad emocional de las etiquetas emocionales, se basan en la escala de valores que la intensidad puede tomar en el módulo emocional. La escala de valores oscila de 0 < x < 9, donde x es el valor de la intensidad actual.

37

Category Patrón

Pattern

/Pattern

Template Enojo

Alegria

Miedo

Tristeza

Sorpresa

Placer

Resignación

Angustia

Neutro

Intensidad 0-3

Texto Respuesta

/Intensidad

Intensidad 3-6

Texto Respuesta

/Intensidad

Intensidad 6-10

Texto Respuesta

/Intensidad

Intensidad 0-3

Texto Respuesta

/Intensidad

Intensidad 3-6

Texto Respuesta

/Intensidad

Intensidad 6-10

Texto Respuesta

/Intensidad

Intensidad 0-3

Texto Respuesta

/Intensidad

Intensidad 3-6

Texto Respuesta

/Intensidad

Intensidad 6-10

Texto Respuesta

/Intensidad

Intensidad 0-3

Texto Respuesta

/Intensidad

Intensidad 3-6

Texto Respuesta

/Intensidad

Intensidad 6-10

Texto Respuesta

/Intensidad

Intensidad 0-3

Texto Respuesta

/Intensidad

Intensidad 3-6

Texto Respuesta

/Intensidad

Intensidad 6-10

Texto Respuesta

/Intensidad

Intensidad 0-3

Texto Respuesta

/Intensidad

Intensidad 3-6

Texto Respuesta

/Intensidad

Intensidad 6-10

Texto Respuesta

/Intensidad

Intensidad 0-3

Texto Respuesta

/Intensidad

Intensidad 3-6

Texto Respuesta

/Intensidad

Intensidad 6-10

Texto Respuesta

/Intensidad

/Enojo

/Alegria

/Miedo

/Tristeza

/Sorpresa

/Placer

/Resignación

Intensidad 0-3

Texto Respuesta

/Intensidad

Intensidad 3-6

Texto Respuesta

/Intensidad

Intensidad 6-10

Texto Respuesta

/Intensidad

/Angustia

Intensidad 0-10 Texto Respuesta

/Intensidad

/ Neutro

/Template /Category

Figura 14. Estructura propuesta para los archivos AIML de la base de conocimientos.

38

A continuación se presenta un fragmento de código que ilustra el uso de la estructura propuesta. PATRON DE USUARIO Diálogo 1 de respuesta al usuario de Personalidad 1 Diálogo 2 de respuesta al usuario de Personalidad 1 Diálogo 3 de respuesta al usuario de Personalidad 1 . . . Diálogo 1 de respuesta al usuario de Personalidad 2 Diálogo 2 de respuesta al usuario de Personalidad 2 Diálogo 3 de respuesta al usuario de Personalidad 2 . . .

En base al código de ejemplo anterior, la funcionalidad de las etiquetas y se mantiene igual que en el AIML original. La etiqueta tiene tres atributos asociados, Imagen, intensidadMin e intensidadMax. En el atributo Imagen se puede especificar el nombre de un archivo de imagen, el cual es enviado a la interfaz principal del Asistente Virtual al recuperar la respuesta asociada al patrón de entrada del usuario. Esto da la posibilidad de presentar imágenes estáticas del Asistente Virtual en el caso de no contar con animaciones. Es recomendable que la imagen asociada al atributo Imagen, sea de acuerdo a la emoción y a la intensidad a las que se quiere representar. En los atributos intensidadMin e intensidadMax, se especifica el valor inicial y final de un rango de intensidad.

39

Entonces, el filtrado de los diálogos depende del valor de la etiqueta de la personalidad, de la emoción actual y de la intensidad de la emoción actual.

4.3 Python y PyAIML Python es el lenguaje de programación orientado a objetos que se utilizará para implementar la interfaz gráfica del asistente virtual, el cual cuenta con una librería externa que sirve para interpretar archivos aiml, que son los que se crean para la base de conocimientos. A continuación se describe el lenguaje. Python es un lenguaje de Scripting independiente de plataforma y orientado a objetos, preparado para realizar cualquier tipo de programa, desde aplicaciones Windows a servidores de red o incluso, páginas Web. Es un lenguaje interpretado, lo que significa que no se necesita compilar el código fuente para poder ejecutarlo, lo que ofrece ventajas como la rapidez de desarrollo e inconvenientes como una menor velocidad (Álvarez, 2003). En las siguientes secciones se presentan las características del lenguaje y de la librería PyAIML.

4.3.1 Características de PYAIML. Esta librería es un complemento de clases escritas 100% en Python, las cuales permiten la interpretación de los archivos escritos en el lenguaje aiml. Es libre.

4.3.2 Características de Python En los últimos años el lenguaje se ha hecho muy popular, gracias a varias razones como: 1) la cantidad de librerías que contiene, tipos de datos y funciones del propio lenguaje, que ayudan a realizar muchas tareas habituales sin necesidad de tener que programarlas desde cero, 2) la sencillez y velocidad con la que se pueden crear programas, 3) la cantidad de plataformas en las que podemos desarrollar, como Unix, Windows, OS/2, Mac, y otros, 4) además, Python es gratuito, incluso para propósitos empresariales.

A continuación se describen sus características más sobresalientes (Álvarez, 2003): 40

Propósito general

Con él se pueden crear todo tipo de programas. No es un lenguaje creado específicamente para la Web, aunque entre sus posibilidades sí se encuentra el desarrollo de páginas.

Multiplataforma

Hay versiones disponibles de

Python en

muchos sistemas

informáticos distintos. Originalmente se desarrolló para Unix, Aunque cualquier sistema es compatible con el lenguaje siempre y cuando exista un intérprete programado para él. Interpretado

Quiere decir que no se debe compilar el código antes de su ejecución. En realidad sí que se realiza una compilación, pero esta se realiza de manera transparente para el programador. En ciertos casos, cuando se ejecuta por primera vez un código, se producen unos bytecodes que se guardan en el sistema y que sirven para acelerar la compilación implícita que realiza el intérprete cada vez que se ejecuta el mismo código.

Interactivo

Python dispone de un intérprete por línea de comandos en el que se pueden introducir sentencias. Cada sentencia se ejecuta y produce un resultado visible, que puede ayudarnos a entender mejor el lenguaje y probar los resultados de la ejecución de porciones de código rápidamente.

Orientado a Objetos

La programación orientada a objetos está soportada en Python y ofrece en muchos casos una manera sencilla de crear programas con componentes reutilizables.

Funciones y librerías

Dispone de muchas funciones incorporadas en el propio lenguaje, para el tratamiento de Strings, números, archivos, etc. Además, existen muchas librerías que podemos importar en los programas para tratar temas específicos como la programación de ventanas o sistemas en red o cosas tan interesantes como crear archivos comprimidos en .zip. Tabla 2. Características de Python

Python se puede programar en consola o de forma gráfica. Para la modalidad gráfica existen varios IDE’s como los siguientes: Boa Constructor, VisualWx, PyDev, OpenKomodo, Eric, PIDA, SPE, WingIDE, PyScripter. 41

En este caso se utilizará el IDE VisualWx para Python. VisualWx pretende ser la última herramienta RAD diseñada para C++, Python, Perl, Ruby, lua y wxWidgets. Algunas de sus características se mencionan a continuación: •

Diseñador de varios frames.

•

Visualwx genera código para C + +, Python, Perl, Ruby, lua

•

Su compilador es compatible (mingw32)

•

Editor de C++, Python, Perl, Ruby, Lua (editor Scintilla)

•

Soporta eventos de teclado, Mouse(VisualWx, 2010).

4.3.3 MySQLdb Python permite la conexión y gestión de bases de datos (DBMS). Un DBMS es uno de los cuales es una colección de numerosas rutinas de software interrelacionadas, cada una de las cuales es responsable de alguna tarea específica. Para su uso se necesita descargar la librería mysql-python. MySQLdb es el Python DB API 2.0._mysql es una API de bajo nivel similar a la API MySQL C. MySQLdb es una interfaz popular para un servidor de base de datos para Python. Los objetivos de diseño son: Cumple con la versión 2.0 de la API de BD para Python, Threads o hilos de seguridad, Hilos de manejo o hilos que no se bloquean mutuamente (Dustman, 2006) .

42

CAPÍTULO 5. DISEÑO DE UN ASISTENTE VIRTUAL CON DIÁLOGO EMOCIONAL En el presente capítulo se describirá la arquitectura general para el diseño de un asistente virtual con diálogo emocional, sus requerimientos, y la metodología para organizar la estructura de los diálogos. La estructura de la base conocimiento que el agente utiliza para construir el diálogo hará uso del lenguaje aiml, ya que para crear una base de conocimientos como ya se había mencionado con anterioridad, se puede utilizar el lenguaje AIML, y para crear la interfaz gráfica se utilizó, el lenguaje Python.

5.1 Arquitectura General En esta sección se presenta la arquitectura general del asistente virtual, la cual se puede apreciar en la figura 15. El diseño de un asistente virtual requiere de contar con los módulos de gestión del diálogo, Modulo de generación de locución del asistente, los cuales cuentan con entradas y salidas. El modulo de gestión del diálogo recibe información como entradas de la Base de Datos AIML, Locución del usuario (pregunta), Base de Datos MySQL. El modulo de generación de locución del asistente recibe como entradas información del intérprete PyAIML, también recibe información de la base de datos MySQL. Estas son tres las etapas del proceso del diálogo: •

Entrada o Pregunta. Es el estimulo o pregunta que se introduce por medio del teclado, para que el Asistente Virtual, inicie con el proceso de conversación.

43

•

Búsqueda: Es el proceso donde se busca un patrón relacionado con la entrada y así producir una respuesta o salida.

•

Salida o respuesta. Es el proceso en el que se despliega en pantalla una respuesta al usuario, que puede ser respuesta proveniente de la base de conocimientos del asistente virtual, o ser la respuesta de una consulta a la base de datos.

En la figura 15, queda ilustrado que el módulo de Generación de locución del asistente, recibe como entrada una locución por parte del usuario, es decir, una pregunta, o de la base de conocimientos en AIML, o de la base de datos en MySQL, todo esto para generé una salida que será mostrada como una respuesta al usuario. Es importante, destacar que lo relevante del Modulo de Generación de locución del Asistente, es que este sirve para generar las respuestas del asistente, es decir, la gestión del diálogo.

Locución del usuario

Gestión del Diálogo Base de Datos AIML

Base de Datos MySQL

Modulo de Generación de locución del Asistente

Locución del asistente virtual Interfaz gráfica

Figura 15. Arquitectura del Asistente Virtual

44

A continuación se presenta nuestra propuesta de estructuración del Modulo de Generación de locuciones del Asistente, el cual genera respuestas a partir de decisiones, las cuales serán explicadas a continuación.

Modulo de Generación de locución del Asistente Locución del asistente virtual

Base de datos AIML Interprete PyAIML

Respuesta

Respuesta == Número

Respuesta

no

Locución del usuario si

Base de datos MySQL

Interfaz Gráfica

Búsqueda de link (idpage) en BD Link

Consulta del link en Internet

“usted recibirá más Información en la página web”

Figura 16. Modulo de Generación de locución del Asistente

Los componentes involucrados son: la base de conocimientos en AIML, la base de Datos en MySQL, la interfaz gráfica en Python. La relación que existe entre estos componentes es la siguiente, debido a que la interfaz gráfica creada en Python podría hacer uso de la base de conocimientos en AIML, así como también podría utilizar la Base de Datos que se creó en MySQL, esto con el fin de dar como resultado una respuesta, a una pregunta realizada con anterioridad, es decir, dar una respuesta por parte del asistente virtual al usuario. Este sería un caso directo en la interacción del asistente virtual con el usuario. Un tipo de interacción indirecta es el siguiente caso, en el que un usuario interactúa con el modulo de generación de locución del asistente virtual sin saberlo, y el solo se percata que el asistente le 45

está respondiendo, así que, a continuación se describirá el proceso interno de la interacción entre la interfaz y las bases de conocimientos, por lo tanto, es válido decir que el usuario da como entrada una palabra o una frase, es decir una locución, y lo que hace el interprete de AIML para Python, llamado PyAIML, realice una búsqueda en la base de conocimientos, y así genere una respuesta y se la presente al usuario, pero en el caso que el resultado ser igual a un numero (idpage), este hará una consulta internamente en una base de datos, el cual buscará un link relacionado a la entrada o pregunta, y al encontrar el link relacionado con la respuesta, se abrirá una página web, que de igual forma se relaciona con la respuesta. Así mismo, en la interfaz gráfica se manda a imprimir un mensaje como el siguiente: “usted recibirá más información en la página web”. En caso contrario, es decir que la respuesta no sea igual a un numero, simplemente el asistente virtual da como respuesta una que se encuentre alojada en la base de conocimientos, es decir, si encuentra coincidencia alguna con la entrada del usuario. Y si no encuentra una respuesta adecuada a lo que pregunto el usuario simplemente dará unas respuestas como las siguientes: No entiendo No tengo ni idea de lo que estás diciendo No entendí eso que has dicho Me encuentro algo perdido en este contexto Lo siento, pero no comprendo Me parece que estoy perdido Mi cerebro no tiene respuesta para eso Esa frase se me escapa No sé que responder a eso No entiendo lo que has dicho Perdóname pero necesito un conocimiento más avanzado para responderte a eso

5.2 Metodología a seguir para organizar la estructura de los diálogos En la escritura de bases de conocimiento para la arquitectura de un asistente virtual se requiere analizar y estructurar el posible diálogo con el que se piensa trabajar. Y así llegar a crear estructuras de diálogos concretas. En esta sección se presenta la descripción del proceso involucrado en la organización de la estructura de los diálogos, desde el análisis hasta la creación. Para crear la estructura de un diálogo sobre un tema en específico, se deben crear unidades de conocimiento con esta información, la cual se tendrán que almacenar como una base de conocimientos.

46

La información podría provenir de análisis de video filmaciones de las situaciones reales que se desean simular. El trabajar con filmaciones permite facilitar el análisis de la conversación y del discurso que permitirán generar una base de los Actos de Habla de la interacción. Además de información sobre un tema en especifico, también se podrían pensar temas relacionados con los usuarios, como lo pueden ser la forma en que se expresa al saludar, es decir, saludos, referentes a su persona como nombre, apariencia física, edad, estado de ánimo, acerca de la familia, género, profesión, nacionalidad, entre otras cosas relacionadas con el usuario. Estos ayudan a crear e identificar contextos, y los roles de los interlocutores. Nosotros tenemos la idea que la gestión del diálogo basada en AIML, y la estructura puede tratarse como un diseño, con esto a partir de la teoría de inteligencia artificial llamada CBR (Case-Based Resasoning), se contextualiza, y en este caso el razonamiento basado en casos vendrían siendo las categorías de AIML. Esta técnica encuentra el patrón que mejor encaja con cada entrada, y así la categoría enlaza la plantilla de respuesta directamente al patrón del estímulo, y regresa una salida que satisfaga la entrada. A continuación se describen algunas condiciones de esta técnica. •

Se estructura una tarea de forma clara; Es decir, que se tenga bien definido el tema o funcionalidad.

•

Se introducen frases pre-establecidas por parte del programador o botmaster; Las frases o preguntas que puede hacer el usuario solamente estarán obligadas a tratar sobre la Maestría en Ciencias en Ciencias de la Computación.

•

En cuanto a las preguntas, se tienen en mente algunas respuestas para las que ya han sido preestablecidas, es decir se espera una determinada respuesta por parte del usuario; En esta parte el sistema da una respuesta a una pregunta.

47

A continuación se presentan las etapas de abstracción con un diagrama, el cual posteriormente será descrito:

Inicio

Establecer objetivo

Definir atributos de conversación

Recabar información relacionada con el tema de conversación.

Análisis de la información recabada

Desarrollar la base de conocimientos

Fin

Figura 17. Diagrama de flujo de la metodología en forma general.

En el diagrama anterior se puede observar a grandes rasgos, los pasos que se deben seguir para crear una base de conocimientos, en la figura 17, se presenta el flujo de una forma muy general, y ya en la figura 18 se muestra el proceso más detallado o especifico. Al utilizar la figura 17, como guía se tiene ha aplicado la metodología de la organización de la estructura de diálogos. A continuación se empezarán a describir cada una de las etapas del diagrama específico. 48

Establecer objetivo En esta parte se pretende que se definan o establezcan claramente el objetivo y la función del asistente virtual. Esto influenciará tanto la construcción de la Base de Conocimiento como el diseño de la Interfaz Gráfica que lo acompañará.

Definir atributos de la conversación En este proceso se quiere que se tengan definidos los atributos como lo pueden ser: las emociones, rangos de intensidad y el tema de conversación, y así asignárselos al asistente virtual.

Recabar información relacionada con el tema de conversación. Este es un proceso de recolección de la información necesaria para posteriormente crear los diálogos de respuestas, etc. que se relacione con el tema de conversación. Para que al momento de querer utilizar la información sea coherente. Por ejemplo análisis de la conversación y del discurso de video filmaciones.

Análisis de la Información recabada. Al usar la información recabada se pueden inferir contextos, crear categorías de acuerdo a la información recopilada, y así determinar diálogos de respuestas, con los cuales se podrán escribir frases o palabras de manera adecuada que expresen emociones, las cuales serán respuestas a preguntas por parte del usuario.

Desarrollo de la base de conocimientos. En este proceso se ve involucrada la programación de categorías en el lenguaje aiml, los cuales se utilizan para crear una base de conocimientos. La programación de categorías, permite darle la funcionalidad al cerebro del asistente virtual, presentando algunas preguntas para conocer al usuario, y otras que están diseñadas para hablar sobre el tema de interés. La estructura de la base de conocimientos del asistente virtual, debe estar construida de tal manera que permita ingresar a modificarla, actualizarla y recuperar el conocimiento de la forma más sencilla posible.

49

En la siguiente imagen se ilustra el detalle de todos estos procesos:

Inicio Determinar los diálogos de respuestas Establecer objetivo

Establecer función

Definir las emociones y rangos de intensidad

Escribir las frases o palabras adecuadamente expresando emociones

Desarrollar la base de conocimientos

Definir el tema de conversación

Fin

Recabar información relacionada con el tema de conversación.

Determinar Contextos.

Hacer categorías con la información recopilada

Figura 18. Diagrama de flujo para desarrollar una base de conocimientos en forma específica.

50

5.3 Análisis de la Información para organizar la estructura de los diálogos Las siguientes son las etapas a considerar para analizar la información que permita el diseño y construcción de la Base de Conocimientos. ETAPAS

DESCRIPCIÓN

1

Identificar cuál es la finalidad de la interacción y las posibles preguntas que se deben responder.

2

Determinar quiénes serán los posibles usuarios del asistente virtual.

3

Identificar las relaciones entre el tema y el usuario, para generar los contextos.

4

Identificar el rol y tipo de actividad que el asistente virtual va a desarrollar.

5 6

Determinar los Dominios de Conocimientos, Tópicos de la Conversación, Categorías, Patrones de Preguntas y las Respuestas a dichos patrones tomando en cuenta los diversos estados emocionales que se considerarán. Integración de la Base de Conocimientos del agente virtual Tabla 3. Etapas de la construcción de la base de conocimientos

A continuación se describen las actividades relacionadas con las etapas de análisis que se deben tomar en cuenta a la hora de hacer una base de conocimientos, y como se puede deducir un contexto. ETAPA 1 Para crear una base de conocimientos, es necesario hacernos las siguientes preguntas y tener las respuestas en mente. Considerando que se tiene un tema especifico, para el cual se presuponen las preguntas y respuestas de las mismas. En esta etapa se piensa en ¿Cuál es la finalidad de la interacción y las posibles preguntas que se deben responder?, pues dado el caso, puede ser resolver dudas, dar información adicional, entre otras cosas. Así que procedemos a determinar los diferentes dominios de conocimiento que el asistente debe tener, es decir, ¿Cuál es el tema especifico que queremos tratar?

ETAPA 2 En la siguiente etapa, se determinan ¿quiénes serán los posibles usuarios del asistente virtual?, es decir quiénes son nuestro público objetivo: por ejemplo pueden ser los mismos Egresados de 51

Ingeniería en Sistemas Computacionales del ITCM, así como alumnos aspirantes a la Maestría en Ciencias en Ciencias de la Computación de otras escuelas, Maestros, y en general alumnos de la Maestría en Ciencias en Ciencias de la Computación. ETAPA 3 En base a las respuestas de las preguntas anteriores se procede identificar las relaciones entre el tema y el usuario, para generar los contextos. Por ejemplo, Maestros, Tesistas, Publicaciones, Plan de estudios; pueden ser palabras clave que sirven para poder diseñar en una base de datos del asistente virtual. ETAPA 4 En ésta etapa se tiene que pensar en el rol y tipo de actividad va a desarrollar el asistente, por ejemplo si es solo conversación, o si es solicitud de información. Aún así, siempre tenemos que pensar en que se tiene que especificar al usuario cual es el objetivo principal del asistente, ya que se puede dar el caso, que el usuario proporcione una entrada, para la cual el asistente virtual no encuentre en la base de conocimientos, y así el usuario este enterado de esto. ETAPA 5 Determinados los dominios de conocimientos que abarcara el asistente virtual, se identifican los tópicos de la conversación y sus categorías. Como componentes de las categorías se determinan o recuperan de los análisis de la conversación los actos del habla que se convertirán en patrones de preguntas y las respuestas a dichos patrones tomando en cuenta los diversos estados emocionales que se considerarán. Los patrones son las palabras clave que el asistente virtual consultará en su base de conocimientos para brindar la información pertinente, estos patrones están contenidos en las categorías que contiene el archivo AIML. Por ejemplo, se puede crear un archivo AIML titulado: Saludos.aiml, el cual puede contener los actos del habla asociados a un contexto específico como el inicio de una conversación. Proponemos que en relación con el contexto se cree el nombre del archivo AIML. En ese archivo se escribirán las categorías que contendrán patrones los cuales se relacionan con los saludos, Ejemplos de palabras o frases relacionadas con saludos que pueden ser considerados como patrones son: hola, que tal, como estas, buenas tardes, buenos días, que onda, etc.

A continuación se muestra un ejemplo de una categoría con un patrón para este contexto. 52

BUEN DIA HOLA

ETAPA 6 Al finalizar la creación de los archivos AIML que conforman los diferentes contextos que tendrá la base de conocimientos, se recomienda la creación de un directorio en el que se puedan agrupar y así facilitar el proceso de la carga e integración de la base de conocimientos del agente virtual. La integración de la base de conocimientos se realiza a través de un archivo std-startup.xml, el cual carga en memoria todos los archivos .aiml, que el asistente podrá utilizar para la búsqueda de respuestas. Cada archivo .aiml, que se procesará se especifica con la etiqueta , indicando la ruta absoluta del archivo. Un ejemplo de la estructura de éste archivo es el siguiente: LOAD AIML B standard/saludos.aiml standard/mcc.aiml standard/infoUsuario.aiml

5.4. Requerimientos del Sistema A continuación se describen los requerimientos tanto de hardware, como los de software del sistema, Con el fin de que funcione correctamente la ejecución de la interfaz gráfica, además se hace mención de algunas características como mínimas, pero si son indispensables: Hardware •

1 GB Memoria RAM o menos

•

Procesador Pentium(R) 4 CPU 2.40 GHz

•

Teclado

•

Monitor

53

Software •

Interprete de AIML, para el lenguaje Python (PyAIML o Programa Y).

•

Python versión 2.5.

•

DBMS: MySQL.

•

Microsoft Windows XP Profesional Versión 2002, Service Pack 3

•

Tener la Base de Datos (páginas) instalada en el Servidor de BD, contar con el usuario “root” y su contraseña “root”, ya que es la configuración que tiene la interfaz.

•

La librería MSVCP71.dll, se busca, se copia y se pega en la carpeta dist, así ya no marcará error, y debe funcionar perfectamente.

54

CAPÍTULO 6. CASO APLICATIVO: ASISTENTE VIRTUAL DE LA MAESTRÍA EN CIENCIAS EN CIENCIAS

COMPUTACIONALES En esta tesis nos interesa la problemática de desarrollar asistentes virtuales con la capacidad de comunicar por medio de su diálogo, emociones. Los asistentes virtuales que se pueden encontrar en diversas aplicaciones, no expresan emociones, se diseñan como un simple personaje virtual con ciertos movimientos de cabeza, lo cual a lo largo contribuye a un rompimiento de la interacción con el usuario, o simplemente un efecto visual. En este capítulo se describe la aplicación de nuestra arquitectura de diseño de un asistente virtual con diálogo emocional, como caso aplicativo se desarrollará un asistente virtual que proporcione información sobre la Maestría en Ciencias en Ciencias de la Computación del Instituto Tecnológico de Ciudad Madero (ITCM).

6.1 Caso de Aplicación El caso de aplicación de este asistente virtual en este caso será utilizado para proporcionar información acerca de la Maestría en Ciencias en Ciencias de la Computación, y la función que realizará el asistente virtual, es encontrar la respuesta adecuada en la base de conocimientos, y darle 55

al usuario una respuesta de acuerdo con su entrada, también es capaz de mostrar una página de Internet en la que se encontrará información más acertada a la pregunta que le haga al asistente el usuario. La aplicación también podría ser desarrollada para un ambiente Web, y así montarlo en la página principal de la Maestría en Ciencias en Ciencias de la Computación.

6.2 Diseño del diálogo En esta sección se realizará el seguimiento de la metodología para estructurar los diálogos y el análisis de los datos para el diseño de AIML, como resultado de esto se obtendrá una interacción con el usuario como la que se ilustra en la figura 19.

Patrón a buscar Pregunta Base De Conocimientos Aiml Respuesta Respuesta Encontrada

Figura 19. Interacción con el usuario.

El proceso inicia de la siguiente forma, el usuario realiza una pregunta, para la cual el asistente virtual busca rápidamente un patrón relacionado en la base de conocimientos, al encontrar un patrón relacionado al de entrada, es decir, a la pregunta, el asistente regresa una respuesta, en forma de texto, y así sucesivamente.

6.2.1 Aplicación de la Metodología Retomar cuales son las etapas de la metodología y que se hizo / obtuvo para el ejemplo de la aplicación. 1.- Establecimiento del objetivo del asistente virtual El objetivo de nuestro asistente virtual es brindar atención y proporcionar información acerca de la Maestría en Ciencias en Ciencias de la Computación.

56

2.- Definición de los atributos de la conversación con un usuario Las emociones que se pueden expresar al usuario son: miedo, tristeza, enojo, alegría, y un estado neutro, las cuales tienen diferentes rangos de intensidad que están predefinidos, por ejemplo se pueden establecer en el rango de 0-10, los cuales se pueden predefinir por ejemplo manejar 3 rangos quedando: 0-3, 3-6, 6-10 estos son algunos de los rangos de intensidad. En el tema de conversación se define como: La Maestría en Ciencias en Ciencias de la Computación.

3.- La recopilación de información relacionada con el tema de conversación. Para crear las respuestas se recopilo información acerca de la maestría, se obtuvo el plan de estudios, donde habla de la línea de investigación a la que se enfoca la maestría, se mencionan las ventajas, también menciona los nombres de los doctores, y los temas en particulares que trata la línea de investigación, es decir los problemas a los que está enfocada a resolver la maestría.

4.- Análisis de la Información recabada. Se estudio el programa o plan de estudios de la Maestría en Ciencias en Ciencias de la Computación, y se determino que la información que se encontraba en ese texto serviría, como respuestas a muchas dudas que les surgen a los aspirantes a la carrera, para así poder solucionarlas, y entonces darles la mejor información posible. Con esto despertar el interés por matricularse en nuestra Maestría en Ciencias en Ciencias de la Computación. Así, de esta forma podemos inferir contextos, para posteriormente crear categorías relacionadas con esta información, y los contextos inferidos son hablar sobre la maestría, su definición, su misión, su visión, quienes son los profesores, que publicaciones tienen como universidad, la línea de investigación. 5.- Desarrollo de la base de conocimientos. En esta etapa se crean las categorías relacionadas con cada uno de los temas inferidos en la etapa anterior, y por cada uno de los contextos, se crean sus categorías pertinentes, y de acuerdo a la teoría de AIML, se crean 4 categorías por cada uno de los patrones de entrada, cuando solo existe una palabra clave, y cuando son más de una palabra clave las que se están introduciendo se crean 4 categorías para la primer palabra clave y 4 para la segunda palabra clave, esto con el fin de ubicar la primer palabra clave en distintos lugares de la frase, de igual forma para la segunda palabra clave. En la siguiente sección se define la estructura de un diálogo. 57

6.2.2 Definición de la Estructura del diálogo En esta sección se describirán los componentes que pertenecen a la etapa 4 de la metodología que servirá para analizar la información para organizar la estructura de los diálogos. A continuación se van a presentar como se aplicaron los procesos las 6 etapas. Como se vió en la sección 5.3 las etapas que ayudan a identificar la finalidad de la interacción, algunas posibles preguntas que se deben responder, los usuarios que utilizarán el asistente virtual, encontrar las relaciones entre el tema y el usuario, añadiendo el rol o actividad que se realizaba el asistente virtual, entre otras. ETAPA 1. Identificar cuál es la finalidad de la interacción y las posibles preguntas que se deben responder. En esta etapa se define el tema específico del cual hablará preferentemente el asistente virtual con un usuario, con el fin de que se genere el interés por incorporarse a la Maestría en Ciencias en Ciencias de la Computación por parte de los aspirantes. ¿Cuál es el tema especifico que queremos tratar? El tema en específico será sobre la Maestría en Ciencias en Ciencias de la Computación.

ETAPA 2. Determinar quiénes serán los posibles usuarios del asistente virtual. En la siguiente etapa, se determinamos ¿quiénes serán los posibles usuarios del asistente virtual?, es decir quiénes son nuestro público objetivo: por ejemplo pueden ser los mismos Egresados de Ingeniería en Sistemas Computacionales del ITCM, así como alumnos aspirantes a la Maestría en Ciencias en Ciencias de la Computación de otras escuelas, Maestros, y en general alumnos de la Maestría en Ciencias en Ciencias de la Computación.

ETAPA 3. Identificar las relaciones entre el tema y el usuario, para generar los contextos. En base a las respuestas de las preguntas anteriores se procede a identificar las relaciones entre el tema y el usuario, para generar los contextos. Materias, Maestros, Tesistas, Publicaciones, Plan de estudios; Estas palabras clave le sirven al asistente virtual, para poder buscar en una base de datos en la que tiene almacenadas, las URL de las diferentes secciones de la página principal de la Maestría en Ciencias en Ciencias de la Computación. 58

También se pueden añadir relaciones que involucren la forma de conocer a una persona: los saludos, su familia, su apariencia física, su edad, su nombre, su nacionalidad, su género, su profesión, su estado de ánimo, pronombres usados en el diálogo, formas de hacer preguntas, etc. En la etapa que sigue, se tiene que pensar en el tipo de actividad que uno va a desarrollar en conjunto con el asistente, si es solo conversación, o si es solicitud de información, u otra cosa. Ya que se identificaron las relaciones pensando en todo lo que el usuario podría preguntarle al asistente virtual, se procede a crear los archivos .aiml para cada una de ellas. Encontrando los posibles patrones que se relacionen con el tema o el usuario. Se consideran todas las posibles preguntas que el usuario le puede hacer al Bot. Por ejemplo, en el archivo nombrado como saludos.aiml, en relación con el contexto se crea el nombre del archivo, es decir, en este archivo se escribirán categorías que contendrán patrones los cuales se relacionan con los saludos, esto mismo se puede hacer para otros contextos. Palabras o frases relacionadas con saludos: hola, que tal, como estas, buenas tardes, buenos días, que onda, etc. Los patrones, son las palabras clave que el asistente virtual consultará en su base de conocimientos para brindar la información pertinente, estos patrones están contenidos en las categorías que contiene el archivo AIML, y se determinan haciendo conjugación de verbos, palabras. A continuación se muestra un ejemplo de una categoría con un patrón. BUEN DIA HOLA

En el ejemplo anterior se muestra como el patrón BUEN DIA, a lo cual se contestaría con lo que contiene el patrón HOLA en su template, ya que en este caso la plantilla es recursiva, para crear los patrones se utilizan las etiquetas , y lo que contiene va en mayúsculas, con la finalidad de que sea una posible coincidencia con la entrada del usuario, y así proporcione una respuesta que se relacione con la entrada del usuario. Posteriormente, si ya se finalizó con la 59

creación de los archivos que conforman la base de conocimientos, se procede a crea un directorio en el que se puedan agrupar. REUTILIZACIÓN DE LA BASE DE CONOCIMIENTOS. La reutilización de una base de conocimientos Esta etapa será de ayuda, por si se llegara a presentar el caso en que se quiere modificar la base de conocimientos para otro tema diferente, a continuación se describen los pasos para saber que se debe modificar en los diferentes archivos aiml de la base de conocimientos. Teniendo en cuenta que los archivos cuentan con recursividad, los cambios que realizarán serán precisamente en la parte recursiva de los programas, la cual es una forma reutilizar el código ya generado, que existe en el archivo mcc.aiml, donde esta almacenada la información de la Maestría en Ciencias en Ciencias de la Computación. La recursividad está programada en el archivo infoUsuario.aiml. Si se quiere personalizar la base de conocimientos para otro proyecto, o empresa, se le tienen que realizar 2 cambios básicos. En

el

archivo

infoUsuario.aiml,

dentro

de

la

categoría

que

tiene

como

patrón

“TEMAESPECIFICO”, se sustituye en la recursión MAESTRÍA por otro tema deseado. Se sustituye el archivo mcc.aiml por uno personalizado con la información que uno desee. Prácticamente realizando estos dos cambio en la base de conocimientos se puede personalizar adecuándola a las necesidades de cada quien.

6.2.3 Caracterización de locuciones De acuerdo a la teoría de los actos del habla, puede decir que la caracterización de locuciones, en esta parte se describirá como se creó cada uno de los archivos .aiml que darán origen a las respuestas del asistente virtual. A continuación se presenta la lista de archivos que conforman la base de conocimientos, de los cuales solo se describirán los más significativos: •

saludos.aiml

•

infoMcc.aiml

•

familia.aiml

•

genero.aiml

•

infoUsuario.aiml

•

pronombres.aiml

•

nombres.aiml

•

astrología.aiml

•

Mcc.aiml

60

Estos archivos que se presentan aquí arriba tienen como objetivo, crear un diálogo emocional, por ende, una conversación. Estos ficheros aiml servirán para darle la capacidad de mantener una conversación al asistente virtual con el usuario. De esta forma quedaría organizado el conocimiento del asistente virtual, posteriormente se explicará cada uno de los archivos más significativos, que conforman la base de conocimientos. El primer archivo que se describirá será el de saludos.aiml, este es un archivo en el que se pensaron las diferentes formas de emitir un saludo, ya sea de bienvenida, despedida, o de encuentros en las diferentes partes de un día, mañana, tarde, y noche, con expresiones simples como las siguientes: buen día, buenas, buenas tardes, buenos días, buenas noches, hola, hi, hello, adiós, gracias, etc. A continuación se muestra un pequeño ejemplo del contenido del archivo, que cuando encuentre un patrón relacionado con buen día este tendrá la respuesta que contiene el patrón HOLA, el cual contiene las respuestas siguientes como las que se pueden apreciar. Al tener un gran número de categorías se busca llegar a tener frases de respuesta por parte del asistente virtual. BUEN DIA HOLA BUEN DIA * HOLA HOLA HOLA.¿Como te llamas? ¡HOLA !

En el código arriba presentado se puede comprobar lo que se dijo anteriormente, ya que se hace uso de la recursividad, y a la vez se puede pensar en BUEN DIA, como un saludo, y por lo tanto sinónimo de HOLA, tiene la misma intención en el contexto. El siguiente archivo a describir es el de sinRespuestas.aiml este contiene categorías con patrones como un “*” el cual le da a entender al asistente virtual, que lo que escribió el usuario como entrada y no se encuentre en la base de conocimientos, le dirá lo siguiente, que no encuentra una respuesta a la pregunta del usuario, y siendo así, mandaría una respuesta la cual le haga saber al usuario que no encontró respuesta alguna o que no entiende, este archivo también contiene categorías con patrones que esperan información acerca de preguntas, gustos, capacidades y aficiones. 61

El código que se presenta a continuación, tiene la función de mandar una respuesta al usuario, aun que no se encuentre coincidencia en toda la base de conocimientos. NOSE interrogativas Siento decirte que no lo sé. No tengo ni idea. No lo sé. Yo que sé. Mira que eres pesado, todo el día preguntando. No te enojes que es broma. Lo desconozco. Pues no tengo ni la menor idea. Si yo lo supiera te lo dijera COMO * NOSE

CUANDO * NOSE

Se podría dar el caso, en que se usen las palabras claves de las preguntas, es decir, como, cuando, donde, también como ya se menciono tiene categorías que fueron programadas para el caso de que no encontrara coincidencia alguna en toda la base de conocimientos, se devolvería una de las frases que se tiene ahí en el código como plantilla. El archivo infoUsuario.aiml tiene como finalidad responder a preguntas relacionadas con la información del usuario. Se implemento con recursividad, en la cual se llega a una categoría que contiene un patrón final, en el cual se puede realizar varias preguntas, para obtener información del usuario.

62

A continuación se muestra una parte del código: PREGUNTA PREGUNTA1 PREGUNTA1 NUEVOTEMA PREGUNTAPERSONAL1 PREGUNTAPERSONAL2 PREGUNTAPERSONAL3 PREGUNTAPERSONAL4 PREGUNTAPERSONAL5 PREGUNTAPERSONAL1 ¿Cómo te llamas? ¿Eres hombre o mujer? ¿Cuántos años tienes? ¿En que trabajas? ¿De que pais eres? Cual es tu signo del zodiaco? ¿Que día cumples años? TEMAESPECIFICO

En este fragmento de código, se presentan algunas preguntas personales, las cuales están dadas en la recursividad en el patrón NUEVO TEMA, esta lleva a generar aleatoriamente preguntas personales como por ejemplo: ¿Cómo te llamas?, ¿Eres hombre o Mujer?, ¿Cuántos años tienes?, ¿En qué trabajas?, etc. En el archivo que lleva por nombre Mcc.aiml, están contenidos patrones que tienen palabras clave que se relacionan con la información de la Maestría en Ciencias en Ciencias de la Computación. Sin embargo en este archivo contiene suficiente información acerca de la Maestría, pero como las respuestas estaban dentro de una etiqueta topic, es decir se creaban respuestas para un contexto predefinido, en este caso la Maestría. Por lo tanto se tuvo que crear un archivo con las mismas categorías, para que respondiera aunque no se le haya hablado al asistente sobre el contexto Maestría y tal archivo es infoMcc.aiml los contiene como categorías independientes de lo anterior.

63

En el siguiente fragmento de código, se recibe como entrada la palabra MAESTRIA, la cual es asignada como topic, y al hacerse topic tiene sus propias categorías, teniendo en cuenta que tiene sus propias categorías, puede responder a cualquier palabra que se dé cómo entrada después de la palabra maestría, por ejemplo ¿QUE ES?. MAESTRIA Maestria Recuerda que puedes formularme tus dudas acerca de la Maestría en Ciencias en Ciencias de la Computación. Mi función es ayudarte con tus dudas acerca de la Maestría en Ciencias en Ciencias de la Computación. Si tienes alguna duda sobre la Maestría en Ciencias en Ciencias de la Computación., aquí estoy para ayudarte Si estas interesado en la Maestría en Ciencias en Ciencias de la Computación, puedes preguntarme lo que quieras. ¿Estas interesado en la Maestría en Ciencias de de la Computación? Como ya te he dicho, mi función es informarte sobre la Maestría en Ciencias en Ciencias de la Computación. ¿QUE ES? Es un programa de estudios que está dedicado a la Investigación. Se profundiza en problemas que por su complejidad, requieren de encontrar soluciones óptimas, mediante los nuevos métodos de computación inteligente (redes neuronales, métodos heurísticos, algoritmos genéticos, etc.)

En el archivo al que se le asigno el nombre de genero.aiml están contenidas categorías las cuales cuentan con patrones que preguntan al usuario si es hombre o mujer, al igual para el bot, es decir, el usuario le pregunta al bot que genero es si es hombre o mujer, obviamente utilizando los sinónimos respectivos. En este código se puede observar que la base de conocimientos espera como entrada SOY HOMBRE o SOY MUJER para dar una respuesta condicionada al género del usuario, siempre y cuando ya lo haya definido. SOY HOMBRE Pues pensé que eras mujer. HOMBREYo soy un hombre robot. PREGUNTA SOY MUJER Pues pensé que eras hombre. MUJERYo tambien. PREGUNTA

64

6.2.4 Reorganización de la base de conocimientos En este paso de reorganización de la base de conocimientos, se propone que los archivos de AIML se cambien al nuevo formato quedando de la siguiente manera los códigos ya modificados: HOLA Hola. Buenas. Hola. Buenas. Hola. Buenas. Hola. Buenas. Hola. Buenas. * HOLA HOLA HOLA * HOLA

65

* HOLA * HOLA HI HOLA * HI HOLA HI * HOLA * HI * HOLA

Como se puede observar, aiml sufrió unos cambios en la sintaxis del código, y por ende se hace un poco más complejo. De esta forma quedaría reorganizada la base de conocimientos, adecuando cada uno de los archivos anteriormente descritos en la sección 6.2.3.

6.3 Desarrollo del Prototipo Una vez definidos los archivos que integran la base de conocimientos del asistente, lo que procede para construcción del prototipo es: •

Construcción de interfaz

•

Integración de base de conocimiento a la interfaz

En esta sección se iniciara la construcción de la interfaz, y después que ya está construida se le integrara la base de conocimientos, para dotarla de conocimiento artificial, y así simule una conversación real. En esta parte de la creación de una aplicación con interfaz gráfica se describirán los pasos necesarios para crearla en VisualWx Python, la cual va a utilizar la base de conocimientos creada en AIML. Hay que asegurarse de que estén instaladas las librerías pywin32 y Wx python2.8-unicode, para el funcionamiento del IDE, por cierto la ruta donde se encuentra Python debe estar en la variable PATH, y si no se encuentra en ella simplemente agregamos la ruta del directorio de Python, en este caso sería; C:\Python25, y se vuelve a guardar ya con la ruta en la variable de entorno, y así funcionará bien.

66

A continuación se prosigue a desarrollar la aplicación con interfaz gráfica utilizando en IDE VisualWx Python. En esta ocasión se va a programar una aplicación con interfaz gráfica, que debe quedar como se puede observar en la figura 20. Este será el producto final. Para ver el proceso de construcción ver el ANEXO A.

Figura 20. Prototipo final

Ahora sigue la parte fundamental de nuestro proyecto la codificación de la interfaz. Para este proyecto se creó una base de datos llamada páginas como se muestra a continuación.

En la siguiente base de datos se almacenaron los links relacionados con la página principal de la Maestría en Ciencias en Ciencias de la Computación. Y contiene los links porque es una forma sencilla de acceder a ellos de manera práctica a la hora de codificar. La base de datos está compuesta de lo siguiente: 1 Tabla pages, 2 campos idpages y pagina. Paginas pages (idpages, pagina) 21 Registros con las páginas de la Maestría en Ciencias en Ciencias de la Computación.

67

Idpages

Pagina

1

http://www.itcm.edu.mx/mccc06/

2

http://www.itcm.edu.mx/mccc06/anteMcc.php

3

http://www.itcm.edu.mx/mccc06/misionMcc.php

4

http://www.itcm.edu.mx/mccc06/equiposMcc.php

5

http://www.itcm.edu.mx/mccc06/logrosMcc.php

6

http://www.itcm.edu.mx/mccc06/ProgMccc07.html

7

http://www.itcm.edu.mx/mccc06/cursoMCCC.php

8

http://www.itcm.edu.mx/mccc06/infoMcc.php

9

http://www.itcm.edu.mx/mccc06/requiMcc.php

10

http://www.itcm.edu.mx/mccc06/material/material.php

11

http://www.itcm.edu.mx/mccc06/aceptados.php

12

http://www.itcm.edu.mx/mccc06/calendarioAspirantes.php

13

http://www.itcm.edu.mx/mccc06/planMcc.php

14

http://www.itcm.edu.mx/mccc06/perfilMcc.php

15

http://www.itcm.edu.mx/mccc06/criteriosEvaluacion.php

16

http://www.itcm.edu.mx/mccc06/calendarioPropuestas2007Nov.php

17

http://www.itcm.edu.mx/mccc06/lineasMcc.php

18

http://www.itcm.edu.mx/mccc06/inveMcc.php

19

http://www.itcm.edu.mx/mccc06/aluMcc.php

20

http://www.itcm.edu.mx/mccc06/publiMcc.php

21

http://www.itcm.edu.mx/mccc06/graduados.pdf

Tabla 4. Registros de la BD paginas.

68

CODIFICACION DE LA INTERFAZ GRÁFICA. A continuación se presenta el código que se le agrego a la interfaz gráfica para que funcionará correctamente, de este modo se inició a detalle la programación en Python. Este código se agrega al inicio del archivo frmChild, el cual será nuestro frame, para colocar los objetos de la interfaz gráfica. Ahora bien se inicia cargando las librerías necesarias para que Python pueda interpretar los archivos aiml, acceder a la base de datos y utilizar subprocesos ver figura 21. Y así poder simular la conversación con el bot. Como se puede observar esta al inicio del archivo frmChild.

Figura 21. Importación de librerías.

La primer librería que se carga es la Wx, ya que es la librería que utiliza la herramienta VisualWx, para manejar los gráficos, después se procede a cargar de la librería AIML, y ya con esta librería, podremos cargar archivos AIML, con los cuales podremos simular una conversación con el bot, ya que los posibles patrones que reconozca el bot están escritos en los archivos .aiml, los cuales se encuentran en una carpeta llamada “standard”, al mismo tiempo estos están siendo cargados por el archivo “std-startup.xml” y se utiliza el método learn para enviarle como parámetro el nombre del archivo y el método respond para que inicie la carga de los archivos aiml. Posteriormente se crea una conexión (línea 10) a la base de datos llamada páginas, la cual contiene lo siguiente ver figura 22:

Figura 22. Acceso a la BD paginas

También se crea un cursor, el cual nos ubica en el inicio de la base de datos (línea 11), posteriormente se crea una consulta utilizando el cursor (línea 12), después se crea un filtro, en el cual solo lo relacionado con la consulta quedara almacenado en el objeto res (línea 13), y en seguida

69

se crean e inicializan las siguientes variables valor, listpages, listcampo cada una con sus respectivos valores (líneas 14-16) como se muestra en la figura 22.

Figura 23. Creación del objeto k, en este caso es como si fuera el cerebro del bot.

En la figura 23 se muestra la creación del bot, cargando la base de conocimientos en su cerebro con el método learn (línea 19) y permitiendo que el bot conteste con el método respond (línea 20) y asignándole un nombre al bot (línea 21).

Figura 24. Código generado por la herramienta VisualWx

En la figura 24 se muestra que a partir de la línea 22 hasta la 99 es código que genera la herramienta VisualWx.

Figura 25. Función pregunta.

La función pregunta solo se activa cuando el evento que tiene especificada la caja de texto, es decir la edit text, que es cuando escribes algo sobre ella y es presionada la tecla Enter, solo así se ejecutara la función pregunta. Y esta se escribe a la misma sangría que los demás métodos que ya vienen por default ver figura 25. 70

Figura 26. Objeto edit text.

En esta parte se creó el objeto donde se podrán teclear las preguntas ver figura 26.

Figura 27. Definición de la función pregunta.

En la línea 99 se define la función pregunta, en la línea 102 y 103 se crean variables de tipo String, en la línea 104 se recupera el contenido de la caja de texto (edit text) que esta nombrado como tx4c, en la variable pregunta la cual es de tipo String, y que cuenta con un método llamado GetValue (), que regresa una cadena de tipo String, en la línea 105 se recupera la respuesta del bot en la variable respuesta, enviándole como parámetro la cadena de la pregunta, posteriormente en la línea 106 se realiza una conversión, la cadena de respuesta se convierte a Unicode que es un estándar de codificación, con el cual se pueden interpretar ciertos caracteres, un ejemplo seria el acento, la ñ, entre otros. Y así también se le pasa como parámetro al método Unicode la cadena que se transformará y el código que en que está representado el carácter o caracteres a convertir ver figura 27.

71

Figura 28. Código para obtener el id de la pagina a mostrar.

Para visualizar el código completo de la clase frmchild.py, que es el código de nuestro interés, ver el anexo A. En la sección A2. Además de la clase frmchild, están también los códigos de las clases generadas automáticamente por el IDE VisualWx.

Pseudocódigo.

Si resp== “01” o resp==”02” o …..resp==”21” entonces Valor= resp //se le convierte a entero con el metodo int (resp) ya que es una String Si valor >= 0 entonces Crear un ciclo para recorrer desde 0 hasta 21(res) Crear una consulta donde el idpages=valor Si lo encuentra que lo liste Crear una variable aux para asignar el contenido de la consulta Lo anterior convertirlo a String Crear dos Strings a partir de la aux pagina1 y pagina2 Crear otro ciclo para recorrer de 0 - 21 (listidpages) Si listidpages[j]==valor Si valor9 Abrir pagina2 Imprimir lo que dice el usuario Imprimir lo que dice el bot Limpiar la caja de texto Sino Imprimir lo que dice el usuario Imprimir lo que dice el bot Limpiar la caja de texto

Así mismo con el Pseudocódigo anterior se espera que la cadena de respuesta sea un número ya sea 01, 02…21 ya que son los ID que tienen las páginas en la base de datos, y así poder realizar todo el procedimiento, y si no simplemente imprime la respuesta, ver figura 28.

72

Para el botón “Enviar” también se le colocó el mismo código solo que en su función llamada bt6_VxXEvOnButtonClick (). Este código se ejecutará cuando sea presionado el botón véase figura 29 y 30 en la que observa el objeto y su forma de programarlo.

Figura 29. Botón Enviar.

Figura 30. Código del botón enviar.

Ahora se verá como está estructurado el archivo std-startup.xml. Este archivo contiene un patrón llamado “LOAD AIML B”, y los archivos en los que posiblemente puede encontrar una respuesta relacionada con el patrón de entrada.

73

Figura 31.- Std-startup.xml

Al ejecutar nuevamente nuestro proyecto, nos solicitara guardar cambios, se da clic en sí y al ejecutarse aparecerán las siguientes dos ventanas, en las cuales se muestra como se cargan los archivos .aiml y en la otra la ejecución de la aplicación.

Figura 32. Carga de archivos aiml.

74

Figura 33. Interfaz gráfica para simular un bot conversacional.

Finalmente se ha concluido la aplicación con interfaz gráfica (bot conversacional) hecho en VisualWx python.

Figura 34. Interacción con el bot, creado en VisualWx Python

Posteriormente se creó un ejecutable de la aplicación desarrollada con el siguiente código que se guardo en un archivo independiente que nombramos prueba.py. Si se quiere ver a detalle favor de ir al ANEXO C.

75

CAPÍTULO 7. EXPERIMENTACIÓN Y RESULTADOS 7.1 Descripción de la Experimentación En esta sección se describirán como objetivos de la experimentación, las pruebas necesarias que se llevaron a cabo. En este caso se registraran los resultados de seguir la metodología respecto al código AIML, la realización de una conversación asistente-usuario, es decir, una interacción humano-computadora, además de la efectividad de la misma.

7.1.1. Resultados de seguir la metodología respecto al código AIML. Etapa 1. Identificar cuál es la finalidad de la interacción y las posibles preguntas que se deben responder. En esta etapa ya se debe tener definida la finalidad de la interacción, para este caso devolver respuestas y las preguntas posibles a realizar, tienen que ser relacionadas con nuestra Maestría. En AIML aun no es necesario crear ninguna categoría.

Etapa 2. Determinar quiénes serán los posibles usuarios del asistente virtual. En esta etapa aún no se realiza ningún procedimiento, ni es necesario aun crear ni un fragmento de código.

Etapa 3. Identificar las relaciones entre el tema y el usuario, para generar los contextos. En esta etapa se analiza la información recabada para poder crear los contextos. Etapa 4. Identificar el rol y tipo de actividad que el asistente virtual va a desarrollar. 76

En esta etapa se identifica el rol del asistente y que actividad realizara. En las primeras cuatro etapas se realiza un análisis de la información recopilada sobre la Maestría en Ciencias en Ciencias de la Computación.

Etapa 5. Determinar los Dominios de Conocimientos, Tópicos de la Conversación, Categorías, Patrones de Preguntas y las Respuestas a dichos patrones tomando en cuenta los diversos estados emocionales que se considerarán. En esta etapa se utiliza el análisis de la información recabada, es decir se crean las categorías con los posibles patrones relacionados con nuestra Maestría. Asignando como dominio de conocimiento la Maestría, así como también el tópico de la conversación, las categorías creadas son en general sobre la Maestría y sobre temas en general, pero limitando a contestar lo básico, en esta misma etapa se crean las respuestas, es decir las templates. Dominio de Conocimiento: Maestría en Ciencias en Ciencias de la Computación. Topics de la Conversación Topic: Maestría. A continuación se presentan algunas de las categorias completas con sus patrones y templates. En la que se involucra el topic, el dominio de conocimiento y las Categorias (Category), Patrones (Pattern), Plantillas o Respuestas (Template), referentes a la Maestría. MAESTRIA Maestria Recuerda que puedes formularme tus dudas acerca de la Maestría en Ciencias en Ciencias de la Computación. Mi funcion es ayudarte con tus dudas acerca de la Maestría en Ciencias en Ciencias de la Computación. Si tienes alguna duda sobre la Maestría en Ciencias en Ciencias de la Computación., aqui estoy para ayudarte Si estas interesado en la Maestría en Ciencias en Ciencias de la Computación, puedes preguntarme lo que quieras. Estas interesado en la Maestria en Ciencias de de la Computación sigueme preguntando acerca de la maestria Como ya te he dicho, mi funcion es informarte sobre la Maestría en Ciencias en Ciencias de la Computación.

77

Categorias y Repuestas acerca de la Maestría HABLAME DE LA MAESTRIA La Maestría en Ciencias en Ciencias de la Computación es un posgrado que tiene un plan de estudios que se ha diseñado considerando como única línea de investigación a la Optimización Inteligente y como áreas de aplicación: Visión y Robótica, Base de Datos Distribuidas, Lenguaje Natural La Maestría en Ciencias en Ciencias de la Computación tiene desde el año 2000, se inició el programa propio denominado originalmente Maestría en Computación. Actualmente cambió de nombre a Maestría en Ciencias en Ciencias de la Computación. La Maestria cuenta con los siguientes Doctores que imparten clases: Dra. Laura Cruz Reyes, Dr. Héctor Joaquin Fraire Huacuja, Dr. Arturo Hernández Ramírez, Dr. Juan Javier González Barbosa, Dra. María Lucila Morales Rodríguez, Dr. Rodolfo Abraham Pazos Rangel, Dr. José Antonio Martínez Flores, M.C. Guadalupe Castilla Valdez, Dra. Claudia Guadalupe Gómez Santillán, M.C. José Apolinar Ramírez Saldivar La Maestria tiene pensado abrir una segunda linea de investigacion que es relacionado a la IA, personajes virtuales con expresiones faciales que representan la emocion que estan sintiendo artificialmente

¿QUE ES? Es un programa de estudios que esta dedicado a la Investigacion. Se profundiza en problemas que por su complejidad, requieren de encontrar soluciones óptimas, mediante los nuevos métodos de computación inteligente (redes neuronales, métodos heurísticos, algoritmos genéticos, entre otros) QUE ES Es un programa de estudios que esta dedicado a la Investigacion. Se profundiza en problemas que por su complejidad, requieren de encontrar soluciones óptimas, mediante los nuevos métodos de computación inteligente (redes neuronales, métodos heurísticos, algoritmos genéticos, entre otros) ¿QUE ES *? Es un programa de estudios que esta dedicado a la Investigacion y Se profundiza en problemas que por su complejidad, requieren de encontrar soluciones óptimas, mediante los nuevos métodos de computación inteligente (redes neuronales, métodos heurísticos, algoritmos genéticos, entre otros). DE QUE TRATA Trata sobre tecnologias de bots y sus aplicaciones en el campo de la educacion. Se profundiza en problemas que por su complejidad, requieren de encontrar soluciones óptimas, mediante los nuevos métodos de computación inteligente (redes neuronales, métodos heurísticos, algoritmos genéticos, entre otros) DE QUE SE TRATA Trata sobre tecnologias de bots y sus aplicaciones en el campo de la educacion. Se profundiza en problemas que por su complejidad, requieren de encontrar soluciones óptimas, mediante los nuevos métodos de computación inteligente (redes neuronales, métodos heurísticos, algoritmos genéticos, entre otros).

78

_ PUBLICACIONES * _ PUBLICACIONES

_ PUBLICACIONES 20 MIEMBROS 18 MIEMBROS * MIEMBROS WEB 01 _ WEB WEB ANTECEDENTES 02 ANTECEDENTES * ANTECEDENTES MISIONVISION 03

_ MISION * VISION MISIONVISION

En todas las categorías anteriores, como respuesta regresan un número, el cual es tratado con Python, y hace consulta a una base de datos, para extraer la página y mostrársela al usuario.

Etapa 6. Integración de la Base de Conocimientos del agente virtual En esta etapa AIML, solamente se carga como una librería en Python, en el momento que se inicia la codificación. 79

7.1.2. Resultado de la conversación con el asistente virtual. Usuario: Hola Bot: Hola. ¿Cómo te llamas? Usuario: Mi nombre es Luis Bot: Encantado Luis. Usuario: Háblame de la Maestría Bot: La Maestría en Ciencias en Ciencias de la Computación es un posgrado que tiene un plan de estudios que se ha diseñado considerando como única línea de investigación a la Optimización Inteligente y como áreas de aplicación: Visión y Robótica, Base de Datos Distribuidas, Lenguaje Natural. Usuario: me podrías decir cuál es la página principal de la Maestría Bot: usted recibirá mayor información en la página que se abre Usuario: me podrías decir que líneas de investigación tiene la Maestría Bot: usted recibirá mayor información en la página que se abre Usuario: dime que publicaciones tiene la maestría Bot: usted recibirá mayor información en la página que se abre Usuario: Quienes son los profesores Bot: usted recibirá mayor información en la página que se abre Usuario: Cuales son las fechas de exámenes Bot: usted recibirá mayor información en la página que se abre Usuario: Sabes matemáticas Bot: Me encuentro algo perdido en este contexto. explícate de otra manera

Identificación de Problemas Debido a que solo se escribieron categorías con patrones pensados como las posibles preguntas del usuario, no se logro abarcar todo el conocimiento existente en el mundo, así que tiene tendencia a equivocarse en las respuestas. Aunque con respecto a la Maestría debería de contestar correctamente, con lo que se le pregunta.

80

CAPÍTULO 8. CONCLUSIONES Y TRABAJOS FUTUROS 8.1 Conclusiones En este trabajo de tesis se realizo el diseño de una metodología para organizar la estructura de los diálogos. También se diseño un asistente virtual con el software iClone PRO 4.1. Se utilizó una base de conocimientos para darle el diálogo al asistente virtual. Se desarrolló la interfaz gráfica para integrar al asistente virtual y la base de conocimientos en Python.

8.2 Aportaciones • Como resultado de este trabajo quedo un asistente creado en Python, que utiliza una base de conocimientos creada en el lenguaje AIML. • Se presentó una metodología, para crear bases de conocimientos, guía para construir interfaces, se presenta caso aplicativo a la maestría en ciencias en ciencias de la computación.

8.3 Trabajos Futuros Al dejar disponible el código fuente de la aplicación con interfaz gráfica y de los archivos AIML (base de conocimientos), pueden servir como base de futuras versiones aplicadas con nuevas técnicas de la Inteligencia Artificial. Dejando como áreas de oportunidad para mejorar el proyecto: el cambio de personaje de estático a dinámico, y su conversión en una aplicación Web, para así acceder a él desde Internet Otra parte interesante y que se deja abierta es la modificación del núcleo de AIML para crear etiquetas, objetivos, intensiones, independientes de la temática. 81

BIBLIOGRAFÍA Álvarez, M. A. (2003). Qué es Python. http://www.desarrolloweb.com/articulos/1325.php

Recuperado

Abril

8,

2011,

a

partir

de

Bates, J. (1994). The role of emotion in believable agents. Communications of ACM. Special Issue on Agents, 9. Botti, V. J. V. (2000). Agentes Inteligentes: el siguiente paso en la Inteligencia Artificial. ATI, 5. Bush, N. (2001). AIML 1.0.1 (A.L.I.C.E. AI Foundation). Recuperado Abril 8, 2011, a partir de http://www.alicebot.org/TR/2001/WD-aiml/#section-introduction Cassell, J., Bickmore, Tim, Campbell, L., Vilhjálmsson,, H., & Yan, H. (2000). Conversation as a System Framework: Designing EmbodiedConversational Agents. Cassell, J., & Bickmore, Timothy. (2002). Negotiated Collusion:Modeling Social Language and its Relationship Effectsin Intelligent Agents. MIT Media Lab 20 Ames St., E15-315 Cambridge, MA 02139 USA. Coca, G. H., & Ángel, S. C. S. del. (2009). METODOLOGÍA PARA LA SIMULACIÓN DE EXPRESIONES NO VERBALES DE UNA RECEPCIONISTA VIRTUAL”. ITCM. dTinfS.L. (2008). Asistente Virtual Semántico (pág pp 15). Dustman, A. (2006). MySQL for Python | Download MySQL for Python software for free at SourceForge.net. Recuperado Abril 8, 2011, a partir de http://sourceforge.net/projects/mysql-python/ Florencia, R. (2010). Agente Conversacional Corpóreo que utiliza AIML para integrar procesos de personalidad. ITCM, Cd. Madero, Tamaulipas. Gratch,, J., Rickel, J., André, E., Badler, N., Cassell, J., & Petajan, E. (2002). Creating interactive Virtual Humans some assembly requided. IEEE Inteligent Systems, pp 10. Jenkins, M.-C. (2010). Using construction grammar in conversational systems. Recuperado Abril 5, 2011, a partir de http://www.slideshare.net/mcjenkins/using-construction-grammar-in-conversational-systems Kopp, S. (2009). Social Resonance and Embodied Coordination inFace-to-Face Conversation with Artificial Interlocutors. Speech Communication, 12 pp. Loyall, A. B., Bates, J., & Mitchell, T. (1997). Believable Agents: Building Interactive Personalities, 97--123. Lun, E. V. (2010a). Conversational Agent - a program that acts on behalf of humans and chats. Recuperado Abril 8, 2011, a partir de http://www.chatbots.org/conversational_agent/ Lun, E. V. (2010b). Chatbots.org 2.6: Forum and even smarter account pages | News. Recuperado Abril 8, 2011, a partir de http://www.chatbots.org/community/buzz_stop/welcome_to_chatbot.org_2.0/ Marcelo, A. C., & P, M. G. E. (2007). Agentes Inteligentes en la webBots de conversación.

82

Monroy, G. L. (2008). Interfaz gráfica para la edicion de cuentos interactivos para ninos. Recuperado Abril 6, 2011, a partir de http://catarina.udlap.mx/u_dl_a/tales/documentos/lis/lopez_m_g/index.html Morales, M. L. (2007). Modèle d’interaction sociale pour des agents conversationnels animés Application à la rééducation de patients cérébro-lésés. L’UNIVERSITÉ TOULOUSE III : PAUL SABATIER. Next IT Corporation. (2010). Next IT - Providing Intelligent Customer Experience Solutions. Recuperado Abril 14, 2011, a partir de file:///C:/Users/Jesus/Documents/Maestria/Tesis/Agentes%20Conversacionales/Paginas%20Web/Next%20IT %20-%20Providing%20Intelligent%20Customer%20Experience%20Solutions(Introduccion).htm Nwana, H. S. (1996). Software Agents: An Overview. Knowledge Engineering Review, Vol. 11(N° 3), pp 49. Pedro Branco. (2003). Emotional Interaction. Ringate, T., Wallace, D. R., Taylon, A., Baer, J., & Daniels, D. (2001). ALICE AIML Primer. Recuperado Mayo 9, 2011, a partir de http://www.alicebot.org/documentation/aiml-primer.html Takeyas, B. L. (2005). Agentes Inteligentes. VisualWx. (2010). VisualWX. Recuperado Abril 8, 2011, a partir de http://visualwx.altervista.org/index.php Wordreference. (2005). conversacional - Definición - WordReference.com. Conversacional- DefiniciónWordreference.com Diccionario de la lengua española. Recuperado Abril 8, 2011, a partir de http://www.wordreference.com/definicion/conversacional Llisterri, J. (2007) “El papel de la fonética en las tecnologías del habla” in Actas do 3º Congreso Internacional de Fonética Experimental. Santiago de Compostela, 24-26 outubro de 2005. Santiago de Compostela : Xunta de Galicia. Pp. 23-37. ISBN : 978-84-453-4451-4 disponible en http://liceu.uab.es/^joaquim/publicacions/Llisteri_05_Fonética_Tecnologias_Habla.pdf

83

ANEXOS ANEXO A: CREACIÓN DE INTERFAZ GRÁFICA Este anexo contiene el proceso detallado paso por paso, de cómo ir añadiendo los componentes gráficos para conformar la interfaz gráfica del asistente virtual. Abrir el IDE VisualWx, una vez abierto proseguimos a crear un nuevo proyecto dando clic en File, después en New Proyect, como se muestra en la figura 35. Posteriormente indicar que el template que se utilizará será WX_MDI_Python y guadar el Proyecto en una carpeta en la que almacene todos los archivos y programas que utilizará. El nuevo proyecto tendrá la extensión .pbc. Figura 35. VisualWx

Una vez terminado el proceso anterior, aparece la ventana principal con un formulario gris (ver figura 36) y podremos construir nuestro propio asistente virtual. Dentro de éste formulario se crearán objetos o controles del tipo botón, caja de texto, panel, y área de texto. El botón para enviar la pregunta, la caja de texto para escribir la pregunta, y la caja de texto para visualizar la pregunta y la respuesta, y el panel para visualizar al personaje virtual.

84

En el lado izquierdo de la interfaz del IDE se encuentran

disponibles

componentes

que

continuación

se

se

los pueden

describirá

el

diferentes utilizar.

A

proceso

de

construcción y programación de la interfaz gráfica del asistente virtual que se desarrolló, ver figura 36.

Figura 36. Frame de inicio de la plantilla Wx_MDI_python

Se inicia colocando una etiqueta de Texto (Static text). En esta siguiente ventana se ha cambiado el color de fondo dando clic propiedades, en la opción backcolor, ver figura 37.

Figura 37 . Elegir color de fondo del Frame

Para cambiar el contenido original de la etiqueta de texto se da clic en su propiedad Text, y después se escribe lo que se desea aparezca en la etiqueta y se da clic en OK.

85

Figura 38 . Escribir texto en una etiqueta (Static Text)

También se le puede dar clic en la propiedad Font y cambiarlo si así se desea, en esta opción se puede cambiar el tipo de letra, el estilo, tamaño y algunos efectos (Figura 38).

Figura 39 .Cambiar Fuente (Font)

En nuestro ejemplo se creó y edito el control static text (etiqueta), para escribir la cadena “Haz tu pregunta”. Como se puede observar en la figura 41.

86

Figura 40. Cambio de texto en la etiqueta.

A continuación se insertan 2 controles un “edit text”, que creará una caja de texto que permitirá mostrar la interacción del usuario con el bot y un “edit text multilínea” o también conocido como área de texto, ver figura 40.

Figura 41. Inserción de Edit Text y Edit Text Multilínea.

Ahora se crea un botón con la leyenda enviar. En esta parte se edita el texto que tiene por default que es control, se le escribe la palabra Enviar, y se da clic en OK, ver figura 42.

87

Figura 42. Asignar nombre al botón.

Así se ve la interfaz gráfica, pero aun falta colocar una imagen de un rostro para simular que es un agente conversacional eso lo veremos más adelante. Ahora se selecciona, un objeto Panel, al cual se le asignará una imagen, para ello seleccionar la opción Bitmap en las propiedades del control y cargar la imagen que se desea especificando el tipo de archivo al que pertenece nuestro recurso, por ejemplo bmp, icon, gif, png, jpg, pcx, iff, tiff, ani, pnm, xpm, cursor, *.rc, etc.

Figura 43.objeto panel.

88

Para asignar un nombre a la ventana principal y a la sub-ventana, se le da clic en la propiedad de “title” y se escribe el nombre. A continuación se procede a escribir el código.

89

ANEXO B: INTEGRACIÓN DE LA BASE DE CONOCIMIENTOS A LA INTERFAZ GRÁFICA Este anexo contiene el código de las cuatro clases que se generan con el IDE VisualWx, en la cual la clase App.py es el equivalente a un main, es decir, el programa principal que hace llamadas a todas las clases relacionadas con la interfaz gráfica. Esta clase frmchild se construye a partir de que se elige el tipo de plantilla Wx_MDI_python, ya que es código que se genera automáticamente, sin embargo en este código es donde se debe incluir nuestro código, ya que es el que contendrá los objetos que pueden esperar algún evento como lo son: botones, cajas de texto, etc. En si aquí escribimos el código para vincular MySQL, AIML con Python para hacer funcional la aplicación. La vinculación de la base de datos con la interfaz gráfica se lleva a cabo mediante instrucciones, es decir, a nivel de código, al igual que el enlace de aiml con la interfaz gráfica para integrar la base de conocimientos. El programa Visualwx crea 4 clases, las cuales se pondrán solo el código necesario: •

App.py, es la clase principal es como si fuera la aplicación main.

•

Frmchild.py, es el frame que nos permite agregar código y generar la interfaz gráfica.

•

Myframe.py, es la segunda ventana que tiene nuestro frame principal.

•

VwXComponent.py, esta es una clase generada por el IDE de Python.

90

Frmchild.py # -*- coding: utf-8 -*# Don't modify comment import wx #[inc]add your include files here import aiml import sys import subprocess import MySQLdb db = MySQLdb.connect(host='localhost', user='root', passwd='root', db='paginas') cursor = db.cursor() busca = cursor.execute('SELECT * FROM pages') res = cursor.fetchall() valor=0 listidpages=[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21] listcampo=['idpages','pagina'] k = aiml.Kernel() k.learn("std-startup.xml") k.respond("LOAD AIML B")

class frmChild(wx.MDIChildFrame): def __init__(self,parent,id = -1,title='',pos = wx.Point(1,1),size = wx.Size(860,500),style = wx.DEFAULT_FRAME_STYLE,name = 'frame'): pre=wx.PreMDIChildFrame() self.OnPreCreate() pre.Create(parent,id,title,pos,size,style,name) self.PostCreate(pre) self.initBefore() self.VwXinit() self.initAfter() def __del__(self): self.Ddel() return def VwXinit(self): self.fileImgBuf=[None] * 1 self.fileImgBuf[0] = wx.Bitmap("cybormona11.jpg",wx.BITMAP_TYPE_JPEG) self.pn8cImg0=self.fileImgBuf[0]; self.SetTitle('Bot') self.Show(True) self.SetBackgroundColour (wx.SystemSettings.GetColour(wx.SYS_COLOUR_INFOBK)) self.st3c = wx.StaticText(self,-1,"",wx.Point(415,330),wx.Size(164,28),wx.ST_NO_AUTORESIZE) self.st3c.SetLabel("Haz tu pregunta") self.st3c.SetFont(wx.Font(14,74,90,92,0,"Tahoma")) self.tx4c = wx.TextCtrl(self,-1,"",wx.Point(410,365),wx.Size(405,21)) self.Bind(wx.EVT_TEXT_ENTER,self.pregunta,self.tx4c) self.txm5c = wx.TextCtrl(self,-1,"",wx.Point(415,20),wx.Size(400,300),wx.TE_MULTILINE) self.bt6c = wx.Button(self,-1,"",wx.Point(685,330),wx.Size(135,25)) self.bt6c.SetLabel("Enviar") self.Bind(wx.EVT_BUTTON,self.bt6c_VwXEvOnButtonClick,self.bt6c) self.pn8c = wx.Panel(self,-1,wx.Point(15,20),wx.Size(365,300)) self.pn8c.Bind (wx.EVT_ERASE_BACKGROUND,self.VwXpn8c_VwXEvOnEraseBackground) self.Refresh() return

# Codigo agregado def pregunta(self,event): #init function usuario="Usuario: " bot="Bot: " pregunta=self.tx4c.GetValue() respuesta= k.respond(pregunta) resp=unicode(respuesta,"utf-8") if(resp=="01" or resp=="02" or resp=="03" or resp=="04" or resp=="05" or resp=="06" or resp=="07" or resp=="08" or resp=="09" or resp=="10" or resp=="11" or resp=="12" or resp=="13" or resp=="14" or resp=="15" or resp=="16" or resp=="17" or resp=="18" or resp=="19" or resp=="20" or resp=="21"):

91

valor=int(resp) if(valor>=0): for i in range (0, len(res)): cursor.execute("SELECT * FROM pages WHERE "+str(listcampo[0])+ " = ' "+str(valor)+" ' " ) encuentra=cursor.fetchall() aux= str(encuentra[0]) pagina1= aux[6:len(aux)-2] pagina2= aux[7:len(aux)-2] for j in range(0, len(listidpages)): if(listidpages[j]==valor): if(valor9): subprocess.Popen( '"C:\Archivos de programa\Internet Explorer\IEXPLORE.EXE" -brokerredirect %s' % pagina2 ) self.txm5c.AppendText(usuario+ pregunta+" \n") self.txm5c.AppendText(bot+ "usted recibira mayor informacion en la pagina que se abre :D"+" \n") self.tx4c.SetValue(" ") else: self.txm5c.AppendText(usuario+ pregunta+" \n") self.txm5c.AppendText(bot+ resp+" \n") self.tx4c.SetValue(" ") return #end function

def bt6c_VwXEvOnButtonClick(self,event): #init function #[688]Code event VwX...Don't modify[688]# #add your code here usuario="Usuario: " bot="Bot: " pregunta=self.tx4c.GetValue() respuesta= k.respond(pregunta) resp=unicode(respuesta,"utf-8") if(resp=="01" or resp=="02" or resp=="03" or resp=="04" or resp=="05" or resp=="06" or resp=="07" or resp=="08" or resp=="09" or resp=="10" or resp=="11" or resp=="12" or resp=="13" or resp=="14" or resp=="15" or resp=="16" or resp=="17" or resp=="18" or resp=="19" or resp=="20" or resp=="21"): valor=int(resp) if(valor>=0): for i in range (0, len(res)): cursor.execute("SELECT * FROM pages WHERE "+str(listcampo[0])+ " = ' "+str(valor)+" ' " ) encuentra=cursor.fetchall() aux= str(encuentra[0]) pagina1= aux[6:len(aux)-2] pagina2= aux[7:len(aux)-2] for j in range(0, len(listidpages)): if(listidpages[j]==valor): if(valor9): subprocess.Popen( '"C:\Archivos de programa\Internet Explorer\IEXPLORE.EXE" -brokerredirect %s' % pagina2 ) self.txm5c.AppendText(usuario+ pregunta+" \n") self.txm5c.AppendText(bot+ "usted recibira mayor informacion en la pagina que se abre :D"+" \n") self.tx4c.SetValue(" ") else: self.txm5c.AppendText(usuario+ pregunta+" \n") self.txm5c.AppendText(bot+ resp+" \n") self.tx4c.SetValue(" ") return #end function

92

ANEXO C: CREACIÓN DE EJECUTABLE DE LA INTERFAZ GRÁFICA Se tiene que tener instalada la librería py2exe que nos permitirá crear un ejecutable de la aplicación. Se importan las librerías “disutils.core, se importa setup”, después se define como script principal App.py, posteriormente se le asigna un icono a la aplicación principal, es decir, una imagen al archivo ejecutable. En este caso se llama bot.ico, después se copian los archivos a los cuales pueda hacer referencia el principal, ver figura 44.

Figura 44. Código para hacer ejecutable

Al terminar esto se procede a abrir el símbolo del sistema (línea de comandos), figura 45.

Figura 45. Línea de comandos o símbolo del sistema.

93

Ya que se abrió el símbolo del sistema se posiciona en el directorio python25, ver figura 46.

Figura 46. Directorio python25

Estando en la carpeta de python25, que es el lugar donde está guardado el archivo prueba.py, que contiene el código para hacer un ejecutable del archivo principal llamado App.py y asignarle un icono. Se tiene que escribir de la siguiente forma para hacer ejecutable el archivo, véase figura 47: Sintaxis:

Figura 47 .Python prueba.py py2exe (instrucciones que hacen el ejecutable)

Posteriormente se verá en la pantalla negra, como se empaquetan todas las librerías necesarias en dos carpetas, una que se llama dist y otra que se llama build.

94

Figura 48. Compresión de librerías.

Figura 49. Fin de la compilación y compresión de librerías.

Después de que terminó el proceso de hacer ejecutable en el directorio Python25 estarán dos carpetas: build y dist. Las que contienen el archivo ejecutable (.exe, además de las librerías empaquetadas), véase figura 50.

Figura 50. Carpetas dist y build.

95

En la siguiente figura se puede observar el contenido de la carpeta build, tiene subcarpetas las cuales contienen librerías empaquetadas.

Figura 51. Directorio build.

En la figura 52 se puede observar lo que contiene la carpeta dist, en la cual se guarda el archivo ejecutable del proyecto, además de las librerías necesarias para funcionar en cualquier otra computadora.

Figura 52. Directorio dist.

96