LLMs como GPT-3, GPT-4 e suas contrapartes de código aberto muitas vezes têm dificuldades com a recuperação de informações atualizadas e podem, às vezes, gerar alucinações ou informações incorretas.
Retrieval-Augmented Era (RAG) é uma técnica que combina o poder dos LLMs com a recuperação de conhecimento externo. O RAG nos permite fundamentar respostas de LLM em informações factuais e atualizadas, melhorando significativamente a precisão e a confiabilidade do conteúdo gerado por IA.
Nesta postagem do weblog, exploraremos como construir agentes LLM para RAG do zero, mergulhando fundo na arquitetura, detalhes de implementação e técnicas avançadas. Abordaremos tudo, desde os conceitos básicos do RAG até a criação de agentes sofisticados capazes de raciocínio complexo e execução de tarefas.
Antes de começarmos a construir nosso agente LLM, vamos entender o que é RAG e por que ele é importante.
RAG, ou Retrieval-Augmented Era, é uma abordagem híbrida que combina recuperação de informação com geração de texto. Em um sistema RAG:
- Uma consulta é usada para recuperar documentos relevantes de uma base de conhecimento.
- Esses documentos são então inseridos em um modelo de linguagem junto com a consulta authentic.
- O modelo gera uma resposta com base na consulta e nas informações recuperadas.
Esta abordagem tem várias vantagens:
- Precisão melhorada:Ao basear as respostas em informações recuperadas, o RAG reduz alucinações e melhora a precisão dos fatos.
- Informação atualizada: A base de conhecimento pode ser atualizada regularmente, permitindo que o sistema acesse informações atuais.
- Transparência: O sistema pode fornecer fontes para suas informações, aumentando a confiança e permitindo a verificação de fatos.
Compreendendo os agentes LLM
Quando você enfrenta um problema sem uma resposta simples, geralmente precisa seguir vários passos, pensar cuidadosamente e lembrar o que já tentou. Os agentes LLM são projetados exatamente para esses tipos de situações em aplicações de modelos de linguagem. Eles combinam análise de dados completa, planejamento estratégico, recuperação de dados e a capacidade de aprender com ações passadas para resolver problemas complexos.
O que são agentes LLM?
Os agentes LLM são sistemas avançados de IA projetados para criar textos complexos que exigem raciocínio sequencial. Eles podem pensar à frente, lembrar de conversas passadas e usar diferentes ferramentas para ajustar suas respostas com base na situação e no estilo necessários.
Considere uma questão no campo jurídico, como: “Quais são os potenciais resultados legais de um tipo específico de violação de contrato na Califórnia?” Um LLM básico com um sistema de geração aumentada de recuperação (RAG) pode buscar as informações necessárias de bancos de dados jurídicos.
Para um cenário mais detalhado: “À luz das novas leis de privacidade de dados, quais são os desafios legais comuns que as empresas enfrentam e como os tribunais abordaram essas questões?” Esta questão vai mais fundo do que apenas procurar fatos. É sobre entender novas regras, seu impacto em diferentes empresas e as respostas dos tribunais. Um agente LLM dividiria essa tarefa em subtarefas, como recuperar as leis mais recentes, analisar casos históricos, resumir documentos legais e prever tendências com base em padrões.
Componentes dos agentes LLM
Os agentes LLM geralmente consistem em quatro componentes:
- Agente/Cérebro: O modelo de linguagem central que processa e entende a linguagem.
- Planejamento: Capacidade de raciocinar, dividir tarefas e desenvolver planos específicos.
- Memória: Mantém registros de interações passadas e aprende com elas.
- Uso de ferramentas: Integra vários recursos para executar tarefas.
Agente/Cérebro
No cerne de um agente LLM está um modelo de linguagem que processa e entende a linguagem com base em grandes quantidades de dados nos quais ele foi treinado. Você começa dando a ele um immediate específico, orientando o agente sobre como responder, quais ferramentas usar e os objetivos a serem alcançados. Você pode personalizar o agente com uma persona adequada para tarefas ou interações específicas, melhorando seu desempenho.
Memória
O componente de memória ajuda os agentes LLM a lidar com tarefas complexas mantendo um registro de ações passadas. Existem dois tipos principais de memória:
- Memória de curto prazo: Funciona como um bloco de notas, monitorando as discussões em andamento.
- Memória de longo prazo: Funciona como um diário, armazenando informações de interações passadas para aprender padrões e tomar melhores decisões.
Ao combinar esses tipos de memória, o agente pode oferecer respostas mais personalizadas e lembrar das preferências do usuário ao longo do tempo, criando uma interação mais conectada e relevante.
Planejamento
O planejamento permite que agentes LLM raciocinem, decomponham tarefas em partes gerenciáveis e adaptem planos conforme as tarefas evoluem. O planejamento envolve dois estágios principais:
- Formulação do Plano: Dividir uma tarefa em subtarefas menores.
- Reflexão do Plano: Revisar e avaliar a eficácia do plano, incorporando suggestions para refinar estratégias.
Métodos como a Cadeia de Pensamento (CoT) e a Árvore de Pensamento (ToT) auxiliam nesse processo de decomposição, permitindo que os agentes explorem diferentes caminhos para resolver um problema.
Para se aprofundar no mundo dos agentes de IA, incluindo suas capacidades e potencial atuais, considere ler “Auto-GPT & GPT-Engineer: Um guia aprofundado para os principais agentes de IA de hoje”
Configurando o ambiente
Para construir nosso agente RAG, precisaremos configurar nosso ambiente de desenvolvimento. Usaremos Python e várias bibliotecas-chave:
- Cadeia Lang: Para orquestrar nossos componentes de LLM e recuperação
- Croma: Como nossa loja de vetores para incorporação de documentos
- Modelos GPT da OpenAI: Como nosso LLM base (você pode substituí-lo por um modelo de código aberto, se preferir)
- API rápida: Para criar uma API simples para interagir com nosso agente
Vamos começar configurando nosso ambiente:
# Create a brand new digital surroundings python -m venv rag_agent_env supply rag_agent_env/bin/activate # On Home windows, use `rag_agent_envScriptsactivate` # Set up required packages pip set up langchain chromadb openai fastapi uvicorn Now, let's create a brand new Python file known as rag_agent.py and import the mandatory libraries: (code language="PYTHON") from langchain.embeddings import OpenAIEmbeddings from langchain.vectorstores import Chroma from langchain.text_splitter import CharacterTextSplitter from langchain.llms import OpenAI from langchain.chains import RetrievalQA from langchain.document_loaders import TextLoader import os # Set your OpenAI API key os.environ("OPENAI_API_KEY") = "your-api-key-here"
Construindo um sistema RAG simples
Agora que configuramos nosso ambiente, vamos construir um sistema RAG básico. Começaremos criando uma base de conhecimento a partir de um conjunto de documentos e, em seguida, usaremos isso para responder a consultas.
Etapa 1: Put together os documentos
Primeiro, precisamos carregar e preparar nossos documentos. Para este exemplo, vamos supor que temos um arquivo de texto chamado knowledge_base.txt com algumas informações sobre IA e machine studying.
# Load the doc loader = TextLoader("knowledge_base.txt") paperwork = loader.load() # Break up the paperwork into chunks text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) texts = text_splitter.split_documents(paperwork) # Create embeddings embeddings = OpenAIEmbeddings() # Create a vector retailer vectorstore = Chroma.from_documents(texts, embeddings)
Etapa 2: Crie uma cadeia de controle de qualidade baseada em recuperação
Agora que temos nosso armazenamento de vetores, podemos criar uma cadeia de controle de qualidade baseada em recuperação:
# Create a retrieval-based QA chain qa = RetrievalQA.from_chain_type( llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever() )
Etapa 3: Consultar o sistema
Agora podemos consultar nosso sistema RAG:
question = "What are the primary functions of machine studying?" outcome = qa.run(question) print(outcome) This primary RAG system demonstrates the core idea: we retrieve related data from our information base and use it to tell the LLM's response. Creating an LLM Agent Whereas our easy RAG system is helpful, it is fairly restricted. Let's improve it by creating an LLM agent that may carry out extra complicated duties and purpose in regards to the data it retrieves. An LLM agent is an AI system that may use instruments and make selections about which actions to take. We'll create an agent that may not solely reply questions but additionally carry out internet searches and primary calculations. First, let's outline some instruments for our agent: (code language="PYTHON") from langchain.brokers import Instrument from langchain.instruments import DuckDuckGoSearchRun from langchain.instruments import BaseTool from langchain.brokers import initialize_agent from langchain.brokers import AgentType # Outline a calculator device class CalculatorTool(BaseTool): title = "Calculator" description = "Helpful for when it's essential reply questions on math" def _run(self, question: str) -> str: attempt: return str(eval(question)) besides: return "I could not calculate that. Please be sure that your enter is a legitimate mathematical expression." # Create device situations search = DuckDuckGoSearchRun() calculator = CalculatorTool() # Outline the instruments instruments = ( Instrument( title="Search", func=search.run, description="Helpful for when it's essential reply questions on present occasions" ), Instrument( title="RAG-QA", func=qa.run, description="Helpful for when it's essential reply questions on AI and machine studying" ), Instrument( title="Calculator", func=calculator._run, description="Helpful for when it's essential carry out mathematical calculations" ) ) # Initialize the agent agent = initialize_agent( instruments, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True )
Agora temos um agente que pode usar nosso sistema RAG, executar pesquisas na internet e fazer cálculos. Vamos testá-lo:
outcome = agent.run(“Qual é a diferença entre aprendizado supervisionado e não supervisionado? Além disso, o que é 15% de 80?”)
imprimir(resultado)
(/código)
Este agente demonstra uma vantagem elementary dos agentes LLM: eles podem combinar diversas ferramentas e etapas de raciocínio para responder a consultas complexas.
Aprimorando o agente com técnicas avançadas de RAG
Embora nosso sistema RAG atual funcione bem, existem diversas técnicas avançadas que podemos usar para melhorar seu desempenho:
a) Busca Semântica com Recuperação de Passagem Densa (DPR)
Em vez de usar recuperação simples baseada em incorporação, podemos implementar DPR para uma pesquisa semântica mais precisa:
from transformers import DPRQuestionEncoder, DPRContextEncoder question_encoder = DPRQuestionEncoder.from_pretrained("fb/dpr-question_encoder-single-nq-base") context_encoder = DPRContextEncoder.from_pretrained("fb/dpr-ctx_encoder-single-nq-base") # Operate to encode passages def encode_passages(passages): return context_encoder(passages, max_length=512, return_tensors="pt").pooler_output # Operate to encode question def encode_query(question): return question_encoder(question, max_length=512, return_tensors="pt").pooler_output
b) Expansão de consulta
Podemos usar a expansão de consulta para melhorar o desempenho da recuperação:
de transformadores importar T5ForConditionalGeneration, T5Tokenizer
modelo = T5ForConditionalGeneration.from_pretrained(“t5-small”)
tokenizador = T5Tokenizer.from_pretrained(“t5-pequeno”)
def expand_query(consulta):
input_text = f”expandir consulta: {consulta}”
input_ids = tokenizer.encode(input_text, return_tensors=”pt”)
saídas = modelo.generate(id_de_entrada, comprimento_máximo=50, num_sequências_de_retorno=3)
expanded_queries = (tokenizer.decode(output, skip_special_tokens=True) para saída em outputs)
retornar consultas_expandidas
# Use isso no seu processo de recuperação
c) Refinamento Iterativo
Podemos implementar um processo de refinamento iterativo onde o agente pode fazer perguntas de acompanhamento para esclarecer ou expandir sua recuperação inicial:
def iterative_retrieval(consulta_inicial, max_iterations=3):
consulta = consulta_inicial
para _ em intervalo(máx_iterações):
resultado = qa.run(consulta)
esclarecimento = agent.run(f”Com base neste resultado: '{outcome}', que pergunta complementar devo fazer para obter informações mais específicas?”)
se esclarecimento.decrease().strip() == “nenhum”:
quebrar
consulta = esclarecimento
retornar resultado
# Use isso no processo do seu agente
Implementando um Sistema Multiagente
Para lidar com tarefas mais complexas, podemos implementar um sistema multiagente onde diferentes agentes se especializam em diferentes áreas. Aqui está um exemplo simples:
classe Agente Especialista:
def __init__(self, nome, ferramentas):
self.title = nome
self.agent = initialize_agent(ferramentas, OpenAI(temperatura=0), agente=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
def run(self, consulta):
retornar self.agent.run(consulta)
# Crie agentes especialistas
research_agent = SpecialistAgent(“Pesquisa”, (Ferramenta(nome=”RAG-QA”, func=qa.run, descrição=”Para perguntas de IA e ML”)))
math_agent = SpecialistAgent(“Math”, (Ferramenta(nome=”Calculadora”, func=calculator._run, descrição=”Para cálculos”)))
general_agent = SpecialistAgent(“Geral”, (Ferramenta(nome=”Pesquisar”, func=search.run, descrição=”Para consultas gerais”)))
Coordenador de turma:
def __init__(self, agentes):
self.brokers = agentes
def run(self, consulta):
# Decide qual agente usar
se “calcular” em question.decrease() ou any(op em question para op em ('+', '-', '*', '/')):
retornar self.brokers('Math').run(consulta)
elif any(termo em consulta.decrease() para termo em ('ai', 'aprendizado de máquina', 'aprendizado profundo')):
retornar self.brokers('Pesquisa').run(consulta)
outro:
retornar self.brokers('Geral').run(consulta)
coordenador = Coordenador({
'Pesquisa': research_agent,
'Matemática': math_agent,
'Geral': general_agent
})
# Teste o sistema multiagente
outcome = coordinate.run(“Qual é a diferença entre CNN e RNN? Além disso, calcule 25% de 120.”)
imprimir(resultado)
(/código)
Este sistema multiagente permite especialização e pode lidar com uma gama maior de consultas de forma mais eficaz.
Avaliação e otimização de agentes RAG
Para garantir que nosso agente RAG esteja tendo um bom desempenho, precisamos implementar métricas de avaliação e técnicas de otimização:
a) Avaliação de Relevância
Podemos usar métricas como BLEU, ROUGE ou BERTScore para avaliar a relevância dos documentos recuperados:
from bert_score import rating def evaluate_relevance(question, retrieved_doc, generated_answer): P, R, F1 = rating((generated_answer), (retrieved_doc), lang="en") return F1.imply().merchandise()
b) Avaliação da Qualidade da Resposta
Podemos usar avaliação humana ou métricas automatizadas para avaliar a qualidade da resposta:
from nltk.translate.bleu_score import sentence_bleu def evaluate_answer_quality(reference_answer, generated_answer): return sentence_bleu((reference_answer.break up()), generated_answer.break up()) # Use this to guage your agent's responses c) Latency Optimization To optimize latency, we will implement caching and parallel processing: import functools from concurrent.futures import ThreadPoolExecutor @functools.lru_cache(maxsize=1000) def cached_retrieval(question): return vectorstore.similarity_search(question) def parallel_retrieval(queries): with ThreadPoolExecutor() as executor: outcomes = listing(executor.map(cached_retrieval, queries)) return outcomes # Use these in your retrieval course of
Direções e desafios futuros
Ao olharmos para o futuro dos agentes RAG, surgem diversas direções e desafios interessantes:
a) RAG multimodal: Estendendo o RAG para incorporar dados de imagem, áudio e vídeo.
b) RAG federado: Implementando RAG em bases de conhecimento distribuídas e que preservam a privacidade.
c) Aprendizagem Contínua: Desenvolver métodos para que agentes RAG atualizem suas bases de conhecimento e modelos ao longo do tempo.
e) Considerações éticas: Abordando preconceito, justiça e transparência em sistemas RAG.
e) Escalabilidade: Otimizando o RAG para aplicações em larga escala e em tempo actual.
Conclusão
Construir agentes LLM para RAG do zero é um processo complexo, mas gratificante. Cobrimos os conceitos básicos de RAG, implementamos um sistema simples, criamos um agente LLM, o aprimoramos com técnicas avançadas, exploramos sistemas multiagentes e discutimos estratégias de avaliação e otimização.