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 brinquedo simples de IA inspirado no 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 sobre os dados usando recursos MLflow e LLM como avaliador
  • 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.
  • databricks-openai: este aplicativo usará o cliente da API OpenAI para chamar modelos hospedados pelo Databricks.
%pip install -qq --upgrade "mlflow[databricks]>=3.1.0" databricks-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 aplicativo de brinquedo abaixo é uma função de conclusão de frases simples. Ele usa a API do OpenAI para chamar um ponto de extremidade do modelo básico 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_openai import DatabricksOpenAI
import mlflow

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

# Create an OpenAI client that is connected to Databricks-hosted LLMs.
client = DatabricksOpenAI()

# 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-sonnet-4",  # This example uses Databricks hosted Claude 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}")

Rastreamento de frases do jogo

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 spans 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 anterior conecta-se a um LLM do Databricks usando o cliente OpenAI e usa o registro em log automático do OpenAI para MLflow. O MLflow Tracing integra-se a mais de 20 SDKs, como Antropic, LangGraph e muito mais. Confira as integrações de rastreamento do MLflow.

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 do brinquedo abaixo. Na prática, você provavelmente criaria conjuntos de dados com base em dados de uso registrados. Consulte a criação de conjuntos de dados de avaliação do MLflow.

# 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 pontuadores para avaliar as saídas. A avaliação registra métricas 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.

Link para a interface do usuário do experimento do 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 frases

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. Consulte Monitorar a IA em 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 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 Aplicativo de Revisão 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 de IA para depuração e criação de perfil, executou uma avaliação com LLM atuando como avaliador e coletou comentários humanos.

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

Notebook de exemplo

Introdução: MLflow 3 para GenAI

Obter laptop

  • Last updated on