TFG_JORGE_JUAN_FERNANDEZ_SANTIAGO

Vista previa del material en texto

Universidad Politécnica 
de Madrid 
Escuela Técnica Superior de 
Ingenieros Informáticos 
 
Grado en Ingeniería Informática 
 
 
Trabajo Fin de Grado 
 
Desarrollo de Chat-bot para Plataforma 
Basada en Moodle Orientada a 
Innovación Educativa 
 
 
 
 
 
 
 
Autor: Jorge Juan Fernández Santiago 
Tutor: César Benavente Peces 
Madrid, junio de 2022
 
 
 
i 
 
Este Trabajo Fin de Grado se ha depositado en la ETSI Informáticos de la 
Universidad Politécnica de Madrid para su defensa. 
Trabajo Fin de Grado 
 
Grado en Ingeniería Informática 
 
Título: Desarrollo de Chat-bot para Plataforma Basada en Moodle Orientada a 
Innovación Educativa 
 
Junio 2022 
 
Autor: Jorge Juan Fernández Santiago 
 
Tutor: 
César Benavente Peces 
Arquitectura y Tecnología de Sistemas Informáticos 
ETSI Informáticos 
Universidad Politécnica de Madrid 
 
 
 
 
ii 
 
Resumen 
El Proyecto consiste en el desarrollo de un sistema basado en un chat-bot y su 
integración en la plataforma educativa Moodle, con el objetivo de dar respuesta 
a posibles solicitudes de los alumnos, siendo éstas expresadas en lenguaje 
natural (lenguaje humano). 
El desarrollo de dicho sistema se ha llevado a cabo utilizando las últimas 
tecnologías en Procesamiento de Lenguaje Natural, Comprensión del Lenguaje 
Natural, Recuperación de Información, Aprendizaje automático y Redes 
neuronales. 
La arquitectura elegida para la implementación del sistema sigue una 
arquitectura multicapa. Para el desarrollo de la capa de interfaz de usuario 
integrada en Moodle, se han utilizado los lenguajes HTML y JavaScript; para la 
capa de servicios se ha utilizado el servidor web Nginx; para la capa de negocio 
se ha utilizado Python como lenguaje de programación sobre el framework 
Django y requiriendo el uso de librerías como SpaCy, Keras o Sklearn; y para la 
capa de datos se ha utilizado como repositorio PostgreSQL. Además, se ha 
utilizado la tecnología Docker para la generación de contenedores 
autodesplegables de forma que el sistema se pueda ejecutar en cualquier tipo 
de sistema operativo. 
Se han completado todas las fases del desarrollo basado en metodología 
Waterfall, desde el análisis y definición de requisitos, hasta las pruebas de 
aceptación, pasando por el diseño y la implementación (codificación del software, 
realización de pruebas unitarias y búsqueda de fallos). 
 
 
 
 
iii 
 
Abstract 
The project consists of the development of a system based on a chat-bot and its 
integration into the Moodle educational platform, with the aim of responding to 
requests from students, these being expressed in natural language (human 
language). 
The development of this system has been conducted using the latest 
technologies in Natural Language Processing, Natural Language Understanding, 
Information Retrieval, Machine Learning and Neural Networks. 
The architecture chosen for the implementation of the system follows a multi-
layer architecture. For the development of the user interface layer integrated in 
Moodle, HTML and JavaScript languages have been used; for the services layer, 
the Nginx web server has been used; for the business layer, Python has been 
used as programming language on the Django framework and requiring the use 
of libraries such as SpaCy, Keras or Sklearn; and for the data layer, PostgreSQL 
has been used as repository. In addition, Docker technology has been used for 
the generation of self-deployable containers so that the system can run on any 
type of operating system. 
All phases of development based on Waterfall methodology have been completed, 
from requirements analysis and definition to acceptance testing, through design 
and implementation (software coding, unit testing and fault finding). 
 
 
 
iv 
 
Tabla de contenidos 
Resumen ................................................................................................ ii 
Abstract ................................................................................................. iii 
1 Introducción ......................................................................................1 
1.1 Objetivos ............................................................................................ 1 
1.1.1 Búsqueda de datos de contacto: ................................................... 2 
1.1.2 Respuesta a preguntas frecuentes de foros o exámenes: .............. 2 
1.1.3 Registrar tareas/alertas en el calendario de Moodle: .................... 3 
2 Marco teórico ....................................................................................4 
2.1 Chat-bots ........................................................................................... 4 
2.1.1 Chat-bots de ITR (Respuesta de Interacción de Texto) .................. 4 
2.1.2 Chat-bots de reconocimiento de palabras claves .......................... 5 
2.1.3 Chat-bots de aprendizaje automático ........................................... 5 
2.2 Inteligencia Artificial (IA) .................................................................... 5 
2.2.1 Procesamiento del Lenguaje Natural (PLN) [1]: ............................. 6 
2.2.1.1 Limpieza ................................................................................... 6 
2.2.1.2 Tokenización: ............................................................................ 6 
2.2.1.3 Filtrado de palabras vacías: ...................................................... 7 
2.2.1.4 Derivación: ............................................................................... 7 
2.2.1.5 Lematización: ............................................................................ 7 
2.2.1.6 Etiquetado: ............................................................................... 7 
2.2.2 Comprensión del Lenguaje Natural (CLN) [2]: ............................... 7 
2.2.3 Generación del Lenguaje Natural (GLN) [3]: .................................. 8 
2.2.4 Recuperación de información (RI) ................................................. 8 
2.2.4.1 Modelo booleano ....................................................................... 8 
2.2.4.2 Modelo de espacio vectorial ....................................................... 9 
2.2.4.3 Modelo probabilístico .............................................................. 11 
2.2.5 Aprendizaje automático – Machine Learning ............................... 11 
2.2.5.1 Aprendizaje supervisado ......................................................... 11 
2.2.5.2 Aprendizaje no supervisado .................................................... 12 
2.2.5.3 Aprendizaje por refuerzo ......................................................... 14 
2.2.6 Redes neuronales ....................................................................... 14 
2.2.6.1 Tipos según arquitectura ........................................................ 15 
2.2.6.2 Tipos según algoritmo de aprendizaje ..................................... 18 
2.3 Moodle ............................................................................................. 19 
 
 
 
v 
 
2.3.1 Arquitectura de Moodle [6] ......................................................... 19 
2.3.1.1 Capa de vista: ......................................................................... 19 
2.3.1.2 Capa del controlador: .............................................................. 20 
2.3.1.3 Capa de modelo: ..................................................................... 20 
2.4 Python .............................................................................................. 20 
2.4.1 SpaCy [7] ................................................................................... 20 
2.4.2 Natural Languaje Toolkit (NLTK) [8] ........................................... 21 
2.4.3 Scikit-learn [9] ........................................................................... 21 
2.4.4 Keras [10] .................................................................................. 223 Arquitectura .................................................................................... 23 
3.1 Frontend .......................................................................................... 23 
3.2 Backend ........................................................................................... 23 
3.2.1 Tecnologías ................................................................................ 24 
3.2.1.1 Docker [11] ............................................................................. 24 
3.2.1.2 Nginx [12] ............................................................................... 24 
3.2.1.3 Django [13] ............................................................................. 24 
3.2.1.4 PostgreSQL [14] ...................................................................... 25 
3.2.2 Estructura ................................................................................. 26 
4 Desarrollo ........................................................................................ 28 
4.1 Estructura de directorios .................................................................. 28 
4.1.1 Carpeta Moodle .......................................................................... 28 
4.1.2 Carpeta Código .......................................................................... 28 
4.1.2.1 Carpeta web ............................................................................ 28 
4.1.2.2 Carpeta src ............................................................................. 28 
4.1.2.3 Paquete chat_bot .................................................................... 29 
4.2 Diagramas de flujo ........................................................................... 30 
4.2.1 Diagrama del sistema ................................................................. 30 
4.2.2 Diagrama módulo PLN ............................................................... 30 
4.2.3 Diagrama módulo CLN ............................................................... 31 
4.2.4 Diagrama módulo NER ............................................................... 31 
4.2.5 Diagrama módulo principal ........................................................ 31 
4.3 Interfaz de usuario ........................................................................... 32 
4.4 Módulo de entrenamiento ................................................................. 33 
4.5 Modulo principal .............................................................................. 34 
4.6 Módulo PLN ...................................................................................... 35 
4.7 Módulo CLN ..................................................................................... 36 
 
 
 
vi 
 
