Pular para o conteúdo principal
Última atualização em

Juiz de Suficiência de Recuperação

O juiz RetrievalSufficiency avalia se o contexto recuperado (de aplicativos RAG, agentes ou qualquer sistema que recupere documentos) contém informações suficientes para responder adequadamente à solicitação do usuário com base no rótulo de verdade básica fornecido como expected_facts ou um expected_response.

Este juiz LLM integrado foi projetado para avaliar sistemas RAG onde você precisa garantir que seu processo de recuperação esteja fornecendo todas as informações necessárias.

Pré-requisitos para executar os exemplos​

  1. Instale o site MLflow e o pacote necessário

    Bash
    pip install --upgrade "mlflow[databricks]>=3.4.0"

  2. Crie um experimento MLflow seguindo o início rápido de configuração do ambiente.

Exemplos de uso​

O juiz RetrievalSufficiency pode ser invocado diretamente para avaliação de traços individuais ou usado com a estrutura de avaliação do MLflow para avaliação de lotes.

Requisitos:

  • Requisitos de rastreamento :

    • O MLflow Trace deve conter pelo menos um intervalo com span_type definido como RETRIEVER
    • inputs e outputs deve estar na extensão raiz do Trace

  • Ground-truth rótulo : Obrigatório - o senhor deve fornecer expected_facts ou expected_response no dicionário expectations

Python
from mlflow.genai.scorers import retrieval_sufficiency
import mlflow

# Get a trace from a previous run
trace = mlflow.get_trace("<your-trace-id>")

# Assess if the retrieved context is sufficient for the expected facts
feedback = retrieval_sufficiency(
    trace=trace,
    expectations={
        "expected_facts": [
            "MLflow has four main components",
            "Components include Tracking",
            "Components include Projects",
            "Components include Models",
            "Components include Registry"
        ]
    }
)
print(feedback)

Exemplo RAG​

Aqui está um exemplo completo mostrando como criar um aplicativo RAG e avaliar se o contexto recuperado é suficiente:

  1. Inicialize um cliente OpenAI para se conectar a LLMs hospedados pela Databricks ou LLMs hospedados pela OpenAI.

Use o MLflow para obter um cliente OpenAI que se conecta aos LLMs hospedados pela Databricks. Selecione um modelo dentre os modelos de base disponíveis.

Python
import mlflow
from databricks.sdk import WorkspaceClient

# Enable MLflow's autologging to instrument your application with Tracing
mlflow.openai.autolog()

# Set up MLflow tracking to Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/docs-demo")

# Create an OpenAI client that is connected to Databricks-hosted LLMs
w = WorkspaceClient()
client = w.serving_endpoints.get_open_ai_client()

# Select an LLM
model_name = "databricks-claude-sonnet-4"

  1. Defina e avalie sua aplicação RAG:

    Python
    from mlflow.genai.scorers import RetrievalSufficiency
    from mlflow.entities import Document
    from typing import List


    # Define a retriever function with proper span type
    @mlflow.trace(span_type="RETRIEVER")
    def retrieve_docs(query: str) -> List[Document]:
        # Simulated retrieval - some queries return insufficient context
        if "capital of france" in query.lower():
            return [
                Document(
                    id="doc_1",
                    page_content="Paris is the capital of France.",
                    metadata={"source": "geography.txt"}
                ),
                Document(
                    id="doc_2",
                    page_content="France is a country in Western Europe.",
                    metadata={"source": "countries.txt"}
                )
            ]
        elif "mlflow components" in query.lower():
            # Incomplete retrieval - missing some components
            return [
                Document(
                    id="doc_3",
                    page_content="MLflow has multiple components including Tracking and Projects.",
                    metadata={"source": "mlflow_intro.txt"}
                )
            ]
        else:
            return [
                Document(
                    id="doc_4",
                    page_content="General information about data science.",
                    metadata={"source": "ds_basics.txt"}
                )
            ]

    # Define your RAG app
    @mlflow.trace
    def rag_app(query: str):
        # Retrieve documents
        docs = retrieve_docs(query)
        context = "\n".join([doc.page_content for doc in docs])

        # Generate response
        messages = [
            {"role": "system", "content": f"Answer based on this context: {context}"},
            {"role": "user", "content": query}
        ]

        response = client.chat.completions.create(
            # This example uses Databricks hosted Claude.  If you provide your own OpenAI credentials, replace with a valid OpenAI model e.g., gpt-4o, etc.
            model=model_name,
            messages=messages
        )

        return {"response": response.choices[0].message.content}

    # Create evaluation dataset with ground truth
    eval_dataset = [
        {
            "inputs": {"query": "What is the capital of France?"},
            "expectations": {
                "expected_facts": ["Paris is the capital of France."]
            }
        },
        {
            "inputs": {"query": "What are all the MLflow components?"},
            "expectations": {
                "expected_facts": [
                    "MLflow has four main components",
                    "Components include Tracking",
                    "Components include Projects",
                    "Components include Models",
                    "Components include Registry"
                ]
            }
        }
    ]

    # Run evaluation with RetrievalSufficiency scorer
    eval_results = mlflow.genai.evaluate(
        data=eval_dataset,
        predict_fn=rag_app,
        scorers=[
            RetrievalSufficiency(
                model="databricks:/databricks-gpt-oss-120b",  # Optional. Defaults to custom Databricks model.
            )
        ]
    )

Compreenda os resultados​

O marcador RetrievalSufficiency avalia cada extensão do retriever separadamente. Isso vai:

  • Retorno "yes" se os documentos recuperados contiverem todas as informações necessárias para gerar os fatos esperados
  • Retornar "no" se os documentos recuperados estiverem faltando informações críticas, juntamente com uma justificativa explicando o que está faltando

Isso ajuda o senhor a identificar quando o sistema de recuperação não está conseguindo obter todas as informações necessárias, o que é uma causa comum de respostas incompletas ou incorretas em aplicativos RAG.

Selecione o LLM que capacita o juiz.​

Por default, esses juízes usam um LLM hospedado Databricks , projetado para realizar avaliações de qualidade do GenAI. Você pode alterar o modelo de juiz usando o argumento model na definição do juiz. O modelo deve ser especificado no formato <provider>:/<model-name>, onde <provider> é um provedor de modelo compatível com LiteLLM. Se você usar databricks como provedor de modelo, o nome do modelo será o mesmo que o nome do endpoint de serviço.

Você pode personalizar o juiz fornecendo um modelo de juiz diferente:

Python
from mlflow.genai.scorers import RetrievalSufficiency

# Use a different judge model
sufficiency_judge = RetrievalSufficiency(
    model="databricks:/databricks-gpt-5-mini"  # Or any LiteLLM-compatible model
)

# Use in evaluation
eval_results = mlflow.genai.evaluate(
    data=eval_dataset,
    predict_fn=rag_app,
    scorers=[sufficiency_judge]
)

Para obter uma lista dos modelos suportados, consulte a documentação do MLflow.

Interpretar resultados​

O juiz retorna um objeto Feedback com:

  • value : " sim " se o contexto for suficiente, " não " se insuficiente
  • rationale : Explicação de quais fatos esperados o contexto abrange ou não.

Próximos passos​