Usar avaliadores LLM predefinidos

Visão geral

MLflow fornece a integração LLM Scorers que MLflow envolve's research-backed LLM judges e pode avaliar traços em dimensões típicas de qualidade.

important

Normalmente, é possível começar a avaliação usando os avaliadores predefinidos, mas, à medida que a lógica do aplicativo e os critérios de avaliação se tornam mais complexos (ou o rastreamento do aplicativo não atende aos requisitos do avaliador), é necessário envolver o juiz subjacente em um avaliador personalizado ou criar um avaliador LLM personalizado.

dica

Quando usar marcadores personalizados em vez disso:

Seu aplicativo tem entradas/saídas complexas que pontuadores predefinidos não conseguem analisar
Você precisa avaliar a lógica comercial específica ou os critérios específicos do domínio
Você deseja combinar vários aspectos de avaliação em um único pontuador
Sua estrutura de rastreamento não corresponde aos requisitos predefinidos do marcador

Consulte o guia de avaliadores personal izados e o guia de juízes de LLM personalizados para obter exemplos detalhados.

Como funcionam os marcadores predefinidos

Após a aprovação de um Trace pelo site evaluate() ou pelo serviço de monitoramento, o pontuador predefinido:

Analisa o site trace para extrair os dados exigidos pelo juiz do LLM que ele envolve.
Chama o juiz do LLM para gerar um Feedback
- O Feedback contém uma pontuação yes/no junto com uma justificativa escrita explicando o raciocínio da pontuação.
Retorna o feedback ao chamador para anexá-lo ao Trace

nota

Para saber mais sobre como o MLflow passa entradas para um Scorer e anexa o Feedback resultante de um Scorer a um Trace, consulte o guia de conceito do Scorer.

Pré-requisitos

Execute o seguinte comando para instalar o MLflow 3.0 e o pacote OpenAI.
Bash
```
pip install --upgrade "mlflow[databricks]>=3.1.0" openai
```
Siga o início rápido do rastreamento para conectar seu ambiente de desenvolvimento a um experimento MLflow.

Etapa 1: criar um aplicativo de amostra para avaliar

Defina um aplicativo simples com um falso retriever.

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

Databricks-hosted LLMs
OpenAI-hosted LLMs

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"

Use o SDK nativo do OpenAI para se conectar a modelos hospedados pelo OpenAI. Selecione um modelo dentre os modelos OpenAI disponíveis.

Python
import mlflow
import os
import openai

# Ensure your OPENAI_API_KEY is set in your environment
# os.environ["OPENAI_API_KEY"] = "<YOUR_API_KEY>" # Uncomment and set if not globally configured

# Enable auto-tracing for OpenAI
mlflow.openai.autolog()

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

# Create an OpenAI client connected to OpenAI SDKs
client = openai.OpenAI()

# Select an LLM
model_name = "gpt-4o-mini"

Defina o aplicativo:

Python
from mlflow.entities import Document
from typing import List

# Retriever function called by the sample app
@mlflow.trace(span_type="RETRIEVER")
def retrieve_docs(query: str) -> List[Document]:
    return [
        Document(
            id="sql_doc_1",
            page_content="SELECT is a fundamental SQL command used to retrieve data from a database. You can specify columns and use a WHERE clause to filter results.",
            metadata={"doc_uri": "http://example.com/sql/select_statement"},
        ),
        Document(
            id="sql_doc_2",
            page_content="JOIN clauses in SQL are used to combine rows from two or more tables, based on a related column between them. Common types include INNER JOIN, LEFT JOIN, and RIGHT JOIN.",
            metadata={"doc_uri": "http://example.com/sql/join_clauses"},
        ),
        Document(
            id="sql_doc_3",
            page_content="Aggregate functions in SQL, such as COUNT(), SUM(), AVG(), MIN(), and MAX(), perform calculations on a set of values and return a single summary value.  The most common aggregate function in SQL is COUNT().",
            metadata={"doc_uri": "http://example.com/sql/aggregate_functions"},
        ),
    ]


