Monitore os aplicativos GenAI em produção.

info

Beta

Este recurso está em versão Beta. Os administradores do espaço de trabalho podem controlar o acesso a este recurso na página de Pré-visualizações . Veja as prévias do Gerenciador Databricks.

O monitoramento de produção permite a execução automática de avaliadores MLflow 3 em rastreamentos de seus aplicativos GenAI para avaliar continuamente a qualidade. Você programa avaliadores em relação a um experimento MLflow , e o serviço de monitoramento avalia uma amostra configurável de rastreamentos recebidos. Os resultados são anexados como feedback a cada traçado avaliado.

O monitoramento da produção inclui o seguinte:

• Avaliação automatizada da qualidade usando avaliadores integrados ou personalizados, incluindo avaliadores de múltiplas interações para avaliar conversas inteiras.
• Taxas de amostragem configuráveis para que você possa controlar a compensação entre cobertura e custo computacional.
• Use os mesmos avaliadores no desenvolvimento e na produção para garantir uma avaliação consistente.
• Avaliação contínua da qualidade com monitoramento em segundo plano.

nota

MLflow O monitoramento da produção 3 é compatível com os registros de traços do site MLflow 2.

Pré-requisitos

Antes de configurar o monitoramento de produção, certifique-se de ter:

• ExperimentoMLflow : Um experimento MLflow onde os rastreamentos estão sendo registrados. Caso nenhum experimento seja especificado, o experimento ativo será utilizado.

• Aplicação de produção instrumentada : Seu aplicativo GenAI deve log rastreamentos usando MLflow Tracing. Consulte o guia de Rastreamento de Produção.

• Pontuadores definidos : Pontuadores testados que funcionam com o formato de rastreamento do seu aplicativo. Se você usou seu aplicativo de produção como o predict_fn em mlflow.genai.evaluate() durante o desenvolvimento, seus avaliadores provavelmente já são compatíveis.

• IDSQL warehouse (para rastreamentos Unity Catalog ) : Se seus rastreamentos estiverem armazenados no Unity Catalog, você deve configurar um ID SQL warehouse para que o monitoramento funcione. Consulte Ativar o monitoramento de produção.

Comece agora

Para configurar o monitoramento de produção, você registra um scorer em seu experimento MLflow e, em seguida, o inicia com uma configuração de amostragem. Este padrão de duas etapas (.register() então .start()) aplica-se a todos os tipos de pontuadores.

nota

A qualquer momento, no máximo 20 avaliadores podem estar associados a um experimento para monitoramento contínuo da qualidade.

Para mais informações sobre os pontuadores, veja o seguinte:

• Avaliadores e juízes de LLM
• Juízes personalizados
• Crie marcadores personalizados baseados em código

As seções a seguir descrevem como usar os diferentes tipos de juízes e como combiná-los. Expanda uma seção para saber mais.

Crie e programe juízes LLM usando a interface do usuário.

Crie e programe juízes LLM usando a interface do usuário.

Você pode usar a interface de usuário de experimentos do MLflow para criar e testar sistemas de pontuação com base em avaliadores de mestrado em direito (LLM).

Para criar um novo juiz de LLM:

1. Acesse a tab "Juízes" na interface de usuário do experimento MLflow .

   

2. Clique em Novo juiz de LLM .

   

3. Especifique o que o avaliador irá avaliar selecionando "Traços" ou "Sessões" .

4. Digite o nome do juiz.

5. Clique na seta conforme mostrado para exibir a seção Critérios de avaliação .

   

6. No menu suspenso, selecione o tipo de juiz. Alguns tipos de juízes permitem inserir instruções personalizadas, incluindo variáveis.

7. Clique na seta conforme mostrado para exibir a seção de avaliação automática .

   

8. Configure a ativação/desativação da execução em todos os rastreamentos futuros conforme desejado.

9. (Opcional) Em Configurações avançadas , ajuste a Taxa de amostragem e as Cadeias de filtro para controlar quais traçados serão avaliados.

10. (Opcional) Para testar o novo juiz em um conjunto de registros existentes:

    1. Clique em Selecionar traços no painel esquerdo. Aparece uma janela pop-up.
    2. Selecione os rastros para execução e clique em Selecionar (n) .
    3. Clique em executar juiz . Os traçados são avaliados e os resultados são exibidos.
    4. Analise os resultados. Use os botões Próximo e Anterior para percorrer os resultados de cada rastreamento selecionado.
    5. Se necessário, edite o juiz e faça ajustes até ficar satisfeito com o desempenho dele.

