milvus-logo
LFAI
Home
  • Integrações
    • Avaliação e observabilidade

Avaliação com Arize Pheonix

Open In Colab GitHub Repository

Este guia demonstra como utilizar o Arize Pheonix para avaliar um pipeline Retrieval-Augmented Generation (RAG) baseado no Milvus.

O sistema RAG combina um sistema de recuperação com um modelo generativo para gerar novo texto com base num determinado pedido. O sistema começa por recuperar documentos relevantes de um corpus utilizando o Milvus e, em seguida, utiliza um modelo generativo para gerar novo texto com base nos documentos recuperados.

Arize Pheonix é um quadro que ajuda a avaliar as condutas RAG. Existem ferramentas e estruturas que ajudam a construir estas condutas, mas avaliá-las e quantificar o seu desempenho pode ser difícil. É aqui que entra o Arize Pheonix.

Pré-requisitos

Antes de executar este notebook, certifique-se de ter as seguintes dependências instaladas:

$ pip install --upgrade pymilvus openai requests tqdm pandas "arize-phoenix>=4.29.0" nest_asyncio

Se estiver a utilizar o Google Colab, para ativar as dependências que acabou de instalar, poderá ter de reiniciar o tempo de execução (clique no menu "Tempo de execução" na parte superior do ecrã e selecione "Reiniciar sessão" no menu pendente).

Neste exemplo, vamos utilizar o OpenAI como LLM. Você deve preparar a chave api OPENAI_API_KEY como uma variável de ambiente.

import os

# os.environ["OPENAI_API_KEY"] = "sk-*****************"

Definir o pipeline do RAG

Vamos definir a classe RAG que usa o Milvus como armazenamento de vectores e o OpenAI como LLM. A classe contém o método load, que carrega os dados de texto no Milvus, o método retrieve, que recupera os dados de texto mais semelhantes à pergunta dada, e o método answer, que responde à pergunta dada com o conhecimento recuperado.

from typing import List
from tqdm import tqdm
from openai import OpenAI
from pymilvus import MilvusClient


class RAG:
    """
    RAG(Retrieval-Augmented Generation) class built upon OpenAI and Milvus.
    """

    def __init__(self, openai_client: OpenAI, milvus_client: MilvusClient):
        self._prepare_openai(openai_client)
        self._prepare_milvus(milvus_client)

    def _emb_text(self, text: str) -> List[float]:
        return (
            self.openai_client.embeddings.create(input=text, model=self.embedding_model)
            .data[0]
            .embedding
        )

    def _prepare_openai(
        self,
        openai_client: OpenAI,
        embedding_model: str = "text-embedding-3-small",
        llm_model: str = "gpt-4o-mini",
    ):
        self.openai_client = openai_client
        self.embedding_model = embedding_model
        self.llm_model = llm_model
        self.SYSTEM_PROMPT = """
            Human: You are an AI assistant. You are able to find answers to the questions from the contextual passage snippets provided.
        """
        self.USER_PROMPT = """
            Use the following pieces of information enclosed in <context> tags to provide an answer to the question enclosed in <question> tags.
            <context>
            {context}
            </context>
            <question>
            {question}
            </question>
        """

    def _prepare_milvus(
        self, milvus_client: MilvusClient, collection_name: str = "rag_collection"
    ):
        self.milvus_client = milvus_client
        self.collection_name = collection_name
        if self.milvus_client.has_collection(self.collection_name):
            self.milvus_client.drop_collection(self.collection_name)
        embedding_dim = len(self._emb_text("demo"))
        self.milvus_client.create_collection(
            collection_name=self.collection_name,
            dimension=embedding_dim,
            metric_type="IP",
            consistency_level="Strong",
        )

    def load(self, texts: List[str]):
        """
        Load the text data into Milvus.
        """
        data = []
        for i, line in enumerate(tqdm(texts, desc="Creating embeddings")):
            data.append({"id": i, "vector": self._emb_text(line), "text": line})
        self.milvus_client.insert(collection_name=self.collection_name, data=data)

    def retrieve(self, question: str, top_k: int = 3) -> List[str]:
        """
        Retrieve the most similar text data to the given question.
        """
        search_res = self.milvus_client.search(
            collection_name=self.collection_name,
            data=[self._emb_text(question)],
            limit=top_k,
            search_params={"metric_type": "IP", "params": {}},  # inner product distance
            output_fields=["text"],  # Return the text field
        )
        retrieved_texts = [res["entity"]["text"] for res in search_res[0]]
        return retrieved_texts[:top_k]

    def answer(
        self,
        question: str,
        retrieval_top_k: int = 3,
        return_retrieved_text: bool = False,
    ):
        """
        Answer the given question with the retrieved knowledge.
        """
        retrieved_texts = self.retrieve(question, top_k=retrieval_top_k)
        user_prompt = self.USER_PROMPT.format(
            context="\n".join(retrieved_texts), question=question
        )
        response = self.openai_client.chat.completions.create(
            model=self.llm_model,
            messages=[
                {"role": "system", "content": self.SYSTEM_PROMPT},
                {"role": "user", "content": user_prompt},
            ],
        )
        if not return_retrieved_text:
            return response.choices[0].message.content
        else:
            return response.choices[0].message.content, retrieved_texts

