Integrar o fluxo de prompt com o DevOps para aplicativos baseados em LLM

O Prompt Flow do Azure Machine Learning é um método intuitivo e fácil de usar, com abordagem "code-first", para desenvolver e iterar fluxos para o desenvolvimento de aplicativos baseados em modelos de linguagem de grande porte (LLM). O Prompt Flow fornece um SDK e uma CLI, uma extensão para o Visual Studio Code e uma interface de usuário para criação de fluxos. Essas ferramentas facilitam o desenvolvimento local de fluxos, o acionamento de execuções locais e de avaliação de fluxos e a transição de fluxos entre ambientes de espaço de trabalho locais e na nuvem.

Você pode combinar a experiência de fluxo de prompts e os recursos de código com as operações de desenvolvimento (DevOps) para aprimorar seus fluxos de trabalho de desenvolvimento de aplicativos baseados em LLM. Este artigo se concentra na integração do fluxo de prompts e do DevOps para aplicativos baseados em LLM do Azure Machine Learning.

O diagrama a seguir mostra a interação do desenvolvimento de fluxo de prompt local e baseado em nuvem com o DevOps.

Pré-requisitos

• Um espaço de trabalho do Azure Machine Learning. Para criar um, consulte Criar recursos para começar.

• Um ambiente local de Python com o SDK do Azure Machine Learning Python v2 instalado, criado seguindo as instruções em Introdução.

  Nota

  Esse ambiente é separado do ambiente que a sessão de computação usa para executar o fluxo, que você define como parte do fluxo. Para obter mais informações, consulte Gerenciar sessão de computação do Prompt Flow no Azure Machine Learning Studio.

• Visual Studio Code com as extensões Python e Prompt Flow instaladas.

  

Use uma experiência de código-fonte no Prompt Flow

O desenvolvimento de aplicativos baseados em LLM geralmente segue um processo de engenharia de aplicativo padronizado que inclui repositórios de código-fonte e pipelines de CI/CD (integração contínua/implantação contínua). Esse processo promove o desenvolvimento simplificado, o controle de versão e a colaboração entre os membros da equipe.

A integração do DevOps com a experiência de desenvolvimento de código orientado por prompts oferece aos desenvolvedores de software um processo de iteração GenAIOps ou LLMOps mais eficiente, com os seguintes principais recursos e benefícios:

• Versionamento de Flow no repositório de código. Você pode definir arquivos de fluxo no formato YAML e eles permanecem alinhados com arquivos de origem referenciados na mesma estrutura de pastas.

• Integração de execução de fluxo com pipelines de CI/CD. Você pode integrar o Prompt Flow perfeitamente aos seus pipelines de CI/CD e ao processo de entrega usando a CLI ou o SDK do Prompt Flow para acionar automaticamente as execuções de fluxo.

• Transição suave entre o local e a nuvem. Você pode exportar facilmente sua pasta de fluxo para seu repositório de código local ou upstream para controle de versão, desenvolvimento local e compartilhamento. Você também pode importar facilmente a pasta de fluxo de volta para Azure Machine Learning para criação, teste e implantação adicionais usando recursos de nuvem.

Acesse o código do Prompt Flow

Cada fluxo de comandos tem uma estrutura de pastas de fluxo contendo arquivos de código essenciais que definem o fluxo. A estrutura de pastas organiza seu fluxo, facilitando transições mais suaves entre o local e a nuvem.

Azure Machine Learning fornece um sistema de arquivos compartilhado para todos os usuários do workspace. Após a criação do fluxo, uma pasta de fluxo correspondente é gerada e armazenada automaticamente no diretório Usuários/<nome> de usuário/promptflow .

Trabalhar com arquivos de código de fluxo

Depois de criar um fluxo no Estúdio do Azure Machine Learning, você poderá exibir, editar e gerenciar os arquivos de fluxo na seção Files da página de criação de fluxo. As modificações feitas nos arquivos refletem diretamente no espaço de armazenamento compartilhado.

A pasta de fluxo para um fluxo baseado em LLM contém os seguintes arquivos de chave.