11. Para criar o juiz, clique em Criar juiz .

Não é possível criar um avaliador de código personalizado usando a interface do usuário. Para visualizar o código padrão que você pode copiar para o seu Notebook e editar conforme necessário, faça o seguinte:

1. Clique na seta dropdown ao lado do botão Novo juiz LLM e selecione Juiz de código personalizado .

   

2. Uma janela pop-up aparece com instruções e código padrão mostrando como definir e executar o juiz de código personalizado.

Use juízes LLM integrados

Use juízes LLM integrados

MLflow oferece diversos juízes LLM integrados que você pode usar imediatamente.

Python

from mlflow.genai.scorers import Safety, ScorerSamplingConfig

# Register the scorer with a name and start monitoring
safety_judge = Safety().register(name="my_safety_judge")  # name must be unique to experiment
safety_judge = safety_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.7))

Por default, cada juiz usa um LLM hospedado Databricks , projetado para realizar avaliações de qualidade do GenAI. Você pode alterar o modelo do juiz para usar um endpoint do modelo de atendimento Databricks usando o argumento model na definição do pontuador. O modelo deve ser especificado no formato databricks:/<databricks-serving-endpoint-name>.

Python

safety_judge = Safety(model="databricks:/databricks-gpt-oss-20b").register(name="my_custom_safety_judge")

Utilize as diretrizes para juízes do LLM

Diretrizes de uso para juízes do LLM

As diretrizes para o exame LLM definem que os avaliadores devem analisar as entradas e saídas usando critérios de linguagem natural de aprovação/reprovação.

Python

from mlflow.genai.scorers import Guidelines

# Create and register the guidelines scorer
english_judge = Guidelines(
  name="english",
  guidelines=["The response must be in English"]
).register(name="is_english")  # name must be unique to experiment

# Start monitoring with the specified sample rate
english_judge = english_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.7))

Assim como os juízes integrados, você pode alterar o modelo do juiz para usar um endpoint do modelo servindo Databricks .

Python

english_judge = Guidelines(
  name="english",
  guidelines=["The response must be in English"],
  model="databricks:/databricks-gpt-oss-20b",
).register(name="custom_is_english")

Use juízes LLM com instruções personalizadas.

Use juízes LLM com prompts personalizados

Para maior flexibilidade do que os avaliadores das Diretrizes, utilize os Avaliadores LLM com instruções personalizadas , que permitem uma avaliação de qualidade em vários níveis com categorias de escolha personalizáveis.

Python

from typing import Literal
from mlflow.genai import make_judge
from mlflow.genai.scorers import ScorerSamplingConfig

# Create a custom judge using make_judge
formality_judge = make_judge(
    name="formality",
    instructions="""You will look at the response and determine the formality of the response.

Request: {{ inputs }}
Response: {{ outputs }}

Evaluate whether the response is formal, somewhat formal, or not formal.
A response is somewhat formal if it mentions friendship, etc.""",
    feedback_value_type=Literal["formal", "semi_formal", "not_formal"],
    model="databricks:/databricks-gpt-oss-20b",  # optional
)

# Register the custom judge and start monitoring
registered_judge = formality_judge.register(name="my_formality_judge")  # name must be unique to experiment
registered_judge = registered_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.1))

Use funções de pontuação personalizadas

Use funções personalizadas de pontuação

Para máxima flexibilidade, defina e utilize uma função de pontuação personalizada.

:::importante Requisitos de pontuação personalizados para monitoramento de produção

• Apenas os avaliadores baseados em decoradores @scorer são suportados. Subclasses baseadas em classes Scorer não podem ser registradas para monitoramento de produção. Se você precisar de um avaliador baseado em classe, refatore-o para usar o decorador @scorer em vez disso.
• Os avaliadores devem ser definidos e registrados a partir de um Notebook Databricks . O serviço de monitoramento serializa o código da função de pontuação para execução remota, e essa serialização requer o ambiente Notebook. Os indicadores de pontuação definidos em arquivos Python independentes ou em ambientes IDE locais não podem ser serializados para monitoramento em produção.
• Os marcadores devem ser autossuficientes. Como as funções de pontuação são serializadas como código para execução remota, todas as importações devem ser feitas diretamente no corpo da função. A função não pode referenciar variáveis, objetos ou módulos definidos fora dela.

:::

Ao definir avaliadores personalizados, não utilize dicas de tipo que precisem ser importadas na assinatura da função. Se o corpo da função de avaliação usar pacotes que precisam ser importados, importe-os diretamente na função para garantir a serialização correta.

