art deco chatbot
1.0.0
Temps de lecture: ~ 10 minutes
Bâtiment Art Deco Rag Chatbot Utilisation de PulseJet Github Repo: https://github.com/jet-engine/art-de-chatbot
Ce blog peut être lu à partir des liens suivants:
Les modèles de grands langues (LLM) ont considérablement avancé, améliorant leur capacité à répondre à un large éventail de questions. Cependant, ils rencontrent toujours des défis, en particulier avec des informations spécifiques ou récentes, entraînant souvent des inexactitudes ou des «hallucinations». Pour résoudre ces problèmes, l'approche de génération augmentée (RAG) de récupération intègre une étape de récupération de documents dans le processus de génération de réponse. Cette approche utilise un corpus de documents et utilise des bases de données vectorielles pour une récupération efficace, améliorant la précision et la fiabilité des réponses LLM à travers trois étapes clés:
Les bases de données vectorielles facilitent les recherches de similitudes rapides et la gestion efficace des données, faisant de Rag une solution puissante pour améliorer les capacités LLM.
L'ère Art Deco, couvrant les années 1920 rugissantes dans les années 40, a laissé un héritage éblouissant en architecture. Malgré les capacités de modèles comme Meta's Llama3.1, leurs réponses peuvent être peu fiables, en particulier pour les requêtes nuancées ou détaillées spécifiques à Art Deco. Notre objectif avec le chatbot Art Deco est d'utiliser RAG pour améliorer la qualité des réponses sur l'architecture art déco, en comparant celles-ci avec celles générées par les LLM traditionnelles à la fois en qualité et en efficacité temporelle.
En concevant le chatbot Art Deco, nous visons également à montrer comment un système de chiffon complexe peut être construit. Vous pouvez accéder au code complet du référentiel GitHub Chatbot Art Deco. En examinant le code et en lisant ce Readme, vous apprendrez:
Olllama est un programme qui facilite la gestion des modèles LLM facilement sur les machines locales.
ollama pull llama3.1 (LLM qui sera utilisé pour le chiffon)ollama pull nomic-embed-text (modèle d'incorporation qui sera utilisé pour RAG) Dans ce projet, nous visons non seulement à écrire du code pour montrer comment le chiffon peut être fait, mais aussi pour comparer et comparer les résultats de RAG avec des requêtes à différents LLM. Certains de ces LLM ne peuvent pas être exécutés localement (comme GPT-4o ), tandis que d'autres sont lourds de calcul et sont exécutés sur des services cloud (comme Llama3.1:70b sur Groq).
Litellm fournit une interface unifiée pour interroger différents LLM, ce qui rend notre code plus propre et plus lisible. La vérification de la bibliothèque Litellm Python est recommandée mais n'est pas requise pour ce projet.
Obtenez vos clés API d'OpenAI et GROQ pour les utiliser dans le projet. Sachez que vous pouvez être facturé pour utiliser ces services. Bien que l' Groq API puisse être utilisée gratuitement au moment de la rédaction, l' OpenAI API n'est pas gratuite.
PulseJet est une base de données vectorielle haute performance qui permet un stockage et une récupération efficaces des intégres de documents. Pour configurer PulseJet:
pip install pulsejetdocker run --name pulsejet_container -p 47044-47045:47044-47045 jetngine/pulsejet Remarque: Vous pouvez ignorer la première étape car Pulsejet est déjà inclus dans le fichier requirements.txt .
Vérifiez les documents PulseJet pour que l'exécution des images Docker PulseJet et l'utilisation de la bibliothèque PulseJet Python pour les opérations de base de données vectorielles.
Installez toutes les dépendances nécessaires en fonctionnant:
pip install -r requirements.txt
Ce projet a été développé à l'aide d'un environnement
condaavecPython 3.11.
Comme nous n'avons pas testé le projet dans différents environnements, nous vous recommandons d'adhérer à cette configuration pour des performances et une compatibilité optimales.
Le chatbot art déco utilise deux fichiers YAML pour la configuration: config.template.yaml et secrets.yaml . Voici une ventilation détaillée de chaque section:
Créez un fichier secrets.yaml avec vos clés 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 "Voici une explication détaillée de chaque section:
true , le système chargera les incorporations du fichier spécifié. Lorsqu'il false , il générera de nouveaux intégres et les enregistrera dans ce fichier. Assurez-vous de mettre à jour ces fichiers de configuration avec vos paramètres spécifiques avant d'exécuter le projet. L'ajustement des paramètres de RAG peut avoir un impact significatif sur les performances et la précision du système de chiffon. L'expérimentation avec différentes valeurs peut être nécessaire pour trouver la configuration optimale pour votre cas d'utilisation spécifique et votre ensemble de documents.
wiki-bot.pyCette étape est facultative car les fichiers de contenu de tous les articles grattés de Wikipedia sont disponibles dans le https://huggingface.co/datasets/Jetenne/art_deco_usa_ds.
Vous pouvez télécharger cet ensemble de données et en copier tous les fichiers texte dans le répertoire RAG_FILES. Si vous prévoyez d'utiliser des intérêts précalculés, qui seront expliqués dans la section suivante, vous n'avez pas vraiment besoin de télécharger cet ensemble de données.
Il n'est pas nécessaire de répéter le processus de grattage. Vous pouvez ignorer le reste de la lecture de cette section si vous n'êtes pas intéressé par le processus de grattage des données.
Notre étape initiale consiste à rassembler des connaissances sur l'architecture art-décor. Nous nous concentrons sur les structures américaines, étant donné leur importance dans le mouvement art-décor. Le script wiki-bot.py automatise la collection d'articles Wikipedia pertinents, les organisant en un répertoire structuré pour faciliter l'accès.
Exécutez le bot en utilisant:
python wiki-bot.py
Lorsque vous exécutez wiki-bot.py avec un répertoire rag_files vide, il enregistre le contenu des articles Wikipedia grattés dans un sous-fichier nommé text sous Rag_files. Le BOT crée également divers sous-reprendurs pour organiser différents types de données tels que les URL d'articles, les références, etc. Étant donné que notre accent actuel est uniquement sur le contenu des articles Wikipedia, pour réduire l'encombrement, nous avons seulement transféré le contenu du sous-dossier text à notre ensemble de données HG et supprimé tous les autres sous-encoldeurs.
Ainsi, si vous souhaitez exécuter le bot vous-même, ce qui est facultatif, car les documents grattés sont déjà disponibles dans un visage étreint, vous devrez soit copier tous les fichiers du sous-fichier de texte vers le répertoire rag_files , puis supprimer tous les sous-lameurs dans rag_files , ou simplement modifier le rag_files_path dans config.yaml en rag_files/text .
indexing.pyIndexez les documents en fonctionnant:
python indexing.py
Ce script traite les documents, génère des intégres et les stocke dans PulseJet. Si vous ne voulez pas perdre de temps pour générer des incorporations, vous pouvez télécharger des incalculations pré-calculées à partir de https://huggingface.co/jetengine/rag_art_deco_emeddings et définir use_precalculated_embeddings: true dans la configuration.
Dans notre configuration, la génération d'incorporation prend environ 15 minutes pour terminer et l'insertion de vecteurs à PulseJet prend environ 4 secondes .
Le script obtient des informations de synchronisation pour:
chat.pyAssurez-vous que votre configuration est correcte, puis exécutez:
python chat.py
Ce script interroge différents LLMS et le système de chiffon, la sortie des résultats dans les formats HTML, JSON et CSV pour comparaison.
Pulsejet est utilisé dans ce projet pour un stockage et une récupération de vecteurs efficaces. Voici un aperçu détaillé de la façon dont Pulsejet est intégré à notre projet Art Deco Chatbot:
Initialisation du client PulseJet :
client = pj . PulsejetClient ( location = config [ 'pulsejet_location' ]) Cela crée un client PulseJet. Dans notre projet, nous utilisons une instance PulseJet distante, donc l' location est défini sur "Remote". Cela se connecte à un serveur PulseJet exécutant dans un conteneur Docker.
Création d'une collection :
client . create_collection ( collection_name , vector_config ) Cela crée une nouvelle collection dans PulseJet pour stocker nos intégres de documents. Le paramètre vector_config spécifie la configuration du stockage vectoriel, tel que la taille du vecteur et le type d'index (par exemple, HNSW pour une recherche de similitude efficace).
Insertion des vecteurs : Dans notre projet, nous utilisons le modèle suivant pour insérer des vecteurs:
collection [ 0 ]. insert_single ( collection [ 1 ], embed , meta )Cela peut sembler déroutant au début, mais voici ce que cela signifie:
collection[0] est en fait notre instance client PulseJet.collection[1] est le nom de la collection dans laquelle nous insérons.embed est le vecteur que nous insérons.meta est des métadonnées supplémentaires associées au vecteur.Cela équivaut à appeler:
client . insert_single ( collection_name , vector , meta )Pour les insertions en vrac, nous utilisons:
client . insert_multi ( collection_name , embeds )Cela insère plusieurs intérêts à la fois, ce qui est plus efficace pour les grands ensembles de données.
Recherche de vecteurs :
results = client [ 'db' ]. search_single ( collection , query_embed , limit = 5 , filter = None ) Cela effectue une recherche de similitude dans la collection PulseJet spécifiée pour trouver les documents les plus pertinents pour un vecteur de requête donné. Le paramètre limit spécifie le nombre maximum de résultats à retourner.
Dans notre projet, client['db'] est utilisé pour accéder aux méthodes de base de données du client PulseJet. Cela équivaut à utiliser directement le client:
results = client . search_single ( collection_name , query_vector , limit = 5 , filter = None )Clôture de la connexion :
client . close ()Cela ferme la connexion à la base de données PulseJet lorsqu'elle n'est plus nécessaire.
La classe PulsejetRagClient est définie dans pulsejet_rag_client.py et fournit une interface de haut niveau pour interagir avec PulseJet dans le contexte de notre système de chiffon. Voici une ventilation de ses composants clés:
Initialisation :
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' ])Le client est initialisé avec les paramètres de configuration, configurant le client PulseJet et stockant des valeurs de configuration pertinentes.
Création d'une collection :
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 ) } " ) Cette méthode crée une nouvelle collection dans PulseJet avec les paramètres spécifiés. Il utilise la fonction get_vector_size pour déterminer la taille du vecteur approprié pour les intégres.
Insertion des vecteurs :
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 ) } " )Ces méthodes gèrent l'insertion de vecteurs simples et multiples dans la collection PulseJet, ainsi que leurs métadonnées associées.
Recherche de vecteurs :
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 []Cette méthode effectue une recherche de similitude dans la collection PulseJet pour trouver les documents les plus pertinents pour un vecteur de requête donné.
Clôture de la connexion :
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 ) } " )Cette méthode ferme la connexion à la base de données PulseJet lorsqu'elle n'est plus nécessaire.
Le PulsejetRagClient est utilisé dans tout le projet pour interagir avec PulseJet. Voici comment il est généralement instancié et utilisé:
Création :
from pulsejet_rag_client import create_pulsejet_rag_client
config = get_config ()
rag_client = create_pulsejet_rag_client ( config )Documents d'indexation :
Dans indexing.py , nous utilisons le client pour créer les vecteurs de collection et d'insertion:
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 ) Dans rag.py , nous utilisons le client pour rechercher des vecteurs similaires pendant le processus de RAG:
results = rag_client . search_similar_vectors ( query_embed , limit = 5 )Une fois les opérations terminées, nous fermons la connexion:
rag_client . close ()Cette implémentation fournit une interface propre et encapsulée pour toutes les opérations de jet de pouls dans notre système de chiffon.
LLama3.1 prennent plus de temps que la réponse simple en raison de l'augmentation de la durée de la requête.Le chatbot Art Deco montre comment les LLM pourraient être mieux utilisées avec RAG. Notre projet propose une exploration complète de la mise en œuvre des chiffons, couvrant chaque étape de la grattage des données et de la bosse de document à la création d'intégration et à l'intégration des bases de données vectorielles.
À mesure que la base de documents pour un système de chiffon augmente, les performances des opérations d'insertion et de recherche deviennent de plus en plus critiques. En apprenant à intégrer la base de données Vector PulseJet dans un système de chiffon à part entière, on peut considérablement bénéficier de ses capacités, en particulier lorsqu'ils traitent des applications de chiffon sur les grandes bases de documents.
Nos réponses de chiffon auraient pu être plus précises. Pour améliorer la performance de notre Art Deco Chatbot, nous envisageons plusieurs approches expérimentales:
Nous prévoyons d'étendre ce projet à travers les initiatives suivantes:
Nous vous encourageons à expérimenter le chatbot Art Deco, à modifier ses paramètres et à l'adapter à vos propres domaines d'intérêt.
Auteur: Güvenç Usanmaz