• flow.dag.yaml é o arquivo de definição de fluxo primário no formato YAML. Esse arquivo é essencial para criar e definir o fluxo de prompt. O arquivo inclui informações sobre entradas, saídas, nós, ferramentas e variantes que o fluxo usa.

• Os arquivos de código-fonte gerenciados pelo usuário no formato Python (.py) ou Jinja 2 (.jinja2) configuram as ferramentas e os nós no fluxo. A ferramenta Python usa arquivos Python para definir a lógica de Python personalizada. A ferramenta de prompt e a ferramenta LLM usam arquivos Jinja 2 para definir o contexto do prompt.

• Arquivos não fonte, como arquivos de dados e utilitários, podem ser incluídos na pasta de fluxo junto com os arquivos de origem.

Para exibir e editar o código bruto dos arquivos flow.dag.yaml e de origem no editor de arquivos, ative o modo de arquivo Bruto.

Como alternativa, você pode acessar e editar todas as pastas de fluxo e arquivos da página Estúdio do Azure Machine Learning Notebooks.

Baixe e faça check-in do código do Prompt Flow

Para verificar o fluxo no repositório de código, exporte a pasta de fluxo de Estúdio do Azure Machine Learning para o computador local. Selecione o ícone de download na seção Arquivos da página de criação de fluxo para baixar um pacote ZIP que contém todos os arquivos de fluxo. Em seguida, você pode verificar esse arquivo em seu repositório de código ou descompactá-lo para trabalhar com os arquivos localmente.

Para obter mais informações sobre a integração do DevOps ao Azure Machine Learning, consulte Git integration for Azure Machine Learning.

Desenvolver e testar localmente

À medida que você refina e ajusta seu fluxo ou prompts durante o desenvolvimento iterativo, pode realizar várias iterações localmente em seu repositório de código. A versão da comunidade do VS Code, a extensão VS Code Prompt Flow e o SDK local do Prompt Flow e a CLI facilitam o desenvolvimento e o teste locais puros sem vinculação ao Azure.

Trabalhar localmente permite que você faça e teste as alterações rapidamente, sem a necessidade de atualizar o repositório de código principal sempre. Para obter mais detalhes e diretrizes sobre como usar versões locais, consulte a comunidade GitHub do Prompt flow.

Utilizar a extensão Prompt Flow do VS Code

Usando a extensão Prompt Flow do VS Code, você pode criar facilmente seu fluxo localmente no editor do VS Code, com uma experiência de interface do usuário semelhante à proporcionada pela nuvem.

Para editar arquivos em sua máquina local no VS Code com a extensão Prompt flow:

1. No VS Code com a extensão de fluxo de prompt habilitada, abra uma pasta de fluxo de prompt.

2. Abra o arquivo flow.dag.yaml e selecione o link do editor visual na parte superior do arquivo.

   

3. Use o editor visual do Prompt Flow para fazer alterações no seu fluxo, como ajustar os prompts em variantes ou adicionar mais nós.

   

4. Para testar seu fluxo, selecione o ícone Executar na parte superior do editor visual ou, para testar qualquer nó, selecione o ícone Executar na parte superior do nó.

   

Use o SDK e a CLI do Prompt Flow.

Se você preferir trabalhar diretamente no código ou usar Jupyter, PyCharm, Visual Studio ou outro IDE (ambiente de desenvolvimento integrado), poderá modificar diretamente o código YAML no arquivo flow.dag.yaml.

Em seguida, você pode acionar uma única execução de fluxo para teste usando a CLI ou o SDK do prompt flow no terminal, da seguinte forma.

pf flow test --flow <directory-name>

from promptflow import PFClient

pf_client = PFClient()

flow_path = "<directory-name>"

# Test flow
flow_inputs = {"<input-type>": "<input-value>", "<input-type>": "<input-value>"}
flow_result = pf_client.test(flow=flow_path, inputs=inputs)
print(f"Flow outputs: {flow_result}")