Alguns pacotes estão disponíveis em default sem a necessidade de uma importação inline. Estes incluem databricks-agents, mlflow-skinny, openai e todos os pacotes incluídos na versão 2 do ambiente sem servidor.

Python

from mlflow.genai.scorers import scorer, ScorerSamplingConfig


# Custom metric: Check if response mentions Databricks
@scorer
def mentions_databricks(outputs):
    """Check if the response mentions Databricks"""
    return "databricks" in str(outputs.get("response", "")).lower()

# Register and start monitoring
databricks_scorer = mentions_databricks.register(name="databricks_mentions")
databricks_scorer = databricks_scorer.start(sampling_config=ScorerSamplingConfig(sample_rate=0.5))

Para obter mais exemplos de pontuadores personalizados, consulte Criar pontuadores personalizados baseados em código.

Use juízes de múltiplas rodadas

Use juízes de múltiplas rodadas

O monitoramento de produção oferece suporte a avaliadores de múltiplas interações que avaliam conversas inteiras em vez de registros individuais. Esses avaliadores analisam padrões de qualidade em múltiplas interações, como a frustração do usuário e a completude da conversa. Os juízes de múltiplas voltas são registrados e começam da mesma forma que os juízes de volta única.

O trabalho de monitoramento agrupa automaticamente os rastreamentos em conversas com base na tag mlflow.trace.session . O recurso de julgamentos de múltiplas rodadas avalia a execução após uma conversa ser considerada completa — por default, uma conversa é considerada completa quando nenhum novo rastreamento com esse ID de sessão é ingerido por 5 minutos . Para configurar este buffer, configure a MLFLOW_ONLINE_SCORING_DEFAULT_SESSION_COMPLETION_BUFFER_SECONDS variável de ambiente no Job de monitoramento.

Para obter a lista completa de juízes de múltiplas rodadas disponíveis, consulte Juízes de múltiplas rodadas. Para obter detalhes sobre a avaliação de conversas, consulte Avaliar conversas.

nota

To use multi-turn judges, your agent must set session IDs on traces. See Track users and sessions for details.

Python

from mlflow.genai.scorers import (
    ConversationCompleteness,
    UserFrustration,
    ScorerSamplingConfig,
)

# Register and start multi-turn judges just like single-turn judges
completeness_scorer = ConversationCompleteness().register(name="conversation_completeness")
completeness_scorer = completeness_scorer.start(
    sampling_config=ScorerSamplingConfig(sample_rate=1.0),
)

frustration_scorer = UserFrustration().register(name="user_frustration")
frustration_scorer = frustration_scorer.start(
    sampling_config=ScorerSamplingConfig(sample_rate=1.0),
)

Juízes Combinados

Juízes Combinados

É possível combinar juízes de turno único e juízes de múltiplos turnos no mesmo experimento. registrar e começar cada artilheiro individualmente.

Python

from mlflow.genai.scorers import Safety, Guidelines, UserFrustration, ScorerSamplingConfig

# Single-turn judges
safety_judge = Safety().register(name="safety")
safety_judge = safety_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=1.0))

english_judge = Guidelines(
    name="english",
    guidelines=["The response must be in English"]
).register(name="is_english")
english_judge = english_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.5))

# Multi-turn judge
frustration_judge = UserFrustration().register(name="frustration")
frustration_judge = frustration_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.3))

visualizar resultados

Após programar os avaliadores, aguarde 15 a 20 minutos para o processamento inicial. Então:

1. Navegue até o seu experimento MLflow.
2. Abra o Traces tab para visualizar as avaliações anexadas aos traços.
3. Utilize os painéis de monitoramento para acompanhar as tendências de qualidade.

Para juízes com múltiplas rodadas, as avaliações são anexadas ao primeiro traçado em cada sessão. Consulte a seção "Como as avaliações são armazenadas" para obter mais detalhes.

Melhores práticas

Estratégia de amostragem

• Para pontuações críticas, como verificações de segurança, use sample_rate=1.0.

• Para avaliadores caros, como juízes LLM complexos, use taxas de amostragem mais baixas (0,05-0,2).

• Para melhoria iterativa durante o desenvolvimento, use taxas moderadas (0,3-0,5).

• Equilibre a cobertura com o custo, conforme mostrado nos exemplos a seguir:

  Python

  # High-priority scorers: higher sampling
  safety_judge = Safety().register(name="safety")
  safety_judge = safety_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=1.0))  # 100% coverage for critical safety
  
  # Expensive scorers: lower sampling
  complex_scorer = ComplexCustomScorer().register(name="complex_analysis")
  complex_scorer = complex_scorer.start(sampling_config=ScorerSamplingConfig(sample_rate=0.05))  # 5% for expensive operations

