Crear un Chatbot de Preguntas Frecuentes Personalizado con BERT

Crear un Chatbot Personalizado con BERT

Los chatbots se han convertido cada vez más en interfaces estándar y valiosas utilizadas por numerosas organizaciones para diversos fines. Encuentran numerosas aplicaciones en diferentes industrias, como proporcionar recomendaciones de productos personalizadas a los clientes, ofrecer soporte al cliente las 24 horas del día para resolver consultas, ayudar con las reservas de los clientes y mucho más. Este artículo explora el proceso de creación de un chatbot de preguntas frecuentes diseñado específicamente para la interacción con los clientes. Los chatbots de preguntas frecuentes responden a preguntas dentro de un dominio específico, utilizando una lista predefinida de preguntas y respuestas correspondientes. Este tipo de chatbot se basa en la coincidencia semántica de preguntas como su mecanismo subyacente.

Objetivos de aprendizaje

• Comprender los conceptos básicos del modelo BERT
• Comprender Elasticsearch y su aplicación en chatbots
• El mecanismo para crear los chatbots
• Indexación y consultas en Elasticsearch

Este artículo fue publicado como parte del Data Science Blogathon.

¿Qué es BERT?

• Analizando datos humanitarios no estructurados en tablas de Excel con el intérprete de código ChatGPT
• Cómo gané en el fútbol de fantasía italiano ⚽ utilizando el aprendizaje automático
• De los videojuegos a la IA el papel fundamental de Nvidia en la Revolución de la IA

BERT, Bidirectional Encoder Representations from Transformers, es un modelo de lenguaje grande creado por Google en 2018. A diferencia de los modelos unidireccionales, BERT es un modelo bidireccional basado en la arquitectura Transformer. Aprende a comprender el contexto de una palabra al considerar tanto las palabras que la preceden como las que la siguen en una oración, lo que permite una comprensión más completa.

Un desafío importante con BERT era que no podía lograr un rendimiento de vanguardia para las tareas de procesamiento del lenguaje natural (NLP, por sus siglas en inglés). El problema principal era que las incrustaciones a nivel de token no se podían utilizar de manera efectiva para la similitud textual, lo que resultaba en un rendimiento deficiente al generar incrustaciones de oraciones.

Sin embargo, se desarrolló Sentence-BERT (SBERT) para abordar este desafío. SBERT se basa en una red siamesa, que toma dos oraciones a la vez y las convierte en incrustaciones a nivel de token utilizando el modelo BERT. Luego, aplica una capa de agrupamiento a cada conjunto de incrustaciones para generar incrustaciones de oraciones. En este artículo, utilizaremos SBERT para las incrustaciones de oraciones.

¿Qué es Elastic Search?

Elastic Search es un motor de búsqueda y análisis de código abierto que es muy potente, altamente escalable y diseñado para manejar grandes cantidades de datos en tiempo real. Desarrollado sobre la biblioteca Apache Lucene, que proporciona capacidades de búsqueda de texto completo. Elasticsearch es altamente escalable ya que proporciona una red altamente distribuida para escalar en varios nodos, brindando alta disponibilidad y tolerancia a fallos. También ofrece una API RESTful flexible y robusta, que permite la interacción con el motor de búsqueda mediante solicitudes HTTP. Admite varios lenguajes de programación y proporciona bibliotecas de cliente para una fácil integración en aplicaciones.

¿Cómo crear un chatbot con BERT y Elastic Search?

Este artículo nos enseñará a crear un chatbot de preguntas frecuentes con BERT pre-entrenado y Elasticsearch.

Paso 1) Instalar la biblioteca SBERT

#instalar la biblioteca de sentence transformers
pip install sentence-transformers

Paso 2) Generar incrustaciones de preguntas

Utilizaremos la biblioteca SBERT para obtener las incrustaciones para las preguntas predefinidas. Para cada pregunta, generará un arreglo numpy de una dimensión de 768, que es equivalente al tamaño de la incrustación a nivel de token de BERT:

from sentence_transformers import SentenceTransformer

sent_transformer = SentenceTransformer("bert-base-nli-mean-tokens")

preguntas = [

    "¿Cómo mejorar tus habilidades de conversación? ",

    "¿Quién decide el nombramiento del Gobernador en India? ",

    "¿Cuál es la mejor manera de ganar dinero en línea?",

    "¿Quién es el jefe del Gobierno en India?",

    "¿Cómo puedo mejorar mis habilidades de habla en inglés? "

]

incrustaciones_preg = sent_transformer.encode(preguntas)

Paso 3) Instalar la biblioteca Elasticsearch

pip install elasticsearch

Paso 4) Creando un Índice en Elasticsearch

from elasticsearch import Elasticsearch