# Test node in the flow
node_name = "<node-name>"  # The node name in the flow.
node_inputs = {"<node-input-type>": "<node-input-value>"}
node_result = pf_client.test(flow=flow_path, inputs=node_inputs, node=node_name)
print(f"Node outputs: {node_result}")

Os valores retornados são os logs de teste e as saídas.

Enviar operações na nuvem a partir de um repositório local

Depois de se sentir satisfeito com os resultados do teste local, você pode usar a CLI ou o SDK do Prompt Flow para submeter execuções para a nuvem a partir do repositório local. O procedimento e o código a seguir baseiam-se no projeto de demonstração Web Classification no GitHub. Você pode clonar o repositório do projeto ou baixar o código do prompt flow para o computador local.

Instalar o SDK de prompt flow

Instale o SDK/CLI do fluxo de prompts do Azure executando pip install promptflow[azure] promptflow-tools.

Se você estiver usando o projeto de demonstração, obtenha o SDK e outros pacotes necessários instalando requirements.txt com
pip install -r <path>/requirements.txt.

Conectar-se ao seu workspace Azure Machine Learning

az login

import json

# Import required libraries
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# Import azure promptflow apis
from promptflow.azure import PFClient

# Configure credential
try:
    credential = DefaultAzureCredential()
    # Check if given credential can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential if DefaultAzureCredential doesn't work
    credential = InteractiveBrowserCredential()

# Get a handle to the workspace from the current credential or config.json in the parent directory
pf = PFClient.from_config(
    credential=credential,
)

Carregar o fluxo e criar uma execução

$schema: https://azuremlschemas.azureedge.net/promptflow/latest/Run.schema.json
flow: <path-to-flow>
data: <path-to-flow>/<data-file>.jsonl

column_mapping:
  url: ${data.url}

# Define cloud compute resource

resources:
  instance_type: <compute-type>

# If using compute instance compute type, also specify instance name
#  compute: <compute-instance-name> 

# Specify connections

  <node-name>:
    connection: <connection-name>
    deployment_name: <deployment-name>

...
connections:
  <node-name>:
    connection: <connection-name>
      deployment_name: <deployment-name>
...

pfazure run create --file run.yml

flow = "<path-to-flow>"
data = "<path-to-flow>/<data-file>.jsonl"

# Define compute resource instance type when using serverless compute

# resources = {"instance_type": "serverless"}

# Also specify compute instance name when using a compute instance

# resources={
#     "instance_type": "<compute-instance-type>",
#     "compute": "<compute-instance-name>"
# }

# Specify the connection and deployment name for each tool in the flow that requires a connection

connections = {"<node-name>":
                  {"connection": <connection-name>,
                  "deployment_name": <deployment-name>},
               "<node-name>":
                  {"connection": <connection-name>,
                  "deployment_name": <deployment-name>}
                }

# Create the run

run = Run(
    flow=flow,
    data=data,
    column_mapping={
        "url": "${data.url}"
    }, 

    connections=connections,
    # To customize identity, you can provide it in identity

    # identity={
    #     "type": "managed",
    # }
)

base_run = pf.runs.create_or_update(run=run)

Criar uma execução de fluxo de avaliação

$schema: https://azuremlschemas.azureedge.net/promptflow/latest/Run.schema.json
flow: <path-to-flow>
data: <path-to-flow>/<data-file>.jsonl
run: <id-of-base-flow-run>
column_mapping:
  <input-name>: ${data.<column-from-test-dataset>}
  <input-name>: ${run.outputs.<column-from-run-output>}

resources:
  instance_type: <compute-type>
  compute: <compute_instance_name> 

connections:
  <node-name>:
    connection: <connection-name>
    deployment_name: <deployment-name>
  <node-name>:
    connection: <connection-name>
    deployment_name: <deployment-name>

pfazure run create --file run_evaluation.yml

flow = "<path-to-flow>"
data = "<path-to-flow>/<data-file>.jsonl"

resources={
    "instance_type": "<compute-instance-type>",
    "compute": "<compute-instance-name>"
    }

