Pular para o conteúdo principal

Usar avaliadores LLM predefinidos

Visão geral​

O MLflow fornece LLM integrado Scorers que envolvem os juízes de LLM do MLflow apoiados por pesquisas e podem avaliar os 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:

  1. Analisa o site trace para extrair os dados exigidos pelo juiz do LLM que ele envolve.

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

  3. 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​

  1. Execute o seguinte comando para instalar o MLflow 3.0 e o pacote OpenAI.

    Bash
    pip install --upgrade "mlflow[databricks]>=3.1.0" openai

  2. 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​

Abaixo, definimos um aplicativo simples com um falso retriever.

Python
import os
import mlflow
from openai import OpenAI
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=mlflow_creds.token,
    base_url=f"{mlflow_creds.host}/serving-endpoints"
)


# 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 that we will 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(
        # 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_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.

Guia de referência​

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

Última atualização em