4.8 Módulo NER ..................................................................................... 37 
4.9 Creación del CORE ........................................................................... 38 
4.9.1 Mail_information ........................................................................ 38 
4.9.2 Office_information ...................................................................... 39 
4.9.3 Telephone_information ............................................................... 39 
4.9.4 Name_information ...................................................................... 39 
4.9.5 Subject_information ................................................................... 39 
4.9.6 Subject_list_information ............................................................. 40 
4.9.7 Frequent-question ...................................................................... 40 
4.9.8 Calendar .................................................................................... 40 
4.10 Ejecución del sistema ....................................................................... 41 
4.11 Pruebas de la funcionalidad ............................................................. 41 
4.11.1 Pruebas unitarias ...................................................................... 41 
4.11.2 Pruebas de integración ............................................................... 42 
4.11.3 Pruebas de campo ...................................................................... 42 
5 Resultados ....................................................................................... 44 
6 Conclusiones ................................................................................... 45 
7 Bibliografía ...................................................................................... 46 
 
 
 
 
 
 
1 
 
 
1 Introducción 
El avance de la tecnología ha llegado hasta tal punto que el uso de ordenadores, 
teléfonos, Internet está prácticamente integrado en la vida cotidiana de la 
mayoría de la sociedad. 
En cualquier colegio, instituto o universidad, ya se trabaja a diario con 
plataformas educativas, esto ya venía encaminado debido a que las nuevas 
generaciones ya están más que acostumbradas al uso de dispositivos 
electrónicos; pero además la pandemia mundial generada por el Covid19 hizo 
imprescindible la modernización y digitalización de la educación, como 
consecuente de las etapas de confinamiento, todo el contacto entre profesores y 
alumnos se comenzó a realizar a través de diferentes plataformas, como por 
ejemplo, Moodle, Teams, etc. 
Esta etapa llevo a muchos alumnos a tener constantemente abierto en una 
pestaña del navegador la plataforma Moodle, necesaria para entrar a clase, 
visualizar las transparencias usadas por el profesor, o incluso realizar exámenes. 
Pero este modelo contenía un problema, la interacción entre alumnos y 
profesores podía llegar a ser especialmente lenta. No es lo mismo poder 
preguntarle una duda a un profesor al finalizar una clase que escribirle un 
mensaje y esperar a que lo lea y te responda, además, generalmente no 
disponías del correo al cual mandar tu pregunta, por lo que desperdicias tiempo 
buscándolo en las guías de aprendizaje, página web de la universidad o en 
correos que te pudiese haber mandado con anterioridad. 
Aquí es donde entra uno de los fines de este proyecto, la implementación de un 
chat-bot que estaría disponible las 24 horas y podría responderte a tus 
preguntas de una manera instantánea. Así, los alumnos obtendrían respuestas 
más fácilmente y los profesores podrían evitar estar atentos a correos de dudas 
una gran parte del tiempo. 
Por lo tanto, el chat-bot estará dirigido a los usuarios de esta plataforma, de 
forma que pueda ayudar y satisfacer las necesidades de los alumnos o 
profesores de manera rápida y eficaz. 
1.1 Objetivos 
El objetivo principal de este proyecto es el desarrollo de un sistema que sea 
capaz de integrar un chat-bot en la plataforma educativa de Moodle. Para lograr 
este objetivo es necesario cumplir diferentes metas. 
Como hitos a conseguir será necesario la investigación individual de diferentes 
campos que componen el proyecto. 
Uno de estos es la plataforma Moodle, es necesario entender el funcionamiento 
de su arquitectura y de las funcionalidades que la componen para poder 
encontrar la mejor manera de incluir el chat-bot dentro de la plataforma. 
Otro de los campos será la Inteligencia Artificial, será necesario entender las 
bases de las ramas principales como, por ejemplo: el lenguaje natural, Machine 
 
 
 
2 
 
Learning, modelos de para la clasificación/predicción de datos y las redes 
neuronales. 
Como ultimo campo, será necesario tener una base de conocimientos sobre 
Python para el desarrollo tanto del chat-bot, como para la implementación de 
una arquitectura que permita una conexión fácil con Moodle. Por ello será 
necesario conocer las posibles librerías que pueden ser usadas en Python para 
el desarrollo de estas actividades. 
Como objetivos específicos, estarían las funcionalidades que puede realizar el 
chat-bot, las cuales son: 
1.1.1 Búsqueda de datos de contacto: 
Esta funcionalidad consiste en que el chat-bot devuelvainformación rápida 
sobre los datos de un profesor, departamento o asignatura. 
Al chat-bot se le podría preguntar por el email de un profesor y te devolvería el 
email institucional guardado en la base de datos. Además de devolver la 
información por un nombre, permitiría también la introducción de solamente el 
cargo que tiene en la escuela o en un departamento específico, y como última 
posible entrada, hacer la pregunta sobre información del coordinador de una 
asignatura o los datos de algún profesor de esta. Con las mismas posibilidades 
de arriba también se encargaría de proporcionar información sobre despachos 
y teléfonos si están disponibles en la base de datos. 
Adicionalmente, si se desconoce el nombre de un cargo de la escuela, 
departamento o asignatura también se podrá preguntar para que el chat-bot te 
responda con la información solicitada. 
En el caso de preguntar por una asignatura el chat-bot podría devolver 
cualquiera de los datos básicos (curso, semestre, créditos, carácter) además de 
poder buscar quien es el coordinador de la asignatura. 
Finalmente disponer de la capacidad de devolver listas de profesores de una 
determinada asignatura y de listas de asignaturas filtrando si son de un 
determinado carácter, curso, semestre o créditos. 
1.1.2 Respuesta a preguntas frecuentes de foros o exámenes: 
Esta funcionalidad consiste en que el chat-bot analice las preguntas frecuentes 
realizadas por los alumnos y contestadas por los profesores. 
El chat-bot incluiría en su entrenamiento las respuestas frecuentes que un 
profesor podría haber creado con anterioridad si prevé que algún alumno podría 
tener dudas sobre algo del trabajo/examen. 
Si un alumno realiza una pregunta que asemeja a que ya está respondida el 
chat-bot devolvería directamente lo especificado por el profesor; en cambio si no 
es capaz de asemejarla a ninguna el chat-bot marcaria la pregunta cómo sin 
responder y la guardaría a la espera de que un profesor la revisase y la incluyera 
en preguntas frecuentes. 
De esta forma el chat-bot evitaría que los alumnos tengan que esperar a que los 
profesores respondan a sus preguntas si ya se han realizado y además evitaría 
que los profesores repitan la misma respuesta una y otra vez. 
 
 
 
3 
 
1.1.3 Registrar tareas/alertas en el calendario de Moodle: 
Esta funcionalidad consiste en que el chat-bot pueda registrar cualquier tipo de 
evento en el calendario personal del usuario de forma rápida y sencilla. 
El chat-bot realizará un análisis del texto introducido por el usuario y obtendrá 
los campos necesarios para guardar el evento deseado. 
Si no es capaz de identificarlos, informará al usuario los datos que le faltan por 
detectar con el fin de que el usuario repita su oración con la nueva información. 
 
 
 
 
 
 
 
4 
 
2 Marco teórico 
En este punto explicaré los conceptos de las técnicas y tecnologías utilizadas 
para el desarrollo del proyecto. 
2.1 Chat-bots 
La definición de un chat-bot es un asistente que se comunica con los usuarios 
a través de mensajes de texto. Se trata de una tecnología que permite al usuario 
mantener una conversación a través de un software que se integra en un 
determinado sistema. 
El sistema está programado para que interactúe con el cliente y le resuelva 
dudas, pero sin que haya una persona física contestando. Tienen la ventaja de 
que están disponibles siempre para resolver las dudas de los usuarios que 
quieran contactar contigo a cualquier hora del día. 
• Algunos de los objetivos del chat-bot son: 
• Ahorrar costes en formación y personal del departamento de atención al 
cliente. 
• Atender las principales dudas y gestiones de los usuarios de manera 
rápida. 
• Posibilitar una interacción muy ágil con el cliente. 
• Atención operativa las 24 horas del día. 
• Atención simultanea de varios usuarios a la vez. 
• Realizar acciones simples como búsquedas de información. 
Para la implementación de este se usan algoritmos desarrollados por la 
Inteligencia Artificial y de Machine Learning que permiten que el chat-bot sea 
capaz de aprender. Pueden llegar a intuir los hábitos y entender los gustos y 
preferencias de los usuarios. 
Existen diferentes tipos de chat-bots en base a las características que poseen y 
las funcionalidades que pueden realizar: 
2.1.1 Chat-bots de ITR (Respuesta de Interacción de Texto) 
Estos chat-bots son también llamados Dumb chatbots debido a que no requieren 
la aplicación de Inteligencia Artificial. 
Este tipo de software funciona a través de una lógica secuencial, siguiendo 
los comandos simples que el programador introduce en él previamente. 
Para ello el chat-bot usa árboles de decisión ya definidos previamente que 
marcan el rumbo de la conversación de manera que el usuario no puede 
interactuar libremente pues de las opciones que le presenta el sistema deberá 
elegir una para recibir una respuesta. 
Es muy útil de cara a que el usuario o cliente pueda realizar una autogestión 
de algunos servicios sin necesidad de atención humana, como reportar 
incidencias. 
Desarrollar este tipo de chat-bots es más sencillo y el tiempo de programación 
es menor, por lo que su coste también suele ser más económico. 
 
 
 
5 
 
2.1.2 Chat-bots de reconocimiento de palabras claves 
Esta categoría de chat-bots es de complejidad intermedia debido a que tampoco 
utilizan Inteligencia Artificial, pero sí que funcionan identificando palabras 
claves en el entorno conversacional durante las interacciones con el cliente. 
Según la ordenación de las palabras clave se emite una respuesta u otra al 
usuario. 
Antes de su configuración, es esencial crear un mapa semántico de las palabras 
clave que más se dan en las conversaciones con atención al cliente. Una vez se 
tiene el mapa semántico, se puede refinar el flujo de conversación ampliando 
variables y combinaciones de las palabras clave. 
A continuación, proporcionan respuestas programadas ante los conjuntos de 
palabras claves. 
2.1.3 Chat-bots de aprendizaje automático 
Estos chat-bots si basan su funcionamiento en la Inteligencia Artificial y el 
Machine Learning y por ello también se les conoce como Smart chatbots. 
Debido al uso de estas tecnologías son capaces de entender y procesar el 
lenguaje humano a un nivel más complejo consiguiendo interpretar la intención 
del usuario y el contexto. Además, también pueden generar respuestas 
ajustadas a esa conversación, logrando mayor naturalidad. 
Ya que son chat-bots contextuales y cognitivos que aprenden de las 
interacciones pasadas ofrecen una conversación más dinámica y real con 
respuestas personalizadas. 
En definitiva, son cada vez más similares a la experiencia de conversación con 
un humano. 
2.2 Inteligencia Artificial (IA) 
La Inteligencia Artificial es, en informática, la inteligencia expresada 
por máquinas, sus procesadores y sus softwares, que serían los análogos 
al cuerpo, el cerebro y la mente, respectivamente, a diferencia de la inteligencia 
natural demostrada por humanos y ciertos animales con cerebros complejos. 
La IA es la combinación de algoritmos planteados con el propósito de crear 
máquinas que presenten las mismas capacidades que el ser humano. Una 
tecnología que todavía resulta lejana y misteriosa, pero que desde hace unos 
años está presente en nuestro día a día a todas horas. 
Los chat-bots usan la IA para generar conversaciones más humanas con los 
usuarios. Así, por un lado, estas herramientas aspiran a ser capaces 
de reconocer emociones humanas y responder en consonancia a través de 
capacidades de procesamiento del lenguaje los cuales utilizan tecnologías 
basadas en varios de los principios del lenguaje natural que se verán a 
continuación. 
A su vez, los chat-bots con IA conversacional pretenden también ser capaces 
de aprender a partir de las conversaciones que mantienen, gracias a la 
aplicación del Machine Learning. 
Algunas de las ramas principales de la IA son estas: 
 
 
 