connections = {"<node-name>":
                  {"connection": <connection-name>,
                  "deployment_name": <deployment-name>},
               "<node-name>":
                  {"connection": <connection-name>,
                  "deployment_name": <deployment-name>}
                }
eval_run = Run(
    flow=flow,
    data=data,
    run=<base-run-id>,
    column_mapping={
        "<input-name>": "${data.<column-from-test-dataset>}",
        "<input-name>": "${run.outputs.<column-from-run-output>}",
    },
    connections=connections,
    identity={
        "type": "managed",
    }
)

eval_run = pf.runs.create_or_update(run=eval_run)

Exibir resultados da execução

O envio da execução do fluxo para a nuvem retorna a URL da execução na nuvem. Você pode abrir a URL para exibir os resultados da execução em Estúdio do Azure Machine Learning. Você também pode executar os comandos da CLI ou do SDK a seguir para exibir os resultados da execução.

Transmitir os registros

pfazure run stream --name <run-name>

pf.stream("<run-name>")

Exibir saídas de execução

pfazure run show-details --name <run-name>

details = pf.get_details("<run-name>")
details.head(10)

Exibir métricas de execução de avaliação

pfazure run show-metrics --name <evaluation-run-name>

pf.get_metrics("<evaluation-run-name>")

Integrar com o DevOps

Uma combinação de um ambiente de desenvolvimento local e um sistema de controle de versão, como o Git, normalmente é mais eficaz para o desenvolvimento iterativo. Você pode fazer modificações e testar seu código localmente e confirmar as alterações no Git. Esse processo cria um registro contínuo de suas alterações e oferece a capacidade de reverter para versões anteriores, se necessário.

Quando precisar compartilhar fluxos em diferentes ambientes, você poderá efetuá-los por push para um repositório de código baseado em nuvem, como GitHub ou Azure Repos. Essa estratégia permite que você acesse a versão de código mais recente de qualquer local e fornece ferramentas para colaboração e gerenciamento de código.

Ao seguir essas práticas, as equipes podem criar um ambiente colaborativo fluido, eficiente e produtivo para o desenvolvimento ágil de processos.

Por exemplo, pipelines LLMOps de ponta a ponta que executam fluxos de classificação da Web, consulte Configurar GenAIOps de ponta a ponta com Prompt Flow e GitHub e o projeto de demonstração Classificação da Web do GitHub.

Acionar execuções de fluxo em pipelines de CI

Depois de desenvolver e testar seu fluxo com sucesso e fazer o check-in como a versão inicial, você estará pronto para iterações de ajuste e teste. Nesta etapa, você pode acionar execuções de fluxo, incluindo testes em lote e execuções de avaliação, usando a CLI do Prompt Flow para automatizar etapas em seu pipeline de CI.

Ao longo do ciclo de vida das iterações de fluxo, você pode usar a CLI para automatizar as seguintes operações:

• Executando o fluxo de prompts após um pull request
• Execução da avaliação do prompt flow solicitada para garantir que os resultados sejam de alta qualidade
• Registrando modelos de fluxo de prompt
• Implantando modelos do Prompt Flow

Utilize a interface do usuário do estúdio para desenvolvimento contínuo

A qualquer momento no desenvolvimento de fluxo, você pode voltar à interface do usuário do Estúdio do Azure Machine Learning e usar recursos e experiências de nuvem para fazer alterações em seu fluxo.

Para continuar desenvolvendo e trabalhando com as versões mais atualizadas dos arquivos de fluxo, você pode acessar um terminal na página Notebook e puxar os arquivos de fluxo mais recentes do seu repositório. Ou você pode importar uma pasta de fluxo local de maneira direta como um rascunho de fluxo novo para facilitar a transição entre o desenvolvimento local e na nuvem.

Implantar o fluxo como um ponto de extremidade online

A última etapa para entrar em produção é implantar seu fluxo como um endpoint online no Azure Machine Learning. Esse processo permite que você integre seu fluxo ao seu aplicativo e o disponibilize para uso. Para obter mais informações sobre como implantar seu fluxo, consulte Implantar fluxos no ponto de extremidade online gerenciado do Azure Machine Learning para inferência em tempo real.

