Juiz de suficiência de contexto &, goleador
O juiz predefinido judges.is_context_sufficient()
avalia se o contexto recuperado pelo seu sistema RAG ou gerado por uma chamada de ferramenta contém informações suficientes para responder adequadamente à solicitação do usuário com base no rótulo de verdade fornecido como expected_facts
ou um expected_response
.
Esse juiz está disponível por meio do avaliador predefinido RetrievalSufficiency
para avaliar os sistemas RAG em que o senhor precisa garantir que o processo de recuperação está fornecendo todas as informações necessárias.
Assinatura da API
from mlflow.genai.judges import is_context_sufficient
def is_context_sufficient(
*,
request: str, # User's question or query
context: Any, # Context to evaluate for relevance, can be any Python primitive or a JSON-seralizable dict
expected_facts: Optional[list[str]], # List of expected facts (provide either expected_response or expected_facts)
expected_response: Optional[str] = None, # Ground truth response (provide either expected_response or expected_facts)
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
-
Instale o site MLflow e o pacote necessário
Bashpip install --upgrade "mlflow[databricks]>=3.1.0"
-
Crie um experimento MLflow seguindo o início rápido de configuração do ambiente.
Uso direto do SDK
from mlflow.genai.judges import is_context_sufficient
# Example 1: Context contains sufficient information
feedback = is_context_sufficient(
request="What is the capital of France?",
context=[
{"content": "Paris is the capital of France."},
{"content": "Paris is known for its Eiffel Tower."}
],
expected_facts=["Paris is the capital of France."]
)
print(feedback.value) # "yes"
print(feedback.rationale) # Explanation of sufficiency
# Example 2: Context lacks necessary information
feedback = is_context_sufficient(
request="What are MLflow's components?",
context=[
{"content": "MLflow is an open-source platform."}
],
expected_facts=[
"MLflow has four main components",
"Components include Tracking",
"Components include Projects"
]
)
print(feedback.value) # "no"
print(feedback.rationale) # Explanation of what's missing
Usando o marcador pré-construído
O juiz is_context_sufficient
está disponível por meio do marcador pré-construído RetrievalSufficiency
.
Requisitos:
-
Requisitos de rastreamento :
- O MLflow Trace deve conter pelo menos um intervalo com
span_type
definido comoRETRIEVER
inputs
eoutputs
deve estar na extensão raiz do Trace
- O MLflow Trace deve conter pelo menos um intervalo com
-
Ground-truth rótulo : Obrigatório - o senhor deve fornecer
expected_facts
ouexpected_response
no dicionárioexpectations
import os
import mlflow
from openai import OpenAI
from mlflow.genai.scorers import RetrievalSufficiency
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 - 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="databricks-claude-3-7-sonnet",
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()]
)
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.
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:
from mlflow.genai.judges import is_context_sufficient
from mlflow.genai.scorers import scorer
from typing import Dict, Any
eval_dataset = [
{
"inputs": {"query": "What are the benefits of MLflow?"},
"outputs": {
"retrieved_context": [
{"content": "MLflow simplifies ML lifecycle management."},
{"content": "MLflow provides experiment tracking and model versioning."},
{"content": "MLflow enables easy model deployment."}
]
},
"expectations": {
"expected_facts": [
"MLflow simplifies ML lifecycle management",
"MLflow provides experiment tracking",
"MLflow enables model deployment"
]
}
},
{
"inputs": {"query": "How does MLflow handle model versioning?"},
"outputs": {
"retrieved_context": [
{"content": "MLflow is an open-source platform."}
]
},
"expectations": {
"expected_facts": [
"MLflow Model Registry handles versioning",
"Models can have multiple versions",
"Versions can be promoted through stages"
]
}
}
]
@scorer
def context_sufficiency_scorer(inputs: Dict[Any, Any], outputs: Dict[Any, Any], expectations: Dict[Any, Any]):
return is_context_sufficient(
request=inputs["query"],
context=outputs["retrieved_context"],
expected_facts=expectations["expected_facts"]
)
# Run evaluation
eval_results = mlflow.genai.evaluate(
data=eval_dataset,
scorers=[context_sufficiency_scorer]
)
Interpretando resultados
O juiz retorna um objeto Feedback
com:
value
: " sim " se o contexto for suficiente, " não " se insuficienterationale
: Explicação de quais fatos esperados estão cobertos ou ausentes no contexto
Próximas etapas
- Avalie a relevância do contexto - Garanta que os documentos recuperados sejam relevantes antes de verificar a suficiência
- Avalie a fundamentação - Verifique se as respostas usam somente o contexto fornecido
- Criar conjunto de dados de avaliação - Criar conjunto de dados de verdade com fatos esperados para teste