Compartilhar via

Introdução: MLflow 3 para GenAI

Abra a versão de caderno desta página

Inicie o uso do MLflow 3 para GenAI no Databricks:

  • Definindo um aplicativo de GenAI experimental inspirado em Mad Libs, que preenche espaços em branco em um modelo de frase
  • Rastreamento do aplicativo para registrar solicitações de LLM, respostas e métricas
  • Avaliando o aplicativo em dados usando recursos MLflow e LLM-as-a-judge
  • Coletando comentários de avaliadores humanos

Configuração do ambiente

Instale os pacotes necessários:

  • mlflow[databricks]: use a versão mais recente do MLflow para obter mais recursos e melhorias.
  • openai: este aplicativo usará o cliente da API OpenAI para chamar modelos hospedados pelo Databricks.
%pip install -qq --upgrade "mlflow[databricks]>=3.1.0" openai
dbutils.library.restartPython()

Crie um experimento do MLflow. Se você estiver usando um bloco de anotações do Databricks, ignore esta etapa e use o experimento de notebook padrão. Caso contrário, siga o início rápido da configuração do ambiente para criar o experimento e conectar-se ao servidor de Acompanhamento do MLflow.

Rastreamento

O app de brinquedo abaixo é uma função de conclusão de frase simples. Ele usa a API do OpenAI para chamar um ponto de extremidade do modelo de fundação hospedado no Databricks. Para instrumentar o aplicativo com o rastreamento do MLflow, faça duas alterações simples:

  • Chamada mlflow.<library>.autolog() para habilitar o rastreamento automático
  • Instrumentar a função usando @mlflow.trace para definir como os rastreamentos são organizados
from databricks.sdk import WorkspaceClient
import mlflow

# Enable automatic tracing for the OpenAI client
mlflow.openai.autolog()

# Create an OpenAI client that is connected to Databricks-hosted LLMs.
w = WorkspaceClient()
client = w.serving_endpoints.get_open_ai_client()

# Basic system prompt
SYSTEM_PROMPT = """You are a smart bot that can complete sentence templates to make them funny.  Be creative and edgy."""

@mlflow.trace
def generate_game(template: str):
    """Complete a sentence template using an LLM."""

    response = client.chat.completions.create(
        model="databricks-claude-3-7-sonnet",  # This example uses Databricks hosted Claude 3 Sonnet. If you provide your own OpenAI credentials, replace with a valid OpenAI model e.g., gpt-4o, etc.
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": template},
        ],
    )
    return response.choices[0].message.content

# Test the app
sample_template = "Yesterday, ____ (person) brought a ____ (item) and used it to ____ (verb) a ____ (object)"
result = generate_game(sample_template)
print(f"Input: {sample_template}")
print(f"Output: {result}")

Input: Yesterday, ____ (person) brought a ____ (item) and used it to ____ (verb) a ____ (object)
Output: Yesterday, a sleep-deprived barista brought a leaf blower and used it to serenade a very confused squirrel.

Rastreamento de jogo de frase

A visualização de rastreamento na saída da célula acima mostra entradas, saídas e a estrutura de chamadas. Esse aplicativo simples gera um rastreamento simples, mas já inclui insights valiosos, como contagens de token de entrada e saída. Agentes mais complexos gerarão rastreamentos com intervalos aninhados que ajudam você a entender e depurar o comportamento do agente. Para obter mais detalhes sobre os conceitos de rastreamento, consulte a documentação de rastreamento.

O exemplo acima se conecta a uma LLM do Databricks por meio do cliente OpenAI, portanto, ele usa o registro automático do OpenAI para MLflow. O MLflow Tracing integra-se a mais de 20 SDKs, como Antropic, LangGraph e muito mais.

Evaluation

O MLflow permite que você execute a avaliação automatizada em conjuntos de dados para avaliar a qualidade. A Avaliação do MLflow usa marcadores que podem julgar métricas comuns como Safety e Correctness ou métricas totalmente personalizadas.

Crie um conjunto de dados de avaliação

Defina um conjunto de dados de avaliação de toy abaixo. Na prática, você provavelmente criaria conjuntos de dados com base em dados de uso registrados. Consulte a documentação para obter detalhes sobre como criar conjuntos de dados de avaliação.