6 
 
2.2.1 Procesamiento del LenguajeNatural (PLN) [1]: 
El procesamiento del lenguaje natural es también conocido como computación 
lingüística y lo que permite es que el ordenador interprete el lenguaje de una 
persona con aprendizaje y razonamiento. 
Según la definición de IBM, el procesamiento de lenguaje natural es la rama de 
la informática que se ocupa de dotar a los ordenadores de la capacidad de 
entender lenguaje hablado y escrito del mismo modo que los seres humanos. 
Inicialmente los primeros modelos de análisis de PLN eran simbólicos y se 
basaban en codificar manualmente las reglas del lenguaje. Años después, en 
lugar de escribir conjuntos de reglas (y excepciones) los sistemas de PLN 
comenzaron a usar algoritmos de inferencia estadística para analizar otros 
textos y realizar comparaciones en busca de patrones. En la actualidad, se 
utilizan sistemas que combinan los modelos estadísticos y simbólicos. 
Los niveles de comprensión que pueden realizar estos sistemas son: 
• Fonéticos: forma en que las palabras son pronunciadas. 
• Morfológicos: estudia la estructura de las palabras para delimitarlas y 
clasificarlas. 
• Sintácticos: divide una oración en cada uno de sus componentes. 
• Semánticos: busca entender el significado de la oración. 
• Pragmáticos: se ocupa del análisis de oraciones y cómo se usan en 
diferentes situaciones. 
• Discursivo: examina el significado de la oración en relación con otra 
oración en el texto o párrafo del mismo documento. 
Las etapas básicas del procesamiento del texto son: 
2.2.1.1 Limpieza 
En esta etapa, la principal intención es limpiar el texto de manera que tenga el 
formato que se desee. 
Para ello se suelen eliminar o sustituir cualquier carácter especial, signo de 
puntuación, emoji o dato que no concuerde con lo que estamos buscando. 
Además de lo anterior se debe convertir todo el texto o en mayúsculas o en 
minúsculas para que no el ordenador pueda reconocer la misma palabra, 
aunque este escrita de forma diferente. 
2.2.1.2 Tokenización: 
Al tokenizar, puede dividir convenientemente el texto por palabra o por 
oración. Esto le permitirá trabajar con fragmentos de texto más pequeños que 
aún son relativamente coherentes y significativos, incluso fuera del contexto del 
resto del texto. Es su primer paso para convertir datos no estructurados en 
datos estructurados, que son más fáciles de analizar. 
Hay dos tipos de tokenización: 
• Palabra: La tokenización por palabra permite identificar palabras que 
aparecen con especial frecuencia. 
• Oración: La tokenización por oración analiza cómo esas palabras se 
relacionan entre sí y ver más sobre el contexto. 
 
 
 
7 
 
2.2.1.3 Filtrado de palabras vacías: 
Las palabras vacías son palabras que desea ignorar, por lo que cuando un texto 
es procesado estas palabras se filtran y se eliminan. Palabras muy comunes a 
menudo se usan como palabras vacías, ya que no agregan mucho significado a 
un texto por sí mismas. 
Los tipos de palabras son: 
• Palabra de contenido: brindan información sobre los temas tratados en 
el texto o el sentimiento que el autor tiene sobre esos temas. 
• Palabras de contexto: brindan información sobre el estilo de escritura. 
2.2.1.4 Derivación: 
La derivación designa el simple proceso heurístico de cortar el final o el inicio 
de las palabras para mantener solo la raíz de la palabra. 
Estas técnicas funcionan basándose en una lista de sufijos y prefijos que según 
el idioma. 
Como una misma palabra se puede encontrar de diferentes formas dependiendo 
del género, número, persona etc.; al aplicarle la derivación obtendríamos la 
misma raíz. 
2.2.1.5 Lematización: 
Este proceso es parecido al anterior ya que también reduce la palabra a otro 
termino. 
Pero en este caso hay una diferencia y es que la lematización trabaja haciendo 
un análisis morfológico de las palabras con ayuda de diccionarios detallados 
según el idioma. 
Por ello la lematización siempre relaciona cada palabra con la forma en la que 
aparece un diccionario. 
Para los chat-bots este método es más efectivo que la derivación si se quiere 
comprender mejor las consultas de los usuarios. 
2.2.1.6 Etiquetado: 
Esta etapa se encarga de asignar la categoría gramatical que toma cada palabra. 
Hay palabras que pueden tomar diferentes categorías dependiendo del contexto 
en el que se usen y por ello el proceso se puede realizar de acuerdo con la 
definición de la palabra o por su relación con las palabras que tiene adyacentes. 
Los posibles roles son: sustantivo, verbo, adjetivo, adverbio, pronombre, 
preposición, conjunción e interjección. 
2.2.2 Comprensión del Lenguaje Natural (CLN) [2]: 
La comprensión del lenguaje natural es un subconjunto de PLN que trata con 
la faceta mucho más estrecha, pero igualmente importante, de cómo manejar 
mejor las entradas no estructuradas y convertirlas en una forma estructurada 
que una máquina puede entender y actuar. Mientras que los humanos son 
capaces de manejar sin esfuerzo las malas palabras, palabras intercambiadas, 
contracciones, coloquialismos y otras peculiaridades, las máquinas no son tan 
expertas en comprender y asimilara aquellos inputs con faltas de ortografía u 
otros supuestos. 
 
 
 
8 
 
La comprensión del lenguaje natural es una rama de la Inteligencia Artificial 
que utiliza software de computadora para comprender la entrada en forma de 
oraciones usando texto o habla. 
CLN analiza los datos para determinar su significado utilizando algoritmos para 
reducir el habla humana a una ontología estructurada. 
Dos conceptos fundamentales de CLN son la intención y el reconocimiento de 
entidades (NER). 
2.2.3 Generación del Lenguaje Natural (GLN) [3]: 
La generación de lenguaje natural es un campo de investigación y desarrollo de 
la Inteligencia Artificial que se ocupa del uso de sistemas informáticos para 
producir automáticamente lenguaje natural, principalmente texto escrito. 
El sofisticado software GLN tiene la capacidad de extraer grandes cantidades de 
datos numéricos, identificar patrones y compartir esa información de una 
manera que sea fácil de entender para los humanos. 
GLN es un proceso de varias etapas, en el que en cada paso refina aún más los 
datos que se utilizan para producir contenido con un lenguaje que suena 
natural. Las seis etapas de GLN son las siguientes: 
• Análisis de contenido. 
• Comprensión de datos. 
• Estructuración documental. 
• Agregación de oraciones. 
• Estructuración gramatical. 
• Presentación del idioma. 
2.2.4 Recuperación de información (RI) 
La recuperación de información es el campo dentro de la informática que se 
encarga de procesar textos de documentos, para poder recuperar partes 
específicas en base a palabras clave. Por ejemplo, técnicas como la extracción 
de información estructurada o los sistemas de respuesta a preguntas de 
usuarios. No genera nuevas frases, por lo que no necesita utilizar reglas 
gramaticales. Tampoco es tan “inteligente” como la Generación del Lenguaje 
Natural. 
Una estrategia de recuperación de información puede utilizar diversos métodos 
que no necesariamente se excluyen entre sí, sino que pueden combinarse. De 
hecho, hoy existen muchos modelos que solo se diferencian en algunos detalles. 
Pueden clasificarse en tres grandes categorías (modelos clásicos): 
2.2.4.1 Modelo booleano 
Se basa en la teoría de conjuntos del álgebra de George Boole, mediante la 
aplicación de operaciones lógicas AND (Intersección), OR (Unión), NOT (Resta) y 
XOR (Complemento). Para llevarlo a efecto sólo se necesita un fichero 
diccionario donde almacenar los términos de los documentos de la colección y 
la correspondencia de aparición de estos. 
Este modelo es el más rápido de ejecutar ya que solo comprueba los términos 
en función de una condición lógica, pero el resultado que nos devuelve solo 
puede tener los valores 0 (ausencia) o 1 (presencia). 
 
 
 
9 
 
En el proceso más básico no se devuelve la cantidad de veces que aparece un 
término en cada documento y para conseguirlohabría que realizar un proceso 
de varios pasos para la optimización de los datos recopilados por el sistema. 
2.2.4.2 Modelo de espacio vectorial 
Desde un punto de vista matemático, la información también puede 
representarse como un conjunto de vectores. En el modelo espacio vectorial los 
términos constituyen los ejes de coordenadas y tanto los documentos como las 
consultas obtienen valores específicos en relación con ellos, de forma que 
pueden representarse como puntos o vectores dentro de un espacio vectorial. A 
continuación, se comparan los vectores y aquel más cercano a la consulta 
corresponde al contenido que debería mostrarse en primer lugar. 
Los dos tipos de modelos más utilizados son: 
2.2.4.2.1 Bag of Words (BOW) 
Este modelo de espacio vectorial se encarga de representar un documento 
ignorando el orden de aparición de cada término y de su importancia en él. Las 
principales ventajas de utilizar este modelo es su facilidad de uso y su eficiencia 
computacional. También es conocido como proceso de vectorización. 
Para comenzar a usar este modelo es necesario conocer las palabras del 
vocabulario sobre el que vamos a trabajar. Con esta información, ya se tiene el 
tamaño del vector que va a resultar de analizar cada documento, el cual va a 
tener como longitud el número de palabras únicas seleccionadas en el 
vocabulario. 
 