# definiendo el cliente de Python para Elasticsearch
es_client = Elasticsearch("localhost:9200")

NOMBRE_INDICE = "chat_bot_index"


# dimensiones del índice para el array de numpy, es decir, 768
dim_embedding = 768

def create_index() -> None:

    es_client.indices.delete(index=NOMBRE_INDICE, ignore=404)

    es_client.indices.create(

        index=NOMBRE_INDICE,

        ignore=400,

        body={

            "mappings": {

                "properties": {

                    "embedding": {

                        "type": "dense_vector",

                        "dims": dim_embedding,

                    },

                    "question": {

                        "type": "text",

                    },

                    "answer": {

                        "type": "text",

                    }

                }

            }

        }

    )



create_index()

El proceso de crear un índice en Elasticsearch es muy similar al proceso de definir un esquema en cualquier base de datos. En el código anterior, hemos creado un índice llamado “chat_bot_index”, que define tres campos, es decir, ’embedding’, ‘question’ y ‘answer’, y sus tipos, es decir, “dense_vector” para “embeddings” y “text” para los otros dos.

Paso 5) Indexando Preguntas-Respuestas en Elasticsearch

def indexing_q(qa_pairs: List[Dict[str, str]]) -> None:

  for pair in qa_pairs:
  
      ques = pair["question"]
  
      ans = pair["answer"]
  
      embedding = sent_transformer.encode(ques)[0].tolist()
  
          data = {
  
              "question": questi,
  
              "embedding": embedding,
  
              "answer": ans,
  
          }
  
          es_client.index(
  
              index=NOMBRE_INDICE,
  
              body=data
  
          )
  
 

qa_pairs = [{

    "question": "¿Cómo mejorar tus habilidades de conversación? ",

    "answer": "Hablar más",

},{

    "question": "¿Quién decide el nombramiento del Gobernador en India? ",

    "answer": "Presidente de India",

},{

    "question": "¿Cómo puedo mejorar mis habilidades para hablar inglés? ",

    "answer": "Más práctica",

}]

indexing_q(qa_pairs)

En el código anterior, hemos indexado pares de preguntas y respuestas en la base de datos de Elasticsearch con los embeddings de las preguntas.

Paso 6) Consultando desde Elasticsearch

ENCODER_BOOST = 10

def query_question(question: str, top_n: int=10) -> List[dict]:
  embedding = sentence_transformer.encode(question)[0].tolist()
      es_result = es_client.search(
          index=NOMBRE_INDICE,
          body={
              "from": 0,
              "size": top_n,
              "_source": ["question", "answer"],
              "query": {
                  "script_score": {
                      "query": {
                          "match": {
                              "question": question
                          }
                      },
                      "script": {
                          "source": """
                              (cosineSimilarity(params.query_vector, "embedding") + 1)
                              * params.encoder_boost + _score
                          """,
                          "params": {
                              "query_vector": embedding,
                              "encoder_boost": ENCODER_BOOST,
                          },
                      },
                  }
              }
          }
      )
      hits = es_result["hits"]["hits"]
      clean_result = []
      for hit in hits:
          clean_result.append({
              "question": item["_source"]["question"],
              "answer": item["_source"]["answer"],
              "score": item["_score"],
          })
  return clean_result

query_question("¿Cómo hacer que mi inglés sea fluido?")#import csv

Podemos modificar la consulta de ES incluyendo un campo “script”, lo que nos permite crear una función de puntuación que calcula la puntuación de similitud coseno en los embeddings. Combinamos esta puntuación con la puntuación general de coincidencia ES BM25. Para ajustar el peso de la similitud coseno de los embeddings, podemos modificar el hiperparámetro llamado “ENCODER_BOOST”.

Conclusión

En este artículo, exploramos la aplicación de SBERT y Elasticsearch en la creación del chatbot. Discutimos la creación de un chatbot que respondería a las consultas basadas en pares de preguntas y respuestas predefinidos, considerando la intención de la consulta.

Aquí están las conclusiones clave de nuestra exploración:

1. Comprender la importancia de SBERT y Elasticsearch en el ámbito del desarrollo de chatbots, aprovechando sus capacidades para mejorar las experiencias de conversación.
2. Utilizar SBERT para generar embeddings para las preguntas permite una comprensión más profunda de su semántica y contexto.
3. Aprovechar Elasticsearch para establecer un índice que almacene y organice eficientemente los pares de preguntas y respuestas, optimizando las operaciones de búsqueda y recuperación.
4. Mostrar el proceso de consulta en Elasticsearch, ilustrando cómo el chatbot recupera de manera efectiva las respuestas más relevantes basadas en la pregunta del usuario.

Preguntas frecuentes

Los medios mostrados en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!