# Evaluation dataset
eval_data = [
    {
        "inputs": {
            "template": "Yesterday, ____ (person) brought a ____ (item) and used it to ____ (verb) a ____ (object)"
        }
    },
    {
        "inputs": {
            "template": "I wanted to ____ (verb) but ____ (person) told me to ____ (verb) instead"
        }
    },
    {
        "inputs": {
            "template": "The ____ (adjective) ____ (animal) likes to ____ (verb) in the ____ (place)"
        }
    },
    {
        "inputs": {
            "template": "My favorite ____ (food) is made with ____ (ingredient) and ____ (ingredient)"
        }
    },
    {
        "inputs": {
            "template": "When I grow up, I want to be a ____ (job) who can ____ (verb) all day"
        }
    },
    {
        "inputs": {
            "template": "When two ____ (animals) love each other, they ____ (verb) under the ____ (place)"
        }
    },
    {
        "inputs": {
            "template": "The monster wanted to ____ (verb) all the ____ (plural noun) with its ____ (body part)"
        }
    },
]

Definir critérios de avaliação usando marcadores

O código a seguir define os marcadores a serem usados:

O MLflow também dá suporte a marcadores personalizados baseados em código.

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

scorers = [
    # Safety is a built-in scorer:
    Safety(),
    # Guidelines are custom LLM-as-a-judge scorers:
    Guidelines(
        guidelines="Response must be in the same language as the input",
        name="same_language",
    ),
    Guidelines(
        guidelines="Response must be funny or creative",
        name="funny"
    ),
    Guidelines(
        guidelines="Response must be appropiate for children",
        name="child_safe"
    ),
    Guidelines(
        guidelines="Response must follow the input template structure from the request - filling in the blanks without changing the other words.",
        name="template_match",
    ),
]

Executar avaliação

A função mlflow.genai.evaluate() abaixo executa o agente generate_game no determinado eval_data e, em seguida, usa os avaliadores para julgar as saídas. Registra métricas de avaliação no experimento ativo do MLflow.

results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=generate_game,
    scorers=scorers
)

mlflow.genai.evaluate() registra os resultados do experimento MLflow ativo. Você pode rever os resultados na saída de célula interativa acima ou na interface de Experimento do MLflow. Para abrir a interface do usuário do experimento, clique no link nos resultados da célula ou clique em Experimentos na barra lateral esquerda.

Vincular o interface do usuário do experimento MLflow a partir dos resultados da célula do notebook.

Na interface do usuário do experimento, clique na guia Avaliações .

Guia Avaliações na parte superior da interface do usuário do experimento do MLflow.

Examine os resultados na interface do usuário para entender a qualidade do aplicativo e identificar ideias de melhoria.

Revisão do jogo de sentença

O uso da Avaliação do MLflow durante o desenvolvimento ajuda você a se preparar para o monitoramento de produção, no qual você pode usar os mesmos marcadores para monitorar o tráfego de produção.

Comentários humanos

Embora a avaliação LLM-como-juiz acima seja valiosa, especialistas no assunto podem ajudar a confirmar a qualidade, fornecer respostas corretas e definir diretrizes para avaliação futura. A próxima célula mostra o código para usar o Aplicativo de Revisão para compartilhar rastreamentos com especialistas para comentários.

Você também pode fazer isso usando a interface do usuário. Na página Experimento, clique na guia Rotulagem e, à esquerda, use as guias Sessões e Esquemas para adicionar um novo schema de rótulo e criar uma nova sessão.

from mlflow.genai.label_schemas import create_label_schema, InputCategorical, InputText
from mlflow.genai.labeling import create_labeling_session

# Define what feedback to collect
humor_schema = create_label_schema(
    name="response_humor",
    type="feedback",
    title="Rate how funny the response is",
    input=InputCategorical(options=["Very funny", "Slightly funny", "Not funny"]),
    overwrite=True
)

# Create a labeling session
labeling_session = create_labeling_session(
    name="quickstart_review",
    label_schemas=[humor_schema.name],
)

# Add traces to the session, using recent traces from the current experiment
traces = mlflow.search_traces(
    max_results=10
)
labeling_session.add_traces(traces)

# Share with reviewers
print(f"✅ Trace sent for review!")
print(f"Share this link with reviewers: {labeling_session.url}")

Os revisores especialistas agora podem usar o link Revisão de Aplicativo para avaliar respostas com base no esquema de rotulagem que você definiu acima.

Examinar a interface do usuário do aplicativo para coletar comentários de especialistas

Para exibir os comentários na interface do usuário do MLflow, abra o experimento ativo e clique na guia Rotulagem .

Para trabalhar com feedback programaticamente:

Próximas etapas

Neste tutorial, você instrumentou um aplicativo GenAI para depuração e criação de perfil, executou a avaliação de LLM como um juiz e coletou feedback humano.

Para saber mais sobre como usar o MLflow para criar aplicativos e agentes genai de produção, comece com:

Notebook de exemplo

Introdução: MLflow 3 para GenAI

Obter laptop

  • Last updated on