Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Junte-se a nós no Amazon Web Services re:Invent 2024! Saiba como usar o MongoDB para casos de uso de AI .
Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Produtoschevron-right
Atlaschevron-right

Avaliação RAG: detectando alucinações com Patronus AI e MongoDB

Han Heloir, Prakul Agarwal11 min read • Published Aug 15, 2024 • Updated Aug 15, 2024
IAAtlasBashPython
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Um dos maiores feedbacks que escutamos dos clientes que criam aplicativos de AI generativa é sobre confiabilidade. No passado, nos associamos à Padronus AI para mostrar como construir sistemas de AI confiáveis com o MongoDB Atlas Vector Search.
Atualmente, temos o privilégio de anunciar uma associação com a Padronus AI no lançamento de seu modelo de detecção de alterações de última geração: Lince (8b e 70b).
Esse modelo de detecção de auditório de pesos abertos supera todos os modelos LLMs-as-a-juge existentes, incluindo o GPT-4o. Esta versão também introduz o HaluBench, um novo benchmark abrangente projetado para avaliar a fidelidade dos sistemas de geração aumentada de recuperação (RAG) usando dados do mundo real. Este tutorial fornece detalhes sobre como usar modelos de código aberto com o MongoDB Atlas para avaliar a confiabilidade dos sistemas RAG.
Você pode encontrar todo o código apresentado no tutorial no Github

Patronus AI, Lince e HaluBench 

Empresa líder em avaliação e segurança automatizada de AI, o mais recente desenvolvimento da Patronus AI, Lynx, é um modelo de detecção de alucinações de código aberto projetado para resolver o problema crítico de alucinações em grandes modelos de linguagem (LLMs), onde os modelos produzem resultados que são coerentes, mas não factualmente preciso ou alinhado com o contexto de entrada.
Aqui estão os principais pontos sobre o Lynx:
  • Detecta alucinações, superando o desempenho de modelos de código aberto e de código fechado
  • Opera em tempo real, fornecendo feedback imediato sobre a fidelidade da resposta da AI
  • Elimina a necessidade de anotações manuais
  • Permite que os desenvolvedores implantem sistemas de AI confiáveis em escala
Em conjunto com a Lince, a Padronus AI desenvolveu o HaluBench, um novo benchmark projetado para avaliar a fidelidade dos sistemas RAG. O HaluBench obtém dados de vários domínios do mundo real, incluindo financeiros, médios e de conhecimento geral, para avaliar de forma abrangente até que ponto as arquiteturas RAG aderem às informações recuperadas. Esse benchmark inclui exemplos de vários conjuntos de dados, como PerformanceBench, DROP, COVID-QA e PubMedQA, garantindo uma ampla variedade de cenários para avaliação robusta.
O gráfico a seguir mostra a precisão de diferentes LLMs no HaluBench do papel Padronus AI. Número 1: Resultado de benchmark da Patronus AI
Resultado de teste da AIdo Padronus Número 1: Resultado de benchmark da Patronus AI
A tabela compara a precisão de vários modelos de linguagem grandes (LLMs) no HaluBench, uma referência para avaliar sistemas RAG. Inclui modelos como GPT-4, Claude, Mistral Instruct, Llama-3-Chat e Lynx em conjuntos de dados como HaluEval, DROP, CovidQA e PubMedQA. Modelos maiores, especialmente Lynx 70B, demonstram maior precisão, destacando sua eficácia na detecção e gerenciamento de alucinações e enfatizando os benefícios de modelos maiores e treinamento especializado para sistemas RAG confiáveis.
A introdução do Lince e do HaluBench fornece ferramentas essenciais para detectar e mitigar eficazmente as atordoamentos. Quando integradas ao MongoDB, essas ferramentas aprimoram o desenvolvimento de aplicativos de AI generativa robustos e escaláveis. O processamento de dados em tempo real do MongoDB, o esquema flexível, os recursos avançados de query e as medidas robustas de segurança garantem a confiabilidade e a precisão do conteúdo gerado por IA.

Por que usar o MongoDB para aplicativos RAG?