Vamos inicializar a classe RAG com os clientes OpenAI e Milvus.

openai_client = OpenAI()
milvus_client = MilvusClient(uri="./milvus_demo.db")

my_rag = RAG(openai_client=openai_client, milvus_client=milvus_client)

Quanto ao argumento de MilvusClient:

  • Definir o uri como um ficheiro local, por exemplo./milvus.db, é o método mais conveniente, pois utiliza automaticamente o Milvus Lite para armazenar todos os dados neste ficheiro.
  • Se tiver uma grande escala de dados, pode configurar um servidor Milvus mais eficiente em docker ou kubernetes. Nesta configuração, utilize o uri do servidor, por exemplo,http://localhost:19530, como o seu uri.
  • Se pretender utilizar o Zilliz Cloud, o serviço de nuvem totalmente gerido para o Milvus, ajuste uri e token, que correspondem ao Ponto Final Público e à chave Api no Zilliz Cloud.

Executar o pipeline RAG e obter resultados

Utilizamos o guia de desenvolvimento do Milvus para ser o conhecimento privado no nosso RAG, que é uma boa fonte de dados para um pipeline RAG simples.

Descarregue-o e carregue-o no pipeline RAG.

import urllib.request
import os

url = "https://raw.githubusercontent.com/milvus-io/milvus/master/DEVELOPMENT.md"
file_path = "./Milvus_DEVELOPMENT.md"

if not os.path.exists(file_path):
    urllib.request.urlretrieve(url, file_path)
with open(file_path, "r") as file:
    file_text = file.read()

text_lines = file_text.split("# ")
my_rag.load(text_lines)
Creating embeddings: 100%|██████████| 47/47 [00:12<00:00,  3.84it/s]

Vamos definir uma pergunta de consulta sobre o conteúdo da documentação do guia de desenvolvimento. E, em seguida, usar o método answer para obter a resposta e os textos de contexto recuperados.

question = "what is the hardware requirements specification if I want to build Milvus and run from source code?"
my_rag.answer(question, return_retrieved_text=True)
('The hardware requirements specification to build and run Milvus from source code are:\n\n- 8GB of RAM\n- 50GB of free disk space',
 ['Hardware Requirements\n\nThe following specification (either physical or virtual machine resources) is recommended for Milvus to build and run from source code.\n\n```\n- 8GB of RAM\n- 50GB of free disk space\n```\n\n##',
  'Building Milvus on a local OS/shell environment\n\nThe details below outline the hardware and software requirements for building on Linux and MacOS.\n\n##',
  "Software Requirements\n\nAll Linux distributions are available for Milvus development. However a majority of our contributor worked with Ubuntu or CentOS systems, with a small portion of Mac (both x86_64 and Apple Silicon) contributors. If you would like Milvus to build and run on other distributions, you are more than welcome to file an issue and contribute!\n\nHere's a list of verified OS types where Milvus can successfully build and run:\n\n- Debian/Ubuntu\n- Amazon Linux\n- MacOS (x86_64)\n- MacOS (Apple Silicon)\n\n##"])

