Pular para o conteúdo principal

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.

Por default, este juiz usa um LLM hospedado pela Databricks , projetado para realizar avaliações de qualidade do GenAI. Você pode alterar o modelo do 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 o provedor do modelo, o nome do modelo será o mesmo que o nome endpoint de serviço.

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.

Uso com mlflow.evaluate()​

O juiz RetrievalSufficiency pode ser usado diretamente com a estrutura de avaliação do MLflow.

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

  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. Use o juiz:

    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.
            )
        ]
    )

Entendendo 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.

Personalizaçã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]
)

Interpretando 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 estão cobertos ou ausentes no contexto

Próximas etapas​

Última atualização em