# Sample app to evaluate
@mlflow.trace
def sample_app(query: str):
    # 1. Retrieve documents based on the query
    retrieved_documents = retrieve_docs(query=query)
    retrieved_docs_text = "\n".join([doc.page_content for doc in retrieved_documents])

    # 2. Prepare messages for the LLM
    messages_for_llm = [
        {
            "role": "system",
            # Fake prompt to show how the various scorers identify quality issues.
            "content": f"Answer the user's question based on the following retrieved context: {retrieved_docs_text}.  Do not mention the fact that provided context exists in your answer.  If the context is not relevant to the question, generate the best response you can.",
        },
        {
            "role": "user",
            "content": query,
        },
    ]

    # 3. Call LLM to generate the response
    return client.chat.completions.create(
        # Provide a valid model name for your LLM provider.
        model=model_name,
        messages=messages_for_llm,
    )
result = sample_app("what is select in sql?")
print(result)

Etapa 2: Criar uma avaliação de amostra dataset

nota

expected_facts só é necessário se você usar pontuadores predefinidos que exijam a verdade básica.

Python
eval_dataset = [
    {
        "inputs": {"query": "What is the most common aggregate function in SQL?"},
        "expectations": {
            "expected_facts": ["Most common aggregate function in SQL is COUNT()."],
        },
    },
    {
        "inputs": {"query": "How do I use MLflow?"},
        "expectations": {
            "expected_facts": [
                "MLflow is a tool for managing and tracking machine learning experiments."
            ],
        },
    },
]
print(eval_dataset)

Etapa 3: avaliação da execução com pontuadores predefinidos

Agora, vamos executar a avaliação com os avaliadores que definimos acima.

Python
from mlflow.genai.scorers import (
    Correctness,
    Guidelines,
    RelevanceToQuery,
    RetrievalGroundedness,
    RetrievalRelevance,
    RetrievalSufficiency,
    Safety,
)


# Run predefined scorers that require ground truth
mlflow.genai.evaluate(
    data=eval_dataset,
    predict_fn=sample_app,
    scorers=[
        Correctness(),
        # RelevanceToQuery(),
        # RetrievalGroundedness(),
        # RetrievalRelevance(),
        RetrievalSufficiency(),
        # Safety(),
    ],
)


# Run predefined scorers that do NOT require ground truth
mlflow.genai.evaluate(
    data=eval_dataset,
    predict_fn=sample_app,
    scorers=[
        # Correctness(),
        RelevanceToQuery(),
        RetrievalGroundedness(),
        RetrievalRelevance(),
        # RetrievalSufficiency(),
        Safety(),
        Guidelines(name="does_not_mention", guidelines="The response not mention the fact that provided context exists.")
    ],
)

Traços de avaliação

UI de avaliação

Marcadores disponíveis

Marcador	O que ele avalia?	Requer verdade fundamental?	Saiba mais
`RelevanceToQuery`	A resposta do aplicativo aborda diretamente a entrada do usuário?	Não	Resposta & Guia de relevância de contexto
`Safety`	A resposta do aplicativo evita conteúdo nocivo ou tóxico?	Não	Guia de segurança
`RetrievalGroundedness`	A resposta do aplicativo é baseada nas informações recuperadas?	Não	Guia de fundamentação
`RetrievalRelevance`	Os documentos recuperados são relevantes para a solicitação do usuário?	Não	Resposta & Guia de relevância de contexto
`Correctness`	A resposta do aplicativo está correta em comparação com a verdade fundamental?	Sim	Guia de correção
`RetrievalSufficiency`	Os documentos recuperados contêm todas as informações necessárias?	Sim	Guia de suficiência de contexto

Próximas etapas

Continue sua jornada com estas ações recomendadas e o tutorial.

Crie marcadores personalizados - Crie métricas baseadas em código para suas necessidades específicas
Criar pontuadores LLM personalizados - Projetar critérios de avaliação sofisticados usando LLMs
Avalie seu aplicativo - Veja pontuadores predefinidos em ação com um exemplo completo

Guia de referência

Explore a documentação detalhada dos conceitos e recursos mencionados neste guia.

Referência pré-construída de pontuadores & para juízes - Visão geral abrangente de todos os juízes disponíveis
Pontuadores - Entenda como os marcadores trabalham e seu papel na avaliação
Juízes do LLM - Saiba mais sobre a arquitetura subjacente do juiz

Visão geral​

Como funcionam os marcadores predefinidos​

Pré-requisitos​

Etapa 1: criar um aplicativo de amostra para avaliar​

Etapa 2: Criar uma avaliação de amostra dataset​

Etapa 3: avaliação da execução com pontuadores predefinidos​

Marcadores disponíveis​

Próximas etapas​

Guia de referência​