Agora, vamos preparar algumas perguntas com as respectivas respostas verdadeiras. Obtemos respostas e contextos do nosso pipeline RAG.

from datasets import Dataset
import pandas as pd

question_list = [
    "what is the hardware requirements specification if I want to build Milvus and run from source code?",
    "What is the programming language used to write Knowhere?",
    "What should be ensured before running code coverage?",
]
ground_truth_list = [
    "If you want to build Milvus and run from source code, the recommended hardware requirements specification is:\n\n- 8GB of RAM\n- 50GB of free disk space.",
    "The programming language used to write Knowhere is C++.",
    "Before running code coverage, you should make sure that your code changes are covered by unit tests.",
]
contexts_list = []
answer_list = []
for question in tqdm(question_list, desc="Answering questions"):
    answer, contexts = my_rag.answer(question, return_retrieved_text=True)
    contexts_list.append(contexts)
    answer_list.append(answer)

df = pd.DataFrame(
    {
        "question": question_list,
        "contexts": contexts_list,
        "answer": answer_list,
        "ground_truth": ground_truth_list,
    }
)
rag_results = Dataset.from_pandas(df)
df
/Users/eureka/miniconda3/envs/zilliz/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
  from .autonotebook import tqdm as notebook_tqdm
Answering questions: 100%|██████████| 3/3 [00:03<00:00,  1.04s/it]
pergunta contextos resposta ground_truth
0 quais são as especificações dos requisitos de hardware... [Requisitos de hardware\n\nAs seguintes especificaç... A especificação dos requisitos de hardware para a... Se queres construir o Milvus e correr a partir da fonte...
1 Qual é a linguagem de programação usada para escrever... [CMake & Conan\n\nA biblioteca de algoritmos do Mil... A linguagem de programação usada para escrever o Knowher... A linguagem de programação usada para escrever o Knowher...
2 O que deve ser assegurado antes de executar a cobertura de... [Cobertura de código\n\nAntes de submeter o seu pull ... Antes de executar a cobertura de código, deve ser... Antes de executar a cobertura de código, deve ...

Avaliação com Arize Phoenix

Usamos o Arize Phoenix para avaliar nosso pipeline de geração aumentada de recuperação (RAG), com foco em duas métricas principais:

  • Avaliação de alucinação: Determina se o conteúdo é factual ou alucinatório (informações não fundamentadas no contexto), garantindo a integridade dos dados.

    • Explicação da alucinação: Explica porque é que uma resposta é factual ou não.
  • Avaliação de QA: Avalia a exatidão das respostas do modelo às consultas de entrada.

    • Explicação de QA: Detalha por que uma resposta está correta ou incorreta.

Visão geral do Phoenix Tracing

O Phoenix fornece rastreamento compatível com OTEL para aplicativos LLM, com integrações para estruturas como Langchain, LlamaIndex e SDKs como OpenAI e Mistral. O rastreamento captura todo o fluxo de solicitações, oferecendo insights sobre:

  • Latência do aplicativo: Identificar e otimizar invocações LLM lentas e desempenho de componentes.
  • Uso de token: Divida o consumo de token para otimização de custos.
  • Exceções em tempo de execução: Capturar problemas críticos como limitação de taxa.
  • Documentos recuperados: Analise a recuperação, a pontuação e a ordem dos documentos.

Ao utilizar o rastreamento do Phoenix, é possível identificar gargalos, otimizar recursos e garantir a confiabilidade do sistema em várias estruturas e linguagens.

import phoenix as px
from phoenix.trace.openai import OpenAIInstrumentor

# To view traces in Phoenix, you will first have to start a Phoenix server. You can do this by running the following:
session = px.launch_app()

# Initialize OpenAI auto-instrumentation
OpenAIInstrumentor().instrument()
🌍 To view the Phoenix app in your browser, visit http://localhost:6006/
📖 For more information on how to use Phoenix, check out https://docs.arize.com/phoenix

Alt Text Texto alternativo

import nest_asyncio

from phoenix.evals import HallucinationEvaluator, OpenAIModel, QAEvaluator, run_evals

nest_asyncio.apply()  # This is needed for concurrency in notebook environments

# Set your OpenAI API key
eval_model = OpenAIModel(model="gpt-4o")

# Define your evaluators
hallucination_evaluator = HallucinationEvaluator(eval_model)
qa_evaluator = QAEvaluator(eval_model)

# We have to make some minor changes to our dataframe to use the column names expected by our evaluators
# for `hallucination_evaluator` the input df needs to have columns 'output', 'input', 'context'
# for `qa_evaluator` the input df needs to have columns 'output', 'input', 'reference'
df["context"] = df["contexts"]
df["reference"] = df["contexts"]
df.rename(columns={"question": "input", "answer": "output"}, inplace=True)
assert all(
    column in df.columns for column in ["output", "input", "context", "reference"]
)

# Run the evaluators, each evaluator will return a dataframe with evaluation results
# We upload the evaluation results to Phoenix in the next step
hallucination_eval_df, qa_eval_df = run_evals(
    dataframe=df,
    evaluators=[hallucination_evaluator, qa_evaluator],
    provide_explanation=True,
)
run_evals |██████████| 6/6 (100.0%) | ⏳ 00:03<00:00 |  1.64it/s
results_df = df.copy()
results_df["hallucination_eval"] = hallucination_eval_df["label"]
results_df["hallucination_explanation"] = hallucination_eval_df["explanation"]
results_df["qa_eval"] = qa_eval_df["label"]
results_df["qa_explanation"] = qa_eval_df["explanation"]
results_df.head()
entrada contextos saída verdade_do_terreno contexto referência avaliação_alucinação explicação_da_alucinação qa_eval qa_explicação
0 quais são as especificações dos requisitos de hardware... [Requisitos de hardware\n\nAs seguintes especificaç... A especificação dos requisitos de hardware para a... Se quiser construir o Milvus e correr a partir da fonte... [Requisitos de Hardware\n\nAs seguintes especificaç... [Requisitos de hardware\n\nAs seguintes especificaç... factual Para determinar se a resposta é factual ou... correta Para determinar se a resposta está correta, precisamos de...
1 Qual é a linguagem de programação utilizada para escrever... [CMake & Conan\n\nA biblioteca de algoritmos de Mil... A linguagem de programação usada para escrever o Knowher... A linguagem de programação usada para escrever o Knowher... [CMake & Conan\n\nA biblioteca de algoritmos de Mil... [CMake & Conan\n\nA biblioteca de algoritmos de Mil... factual Para determinar se a resposta é factual ou... correta Para determinar se a resposta está correta, precisamos de...
2 O que deve ser assegurado antes de executar a cobertu... [Cobertura de código\n\nAntes de submeter o seu pull ... Antes de executar a cobertura de código, deve ser... Antes de executar a cobertura de código, deve ser ... [Cobertura de código\n\nAntes de enviar seu pull ... [Cobertura de código\n\nAntes de enviar seu pull ... factual O texto de referência especifica que antes de executar... correta Para determinar se a resposta está correta, precisamos de...

Traduzido porDeepL

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started
Feedback

Esta página foi útil?