Monitorar aplicativos GenAI em produção

Criar e agendar 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 pontuadores baseados em juízes LLM.

Para criar um novo julgador LLM:

1. Navegue até a guia Avaliadores na interface do usuário do experimento do MLflow.

   

2. Clique em Novo juiz LLM.

   

3. Especifique o que o avaliador avaliará selecionando Rastreamentos ou Sessões.

4. Insira um nome para o 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 juiz permitem que você insira instruções personalizadas, incluindo variáveis.

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

   

8. Defina a alternância Executar em todos os rastreamentos futuros conforme desejado.

9. (Opcional) Em Configurações Avançadas, ajuste a taxa de amostragem e a cadeia de filtro para controlar os rastreamentos que serão avaliados.

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

    1. Clique em Selecionar rastreamentos no painel esquerdo. Um pop-up aparece.
    2. Selecione os rastreamentos a serem executados e clique em Selecionar (n).
    3. Clique em Executar juiz. Os rastreamentos são avaliados e os resultados são exibidos.
    4. Revise os resultados. Use os botões Avançar e Anterior para percorrer os resultados de cada rastreamento selecionado.
    5. Se necessário, edite o juiz e itera até que você esteja feliz com o desempenho do juiz.

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

Não é possível criar um juiz de código personalizado usando a interface. Para ver o código do modelo que você pode copiar para o bloco de anotações e editar conforme necessário, faça o seguinte:

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

   

2. Um pop-up é exibido com instruções e código de exemplo mostrando como definir e executar o avaliador de código personalizado.

Usar juízes LLM integrados

O MLflow fornece vários juízes LLM integrados prontos para uso.

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 padrão, cada juiz usa uma LLM hospedada pelo Databricks projetada para executar avaliações de qualidade do GenAI. Você pode alterar o modelo de juiz para usar um ponto de extremidade do serviço de modelo do Databricks usando o argumento model na definição do pontuador. O modelo deve ser especificado no formato databricks:/<databricks-serving-endpoint-name>.

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

Diretrizes para o Uso de Juízes LLMs

As Diretrizes dos Juízes LLM avaliam as entradas e saídas usando critérios de linguagem natural de aprovação/falha.

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 de juiz para usar, em vez disso, um ponto de extremidade do serviço de modelo do Databricks.

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

Usar juízes LLM com prompts personalizados

Para obter mais flexibilidade do que os juízes de diretrizes, use Juízes LLM com prompts personalizados que permitem avaliação de qualidade de vários níveis com categorias de escolha personalizáveis.

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))

Usar funções de pontuador personalizado

Para obter flexibilidade máxima, defina e use uma função de pontuador personalizado.

Importante: Requisitos de avaliador personalizado para monitoramento de produção

• Apenas @scorer pontuadores baseados em decorador são suportados. Subclasses baseadas na classe Scorer não podem ser registradas para monitoramento de produção. Se você precisar de um pontuador baseado em classe, refatore-o para usar o decorador @scorer.
• Os pontuadores devem ser definidos e registrados a partir de um notebook do Databricks. O serviço de monitoramento serializa o código da função de avaliação para execução remota e essa serialização requer o ambiente do notebook. Os avaliadores definidos em arquivos Python autônomos ou em IDEs locais não podem ser serializados para monitoramento de produção.
• Os marcadores devem ser independentes. Como as funções de pontuação são serializadas como código para execução remota, todas as importações devem ser feitas inline dentro do 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 use anotações de tipo que precisam ser importadas na assinatura da função. Se o corpo da função de pontuação usar pacotes que precisam ser importados, importe esses pacotes inline dentro da função para garantir a serialização correta.

Alguns pacotes estão disponíveis por padrão sem a necessidade de uma importação embutida. Isso inclui databricks-agents, mlflow-skinny, openai e todos os pacotes incluídos no Ambiente versão 2.

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 pontuador personalizados, consulte marcadores baseados em código.

Usar juízes de vários turnos

O monitoramento de produção oferece suporte a juízes de vários turnos que avaliam conversas inteiras em vez de rastreamentos individuais. Esses juízes avaliam padrões de qualidade em várias interações, como frustração do usuário e integridade da conversa. Juízes de multi-turno são registrados e iniciados da mesma forma que juízes de turno único.

O trabalho de monitoramento agrupa automaticamente rastreamentos em conversas com base na marcação mlflow.trace.session. Os juízes de vários turnos são executados após uma conversa ser considerada concluída. Por padrão, uma conversa é considerada concluída quando nenhum novo rastreamento com esse identificador de sessão é recebido durante 5 minutos. Para configurar esse buffer, defina a variável de MLFLOW_ONLINE_SCORING_DEFAULT_SESSION_COMPLETION_BUFFER_SECONDS ambiente no trabalho de monitoramento.

Para obter a lista completa de juízes de vários turnos disponíveis, consulte os juízes de vários turnos. Para obter detalhes sobre a avaliação da conversa, consulte Avaliar conversas.

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),
)

Combinar juízes

Você pode combinar juízes de turno único e juízes de várias voltas no mesmo experimento. Registre e inicie cada pontuador individualmente.

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))