O MongoDB Atlas é uma plataforma exclusiva totalmente gerenciada que integra dados empresariais, pesquisa vetorial e análise, permitindo a criação de aplicativos de AI personalizados. A construção de bases tecnológicas robustas e escaláveis torna-se crucial à medida que as empresas correm para obter o poder transformador da IA generativa. O MongoDB aborda vários desafios importantes nesse campo de rápida evolução, tornando-o uma escolha ideal para aplicativos RAG.
Responsivo em tempo real: a arquitetura do MongoDBde interações de dados em tempo real é crucial para sistemas de AI generativos. Sua capacidade de resposta garante que as respostas sejam entregues aos clientes em segundos ou até milésimos de segundo, mantendo o envolvimento e a satisfa ção do usuário.
Manipulação rápida de dados: a natureza flexível e o modelo de dados flexíveis do MongoDB suportam a rápida iteração de aplicativos, permitindo que as organizações adicionem novos tipos de dados e recursos rapidamente. Essa flexibilidade facilita a melhoria contínua e a readaptação dos aplicativos, garantindo que eles permaneçam comparativos e relevantes. 
Integração e queries inteligentes de dados: os principais recursos do Atlas Search vetorial do MongoDBaprimoram a funcionalidade de aplicativos de AI generativa ao oferecer suporte ao Atlas Search semântica. Além disso, o MongoDB fornece recursos de query avançados adicionais, como Atlas Search de texto completo, queries geoespaciais e queries vetorizadas, que são essenciais para recuperar com eficiência dados relevantes de conjuntos de dados grandes e diversos. 
Proteção de dados confidenciais: o MongoDB enfatiza fortemente a segurança, especialmente ao gerenciar dados confidenciais em plataformas de engajamento de clientes. Ela emprega controles de segurança robustos para proteger dados contra acesso não autorizado e garantir a integridade e confidencialidade dos dados do cliente. Os recursos de segurança abrangentes do MongoDB, incluindo criptografia de repouso e trânsito, controle de acesso baseado em função e auditoria, ajudam a fortalecer os dados contra violações e acesso não autorizado.
Em todos os lugares: o MongoDB foi projetado para se integrar facilmente a qualquer provedor de nuvem, modelo de linguagem grande (LLM) e framework. Essa flexibilidade é crucial para atender às necessidades dinâmicas de aplicativos de AI generativa em vários setores e casos de uso. 

A importância da avaliação RAG

Os sistemas de geração aumentada de recuperação (RAG) combinam modelos baseados em recuperação e em geração para produzir respostas mais precisas e contextualmente relevantes. No entanto, as afirmações que a AI gera informações coerentes, mas imprecisas — representam um desafio significativo, solapando a confiabilidade e a confiança. Uma avaliação robusta garante a precisão, melhora a confiabilidade e aumenta a confiança do usuário.

Usando Lynx e HaluBench para avaliação RAG

O HaluBench, desenvolvido pela Padronus AI, fornece um parâmetro abrangente para avaliar a fidelidade dos sistemas RAG usando dados do mundo real. Lynx aprimora os sistemas RAG ao:
Deteção de atordoamento em tempo real: fornece feedback imediato sobre as respostas de AI , permitindo a correção rápida de imprecisões
Avaliação automatizada: acelera o processo de avaliação eliminando a necessidade de anotações manuais, garantindo avaliações consistentes
Integração perfeita: Monitora e avalia continuamente o conteúdo nos sistemas RAG existentes, mantendo a precisão e a confiabilidade
Benchmarking com HaluBench: Quando usados juntos, Lynx e HaluBench oferecem uma estrutura robusta para testar sistemas RAG em diversos cenários do mundo real, melhorando sua robustez e aplicabilidade.
Imagem 2: Processo típico de avaliação do RAG Imagem 2: Processo típico de avaliação do RAG
O diagrama acima ilustra um processo típico de avaliação de RAG envolvendo aplicativos de AI generativa em tempo real, um modelo LLM para geração de RAG , MongoDB Atlas para o Atlas Search vetorial e o Lince da AIdo Padronus como árbitro.
  1. Aplicativos de generativos em tempo AI real: as perguntas do usuário são inseridas nos aplicativos de generativos em tempo AI RAG real.
  2. MongoDB Atlas: o MongoDB Atlas gerencia a pesquisa vetorial e processa a pergunta do usuário para encontrar documentos relevantes.
  3. Modelo LLM usado na geração de RAG: ele recupera documentos relevantes e os usa para formular um prompt. O modelo LLM processa a pergunta do usuário com documentos recuperados para gerar uma resposta.
  4. LLM como árbitro (Lyx): as entradas incluem os documentos recuperados, a pergunta do usuário e a resposta do LLM. O Lince avalia a fidelidade da resposta e gera uma pontuação binária indicando se a resposta é confiável ou não.

