art deco chatbot
1.0.0
Tiempo de lectura: ~ 10 minutos
Building Art Deco Rag Chatbot usando Repo de PulseJet Github: https://github.com/Jet-Engine/art-deco-chatbot
Esta publicación de blog se puede leer desde los siguientes enlaces:
Los modelos de idiomas grandes (LLM) han avanzado significativamente, mejorando su capacidad para responder una amplia gama de preguntas. Sin embargo, todavía encuentran desafíos, particularmente con información específica o reciente, que a menudo resultan en inexactitudes o "alucinaciones". Para abordar estos problemas, el enfoque de generación aumentada de recuperación (RAG) integra un paso de recuperación de documentos en el proceso de generación de respuesta. Este enfoque utiliza un corpus de documentos y emplea bases de datos vectoriales para una recuperación eficiente, mejorando la precisión y confiabilidad de las respuestas LLM a través de tres pasos clave:
Las bases de datos vectoriales facilitan las búsquedas de similitud rápida y la gestión de datos eficientes, lo que hace que RAG sea una solución poderosa para mejorar las capacidades de LLM.
La era de Art Deco, que abarcaba la década de 1920 a la década de 1940, dejó un deslumbrante legado en la arquitectura. A pesar de las capacidades de modelos como Meta's Llama3.1, sus respuestas pueden ser poco confiables, especialmente para consultas matizadas o detalladas específicas de Art Deco. Nuestro objetivo con el chatbot Art Deco es usar el trapo para mejorar la calidad de las respuestas sobre la arquitectura Art Deco, comparándolas con las generadas por LLM tradicionales tanto en eficiencia de calidad como en el tiempo.
Al diseñar el chatbot Art Deco, también pretendemos mostrar cómo se puede construir un sistema de trapo complejo. Puede acceder al código completo en el repositorio de GitHub de Art Deco Chatbot. Al examinar el código y leer este readme, aprenderá:
Ollama es un programa que facilita la ejecución de modelos LLM fácilmente en máquinas locales.
ollama pull llama3.1 (LLM que se utilizará para trapo)ollama pull nomic-embed-text (modelo de incrustación que se utilizará para trapo) En este proyecto, no solo pretendemos escribir código para mostrar cómo se puede hacer RAG, sino también para comparar y comparar los resultados de RAG con consultas a diferentes LLM. Algunos de estos LLM no se pueden ejecutar localmente (como GPT-4o ), mientras que otros son pesados y se ejecutan en servicios en la nube (como Llama3.1:70b en Groq).
Litellm proporciona una interfaz unificada para consultar diferentes LLM, haciendo que nuestro código sea más limpio y legible. Se recomienda ver la biblioteca Litellm Python pero no se requiere para este proyecto.
Obtenga sus claves API de Openai y Groq para usarlas en el proyecto. Tenga en cuenta que puede ser facturado por utilizar estos servicios. Si bien la Groq API se puede usar de forma gratuita al momento de escribir, la OpenAI API no es gratuita.
PulseJet es una base de datos vectorial de alto rendimiento que permite el almacenamiento y la recuperación eficientes de los incrustaciones de documentos. Para configurar Pulsejet:
pip install pulsejetdocker run --name pulsejet_container -p 47044-47045:47044-47045 jetngine/pulsejet Nota: Puede omitir el primer paso ya que PulseJet ya está incluido en el archivo requirements.txt .
Verifique los documentos de PulseJet para obtener detalles sobre la ejecución de imágenes de Pulsejet Docker y utilizando la biblioteca PulseJet Python para las operaciones de la base de datos de vectores.
Instale todas las dependencias necesarias ejecutando:
pip install -r requirements.txt
Este proyecto se desarrolló utilizando un entorno
condaconPython 3.11.
Como no hemos probado el proyecto en diferentes entornos, recomendamos adherirse a esta configuración para un rendimiento y compatibilidad óptimos.
El ChatBot Art Deco usa dos archivos YAML para la configuración: config.template.yaml y secrets.yaml . Aquí hay un desglose detallado de cada sección:
Cree un archivo secrets.yaml con sus claves API:
# api_keys:
openai_key : " your_openai_key_here "
groq_key : " your_groq_key_here " # models:
main_model : " llama3.1 "
embed_model : " nomic-embed-text "
# vector_db:
vector_db : " pulsejet "
# pulsejet:
pulsejet_location : " remote "
pulsejet_collection_name : " art-deco "
# paths:
rag_files_path : " rag_files/ "
questions_file_path : " evaluation/questions.csv "
evaluation_path : " evaluation/ "
rag_prompt_path : " evaluation/rag_prompt.txt "
metrics_file_path : " evaluation/metrics.json "
# embeddings:
embeddings_file_path : " embeddings_data/all_embeddings_HSNW.h5 "
use_precalculated_embeddings : true
# llm_models:
all_models :
gpt-4o : " gpt-4o "
groq-llama3.1-8b : " groq/llama-3.1-8b-instant "
groq-llama3.1-70b : " groq/llama-3.1-70b-versatile "
ollama-llama3.1 : " ollama/llama3.1 "
ollama-llama3.1-70b : " ollama/llama3.1:70b "
selected_models :
- " gpt-4o "
- " groq-llama3.1-70b "
- " ollama-llama3.1 "
# rag_parameters:
sentences_per_chunk : 10
chunk_overlap : 2
file_extension : " .txt "Aquí hay una explicación detallada de cada sección:
true , el sistema cargará incrustaciones desde el archivo especificado. Cuando false , generará nuevos incrustaciones y los guardará en este archivo. Asegúrese de actualizar estos archivos de configuración con su configuración específica antes de ejecutar el proyecto. Ajustar los parámetros de RAG puede afectar significativamente el rendimiento y la precisión del sistema RAG. La experimentación con diferentes valores puede ser necesaria para encontrar la configuración óptima para su caso de uso específico y conjunto de documentos.
wiki-bot.pyEste paso es opcional ya que los archivos de contenido de todos los artículos raspados de Wikipedia están disponibles en https://huggingface.co/datasets/jetengine/art_deco_usa_ds.
Puede descargar este conjunto de datos y copiar todos los archivos de texto de él en el directorio RAG_FILES. Si planea usar incrustaciones precalculadas, que se explicarán en la siguiente sección, en realidad no necesita descargar este conjunto de datos.
No hay necesidad de repetir el proceso de raspado. Puede omitir la lectura del resto de esta sección si no está interesado en el proceso de raspado de datos.
Nuestro paso inicial implica reunir conocimiento sobre la arquitectura del arte del arte. Nos centramos en las estructuras estadounidenses, dada su prominencia en el movimiento Art-Deco. El script wiki-bot.py automatiza la colección de artículos relevantes de Wikipedia, organizándolos en un directorio estructurado para facilitar el acceso.
Ejecute el bot usando:
python wiki-bot.py
Cuando ejecuta wiki-bot.py con un directorio rag_files vacío, guarda el contenido de los artículos de Wikipedia raspados en un subfolder llamado text bajo rag_files. El BOT también crea varios subfolders para organizar diferentes tipos de datos, como URL de artículos, referencias, etc. Dado que nuestro enfoque actual es solo en el contenido de los artículos de Wikipedia, para reducir el desorden, solo transferimos el contenido del subdiector text a nuestro conjunto de datos HG y obtuvimos todas las demás subfolders.
Por lo tanto, si desea ejecutar el bot, lo que es opcional, ya que los documentos raspados ya están disponibles en la cara de abrazo, necesitaría copiar todos los archivos del subcargador de texto al directorio rag_files y luego eliminar todos los subcarpetas dentro rag_files , o simplemente cambiar el rag_files_path en config.yaml a rag_files/text .
indexing.pyIndexe los documentos ejecutando:
python indexing.py
Este script procesa los documentos, genera incrustaciones y los almacena en Pulsejet. Si no desea perder tiempo para generar integridades, puede descargar incrustaciones precalculadas de https://huggingface.co/Jetengine/rag_art_deco_embeddings y establecer use_precalculated_embeddings: true en la configuración.
En nuestra generación de incrustaciones de configuración, tarda alrededor de 15 minutos en completarse y la inserción de vectores a Pulsejet toma alrededor de 4 segundos .
El script genera información de tiempo para:
chat.pyAsegúrese de que su configuración sea correcta, luego ejecute:
python chat.py
Este script consulta diferentes LLM y el sistema RAG, la producción de resultados en formatos HTML, JSON y CSV para comparar.
PulseJet se utiliza en este proyecto para un almacenamiento y recuperación de vectores eficientes. Aquí hay una descripción detallada de cómo Pulsejet se integra en nuestro proyecto Art Deco Chatbot:
Inicializando el cliente PulseJet :
client = pj . PulsejetClient ( location = config [ 'pulsejet_location' ]) Esto crea un cliente Pulsejet. En nuestro proyecto, estamos utilizando una instancia remota de Pulsejet, por lo que la location está configurada en "remoto". Esto se conecta a un servidor PulseJet que se ejecuta en un contenedor Docker.
Creando una colección :
client . create_collection ( collection_name , vector_config ) Esto crea una nueva colección en PulseJet para almacenar nuestros incrustaciones de documentos. El parámetro vector_config especifica la configuración para el almacenamiento vectorial, como el tamaño de vector y el tipo de índice (por ejemplo, HNSW para una búsqueda de similitud eficiente).
Inserción de vectores : en nuestro proyecto, utilizamos el siguiente patrón para insertar vectores:
collection [ 0 ]. insert_single ( collection [ 1 ], embed , meta )Esto puede parecer confuso al principio, pero esto es lo que significa:
collection[0] es en realidad nuestra instancia de cliente Pulsejet.collection[1] es el nombre de la colección en la que estamos insertando.embed es el vector que estamos insertando.meta es metadatos adicionales asociados con el vector.Esto es equivalente a llamar:
client . insert_single ( collection_name , vector , meta )Para las inserciones a granel, usamos:
client . insert_multi ( collection_name , embeds )Esto inserta múltiples incrustaciones a la vez, lo que es más eficiente para grandes conjuntos de datos.
Buscando vectores :
results = client [ 'db' ]. search_single ( collection , query_embed , limit = 5 , filter = None ) Esto realiza una búsqueda de similitud en la colección Pulsejet especificada para encontrar los documentos más relevantes para un vector de consulta dado. El parámetro limit especifica el número máximo de resultados para devolver.
En nuestro proyecto, client['db'] se utiliza para acceder a los métodos de la base de datos del cliente PULSEJET. Esto es equivalente a usar el cliente directamente:
results = client . search_single ( collection_name , query_vector , limit = 5 , filter = None )Cerrar la conexión :
client . close ()Esto cierra la conexión a la base de datos PULSEJET cuando ya no es necesaria.
La clase PulsejetRagClient se define en pulsejet_rag_client.py y proporciona una interfaz de alto nivel para interactuar con Pulsejet en el contexto de nuestro sistema RAG. Aquí hay un desglose de sus componentes clave:
Inicialización :
class PulsejetRagClient :
def __init__ ( self , config ):
self . config = config
self . collection_name = config [ 'pulsejet_collection_name' ]
self . main_model = config [ 'main_model' ]
self . embed_model = config [ 'embed_model' ]
self . client = pj . PulsejetClient ( location = config [ 'pulsejet_location' ])El cliente se inicializa con los parámetros de configuración, configurando el cliente PULSEJET y almacenando valores de configuración relevantes.
Creando una colección :
def create_collection ( self ):
vector_size = get_vector_size ( self . config [ 'embed_model' ])
vector_params = pj . VectorParams ( size = vector_size , index_type = pj . IndexType . HNSW )
try :
self . client . create_collection ( self . collection_name , vector_params )
logger . info ( f"Created new collection: { self . collection_name } " )
except Exception as e :
logger . info ( f"Collection ' { self . collection_name } ' already exists or error occurred: { str ( e ) } " ) Este método crea una nueva colección en Pulsejet con los parámetros especificados. Utiliza la función get_vector_size para determinar el tamaño de vector apropiado para los incrustaciones.
Insertar vectores :
def insert_vector ( self , vector , metadata = None ):
try :
self . client . insert_single ( self . collection_name , vector , metadata )
logger . debug ( f"Inserted vector with metadata: { metadata } " )
except Exception as e :
logger . error ( f"Error inserting vector: { str ( e ) } " )
def insert_vectors ( self , vectors , metadatas = None ):
try :
self . client . insert_multi ( self . collection_name , vectors , metadatas )
logger . debug ( f"Inserted { len ( vectors ) } vectors" )
except Exception as e :
logger . error ( f"Error inserting multiple vectors: { str ( e ) } " )Estos métodos manejan la inserción de vectores individuales y múltiples en la colección Pulsejet, junto con sus metadatos asociados.
Buscando vectores :
def search_similar_vectors ( self , query_vector , limit = 5 ):
try :
results = self . client . search_single ( self . collection_name , query_vector , limit = limit , filter = None )
return results
except Exception as e :
logger . error ( f"Error searching for similar vectors: { str ( e ) } " )
return []Este método realiza una búsqueda de similitud en la colección Pulsejet para encontrar los documentos más relevantes para un vector de consulta dado.
Cerrar la conexión :
def close ( self ):
try :
self . client . close ()
logger . info ( "Closed Pulsejet client connection" )
except Exception as e :
logger . error ( f"Error closing Pulsejet client connection: { str ( e ) } " )Este método cierra la conexión a la base de datos PULSEJET cuando ya no es necesaria.
El PulsejetRagClient se usa a lo largo del proyecto para interactuar con Pulsejet. Así es como se instancia y usa típicamente:
Creación :
from pulsejet_rag_client import create_pulsejet_rag_client
config = get_config ()
rag_client = create_pulsejet_rag_client ( config )Documentos de indexación :
En indexing.py , usamos el cliente para crear la colección e insertar vectores:
rag_client . create_collection ()
for file_name , file_embeddings in embeddings_data . items ():
for chunk_id , content , embed in file_embeddings :
metadata = { "filename" : file_name , "chunk_id" : chunk_id , "content" : content }
rag_client . insert_vector ( embed , metadata ) En rag.py , usamos el cliente para buscar vectores similares durante el proceso de RAG:
results = rag_client . search_similar_vectors ( query_embed , limit = 5 )Después de completar las operaciones, cerramos la conexión:
rag_client . close ()Esta implementación proporciona una interfaz limpia y encapsulada para todas las operaciones de pulso en nuestro sistema RAG.
LLama3.1 tardan más que la respuesta de preguntas simples debido al aumento de la longitud de la consulta.El Art Deco Chatbot demuestra cómo los LLM podrían utilizarse mejor con RAG. Nuestro proyecto ofrece una exploración integral de la implementación de RAG, que cubre cada paso desde el raspado de datos y la fragmentación de documentos hasta la creación de integración y la integración de las bases de datos vectoriales.
A medida que la base de documentos para un sistema RAG se hace más grande, el rendimiento de la inserción y las operaciones de búsqueda se vuelve cada vez más crítica. Al aprender a integrar la base de datos PulseJet Vector en un sistema RAG completo, uno puede beneficiarse significativamente de sus capacidades, particularmente cuando se trata de aplicaciones RAG en grandes bases de documentos.
Nuestras respuestas de trapo podrían haber sido más precisas. Para mejorar la actuación de nuestro Art Deco Chatbot, estamos considerando varios enfoques experimentales:
Planeamos expandir este proyecto a través de las siguientes iniciativas:
Le recomendamos que experimente con el chatbot Art Deco, modifique sus parámetros y lo adapte a sus propios dominios de interés.
Autor: Güvenç Usanmaz