𝐵𝑂𝑊 = [𝑥1 … 𝑥𝑛] 
Ecuación 1.Vector bag of words 
 
A continuación, ya se puede realizar el vector resultante de procesar un 
documento, para ello se comprueba si cada palabra del vocabulario aparece en 
el documento analizado, si lo contiene se asignará a el valor ‘xi’, siendo ‘i’ la 
posición del término; el valor de 1, en cambio si no lo contiene se le asignara un 
valor de 0. 
 
𝑥𝑖 = {
0 𝑠𝑖 𝑑 ⊄ 𝑖
1 𝑠𝑖 𝑑 ⊂ 𝑖
 
Ecuación 2. condición para asignación del valor xi 
 
La variable ‘i’ se refiere al termino correspondiente y la variable ‘d’ representa el 
documento en el que se está analizando. 
Con este método se consigue un espacio vectorial normalizado en el que cada 
dimensión solo puede tener los valores 0 o 1 y por consiguiente la distancia 
entre dos vectores de este mismo espacio esta estandarizada. 
Al tener la característica anterior este modelo de espacio vectorial puede ser 
usado con clasificadores de aprendizaje automático y redes neuronales sin que 
haya problemas en sus algoritmos. 
 
 
 
10 
 
2.2.4.2.2 TF-IDF 
Este tipo de modelo de espacio vectorial se basa en la relación de cada termino 
en un documento en comparación con los demás documentos del conjunto total. 
Esta medida se calcula al multiplicar la frecuencia de cada termino (TF), que 
representa el peso de ese término en particular en un documento especifico; por 
la frecuencia inversa del documento (IDF), que representa el peso del término 
en base a todos los documentos. 
Para la obtención del valor de TF es necesario contar el número de veces que 
aparece el termino en su documento y dividirlo por el número total de palabras 
que hay en él. 
 
𝑇𝐹𝑡,𝑑 =
𝑓𝑟𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎 𝑑𝑒 𝑡 𝑒𝑛 𝑑
𝑛ú𝑚𝑒𝑟𝑜 𝑝𝑎𝑙𝑎𝑏𝑟𝑎𝑠 𝑡𝑜𝑡𝑎𝑙 𝑑𝑒 𝑑
 
Ecuación 3. Función TF 
 
El valor IDF se puede calcular de distintas formas que son ligeramente 
diferentes. Esto se debe a que esta medida es igual para cada termino ya que 
no requiere de un documento específico para calcularlo, si no el uso de todos. 
Como durante el desarrollo he usado la librería Sklearn escribiré la formula 
predeterminada que usa esta librería para este cálculo. 
La fórmula correspondiente es logaritmo del número total de documentos 
dividido por el número de documentos que contienen el término. 
 
𝐼𝐷𝐹𝑡 = log(
𝑛ú𝑚𝑒𝑟𝑜 𝑡𝑜𝑡𝑎𝑙 𝑑𝑒 𝑑𝑜𝑐𝑢𝑚𝑒𝑛𝑡𝑜𝑠 
𝑛ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑑𝑜𝑐𝑢𝑚𝑒𝑛𝑡𝑜𝑠 𝑞𝑢𝑒 𝑐𝑜𝑛𝑡𝑖𝑒𝑛𝑒𝑛 𝑡
) 
Ecuación 4. Función IDF 
 
Finalmente se obtiene la medida TF-IDF como la multiplicación de estos valores. 
 
𝑇𝐹_𝐼𝐷𝐹𝑡,𝑑 = 𝑇𝐹𝑡,𝑑 × 𝐼𝐷𝐹𝑡 
Ecuación 5. Función TF-IDF 
 
El resultado final de este algoritmo es la creación de una matriz en la cada fila 
representa un término y cada columna un documento. 
 
𝑀𝑎𝑡𝑟𝑖𝑧𝑇𝐹_𝐼𝐷𝐹 = [
𝑇𝐹𝐼𝐷𝐹𝑡1,𝑑1 ⋯ 𝑇𝐹𝐼𝐷𝐹𝑡1,𝑑𝑛
⋮ ⋱ ⋮
𝑇𝐹𝐼𝐷𝐹𝑡𝑛,𝑑1 ⋯ 𝑇𝐹𝐼𝐷𝐹𝑡𝑛,𝑑𝑛
] 
Ecuación 6. Matriz resultante por el algoritmo 
 
 
 
 
11 
 
La variable ‘t’ se refiere al termino correspondiente y la variable ‘d’ representa el 
documento en el que se está analizando. 
Para la medida de coincidencia usando este modelo se puede usar la métrica 
conocida como cosine similarity. Esta calcula el coseno del ángulo que forman 
dos vectores en un espacio multidimensional. Los valores que puede tomar esta 
medida son [-1, 1], en el caso de -1 significa que los vectores son completamente 
opuestos y que apuntan en direcciones contrarias; en cambio, el valor 1 se 
obtiene cuando ambos vectores tienen la misma dirección. 
Usando el modelo TF-IDF y la métrica cosine similarity se puede obtener la 
similitud de un documento u oración en comparación con otro gran número de 
documentos. Primero se realizaría la matriz TF-IDF y después se calcularía la 
medida cosine similarity entre el vector perteneciente al documento entrante y 
todos los demás vectores de los otros documentos. El mayor valor de estos 
resultados se podría prever como que es el documento más similar frente al 
documento entrante. 
2.2.4.3 Modelo probabilístico 
Este modelo recurre a la teoría de la probabilidad. A cada contenido se le asigna 
un valor de probabilidad y los resultados se ordenan en función de la 
probabilidad con la que se ajustan a la intención de búsqueda. Para calcularla, 
el modelo utiliza el llamado feedback de relevancia, por el cual se anima a los 
usuarios a valorar manualmente los resultados, de tal modo que en la próxima 
búsqueda idéntica el modelo pueda mostrar una lista diferente de resultados, 
quizá mejor que la primera. 
2.2.5 Aprendizaje automático – Machine Learning 
El Machine Learning es una rama de la inteligencia artificial que permite que las 
máquinas aprendan sin ser expresamente programadas para ello. Una 
habilidad indispensable para hacer sistemas capaces de identificar patrones 
entre los datos para hacer predicciones. 
Básicamente, esta rama consigue que un ordenador se convierta en un maestro 
del reconocimiento de patrones, y que sea capaz de convertir una muestra de 
datos en un programa informático capaz de extraer inferencias de nuevos 
conjuntos de datos para los que no ha sido entrenado previamente. 
Automáticamente, también en este contexto, implica que estos sistemas se 
mejoran de forma autónoma con el tiempo, sin intervención humana. 
La base fundamental del aprendizaje automático es la estadística y las 
matemáticas, su funcionamiento consiste en una serie de algoritmos capaces 
de analizar grandes cantidades de datos para deducir cuál es el resultado 
óptimo para un determinado problema. 
2.2.5.1 Aprendizaje supervisado 
El aprendizaje supervisado se define por el uso de conjuntos de datos 
etiquetados para entrenar los algoritmos para clasificar datos o predecir 
resultados con precisión. A medida que se introducen datos de entrada en el 
modelo, adapta sus pesos hasta que el modelo se haya ajustado correctamente. 
El objetivo de este aprendizaje de clasificar y predecir conjuntos de datos, que 
no se han usado en el entrenamiento, con la mayor precisión posible. 
 
 
 
12 
 
Para conseguirlo se necesita ajustar bien el modelo con los parámetros 
necesarios. Existen muchos tipos de clasificadores y por ello es importante 
encontrar cual se ajusta más a las necesidades del problema que se quiere 
resolver. 
Todos los modelos deben ser entrenados con anterioridad y por ello es necesario 
elegir un buen conjunto de datos evitando el underfitting o el overfitting. 
• Underfitting: esto ocurre cuando un modelo de datos no puede capturar 
la relación entre las variables de entrada y salida con precisión, 
generando una alta tasa de error tanto en el conjuntode entrenamiento 
como en los datos no vistos. Ocurre cuando un modelo es demasiado 
simple, lo que puede ser el resultado de un modelo que necesita más 
tiempo de entrenamiento, más características de entrada o menos 
regularización. 
Unos buenos indicadores de que esto está ocurriendo en el modelo son 
un alto sesgo y una varianza baja. 
• Overfitting: esto ocurre cuando un modelo de datos genera una 
predicción perfecta en los datos de entrenamiento, pero en cambio, en 
los conjuntos nuevos no es capaz de ser preciso. 
Este suceso se produce cuando el modelo memoriza el ruido producido 
por el conjunto de datos inicial y se ajusta demasiado al conjunto de 
entrenamiento. 
Unos buenos indicadores de que esto está ocurriendo en el modelo son 
una tasa de error baja y una varianza alta. 
En el aprendizaje supervisado existen dos categorías principales en función de 
la salida que producen: 
2.2.5.1.1 Clasificación 
La clasificación es el lugar donde se entrena a un algoritmo para clasificar los 
datos de entrada en variables discretas. 
Por lo tanto, el objetivo de estos algoritmos es predecir a qué clase de las posibles 
pertenece el conjunto de datos de entrada. 
2.2.5.1.2 Regresión 
La regresión es un método en el que se entrena a un algoritmo para predecir 
una salida a partir de un rango continuo de valores posibles. 
En la regresión, los algoritmos necesitan identificar relaciones funcionales entre 
los parámetros de entrada y salida. Los valores de salida no son discretos como 
en la clasificación, sino una función de los parámetros de entrada. La precisión 
de un algoritmo de regresión se calcula como la desviación entre el resultado 
exacto y el resultado previsto. 
2.2.5.2 Aprendizaje no supervisado 
El aprendizaje no supervisado se define por el uso de conjuntos de datos que 
no están etiquetados por lo que el algoritmo tiene que intentar entender por sí 
mismo. 
El objetivo es simplemente dejar que la máquina aprenda sin ayuda o 
indicaciones. En el camino, también deberá aprender a ajustar los resultados y 
 
 
 
13 
 
agrupaciones cuando haya resultados más adecuados, permitiendo que la 
máquina comprenda los datos y los procese como mejor le parezca. 
El aprendizaje no supervisado se utiliza para explorar datos desconocidos. 
Puede revelar patrones que podrían haberse pasado por alto o examinar grandes 
conjuntos de datos que serían demasiado para que los abordara una sola 
persona. 
Los algoritmos de este aprendizaje se utilizan para agrupar los datos no 
estructurados según sus similitudes y patrones distintos en el conjunto de 
datos. 
La salida de estos algoritmos se utiliza para poder describir la estructura de los 
datos e intentar encontrar algún tipo de organización que simplifique el análisis. 
Por ello, tienen un carácter exploratorio. 
En el aprendizaje no supervisado es usado para resolver diferentes tipos de 
problemas: 
2.2.5.2.1 Agrupamiento (clustering) 
En estos problemas el objetivo es encontrar diferentes grupos dentro de los 
elementos de los datos. Para ello, los algoritmos de agrupamiento encuentran 
patrones ocultos en los datos de manera que los elementos del mismo clúster 
son más similares entre sí que con los demás clústeres diferentes. 
El resultado de estos algoritmos será un nuevo patrón en los datos asociado a 
una etiqueta o clase. La interpretación de las clases o grupos obtenidos es una 
tarea que se realiza ‘a posteriori’ por un analista. 
Este tipo de comportamiento de aprendizaje es similar al de los humanos. 
Imagina cómo analizamos y observamos el entorno para recoger los datos y 
entender y reconocer las cosas. 
Los tipos de algoritmos se pueden categorizar en estas categorías: 
• Clustering particional. 
• Clustering jerárquico. 
• Clustering probabilístico. 
2.2.5.2.2 Asociación 
El objetivo de estos algoritmos es la búsqueda de asociaciones entre ciertos 
valores de las variables que componen las muestras. 
Para conseguirlo se busca la concurrencia entre ellos, es decir, contando las 
veces que aparecen simultáneamente. Este tipo de problema puede generar 
como resultado un conjunto de reglas de asociación. 
Las reglas de asociación permiten establecer asociaciones entre objetos de datos 
dentro de grandes bases de datos. 
Esta técnica no supervisada trata de descubrir relaciones interesantes entre 
variables que inicialmente un ser humano no es capaz de observar a simple 
vista. 
 
 
 
14 
 
2.2.5.2.3 Reducción de la dimensionalidad 
El Machine Learning trabaja con datos que pueden tener una gran complejidad 
y por ello requiera una mayor capacidad de procesamiento. Los datos están 
compuestos de variables que son también conocidas como características. 
Aunque se pueda pensar que a mayor número de variables el modelo será más 
preciso esto no es exactamente cierto ya que además de requerir más tiempo y 
recursos, el modelo puede llegar a verse afectado por el overfitting si el conjunto 
de datos no es de calidad. 
Por ello, algunas características a veces son redundantes y están 
correlacionadas. Es entonces cuando se necesita ayuda del algoritmo de 
reducción de dimensionalidad. Este algoritmo no supervisado reducirá las 
variables aleatorias y obtendrá una selección óptima para estas variables. 
Se usa comúnmente para la etapa de preprocesado de los datos y para favorecer 
la visualización de los datos. 
2.2.5.3 Aprendizaje por refuerzo 
El aprendizaje por refuerzo es un modelo que no se basa ni en reconocer 
patrones ni en predecir un resultado, en cambio se basa en la retroalimentación 
que recibe de su entorno en función de las acciones o comportamientos que 
toma. 
El objetivo es que en base a los refuerzos que el modelo recibe ajuste su 
comportamiento de manera que la próxima vez que tome una decisión esta sea 
la correcta. 
En los modelos anteriores se intenta minimizar la función de coste (reducir el 
error), en cambio, con el aprendizaje por refuerzo se busca maximizar la 
recompensa. 
Para conseguirlo trabajan a base de ensayo y error. Esto en los ordenadores es 
una tarea fácil ya que pueden ejecutar el mismo proceso sin cansarse y además 
a una velocidad extremadamente rápida. Por ello pueden sacar un gran 
rendimiento al proceso de prueba y error. 
El aprendizaje por refuerzo se diferencia del aprendizaje supervisado por que no 
recibe datos etiquetados si no la intervención humana que verifica el 
comportamiento y refuerza al modelo con lo que corresponda. Y la diferencia 
con el aprendizaje no supervisado es que no busca la agrupación en grupos si 
no que ya se conoce el resultado esperado. 
2.2.6 Redes neuronales 
Las redes de neuronas artificiales (RNA) son un paradigma de aprendizaje y 
procesamiento automático inspirado en la forma en que funciona el sistema 
nervioso de los animales. Consiste en simular las propiedades observadas en 
los sistemas neuronales biológicos a través de modelos matemáticos recreados 
mediante mecanismos artificiales (como un circuito integrado, un ordenador o 
un conjunto de válvulas). 
Una neurona se compone de tres partes: 
 
 
 
15 
 
• Cuerpo celular o soma: el cual contiene al núcleo celular. Es la zona 
encargada de manejar todas las funciones de la célula. Al albergar el 
núcleo celular contiene material genético en forma de ADN y ARN. 
• Axones: son prolongaciones del cuerpo celular en forma de finas 
estructuras alargadas y su función es la de transmitir sustancias desde 
el cuerpo celular a cada uno de los extremos, y desde un extremo a otro 
de la célula. Su forma es muy característica debido a que facilita 
la transmisión del impulso nervioso y a que permite agrupar densamente 
todas las neuronas 
• Dendritas: son ramificaciones que se encuentran en las porciones 
distales de los axones, siendo estas estructuras las que generalmente 
entran en contacto con otras neuronas. Su forma ramificada permite que 
una sola neurona tenga un mejor alcance sobre una o varias células al 
mismo tiempo, constituyendo una auténticamalla de conexiones 
intercelulares bastante fuente y organizada que permite la adecuada 
transmisión de los impulsos nerviosos. 
Cuando se establece el contacto entre dos células diferentes, generalmente se 
da un proceso conocido como sinapsis química. 
Las redes neuronales buscan simular este mecanismo biológico, consiguiendo 
que los ordenadores encuentren la capacidad de resolver problemas complejos 
al analizar y procesar la información. 
El modelo de una red neuronal está organizado en varias capas, una de entrada, 
una o más capas ocultas y finalmente una de salida. 
Cada una de estas capas está compuesta por un conjunto de nodos llamados 
neuronas artificiales que a su vez están conectados con todos los nodos de la 
capa siguiente. 
En estos enlaces el valor de salida de la neurona anterior es multiplicado por 
un valor de peso. Estos pesos en los enlaces pueden incrementar o inhibir el 
estado de activación de las neuronas adyacentes. Del mismo modo, a la salida 
de la neurona, puede existir una función limitadora o umbral, que modifica el 
valor resultado o impone un límite que no se debe sobrepasar antes de 
propagarse a otra neurona. 
El aprendizaje automático de estos modelos se produce cuando la propia red 
neuronal cambia los pesos que conectan las neuronas. 
Las redes neuronales se pueden clasificar en diferentes tipos según la topología 
o según el método de aprendizaje. [4] [5] 
2.2.6.1 Tipos según arquitectura 
2.2.6.1.1 Red neuronal monocapa 
Se corresponde con la red neuronal más simple, únicamente está compuesta 
por dos capas, aunque como la de entrada no ejecuta operaciones sobre los 
pesos no se contabiliza. Por lo tanto, la única capa que realiza cálculos es la de 
salida y sobre ella está proyectada la de entrada. 
 
 
 
16 
 
 
Ilustración 1. Diagrama de una red neuronal monocapa 
2.2.6.1.2 Red neuronal multicapa 
Mantiene las capas de entrada y salida igual que en la anterior, pero entre las 
conexiones de entrada y de salida, existen diversas capas de neuronas que 
hacen de intermediarias, denominadas capas ocultas. Estas capas de neuronas 
pueden conectarse entre ellas o no. 
 
Ilustración 2. Diagrama de una red neuronal multicapa 
2.2.6.1.3 Red neuronal convolucional (CNN) 
La diferencia principal de este tipo de red comparándola con las multicapas 
comunes es que las diferentes partes de la red neuronal se pueden entrenar 
para tareas diversas. Con esto se consigue aumentar la velocidad de 
entrenamiento e identificar patrones de una forma más avanzada. Gracias al 
uso de algoritmos para redes convolucionales, se reduce el número de 
conexiones y de parámetros, por lo que requiere de menor entrenamiento. 
 
 
 
17 
 
 
Ilustración 3. Diagrama de una red neuronal convolucional 
2.2.6.1.4 Red neuronal recurrente (RNN) 
Las redes neuronales recurrentes están especializadas en procesar datos 
secuenciales o series temporales debido a que tienen la posibilidad de realizar 
conexiones de realimentación, ya sea entre neuronas de una misma capa o de 
diferentes capas. El proceso de realimentación consigue que este tipo de redes 
sea capaz de obtener una memoria artificial. 
 
Ilustración 4. Diagrama de una red neuronal recurrente 
2.2.6.1.5 Red de base radial (RBF) 
Las redes de base radial calculan la salida de la función en función de la 
distancia a un punto denominado centro. La salida es una combinación lineal 
de las funciones de activación radiales utilizadas por las neuronas individuales. 
Las redes de base radial tienen la ventaja de que no presentan mínimos locales 
donde la retro propagación pueda quedarse bloqueada. 
 
 
 
18 
 
 
Ilustración 5. Diagrama de una red neuronal de base radial 
2.2.6.2 Tipos según algoritmo de aprendizaje 
2.2.6.2.1 Aprendizaje supervisado 
El funcionamiento de este aprendizaje es prácticamente idéntico al explicado 
anteriormente, las únicas diferencias que poseen son que dispone de un agente 
externo, también llamado supervisor maestro, que se encarga de controlar la 
salida de la red y en caso de no coincidir, procede a modificar los pesos de las 
conexiones. Repite este proceso hasta que la salida obtenida se aproxime a la 
deseada. 
2.2.6.2.1.1 Aprendizaje por corrección de error. 
Este tipo de aprendizaje consiste en calcular la función de error en la salida y 
ajustar los pesos en base al resultado. Esta función es la diferencia entre los 
valores deseados y los obtenidos en la salida. 
Algunos de los algoritmos de este tipo son: 
• Regla de aprendizaje del Perceptrón 
• Regla de aprendizaje Delta o regla del mínimo error cuadrado (LMS Error) 
• Regla de aprendizaje de propagación hacia atrás o de backpropagation 
(LMS multicapa) 
2.2.6.2.1.2 Aprendizaje estocástico. 
Este tipo de aprendizaje consiste en cambiar los pesos de forma aleatoria y 
evaluar cual es el efecto en función de los valores deseados y distribuciones de 
posibilidad. 
2.2.6.2.2 Aprendizaje no supervisado 
En este aprendizaje no hay diferencia con el explicado arriba ya que no se 
proporciona la salida deseada en función de la entrada proporcionada. El ajuste 
de los pesos se genera sin saber si la salida es correcta o no. Así que el objetivo 
de este aprendizaje no es predecir un resultado si no representar el grado de 
familiaridad o similitud de los datos de entrada. 
2.2.6.2.2.1 Aprendizaje hebbiano. 
Esta regla de aprendizaje funciona de manera simple, aumenta el peso de la 
conexión de dos neuronas si ambas toman el mismo estado simultáneamente. 
Los posibles estados son activo o inactivo y para ello se usan neuronas binarias. 
 
 
 
19 
 
2.2.6.2.2.2 Aprendizaje competitivo y comparativo. 
Este aprendizaje se orienta al clustering de los datos de entrada. 
Comienza clasificando los datos de entrada en las clases que repiten un 
determinado patrón, si el nuevo dato de entrada se reconoce como perteneciente 
a una clase ya existente, la red ajusta los pesos para matizar la representación 
de esta clase; en cambio, si determina que no pertenece a ninguna clase, la red 
neuronal ajustara su estructura para añadir nuevos pesos que reconocerán la 
nueva clase en siguientes iteraciones. 
2.2.6.2.3 Aprendizaje por refuerzo 
Podría considerarse dentro del aprendizaje supervisado ya que el proceso del 
aprendizaje es parecido al aprendizaje por corrección de error, pero en este caso 
se basa en no tener durante el entrenamiento la salida exacta si no que se 
calculen los pesos en función de una señal de refuerzo y un mecanismo de 
probabilidades. 
2.3 Moodle 
Moodle es una aplicación de aprendizaje electrónico que le permite crear cursos 
y programas de capacitación en línea. 
Es muy popular entre los profesores de todo el mundo como herramienta para 
crear sitios web dinámicos en Internet para sus alumnos. Para usarlo, debe 
estar instalado en un servidor web, y puede instalarse en una computadora 
personal y en un servidor proporcionado por una empresa de alojamiento web. 
El objetivo del proyecto Moodle siempre ha sido brindar a los docentes las 
mejores herramientas. 
Moodle fue creado por Martin Dougiamas, quien fue administrador 
de WebCT en la Universidad Tecnológica de Curtin. Basó su diseño en las ideas 
del constructivismo en pedagogía que afirman que el conocimiento se construye 
en la mente del estudiante en lugar de ser transmitido sin cambios a partir de 
libros o enseñanzas y en el aprendizaje colaborativo. Un profesor que opera 
desde este punto de vista crea un ambiente centrado en el estudiante que le 
ayuda a construir ese conocimiento con base en sus habilidades y 
conocimientos propios en lugar de simplemente publicar y transmitir la 
información que se considera que los estudiantes deben conocer. 
2.3.1 Arquitectura de Moodle [6] 
En términos de arquitectura, Moodle es una aplicación web que se ejecuta sin 
modificaciones en Unix, GNU/Linux, OpenSolaris, FreeBSD, Windows, Mac OS 
X, NetWare y otros sistemas que soportan PHP, incluyendo la mayoría de los 
proveedoresde hosting web. 
Moodle dispone de bastantes módulos por defecto y permite al desarrollador 
incluir módulos ya implementados o diseñar un módulo propio. 
Moodle está diseñado siguiendo la lógica de la arquitectura modelo, vista y 
controlador (MVC). 
2.3.1.1 Capa de vista: 
En esta capa se mostrarán cada uno de los elementos que serán manejables por 
los usuarios. Estos elementos se crearán a partir de funciones y bibliotecas 
 
 
 
20 
 
dadas por Moodle, están creados en PHP. El uso de estas funciones permite 
mantener este esquema en toda la plataforma. 
También permite la introducción de bloques de texto directamente desde el sitio 
web usando los formularios disponibles, el formato puede ser HTML o texto. 
2.3.1.2 Capa del controlador: 
En esta capa se concentra toda la lógica del negocio de la aplicación. Cada uno 
de los módulos que componen la plataforma tienen su propia capa de negocio, 
y es en cada una de estas capas donde se encuentran todos los componentes 
encargados de generar la funcionalidad del sistema. Esta capa es la encargada 
de comunicarse con la capa de presentación para recibir las peticiones y con la 
capa de datos para almacenar o recuperar los datos almacenados en ella. Toda 
la lógica que compone esta capa esta implementada en PHP y siguiendo los 
estándares de codificación indicados por la plataforma Moodle. 
2.3.1.3 Capa de modelo: 
La capa de datos contiene todo lo relacionado con el servidor de base de datos. 
Este servidor contiene todas las tablas necesarias para guardar la información 
de los usuarios, así como la gestión de instalación y actualización de las 
actividades. La plataforma Moodle únicamente soporta de forma nativa los 
servidores de base de datos PostgreSQL, MySQL y MariaDB, aunque 
actualmente dispone de extensiones que permiten el uso de la mayoría de los 
sistemas de bases de datos existentes. 
2.4 Python 
Python es un lenguaje de programación de alto nivel que se utiliza para 
desarrollar aplicaciones de todo tipo. A diferencia de otros lenguajes como Java 
o .NET, se trata de un lenguaje interpretado, es decir, que no es necesario 
compilarlo para ejecutar las aplicaciones escritas en Python, sino que se 
ejecutan directamente por el ordenador utilizando un programa denominado 
interpretador, por lo que no es necesario “traducirlo” a lenguaje máquina. 
Python es un lenguaje sencillo de leer y escribir debido a su alta similitud con 
el lenguaje humano. Además, se trata de un lenguaje multiplataforma de código 
abierto y, por lo tanto, gratuito, lo que permite desarrollar software sin límites. 
Con el paso del tiempo, Python ha ido ganando adeptos gracias a su sencillez y 
a sus amplias posibilidades, sobre todo en los últimos años, ya que 
facilita trabajar con Inteligencia Artificial, Big Data, Machine Learning y Data 
Science, entre muchos otros campos en auge. 
Para la implementación del chat-bot es necesario el uso de librerías de Python 
tales como: 
2.4.1 SpaCy [7] 
SpaCy es una librería de Python que permite construir aplicaciones de 
procesamiento de lenguaje natural (PLN). SpaCy proporciona modelos 
preentrenados de diferentes idiomas, lo cual junto a una sintaxis clara hace que 
sea ideal para principiantes en el campo de la PLN. 
SpaCy funciona ejecutando una serie de pipelines predefinidas. 
 
 
 
 
21 
 
 
 
Ilustración 6. Diagrama flujo de ejecución de los pipelines 
Además de estos pipelines, permite crear modelos nuevos o reentrenar los 
modelos que proporciona con datos propios para entrenar los modelos en 
campos específicos. 
SpaCy está orientado al uso de producción, proporcionando un framework para 
construir aplicaciones completas que requieran de procesamiento de lenguaje 
natural. Además, es eficiente en CPU pese a utilizar modelos de redes 
neuronales. 
2.4.2 Natural Languaje Toolkit (NLTK) [8] 
NLTK es una biblioteca de Python para trabajar con datos en lenguaje humano. 
Proporciona interfaces fáciles de usar junto con un conjunto de bibliotecas de 
procesamiento de texto para clasificación, tokenización, derivación, etiquetado, 
análisis y razonamiento semántico. 
Muchas de las tareas de preprocesamiento que se necesitan ya están 
programadas de manera eficiente en NLTK y se pueden usar directamente en 
cualquier programa. Además de los programas, se distribuyen también una 
cantidad mayor de cincuenta corpus y otros datos lingüísticos. 
2.4.3 Scikit-learn [9] 
Scikit-learn es una biblioteca para aprendizaje automático para el lenguaje de 
programación Python. 
Incluye varios algoritmos de clasificación, regresión y análisis de grupos entre 
los cuales están máquinas de vectores de soporte, bosques aleatorios, Gradient 
Boosting, K-Means y DBSCAN. Está diseñada para interoperar con las 
bibliotecas numéricas y científicas NumPy y SciPy. 
Scikit-learn es ampliamente utilizado en la competencia Kaggle, así como en 
empresas tecnológicas prominentes. Scikit-Learn ayuda en el 
preprocesamiento, la reducción de dimensionalidad (selección de parámetros), 
la clasificación, la regresión, la agrupación y la selección de modelos. 
La gran variedad de algoritmos y utilidades de Scikit-learn la convierten en la 
herramienta básica para empezar a programar y estructurar los sistemas de 
análisis datos y modelado estadístico. Los algoritmos de Scikit-Learn se 
combinan y depuran con otras estructuras de datos y aplicaciones externas 
como Pandas o PyBrain. 
Dentro de Scikit-learn se incluyen diferentes paquetes: 
 
 
 
22 
 
• NumPy: una librería de Python que se utiliza en proyectos de Machine 
Learning. Se utiliza para crear estructuras de datos con matrices y 
matrices multidimensionales. 
• Pandas: una extensión de Numpy que se utiliza para estructurar, 
analizar y visualizar datos de manera automática. 
• Matplotlib: se utiliza para crear representaciones gráficas de los datos. 
• SymPy: esta librería permite automatizar el cálculo simbólico. 
• Ipython: incluye una consola que incorpora funcionalidades que facilitan 
el trabajo. Entre otras cosas, permite que varias aplicaciones se ejecuten 
y monitoreen de forma interactiva y en paralelo. 
• SciPy: es una librería científica que incluye módulos para el desarrollo de 
tareas de ciencia e ingeniería. 
2.4.4 Keras [10] 
Keras es una biblioteca de redes neuronales de código abierto escrita 
en Python. 
Está especialmente diseñada para posibilitar la experimentación en más o 
menos poco tiempo con redes de Aprendizaje Profundo. Sus fuertes se centran 
en ser amigable para el usuario, modular y extensible. 
Keras es una abstracción, un API High-level, para la creación de modelos de 
aprendizaje. Aporta una sintaxis homogénea y una interfaz sencilla, modular y 
ampliable para la creación de redes neurales. 
Keras consta de tres motores de backend, que son los siguientes: 
• TensorFlow: es un producto de Google, que es una de las herramientas 
de aprendizaje profundo más famosas y ampliamente utilizada en el área 
de investigación de aprendizaje automático y redes neuronales 
profundas. 
• Está construido de tal manera que puede ejecutarse fácilmente en 
múltiples CPU y GPU, así como en sistemas operativos móviles. Consiste 
en varios contenedores en distintos lenguajes como Java, C++ o Python. 
 
• Theano: es una biblioteca de Python de código abierto que se usa 
ampliamente para realizar operaciones matemáticas en matrices 
multidimensionales mediante la incorporación de Scipy y Numpy. Utiliza 
GPU para un cálculo más rápido y calcula de manera eficiente los 
gradientes mediante la creación automática de gráficos simbólicos. Ha 
resultado ser muy adecuado para expresiones inestables, ya que primero 
las observa numéricamente y luego las calcula con algoritmos más 
estables. 
 
• CNTK: Microsoft Cognitive Toolkit es el marco de código abierto de 
aprendizaje profundo. Consta de todos los componentes básicos 
necesarios para formar una red neuronal. Los modelos se entrenan 
usando C++ o Python, pero incorpora C# o Javapara cargar el modelo 
para hacer predicciones. 
 
 
 
 
23 
 
3 Arquitectura 
Para el desarrollo de este sistema se usará una arquitectura de N capas que 
sigue la arquitectura MVC, el objetivo de esta elección es separar las partes que 
componen el software en capas lógicas con la finalidad de gestionar y controlar 
de mejor manera el desarrollo que se lleva a cabo en cada una de ellas. 
 
Ilustración 7. Diagrama de la arquitectura de N capas 
3.1 Frontend 
Esta es la capa externa del software y es con la que el usuario podrá interactuar. 
Como el sistema tiene que estar integrado en la plataforma educativa Moodle 
pues se usa la misma capa vista para el funcionamiento de las propias 
funcionalidades de Moodle como para el uso del chat-bot que se conectara a 
una capa controladora diferente. 
Esta capa hará uso del lenguaje HTML y JavaScript. 
Con el lenguaje HTML se diseñará el campo visual donde el usuario podrá 
escribirle al chat-bot y por donde recibirá la respuesta generada por él. Además, 
se ha usado CSS para darle estilo al HTML. 
Con el lenguaje JavaScript se realizará las funciones para recuperar los 
mensajes escritos por el usuario, a continuación, enviar las peticiones al 
backend y finalmente mostrar la respuesta recibida en el lugar que le 
corresponde. 
Para hacer las peticiones al backend se ha hecho uso de la librería Axios de 
JavaScript. 
3.2 Backend 
Esta es la capa del software donde se ha desarrollado toda la lógica del chat-
bot, la recepción de peticiones del frontend, el procesamiento del texto de 
entrada, seguido del flujo correspondiente a la intención encontrada y la 
administración de la base de datos. 
A continuación, se explica brevemente las tecnologías que se han usado para 
que se pueda entender el funcionamiento completo del backend. Después se 
explicará la estructura que forman estas tecnologías. 
 
 
 
24 
 
3.2.1 Tecnologías 
3.2.1.1 Docker [11] 
La idea detrás de Docker es crear contenedores ligeros y portables para las 
aplicaciones software que puedan ejecutarse en cualquier máquina con Docker 
instalado, independientemente del sistema operativo que la máquina tenga por 
debajo, facilitando así también los despliegues. 
Docker es una herramienta diseñada para beneficiar tanto a desarrolladores, 
QA, como administradores de sistemas, en relación a las máquinas, a los 
entornos en sí donde se ejecutan las aplicaciones software, los procesos de 
despliegue, etc. 
En el caso de los desarrolladores, el uso de Docker hace que puedan centrarse 
en desarrollar su código sin preocuparse de si dicho código funcionará en la 
máquina en la que se ejecutará. 
 
Docker también es muy bueno para el testeo, para tener varios entornos de 
pruebas. Por un lado, es muy sencillo crear y borrar un contenedor, además de 
que son muy ligeros, por lo que podemos ejecutar varios contenedores en una 
misma máquina (base de datos, servidor, librerías…). 
Esto además beneficia a la parte de sistemas, ya como los contenedores son 
más ligeros que las máquinas virtuales, se reduce el número de máquinas 
necesarias para tener un entorno. 
3.2.1.2 Nginx [12] 
Nginx es un famoso software de servidor web de código abierto. En su versión 
inicial, funcionaba en servidores web HTTP. Sin embargo, hoy en día también 
sirve como proxy inverso, balanceador de carga HTTP y proxy 
de correo electrónico para IMAP, POP3 y SMTP. 
Nginx está diseñado para ofrecer un bajo uso de memoria y alta 
concurrencia. En lugar de crear nuevos procesos para cada solicitud web, Nginx 
usa un enfoque asincrónico basado en eventos donde las solicitudes se manejan 
en un solo hilo. 
Con Nginx, un proceso maestro puede controlar múltiples procesos de trabajo. 
El proceso maestro mantiene los procesos de trabajo, y son estos lo que hacen 
el procesamiento real. 
Algunas características comunes que se ven en Nginx incluyen: 
• Proxy inverso con caché 
• IPv6 
• Balanceo de carga 
• Soporte FastCGI con almacenamiento en caché 
• Websockets 
• Manejo de archivos estáticos, archivos de índice y auto indexación 
• TLS / SSL con SNI 
3.2.1.3 Django [13] 
Django es un framework web de alto nivel que permite el desarrollo rápido de 
sitios web seguros y mantenibles. Desarrollado por programadores 
experimentados, Django se encarga de gran parte de las complicaciones del 
 
 
 
25 
 
desarrollo web, por lo que puedes concentrarte en escribir tu aplicación sin 
necesidad de reinventar la rueda. Es gratuito y de código abierto, tiene una 
comunidad próspera y activa, una gran documentación y muchas opciones de 
soporte gratuito y de pago. 
Las características que hacen que Django sea tan bueno son que ayuda a crear 
un software: 
• Completo. 
• Versátil. 
• Seguro. 
• Escalable. 
• Mantenible. 
• Portable. 
La arquitectura que maneja este framework es así de simple. 
 
Ilustración 8. Diagrama de la arquitectura de Django 
3.2.1.4 PostgreSQL [14] 
PostgreSQL es un sistema de código abierto de administración de bases de datos 
del tipo relacional y orientado a objetos que es capaz de funcionar de manera 
muy estable en un servidor. 
Algunas de sus principales características son: 
• Alta concurrencia. 
• Soporte para múltiples tipos de datos de manera nativa. 
• Soporte a triggers. 
• Trabajo con vistas. 
• Objeto-relacional. 
• Soporte para bases de datos distribuidas. 
• Soporte para gran cantidad de lenguajes. 
PostgreSQL permite crear, gestionar y consultar bases de datos relacionales de 
gran tamaño, lo que lo convierte en un sistema ideal para la creación de páginas 
web que necesiten interactuar con datos. 
 
 
 
 
26 
 
3.2.2 Estructura 
En este apartado explicaré la estructura que compone el backend, comentando 
las ventajas que suponen el diseño de esta forma. El principal objetivo del 
backend fue desarrollar una arquitectura que permitiese la ejecución del 
sistema desde cualquier tipo de maquina sin importar el sistema operativo del 
que dispusiese. 
Las dos opciones para realizar esto fueron el uso de máquinas virtuales que 
contuvieran los diferentes entornos o el uso de contenedores ligeros que dispone 
la herramienta Docker. 
La estructura general se basa en el uso de la tecnología Docker, el motivo del 
uso de ella, aparte de lo explicado anteriormente, es que Docker permite un 
tiempo de inicio prácticamente instantáneo. Todos los contenedores se inician 
en una fracción mínima de tiempo, lo cual supone una ventaja en vez de usar 
máquinas virtuales para crear cada entorno. 
Otra de las diferencias fundamentales entre los contenedores y las máquinas 
virtuales es la carga de procesamiento a la que se somete un procesador. En el 
caso del uso de máquinas virtuales, la máquina que actúa como host necesita 
mantener varios sistemas operativos simultáneamente además de sus discos 
duros virtuales a la vez que usa su propio sistema operativo. Para solucionar 
este problema se recurre al uso de los contenedores que realizan el mismo 
trabajo de aislamiento entre los distintos entornos, pero usando la misma CPU 
y memoria del sistema host. La propia herramienta de Docker se encarga de 
administrar los recursos disponibles para cada contenedor en función de lo que 
requieran para ejecutar sus servicios. 
 
Ilustración 9. Diagrama de estructura: Máquina virtual vs Contenedores Docker 
Ahora entrare en la explicación de los contenedores específicos creados. Para el 
desarrollo de esta arquitectura he creado 3 contenedores distintos dentro de 
Docker. Toda la configuración de los contenedores se encuentra en el archivo 
“docker-compose.yml”. 
 
 
 
27 
 
 
Ilustración 10. Esquema de la composición de contenedores y sus tecnologías 
El primer contenedor está compuesto por el servicio que administrará la base 
de datos. En él se encuentra la imagen correspondiente de PostgreSQL. En ella 
se crearán las tablas necesarias para guardar la información necesaria para el 
desarrollo del chat-bot. 
El segundo contenedor alberga el servidorweb de Nginx, el cual da la ventaja 
de ahorrar recursos durante la gestión de las solicitudes. He decidido usar este 
servidor frente a otros como Apache por la arquitectura usada por Nginx. La 
mayor diferencia es que permite manejar múltiples en un solo hilo y no 
sobrecargar el sistema con múltiples hilos como haría Apache. 
Y, por último, el tercer contenedor contendrá la aplicación web desarrollada con 
el lenguaje Python y usando el framework Django. Esta aplicación contendrá la 
configuración para conectarse a los otros dos contenedores. 
En conclusión, la capa frontend es la encargada de recuperar la entrada de datos 
del usuario, creara la petición y la realizara al servidor web Nginx contenido en 
un contenedor de Docker, este servidor gestionará la solicitud y cuando sea 
procesada la recibirá la aplicación web, haciendo uso de Django. A 
continuación, la lógica del chat-bot generará una respuesta, la cual puede 
necesitar consultar datos de la base de datos PostgreSQL o no. Finalmente, 
Django retornara la respuesta al frontend pasando por el servidor web Nginx. 
 
 
 
 
 
28 
 
4 Desarrollo 
4.1 Estructura de directorios 
En este apartado explicare los directorios más relevantes para el desarrollo del 
proyecto y solo comentare por encima los directorios que son usados para la 
configuración de los componentes. 
4.1.1 Carpeta Moodle 
En esta carpeta se encuentran los archivos necesarios para la configuración de 
la plataforma web y para poder ejecutar la capa vista. Todo su contenido ha sido 
autogenerado al descargar de la página web de Moodle. 
Los archivos “Start Moodle.exe” y “Stop Moodle.exe” se usan para iniciar o 
finalizar el sitio web de Moodle, que actuara como capa vista del sistema, 
usando como servidor la máquina anfitriona. Usa la dirección ‘localhost:80’. 
El directorio “server” no ha sido modificado a mano, en cambio, toda la 
configuración añadida ha sido realizada desde el navegador web en base a la 
interfaz que proporciona el sitio. 
4.1.2 Carpeta Código 
En esta carpeta se encuentra el conjunto de ficheros necesarios para el 
desarrollo de las capas controlador y modelo. 
Contiene dos subdirectorios que son “nginx” el cual tiene un archivo de 
configuración del servidor proxy que usara el framework de Django. Y el 
subdirectorio “web” el cual posee toda la lógica del chat-bot. 
También contiene el archivo “Makefile” que será usado para ejecutar comandos 
de una manera sencilla y rápida, como puede ser desplegar el servidor del 
backend, entrenar el chat-bot o ejecutar las pruebas unitarias. Otro archivo 
dentro de este directorio es el “docker-compose.yml” el cual contiene la 
información para configurar los contenedores de Docker, y finalmente está el 
archivo “index.html” usado para configurar la interfaz de usuario. 
4.1.2.1 Carpeta web 
Contiene toda la aplicación del chat-bot, en ella se encuentra el fichero 
“Dockerfile” usado para configurar la imagen del contenedor de la aplicación y 
el fichero “requirements.pip”, contiene todas las librerías que es necesario 
importar para ejecutar el código del chat-bot. 
También contiene un archivo “.env” que proporciona las variables usadas 
durante el proyecto. Este archivo no se sube a git porque contine información 
sobre contraseñas y nombres de usuarios para la conexión con la base de datos. 
4.1.2.2 Carpeta src 
Esta carpeta es el content root de la aplicación web. En ella se encuentran dos 
archivos usados por Django para ejecutar sus configuraciones y diferentes 
operaciones. 
El archivo “manage.py” es el script necesario para ejecutar las herramientas de 
las que dispone Django. 
Los dos paquetes que cuelgan de esta carpeta son: 
 
 
 
29 
 
• “_setup”: usado para configurar el API REST y conexiones con la base de 
datos. 
• “chat_bot”: directorio en el que se encuentran las clases y ficheros que 
definen los módulos y operaciones del chat-bot. 
4.1.2.3 Paquete chat_bot 
Los ficheros que se encuentran dentro están separados en los distintos módulos 
del chat-bot: 
• “trainer” contiene la programación del módulo de entrenamiento. 
• “moodle_bot” contiene la programación del módulo principal. 
• “natural_language_processor.py” contiene la programación del módulo 
PLN. 
• “natural_language_understander.py” contiene la programación del 
módulo CLN. 
• “named_entity_recognizer.py” contiene la programación del módulo NER. 
4.1.2.3.1 Paquete admin 
Este paquete contiene el registro de las clases pertenecientes a las tablas de la 
base de datos. Simplemente registra en el sitio web desplegado por Django las 
tablas para poder hacer modificaciones a la base de datos desde el propio 
navegador. Creando un usuario administrador y desde la url 
‘http://localhost:8000/admin/’ es posible acceder a la administración de 
Django. 
 
Ilustración 11. Sitio web para la administración de Django 
4.1.2.3.2 Paquete core 
Dentro de este paquete están creadas todas las clases pertenecientes al CORE 
del chat-bot, hay una clase por cada posible intención y dentro de ellas esta 
implementada el seguimiento del flujo correspondiente según el resultado del 
análisis de entidades. También se encargan de hacer las consultas necesarias 
a la base de datos para obtener los campos necesarios para la devolución de 
cada respuesta. 
4.1.2.3.3 Directorio database 
Contiene los ficheros usados para el entrenamiento de la red neuronal como es 
el archivo “intents.json” y “frequent_questions.txt”. También alberga los 
archivos generados por el módulo de entrenamiento que más adelante serán 
usados por los otros módulos. Por último, contiene el archivo del logger y el 
fichero de preguntas frecuentes sin responder. 
 
 
 
30 
 
4.1.2.3.4 Paquete migrations 
Paquete usado por el propio Django para la creación y modificación de la base 
de datos. Se generan automáticamente cuando se hace un cambio en las tablas. 
Cuando se realiza una modificación de los atributos de un modelo es necesario 
ejecutar desde la carpeta “Codigo” el comando ‘make migrate’. 
4.1.2.3.5 Paquete models 
Aquí están desarrolladas las clases que representan las tablas de la base de 
datos. Estas clases son necesarias para la creación de nuevos valores, para la 
consulta de datos y para la modificación o eliminación desde el código de 
Python. 
4.1.2.3.6 Paquete rest 
Simplemente contiene la clase encargada de funcionar como interfaz entre el 
backend y el frontend. En ella se recibe la petición y se devuelve la respuesta 
generada. 
4.1.2.3.7 Paquete test 
Alberga los ficheros encargados de definir las pruebas unitarias realizadas en el 
sistema. Dispone de una clase por cada fichero del CORE. 
4.2 Diagramas de flujo 
A continuación se representan los diagramas de flujo de cada uno de los 
módulos que componen el proyecto. Del módulo CORE no hay diagrama de flujo 
porque depende de la predicción obtenida y cada intención esta explicada más 
a continuación. 
4.2.1 Diagrama del sistema 
 
 
Ilustración 12. Flujo a través de los entornos del sistema 
 
4.2.2 Diagrama módulo PLN 
 
 
Ilustración 13. Flujo de los procesos del módulo PLN 
 
 
 
31 
 
 
4.2.3 Diagrama módulo CLN 
 
 
Ilustración 14. Flujo de los procesos del módulo CLN 
 
4.2.4 Diagrama módulo NER 
 
 
Ilustración 15. Flujo de los procesos del módulo NER 
 
4.2.5 Diagrama módulo principal 
 
 
Ilustración 16. Flujo de los procesos del módulo principal 
 
 
 
32 
 
4.3 Interfaz de usuario 
La interfaz de usuario la he implementado directamente desde el sitio web de 
Moodle, desde la opción de añadir bloque de texto. 
Para llegar hasta este formulario es necesario acceder al sitio con un usuario de 
administrador, a continuación, hacer click en el botón de activar edición. Ahora 
el sitio te permite agregar un bloque en la columna que se desee del apartado 
seleccionado. En mi caso he decidido colocara en la página del área personal en 
la columna central y como primer bloque. 
Para acceder a rellenar el bloque es necesario seleccionar