O guia técnico sobre avaliação RAG

Como consultar e recuperar resultados do armazenamento de vetores do Atlas 

Para consultar e recuperar resultados do armazenamento de vetores do MongoDB Atlas, siga estas três etapas:
  1. Configure o banco de dados no Atlas. Primeiro, você precisa criar uma conta no MongoDB Atlas. Isso envolve entrar em sua conta do MongoDB Atlas, criar um novo cluster e adicionar um banco de dados e uma collection. Você pode pular esta etapa se você já tiver sua coleção para o Atlas Search vetorial.
  2. Crie um índice Atlas. Você pode criar um índice via código ou usando a UI do Atlas. Aqui está um exemplo de como criar um índice utilizando a UI do Atlas:
  • Navegue até sua coleção.
  • Clique em "Atlas search " e depois em "Create Index. " MongoDB Atlas
  • Defina os campos e o tipo do índice.  Criando índice
Definindo índice
Alternativamente, você pode criar um índice programaticamente. A seguinte definição de índice indexa o campo de incorporações vetoriais (fieldToIndex) para executar a pesquisa vetorial.
1 import pymongo
2 from pymongo.mongo_client import MongoClient
3 from pymongo.operations import SearchIndexModel
4
5 # Connect to your Atlas deployment
6 uri = "<connectionString>"
7 client = MongoClient(uri)
8
9 # Access your database and collection
10 database = client["<databaseName>"]
11 collection = database["<collectionName>"]
12
13 # Create your index model, then create the search index
14 search_index_model = SearchIndexModel(
15   definition={
16     "fields": [
17       {
18         "type": "vector",
19         "numDimensions": <numberofDimensions>,
20         "path": "<fieldToIndex>",
21         "similarity": "euclidean | cosine | dotProduct"
22       },
23       {
24         "type": "filter",
25         "path": "<fieldToIndex>"
26       },
27       ...
28     ]
29   },
30   name="<index name>",
31   type="vectorSearch",
32 )
33
34 result = collection.create_search_index(model=search_index_model)
35 print(result)
Observação: o create_search_index só funciona para o Atlas cluster M10+. Use a UI do Atlas para o M0-M5.
  1. Execute uma query vetorial com código. Depois de configurar seu banco de dados e criar os índices necessários, você poderá realizar uma query vetorial. Abaixo está um exemplo de código Python usando a biblioteca PyMongo:
1 import pymongo
2 import datetime
3
4 # connect to your Atlas cluster
5 client = pymongo.MongoClient("<connection-string>")
6
7 # define pipeline
8 pipeline = [
9   {
10     '$vectorSearch': {
11       'index': "<index-name>"
12       'path':  "<field-to-search>",
13       'queryVector': [<array-of-numbers>]
14       'numCandidates': <number-of-candidates>,
15       'limit': <number-of-results>
16     }
17   }
18 ]
19
20 # run pipeline
21 result = client["db_name"][collection_name"].aggregate(pipeline)
22
23 # print results
24 for i in result:
25     print(i)

Como escolher o modelo certo

A Padronus disponibiliza duas versões do modelo Lince:
  1. Usando o modelo grande: O modelo Lince-70B requer recursos computacionais significativos. Verifique se você tem memória e capacidade de computação suficientes para lidar com isso. Você precisará de uma instância com uma CPU A100 ou H100 . Usaremos o vLLM para executar o modelo na CPU e obter um endpoint para o nosso processo de avaliação.
  2. Usando um modelo menor: se o modelo 70B for muito grande para o seu caso de uso, considere usar uma variante menor do modelo Lince (LyNX-8B-Instruct). Isso pode ser executado em um sistema local usando o Ollama. Você pode encontrar tamanhos diferentes no centro do modelo Hugging Face no repositório PadronusAI.

Como baixar o modelo do Hugging Face 

Siga estas etapas para baixar o modelo Lince do Abraçando o Face. Isso envolve configurar o ambiente e a CLI do Abraçando Face, fazendo login no Abraçando o Face e baixando o modelo.
Etapa 1: instale o Hugging Face Hub CLI
Primeiro, você precisa instalar a CLI do Hugging Face Hub. Isso permite que você interaja diretamente com o hub de modelo do Hugging Face a partir da linha de comando.
1 pip3 install -U huggingface_hub[cli]
Etapa 2: faça login no Abraço do Rosto
Em seguida, faça login na sua conta do Abraçando Face. Se você não tiver uma conta, precisará criar uma em Abraçando a Face.
1huggingface-cli login
Você será solicitado a inserir seu token Hugging Face. Você pode encontrar seu token nas configurações da sua conta Hugging Face em “Access Tokens.”
Etapa 3: baixe o modelo Lynx
Após o login, você pode baixar o modelo Lynx. Aqui está um exemplo de comando para baixar a variante 70B do modelo Lynx:
1 huggingface-cli download PatronusAI/Patronus-Lynx-8B-Instruct --local-dir Patronus_8B
Este comando baixará o modelo para um diretório local chamado Patronus_8B.

Como implantar o Lix no servidor usando o vllm 

Com o servidor de inferênciavLLM em execução, você obterá um URI (por exemplo, http://localhost:5123/). Você pode usar a especificação da API OpenAI para enviar solicitações e avaliar a fidelidade das respostas geradas pela IA. Esta seção aborda o envio de uma solicitação cURL para testar o servidor e a implementação de um modelo de prompt estruturado para detecção de alucinações.
Etapa 1: Crie um novo ambiente conda e instale o vllm
A criação de um ambiente conda dedicado ajuda a gerenciar as dependências e a evitar conflitos. Veja como configurar um novo ambiente com o Python 3.10:
1 # (Recommended) Create a new conda environment.
2 conda create -n myenv python=3.10 -y
3 # Activate the newly created environment.
4 conda activate myenv
Instale a vLLM, uma biblioteca projetada para atender com eficiência a grandes modelos de linguagem. Se você tiver CUDA 12.1 instalado, você pode instalar o vLLM com suporte CUDA para melhor desempenho.
1 # Install vLLM with CUDA 12.1.
2 pip install vllm
Etapa 2: Executar o modelo Lince em um servidor
Depois que o vLLM estiver instalado, você poderá iniciar o servidor para hospedar o modelo Lynx. Isso envolve especificar a porta, o modelo e o tokenizador. O seguinte comando executa o modelo na porta 5123:
1 python -m vllm.entrypoints.openai.api_server --port 5123 --model PatronusAI/Patronus-Lynx-8B-Instruct --tokenizer meta-llama/Meta-Llama-3-8B

Como detectar alucinações no sistema RAG baseado em Atlas usando a API Lynx local 

Com o servidor de inferência vLLM em execução em http://localhost:5123/, você pode usar a especificação da API OpenAI para enviar solicitações e avaliar a fidelidade das respostas geradas pela IA. Esta seção aborda o envio de uma solicitação cURL para testar o servidor e a implementação de um modelo de prompt estruturado para detecção de alucinações.
Etapa 1: testar o servidor com uma solicitação cURL
Verifique se o servidor está funcionando enviando uma solicitação cURL. Essa solicitação consulta o modelo para definir o que é uma alucinação:
1 curl http://localhost:5123/v1/chat/completions \
2   -H "Content-Type: application/json" \
3   -d '{
4   "model": "PatronusAI/Patronus-Lynx-70B-Instruct",
5   "messages": [
6     {"role": "user", "content": "What is a hallucination?"}
7   ]
8 }'
Etapa 2: Definir o modelo de prompt
Use um modelo de prompt estruturado para avaliar a fidelidade das respostas geradas por IA. O modelo ajuda a garantir que a resposta seja fiel ao documento fornecido e não contenha alucinações.
1 # Prompt template
2 Given the following QUESTION, DOCUMENT and ANSWER you must analyze the provided answer and determine whether it is faithful to the contents of the DOCUMENT.
3
4 The ANSWER must not offer new information beyond the context provided in the DOCUMENT.
5
6 The ANSWER also must not contradict information provided in the DOCUMENT.
7
8 Output your final score by strictly following this format: "PASS" if the answer is faithful to the DOCUMENT and "FAIL" if the answer is not faithful to the DOCUMENT.
9
10 Show your reasoning.
11
12 --
13 QUESTION (THIS DOES NOT COUNT AS BACKGROUND INFORMATION):
14 {{ user_input }}
15
16 --
17 DOCUMENT:
18 {{ provided_context }}
19
20 --
21 ANSWER:
22 {{ bot_response }}
23
24 --
25
26 Your output should be in JSON FORMAT with the keys "REASONING" and "SCORE".
27
28 Ensure that the JSON is valid and properly formatted.
29
30 {"REASONING": ["<your reasoning as bullet points>"], "SCORE": "<final score>"}
Etapa 3: Implemente a função de avaliação
Use o Python para enviar uma solicitação estruturada para a API do Lince local, incluindo a pergunta, o documento e a resposta. O código a seguir demonstra como formatar a solicitação e manipular a resposta:
1 import requests
2 import json
3
4 # Define the endpoint URL
5 url = "http://localhost:5123/v1/chat/completions"
6
7 # Define the prompt template
8 prompt_template = """
9 Given the following QUESTION, DOCUMENT and ANSWER you must analyze the provided answer and determine whether it is faithful to the contents of the DOCUMENT.
10
11 The ANSWER must not offer new information beyond the context provided in the DOCUMENT.
12
13 The ANSWER also must not contradict information provided in the DOCUMENT.
14
15 Output your final score by strictly following this format: "PASS" if the answer is faithful to the DOCUMENT and "FAIL" if the answer is not faithful to the DOCUMENT.
16
17 Show your reasoning.
18
19 --
20 QUESTION (THIS DOES NOT COUNT AS BACKGROUND INFORMATION):
21 {user_input}
22
23 --
24 DOCUMENT:
25 {provided_context}
26
27 --
28 ANSWER:
29 {bot_response}
30
31 --
32
33 Your output should be in JSON FORMAT with the keys "REASONING" and "SCORE".
34
35 Ensure that the JSON is valid and properly formatted.
36
37 {"REASONING": ["<your reasoning as bullet points>"], "SCORE": "<final score>"}
38 """
39
40 # Define the input data
41 data = {
42     "model": "PatronusAI/Patronus-Lynx-70B-Instruct",
43     "messages": [
44         {"role": "system", "content": "You are an AI that evaluates the faithfulness of responses."},
45         {"role": "user", "content": prompt_template.format(
46             user_input="What is the capital of France?",
47             provided_context="France is a country in Europe. The capital city of France is Paris.",
48             bot_response="The capital of France is Lyon."
49         )}
50     ]
51 }
52
53 # Send the request
54 response = requests.post(url, headers={"Content-Type": "application/json"}, data=json.dumps(data))
55
56 # Process the server response
57 response_json = response.json()
58
59 # Extract reasoning and score
60 reasoning = response_json.get("choices", [{}])[0].get("message", {}).get("content", {})
61 score = response_json.get("choices", [{}])[0].get("message", {}).get("content", {}).get("SCORE", "")
62
63 # Print the results
64 print("Reasoning:", reasoning)
65 print("Score:", score)

Conclusão

O Lince e o HaluBench da Patronuus AI avançam significativamente a detecção de atordoamentos e a avaliação do sistema RAG. Lynx fornece feedback automatizado em tempo real, enquanto HaluBench oferece um benchmark robusto usando dados do mundo real. O MongoDB Atlas aprimora essas ferramentas com processamento de dados em tempo real, manuseio rápido, consulta avançada e segurança robusta. Sua integração perfeita com qualquer fornecedor de nuvem, LLM e framework o torna ideal para aplicativos generativos de AI RAG. 
O Lix, o HaluBench e o MongoDB permitem o desenvolvimento de aplicativos de RAG AI confiáveis, precisos e escaláveis, impulsionando a melhoria e a novidade contínuas em generativa AI.

Perguntas frequentes (FAQ)

1. O que são Lince e HaluBench, e por que são importantes para os sistemas RAG?
O Lince é um modelo de detecção de atordoamento de código aberto desenvolvido pela Padronus AI. Ele detecta atordoamentos em tempo real, superando os modelos de código aberto e fechado. O HaluBench é um benchmark abrangente para avaliar a fidelidade dos sistemas de geração aumentada de recuperação (RAG) usando dados do mundo real. Juntos, eles fornecem uma estrutura robusta para testar e melhorar os sistemas RAG , permitindo que os desenvolvedores implementem aplicativos de AI mais confiáveis em escala.
2. Por que usar o MongoDB Atlas para aplicativos RAG? O MongoDB Atlas é uma plataforma de banco de dados em nuvem que oferece um ambiente escalável, seguro e de alto desempenho para aplicativos RAG (Reactive Applications). Ele fornece recursos como replicação, balanceamento de carga e failover automático, o que garante alta disponibilidade e confiabilidade para seus aplicativos. Além disso, o MongoDB Atlas oferece uma variedade de ferramentas e serviços que facilitam o desenvolvimento e a manutenção de aplicativos RAG, como: * **MongoDB Compass:** Uma interface gráfica de usuário (GUI) que permite gerenciar e monitorar seus bancos de dados MongoDB. * **MongoDB Shell:** Uma ferramenta de linha de comando que permite interagir com seus bancos de dados MongoDB. * **MongoDB Stitch:** Um serviço de computação em nuvem que permite criar funções e serviços personalizados para seus aplicativos MongoDB. Com o MongoDB Atlas, você pode se concentrar em desenvolver seus aplicativos RAG sem se preocupar com a infraestrutura de banco de dados.
O MongoDB Atlas é ideal para aplicativos RAG porque:
  • Fornece processamento de dados em tempo real e capacidade de resposta.
  • Oferece manuseio flexível de dados para rápida iteração do aplicativo.
  • Suporta o Atlas Search vetorial e recursos avançados de query.
  • Garante segurança robusta para dados confidenciais.
  • Integra-se facilmente a vários provedores de nuvem, LLMs e frameworks.
3. Como posso configurar e implantar o modelo Lynx para avaliar as respostas geradas por IA?
Para configurar e implantar o modelo Lynx:
  • Baixe o modelo do Abraçando o Face.
  • Crie um novo ambiente conda e instale o vLLM.
  • Execute o modelo Lince em um servidor usando o vLLM.
  • Use a especificação da API OpenAI para enviar solicitações e avaliar as respostas geradas pela IA.
  • Observe que o modelo Lix-70B requer recursos computacionais significativos (normalmente uma CPU A100 ou H100 ), enquanto o modelo Lix-8B-Instruct menor pode ser executado em um sistema local usando o Ollama .
4. Como esse sistema melhora a confiabilidade dos aplicativos de IA generativa?
Este sistema melhora a confiabilidade ao:
  • Detecção e mitigação de atordoamentos em tempo real.
  • Fornecendo feedback imediato sobre a fidelidade da resposta da AI .
  • Oferecendo benchmarking abrangente com dados do mundo real.
  • Habilitando o monitoramento e a avaliação contínuos do conteúdo nos sistemas RAG.
  • Eliminando a necessidade de anotações manuais no processo de avaliação.
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.
Iniciar a conversa

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Tutorial

Como distribuir um aplicativo no Kubernetes com o MongoDB Atlas Operator


Aug 30, 2024 | 9 min read
Artigo

Comparação de técnicas de NLP para Atlas Search de produtos escaláveis


Sep 23, 2024 | 8 min read
Artigo

Implementação de pipelines RAG robustos: integração do Gemma 2 do Google (2B) técnicas de avaliação do MongoDB e LLM


Sep 12, 2024 | 20 min read
Tutorial

Hospedando com segurança um aplicativo Lambda com uma arquitetura de microsserviço e MongoDB Atlas


Sep 19, 2024 | 4 min read
Sumário
  • A importância da avaliação RAG