Pular para o conteúdo principal

Juiz de Recuperação de Fundamentos

O juiz RetrievalGroundedness avalia se a resposta do seu aplicativo é factualmente apoiada pelo contexto fornecido (de um sistema RAG ou gerado por uma chamada de ferramenta), ajudando a detectar alucinações ou declarações não apoiadas por esse contexto.

Este juiz LLM integrado foi projetado para avaliar aplicações RAG que precisam garantir que as respostas sejam baseadas nas informações recuperadas.

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 RetrievalGroundedness 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
  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 RetrievalGroundedness
    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 based on query
        if "mlflow" in query.lower():
            return [
                Document(
                    id="doc_1",
                    page_content="MLflow is an open-source platform for managing the ML lifecycle.",
                    metadata={"source": "mlflow_docs.txt"}
                ),
                Document(
                    id="doc_2",
                    page_content="MLflow provides tools for experiment tracking, model packaging, and deployment.",
                    metadata={"source": "mlflow_features.txt"}
                )
            ]
        else:
            return [
                Document(
                    id="doc_3",
                    page_content="Machine learning involves training models on data.",
                    metadata={"source": "ml_basics.txt"}
                )
            ]

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

        # Generate response using LLM
        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
    eval_dataset = [
        {
            "inputs": {"query": "What is MLflow used for?"}
        },
        {
            "inputs": {"query": "What are the main features of MLflow?"}
        }
    ]

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

Personalização​

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

Python
from mlflow.genai.scorers import RetrievalGroundedness

# Use a different judge model
groundedness_judge = RetrievalGroundedness(
    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=[groundedness_judge]
)

Interpretando resultados​

O juiz retorna um objeto Feedback com:

  • value : " sim " se a resposta for fundamentada, " não " se contiver alucinações
  • rationale : Explicação detalhada identificando:
    • Quais declarações são apoiadas pelo contexto
    • Quais afirmações carecem de apoio (alucinações)
    • Citações específicas do contexto que apoiam ou contradizem afirmações

Próximas etapas​

Última atualização em