art deco chatbot
1.0.0
Tempo de leitura: ~ 10 minutos
Construindo Art Deco Rag Chatbot usando o PulseJet Github Repo: https://github.com/jet-engine/art-deco-chatbot
Este post do blog pode ser lido nos seguintes links:
Os grandes modelos de linguagem (LLMs) avançaram significativamente, melhorando sua capacidade de responder a uma ampla variedade de perguntas. No entanto, eles ainda encontram desafios, particularmente com informações específicas ou recentes, geralmente resultando em imprecisões ou "alucinações". Para resolver esses problemas, a abordagem de geração aumentada de recuperação (RAG) integra uma etapa de recuperação de documentos no processo de geração de respostas. Essa abordagem usa um corpus de documentos e emprega bancos de dados de vetores para recuperação eficiente, aumentando a precisão e a confiabilidade das respostas do LLM através de três etapas principais:
Os bancos de dados de vetores facilitam pesquisas de similaridade rápida e gerenciamento de dados eficientes, tornando o RAG uma solução poderosa para aprimorar os recursos do LLM.
A era Art Deco, abrangendo a década de 1920 até a década de 1940, deixou um legado deslumbrante na arquitetura. Apesar das capacidades de modelos como o Llama3.1 da Meta, suas respostas podem não ser confiáveis, especialmente para consultas diferenciadas ou detalhadas específicas para o Art Deco. Nosso objetivo com o Art Deco Chatbot é usar o RAG para melhorar a qualidade das respostas sobre a arquitetura Art Deco, comparando -as com aquelas geradas pelo LLMS tradicional na eficiência da qualidade e do tempo.
Ao projetar o Art Deco Chatbot, também pretendemos mostrar como um sistema de pano complexo pode ser construído. Você pode acessar o código completo no repositório Art Deco Chatbot Github. Examinando o código e lendo este readme, você aprenderá:
Ollama é um programa que facilita a execução de modelos LLM facilmente em máquinas locais.
ollama pull llama3.1 (LLM que será usado para RAG)ollama pull nomic-embed-text (modelo de incorporação que será usado para RAG) Neste projeto, não apenas pretendemos escrever código para mostrar como o RAG pode ser feito, mas também comparar e comparar os resultados do RAG com consultas com diferentes LLMs. Alguns desses LLMs não podem ser executados localmente (como GPT-4o ), enquanto outros são pesados e são executados em serviços em nuvem (como Llama3.1:70b no GROQ).
A Litellm fornece uma interface unificada para consultar diferentes LLMs, tornando nosso código mais limpo e mais legível. Verificando a biblioteca Litellm Python é recomendada, mas não é necessária para este projeto.
Obtenha suas chaves da API do OpenAI e Groq para usá -las no projeto. Esteja ciente de que você pode ser cobrado por usar esses serviços. Embora a Groq API possa ser usada gratuitamente no momento da redação deste artigo, a OpenAI API não é gratuita.
O PulseJet é um banco de dados vetorial de alto desempenho que permite armazenamento e recuperação eficientes das incorporações de documentos. Para configurar o PulseJet:
pip install pulsejetdocker run --name pulsejet_container -p 47044-47045:47044-47045 jetngine/pulsejet Nota: Você pode pular a primeira etapa, já que o PulseJet já está incluído no arquivo requirements.txt .
Verifique os documentos do PulseJet para obter detalhes sobre a execução de imagens do PulseJet Docker e o uso da biblioteca Python Python para operações de banco de dados vetorial.
Instale todas as dependências necessárias em execução:
pip install -r requirements.txt
Este projeto foi desenvolvido usando um ambiente
condacomPython 3.11.
Como não testamos o projeto em diferentes ambientes, recomendamos aderir a essa configuração para obter o melhor desempenho e compatibilidade.
O ART DECO CHATBOT usa dois arquivos YAML para configuração: config.template.yaml e secrets.yaml . Aqui está um detalhamento detalhado de cada seção:
Crie um arquivo secrets.yaml com suas chaves da 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 "Aqui está uma explicação detalhada de cada seção:
true , o sistema carregará incorporação do arquivo especificado. Quando false , ele gerará novas incorporações e as salvará nesse arquivo. Certifique -se de atualizar esses arquivos de configuração com suas configurações específicas antes de executar o projeto. Ajustar os parâmetros de pano pode afetar significativamente o desempenho e a precisão do sistema de pano. A experimentação com valores diferentes pode ser necessária para encontrar a configuração ideal para o seu caso de uso específico e conjunto de documentos.
wiki-bot.pyEsta etapa é opcional , pois os arquivos de conteúdo de todos os artigos raspados da Wikipedia estão disponíveis no https://huggingface.co/datasets/jetengine/art_deco_usa_ds.
Você pode baixar este conjunto de dados e copiar todos os arquivos de texto para o diretório rag_files. Se você planeja usar incorporações pré-calculadas, que serão explicadas na próxima seção, na verdade não precisa baixar esse conjunto de dados.
Não há necessidade de repetir o processo de raspagem. Você pode pular a leitura do resto desta seção se não estiver interessado no processo de raspagem de dados.
Nosso passo inicial envolve a coleta de conhecimentos sobre a arquitetura de arte-deco. Nós nos concentramos nas estruturas dos EUA, dado seu destaque no movimento de arte-deco. O script Wiki-Bot.py automatiza a coleção de artigos relevantes da Wikipedia, organizando-os em um diretório estruturado para facilitar o acesso.
Execute o bot usando:
python wiki-bot.py
Quando você executa o Wiki-Bot.py com um diretório vazio rag_files , ele salva o conteúdo dos artigos da Wikipedia raspados em um sub-dobrador denominado text em Rag_files. O BOT também cria vários subpastas para organizar diferentes tipos text dados, como URLs, referências, etc.
Assim, se você deseja executar o bot, o que é opcional, pois os documentos raspados já estão disponíveis para abraçar o rosto, você precisaria copiar todos os arquivos do subpasto de texto para o diretório rag_files e depois excluir todos os sub-foldadores em rag_files ou simplesmente alterar o rag_files_path em config.yaml a rag_files/text .
indexing.pyIndex os documentos em execução:
python indexing.py
Esse script processa os documentos, gera incorporação e os armazena no PulseJet. Se você não quiser perder tempo para gerar incorporação, pode baixar incorporações pré-calculadas em https://huggingface.co/jetengine/rag_art_deco_embeddings e definir use_precalculated_embeddings: true na configuração.
Em nossa geração de incorporação, leva cerca de 15 minutos para concluir e a inserção de vetores no PulseJet leva cerca de 4 segundos .
O script produz informações de tempo para:
chat.pyVerifique se sua configuração está correta e execute:
python chat.py
Esse script consulta LLMs diferentes e o sistema de pano, a saída resulta nos formatos HTML, JSON e CSV para comparação.
O PulseJet é usado neste projeto para armazenamento e recuperação de vetores eficientes. Aqui está uma visão geral detalhada de como o PulseJet é integrado ao nosso projeto Art Deco Chatbot:
Inicializando o cliente PulseJet :
client = pj . PulsejetClient ( location = config [ 'pulsejet_location' ]) Isso cria um cliente PulseJet. Em nosso projeto, estamos usando uma instância remota de pulsejet, para que o location seja definido como "remoto". Isso se conecta a um servidor PulseJet em execução em um contêiner do Docker.
Criando uma coleção :
client . create_collection ( collection_name , vector_config ) Isso cria uma nova coleção no PulseJet para armazenar nossas incorporações de documentos. O parâmetro vector_config especifica a configuração do armazenamento vetorial, como o tamanho do vetor e o tipo de índice (por exemplo, HNSW para pesquisa eficiente de similaridade).
Inserção de vetores : em nosso projeto, usamos o seguinte padrão para inserir vetores:
collection [ 0 ]. insert_single ( collection [ 1 ], embed , meta )Isso pode parecer confuso no começo, mas aqui está o que isso significa:
collection[0] é na verdade a nossa instância do cliente PulseJet.collection[1] é o nome da coleção em que estamos inserindo.embed é o vetor que estamos inserindo.meta são metadados adicionais associados ao vetor.Isso é equivalente a chamar:
client . insert_single ( collection_name , vector , meta )Para inserções em massa, usamos:
client . insert_multi ( collection_name , embeds )Isso insere várias incorporações ao mesmo tempo, o que é mais eficiente para conjuntos de dados grandes.
Pesquisando vetores :
results = client [ 'db' ]. search_single ( collection , query_embed , limit = 5 , filter = None ) Isso executa uma pesquisa de similaridade na coleção PulseJet especificada para encontrar os documentos mais relevantes para um determinado vetor de consulta. O parâmetro limit especifica o número máximo de resultados para retornar.
Em nosso projeto, client['db'] é usado para acessar os métodos de banco de dados do cliente PulseJet. Isso é equivalente a usar o cliente diretamente:
results = client . search_single ( collection_name , query_vector , limit = 5 , filter = None )Fechando a conexão :
client . close ()Isso fecha a conexão com o banco de dados PulseJet quando não é mais necessário.
A classe PulsejetRagClient é definida em pulsejet_rag_client.py e fornece uma interface de alto nível para interagir com o PulseJet no contexto do nosso sistema de pano. Aqui está um colapso de seus principais componentes:
Inicialização :
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' ])O cliente é inicializado com os parâmetros de configuração, configurando o cliente PulseJet e armazenando valores de configuração relevantes.
Criando uma coleção :
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 cria uma nova coleção no PulseJet com os parâmetros especificados. Ele usa a função get_vector_size para determinar o tamanho do vetor apropriado para as incorporações.
Inserção de vetores :
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 ) } " )Esses métodos lidam com a inserção de vetores únicos e múltiplos na coleção de pulsejet, juntamente com seus metadados associados.
Pesquisando vetores :
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 executa uma pesquisa de similaridade na coleção PulseJet para encontrar os documentos mais relevantes para um determinado vetor de consulta.
Fechando a conexão :
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 fecha a conexão com o banco de dados PulseJet quando não é mais necessário.
O PulsejetRagClient é usado em todo o projeto para interagir com o PulseJet. Veja como é normalmente instanciado e usado:
Criação :
from pulsejet_rag_client import create_pulsejet_rag_client
config = get_config ()
rag_client = create_pulsejet_rag_client ( config )Documentos de indexação :
Em indexing.py , usamos o cliente para criar a coleção e inserir vetores:
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 ) Em rag.py , usamos o cliente para procurar vetores semelhantes durante o processo RAG:
results = rag_client . search_similar_vectors ( query_embed , limit = 5 )Após a conclusão das operações, fechamos a conexão:
rag_client . close ()Esta implementação fornece uma interface limpa e encapsulada para todas as operações de pulsejet em nosso sistema de pano.
LLama3.1 levam mais tempo do que uma simples resposta de perguntas devido ao aumento do comprimento da consulta.O Art Deco Chatbot demonstra como os LLMs podem ser melhor utilizados com RAG. Nosso projeto oferece uma exploração abrangente da implementação do RAG, cobrindo todas as etapas desde a raspagem de dados e o documento de documentação até a criação da criação e a integração de bancos de dados vetoriais.
À medida que a base de documentos para um sistema de pano aumenta, o desempenho das operações de inserção e pesquisa se torna cada vez mais crítico. Ao aprender a integrar o banco de dados de vetores do PulseJet em um sistema de pano completo, pode-se se beneficiar significativamente de seus recursos, principalmente ao lidar com aplicativos de pano em grandes bases de documentos.
Nossas respostas de pano poderiam ter sido mais precisas. Para aprimorar o desempenho do nosso Art Deco Chatbot, estamos considerando várias abordagens experimentais:
Planejamos expandir este projeto através das seguintes iniciativas:
Incentivamos você a experimentar o Art Deco Chatbot, modificar seus parâmetros e adaptá -lo aos seus próprios domínios de interesse.
Autor: Güvenç USANMAZ
