Pular para o conteúdo principal

Fundamento: juiz & goleador

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

Esse juiz está disponível por meio do pontuador predefinido RetrievalGroundedness para avaliar os aplicativos RAG que precisam garantir que as respostas sejam fundamentadas nas informações recuperadas.

Assinatura da API

Python
from mlflow.genai.judges import is_grounded

def is_grounded(
*,
request: str, # User's original query
response: str, # Application's response
context: Any, # Context to evaluate for relevance, can be any Python primitive or a JSON-seralizable dict
name: Optional[str] = None # Optional custom name for display in the MLflow UIs
) -> mlflow.entities.Feedback:
"""Returns Feedback with 'yes' or 'no' value and a rationale"""

Pré-requisitos para executar os exemplos

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

    Bash
    pip install --upgrade "mlflow[databricks]>=3.1.0"
  2. Crie um experimento MLflow seguindo o início rápido de configuração do ambiente.

Uso direto do SDK

Python
from mlflow.genai.judges import is_grounded

# Example 1: Response is grounded in context
feedback = is_grounded(
request="What is the capital of France?",
response="Paris",
context=[
{"content": "Paris is the capital of France."},
{"content": "Paris is known for its Eiffel Tower."}
]
)
print(feedback.value) # "yes"
print(feedback.rationale) # Explanation of groundedness

# Example 2: Response contains hallucination
feedback = is_grounded(
request="What is the capital of France?",
response="Paris, which has a population of 10 million people",
context=[
{"content": "Paris is the capital of France."}
]
)
print(feedback.value) # "no"
print(feedback.rationale) # Identifies unsupported claim about population

Usando o marcador pré-construído

O juiz is_grounded está disponível por meio do marcador pré-construído RetrievalGroundedness.

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
Python
import os
import mlflow
from openai import OpenAI
from mlflow.genai.scorers import RetrievalGroundedness
from mlflow.entities import Document
from typing import List

mlflow.openai.autolog()

# Connect to a Databricks LLM via OpenAI using the same credentials as MLflow
# Alternatively, you can use your own OpenAI credentials here
mlflow_creds = mlflow.utils.databricks_utils.get_databricks_host_creds()
client = OpenAI(
api_key=cred.token,
base_url=f"{cred.host}/serving-endpoints"
)

# 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="databricks-claude-3-7-sonnet",
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()]
)

Usando em um marcador personalizado

Ao avaliar aplicativos com estruturas de dados diferentes dos requisitos do pontuador predefinido, envolva o juiz em um marcador personalizado:

Python
from mlflow.genai.judges import is_grounded
from mlflow.genai.scorers import scorer
from typing import Dict, Any

eval_dataset = [
{
"inputs": {"query": "What is MLflow used for?"},
"outputs": {
"response": "MLflow is used for managing the ML lifecycle, including experiment tracking and model deployment.",
"retrieved_context": [
{"content": "MLflow is a platform for managing the ML lifecycle."},
{"content": "MLflow includes capabilities for experiment tracking, model packaging, and deployment."}
]
}
},
{
"inputs": {"query": "Who created MLflow?"},
"outputs": {
"response": "MLflow was created by Databricks in 2018 and has over 10,000 contributors.",
"retrieved_context": [
{"content": "MLflow was created by Databricks."},
{"content": "MLflow was open-sourced in 2018."}
]
}
}
]

@scorer
def groundedness_scorer(inputs: Dict[Any, Any], outputs: Dict[Any, Any]):
return is_grounded(
request=inputs["query"],
response=outputs["response"],
context=outputs["retrieved_context"]
)

# Run evaluation
eval_results = mlflow.genai.evaluate(
data=eval_dataset,
scorers=[groundedness_scorer]
)

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