Rastreamento de filtros

Use o parâmetro filter_string em ScorerSamplingConfig para controlar quais traços um avaliador avalia. Isso usa a mesma sintaxe de filtro que mlflow.search_traces().

Python

from mlflow.genai.scorers import Safety, ScorerSamplingConfig

# Only evaluate traces that completed successfully
safety_judge = Safety().register(name="safety")
safety_judge = safety_judge.start(
    sampling_config=ScorerSamplingConfig(
        sample_rate=1.0,
        filter_string="attributes.status = 'OK'"
    ),
)

Você pode combinar várias condições:

Python

import time

# Evaluate successful traces from the last 24 hours
one_day_ago = int((time.time() - 86400) * 1000)
safety_judge = safety_judge.start(
    sampling_config=ScorerSamplingConfig(
        sample_rate=0.5,
        filter_string=f"attributes.status = 'OK' AND attributes.timestamp_ms > {one_day_ago}"
    ),
)

Design de marcador personalizado

Mantenha os marcadores personalizados independentes, conforme mostrado no exemplo a seguir:

Python

@scorer
def well_designed_scorer(inputs, outputs):
    # All imports inside the function
    import re
    import json

    # Handle missing data gracefully
    response = outputs.get("response", "")
    if not response:
        return 0.0

    # Return consistent types
    return float(len(response) > 100)

Solução de problemas

Os marcadores não estão correndo

Se os marcadores não estiverem em execução, verifique o seguinte:

1. Verifique o experimento : certifique-se de que os rastreamentos são registros do experimento, e não de execuções individuais.
2. Taxa de amostragem : Com taxas de amostragem baixas, pode demorar para ver os resultados.
3. Verifique as strings de filtro : Certifique-se de que seu filter_string corresponda aos rastreamentos reais.

Problemas de serialização

Os indicadores personalizados para monitoramento de produção são serializados para que possam ser executados remotamente pelo serviço de monitoramento. Isso impõe diversas restrições:

• RequisitoNotebook : Funções personalizadas @scorer devem ser definidas e registradas a partir de um Notebook Databricks . O mecanismo de serialização depende do ambiente Notebook.
• Funções autocontidas : Todas as importações devem estar embutidas no corpo da função. Referências a variáveis externas, módulos ou objetos definidos fora da função não são capturadas durante a serialização.
• Não há avaliadores baseados em classes : apenas avaliadores baseados em decoradores @scorer podem ser registrados. Subclasses baseadas em classes Scorer não podem ser serializadas para execução remota.
• Sem dicas de tipo que exigem importações : Dicas de tipo na assinatura da função que exigem instruções de importação (por exemplo, List de typing) causam falhas de serialização.

Ao criar um marcador personalizado, inclua as importações na definição da função.

Python

# Avoid external dependencies
import external_library  # Outside function

@scorer
def bad_scorer(outputs):
    return external_library.process(outputs)

# Include imports in the function definition
@scorer
def good_scorer(outputs):
    import json  # Inside function
    return len(json.dumps(outputs))

# Avoid using type hints in scorer function signature that requires imports
from typing import List

@scorer
def scorer_with_bad_types(outputs: List[str]):
    return False

# Class-based scorers are not supported for production monitoring
class MyScorer(Scorer):
    name: str = "my_scorer"
    def __call__(self, outputs):
        return len(outputs) > 10

Próximos passos

• Gerenciar avaliadores de produção - gerenciar o ciclo de vida de seus avaliadores de produção.
• Preencher registros históricos com marcadores - Aplicar marcadores retroativamente a registros históricos.
• Arquivar rastros em uma tabela Delta - Salvar rastros e avaliações em uma tabela Delta.
• Crie sistemas de pontuação personalizados baseados em código - Desenvolva sistemas de pontuação adaptados às suas necessidades.
• Avalie conversas - Aprenda sobre avaliação de conversas com múltiplas interações e juízes de múltiplas interações.
• Construindo um conjunto de dados de avaliação MLflow - Utilizando os resultados do monitoramento para melhorar a qualidade.

Guia de referência

• Referência da API de gerenciamento do ciclo de vida do avaliador - Referência da API para gerenciamento do ciclo de vida do avaliador.
• Avaliadores e juízes de LLM - Compreendam as métricas que impulsionam o monitoramento.
• Avalie o GenAI durante o desenvolvimento : como a avaliação offline se relaciona com a produção.