Colaborar no desenvolvimento de fluxo

A colaboração entre os membros da equipe pode ser essencial ao desenvolver um aplicativo baseado em LLM com fluxo de prompt. Os membros da equipe podem estar criando e testando o mesmo fluxo, trabalhando em diferentes facetas do fluxo ou fazendo alterações iterativas e aprimoramentos simultaneamente. Essa colaboração requer uma abordagem eficiente e simplificada para compartilhar código, acompanhar modificações, gerenciar versões e integrar alterações ao projeto final.

O SDK/CLI do Prompt Flow e a extensão Prompt Flow do VS Code facilitam a colaboração no desenvolvimento de fluxos baseados em código dentro de um repositório de código-fonte. Você pode usar um sistema de controle do código-fonte baseado em nuvem, como GitHub ou Azure Repos para controlar alterações, gerenciar versões e integrar essas modificações ao projeto final.

Siga as práticas recomendadas de desenvolvimento colaborativo

1. Configure um repositório de código centralizado.

   A primeira etapa do processo colaborativo envolve a configuração de um repositório de código como base para o código do projeto, incluindo o código de fluxo de comandos. Esse repositório centralizado permite uma organização eficiente, controle de alterações e colaboração entre os membros da equipe.

2. Crie e teste seu fluxo localmente no VS Code com a extensão Prompt Flow.

   Depois que o repositório for configurado, os membros da equipe poderão usar o VS Code com a extensão Prompt flow para autoria local e teste do fluxo com entrada única. O ambiente de desenvolvimento integrado padronizado promove a colaboração entre vários membros que trabalham em diferentes aspectos do fluxo.

   

3. Use o CLI ou o pfazure SDK para enviar execuções em lotes e execuções de avaliação a partir de fluxos locais para a nuvem.

   Após o desenvolvimento e teste locais, os membros da equipe podem usar a CLI/SDK do prompt flow para enviar e avaliar execuções em lote e de avaliação para a nuvem. Esse processo permite o uso de computação em nuvem, armazenamento persistente de resultados, criação de endpoints para implantações e gerenciamento eficiente na interface do estúdio.

   

4. Exibir e gerenciar resultados de execução na interface do usuário do workspace Estúdio do Azure Machine Learning.

   Depois que eles enviam execuções para a nuvem, os membros da equipe podem acessar a interface do usuário do estúdio para exibir os resultados e gerenciar experimentos com eficiência. O espaço de trabalho na nuvem oferece um local centralizado para coletar e gerenciar o histórico de execuções, logs, instantâneos, resultados abrangentes, bem como entradas e saídas ao nível da instância.

   

5. Use a lista Execuções que registra todo o histórico de execuções para comparar facilmente os resultados de diferentes execuções, auxiliando na análise de qualidade e nos ajustes necessários.

   

6. Continue a usar o desenvolvimento iterativo local.

   Depois de analisar os resultados dos experimentos, os membros da equipe podem retornar ao ambiente local e ao repositório de código para obter mais desenvolvimento e ajuste fino e enviar iterativamente as execuções subsequentes para a nuvem. Essa abordagem iterativa garante um aprimoramento consistente até que a equipe esteja satisfeita com a qualidade da produção.

7. Use a implantação em uma única etapa para produção no estúdio.

   Depois que a equipe estiver totalmente confiante na qualidade do fluxo, ela poderá implantá-lo sem problemas como um endpoint online em um ambiente de nuvem robusto. A implantação como um ponto de extremidade online pode ser baseada em um snapshot de execução, permitindo um serviço estável e seguro, alocação e rastreamento de recursos adicionais e monitoramento de logs na nuvem.

   

   O assistente Estúdio do Azure Machine Learning Deploy ajuda você a configurar facilmente sua implantação.

   

Conteúdo relacionado

• Configure o GenAIOps completo com fluxo de prompts e GitHub
• Documentação do CLI Prompt flow para Azure