Partilhar via

Desenvolver pontuadores baseados em código

No MLflow Evaluation for GenAI, pontuadores personalizados baseados em código permitem que você defina métricas de avaliação flexíveis para seu agente ou aplicativo de IA.

À medida que você desenvolve marcadores, muitas vezes você precisará iterar rapidamente. Use este fluxo de trabalho do desenvolvedor para atualizar seu marcador sem executar novamente todo o aplicativo a cada vez:

  1. Definir dados de avaliação
  2. Gerar rastreamentos a partir da sua aplicação
  3. Consultar e armazenar os rastreamentos resultantes
  4. À medida que você itera em seu marcador, avalie usando os rastreamentos armazenados

O bloco de anotações de exemplo contém todo o código deste tutorial.

Pré-requisitos: configurar o MLflow e definir seu aplicativo

Atualize mlflow[databricks] para a versão mais recente para a melhor experiência GenAI e instale openai , já que o aplicativo de exemplo abaixo usa o cliente OpenAI.

%pip install -q --upgrade "mlflow[databricks]>=3.1" openai
dbutils.library.restartPython()

A mlflow.openai.autolog() chamada abaixo instrumenta automaticamente a aplicação com MLflow Tracing. Os traços registados serão os inputs para os pontuadores durante a avaliação.

import mlflow

mlflow.openai.autolog()

# If running outside of Databricks, set up MLflow tracking to Databricks.
# mlflow.set_tracking_uri("databricks")

# In Databricks notebooks, the experiment defaults to the notebook experiment.
# mlflow.set_experiment("/Shared/docs-demo")

Use o MLflow para obter um cliente OpenAI que se conecta a LLMs hospedados pelo Databricks. Selecione um modelo entre os modelos de fundação disponíveis:

from databricks.sdk import WorkspaceClient

# 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"

Crie um aplicativo de assistente de resposta a perguntas simples para este tutorial:

@mlflow.trace
def sample_app(messages: list[dict[str, str]]):
    # 1. Prepare messages for the LLM
    messages_for_llm = [
        {"role": "system", "content": "You are a helpful assistant."},
        *messages,
    ]

    # 2. Call LLM to generate a response
    response = client.chat.completions.create(
        model= model_name,
        messages=messages_for_llm,
    )
    return response.choices[0].message.content


sample_app([{"role": "user", "content": "What is the capital of France?"}])

Passo 1: Definir dados de avaliação

Os dados de avaliação abaixo são uma lista de pedidos para o LLM responder. Para este aplicativo, as solicitações podem ser perguntas simples ou conversas com várias mensagens.

eval_dataset = [
    {
        "inputs": {
            "messages": [
                {"role": "user", "content": "How much does a microwave cost?"},
            ]
        },
    },
    {
        "inputs": {
            "messages": [
                {
                    "role": "user",
                    "content": "Can I return the microwave I bought 2 months ago?",
                },
            ]
        },
    },
    {
        "inputs": {
            "messages": [
                {
                    "role": "user",
                    "content": "I'm having trouble with my account.  I can't log in.",
                },
                {
                    "role": "assistant",
                    "content": "I'm sorry to hear that you're having trouble with your account.  Are you using our website or mobile app?",
                },
                {"role": "user", "content": "Website"},
            ]
        },
    },
]

Etapa 2: gerar rastreamentos a partir do seu aplicativo

Use mlflow.genai.evaluate() para gerar rastreamentos a partir do aplicativo. Como evaluate() requer pelo menos um marcador, defina um marcador de espaço reservado para esta geração inicial de rastreamento:

from mlflow.genai.scorers import scorer

@scorer
def placeholder_metric() -> int:
    # placeholder return value
    return 1

Execute a avaliação usando o avaliador de espaço reservado:

eval_results = mlflow.genai.evaluate(
    data=eval_dataset,
    predict_fn=sample_app,
    scorers=[placeholder_metric]
)

Depois de executar o código acima, você deve ter um rastreamento em seu experimento para cada linha em seu conjunto de dados de avaliação. Os Notebooks Databricks também exibem visualizações de rastreamento como parte dos resultados das células. A resposta gerada pelo LLM durante a avaliação aparece no campo sample_app da interface de rastreamento do bloco de notas e na coluna Resposta da interface do usuário do experimento MLflow.

Rastreamentos de amostra gerados

Etapa 3: Consultar e armazenar os rastreamentos resultantes

Armazene os rastreamentos gerados em uma variável local. A mlflow.search_traces() função retorna um Pandas DataFrame de rastreamentos.

generated_traces = mlflow.search_traces(run_id=eval_results.run_id)
generated_traces

Passo 4: À medida que itera no seu avaliador, chame evaluate() usando os rastreamentos armazenados

Passe o Pandas DataFrame de rastreamentos diretamente para evaluate() como um conjunto de dados de entrada. Isto permite que revises rapidamente a tua métrica sem teres de executar novamente a tua aplicação. O código abaixo executa um novo avaliador nos dados pré-calculados generated_traces.

from mlflow.genai.scorers import scorer

@scorer
def response_length(outputs: str) -> int:
    # Example metric.
    # Implement your actual metric logic here.
    return len(outputs)

# Note the lack of a predict_fn parameter.
mlflow.genai.evaluate(
    data=generated_traces,
    scorers=[response_length],
)

Exemplo de bloco de notas

O bloco de notas seguinte inclui todo o código desta página.

Fluxo de trabalho do desenvolvedor para avaliadores baseados em código na Avaliação do MLflow

Obter bloco de notas

Próximos passos

  • Last updated on