Integrar o prompt flow com aplicativo DevOps baseado em LLM

Nesse artigo, você aprende sobre a integração do prompt flow com o DevOps do aplicativo baseado em LLM no Azure Machine Learning. O Fluxo de Prompt oferece uma experiência de Code First fácil de usar e amigável para o desenvolvimento de fluxo e iteração com todo o seu fluxo de trabalho de desenvolvimento de aplicativos baseado em LLM.

Ele fornece um SDK e CLI de fluxo de prompt, uma extensão de código VS e a nova interface do usuário do explorador de pastas de fluxo para facilitar o desenvolvimento local de fluxos, o acionamento local de execuções de fluxo e execuções de avaliação e a transição de fluxos de ambientes locais para ambientes de nuvem (espaço de trabalho do Azure Machine Learning).

Essa documentação se concentra em como combinar efetivamente os recursos de fluxo rápido, experiência de código e DevOps para aprimorar seus fluxos de trabalho de desenvolvimento de aplicativos baseados em LLM.

Introdução da experiência de primeiro código no prompt flow

Ao desenvolver aplicativos usando LLM, é comum ter um processo de engenharia de aplicação padronizado que inclui repositórios de código e pipelines de CI/CD. Essa integração permite um processo de desenvolvimento simplificado, controle de versão e colaboração entre os membros da equipe.

Para desenvolvedores experientes em desenvolvimento de código que buscam um processo de iteração LLMOps mais eficiente, os seguintes recursos e benefícios principais que você pode obter com a experiência de código de fluxo de prompt:

• Controle de versão de fluxo no repositório de código. Você pode definir seu fluxo no formato YAML, que pode permanecer alinhado com os arquivos de origem referenciados em uma estrutura de pastas.
• Integrar a execução do fluxo com o pipeline de CI/CD. Você pode acionar execuções de fluxo usando a CLI ou SDK de fluxo de prompt, que pode ser perfeitamente integrado ao pipeline de CI/CD e ao processo de entrega.
• Transição suave do local para a nuvem. Você pode facilmente exportar sua pasta de fluxo para seu repositório local ou de código para controle de versão, desenvolvimento local e compartilhamento. Da mesma forma, a pasta de fluxo pode ser facilmente importada de volta para a nuvem para posterior criação, teste e implantação em recursos de nuvem.

Acessando a definição de código de fluxo de prompt

Cada fluxo de cada fluxo de prompt é associado a uma estrutura de pastas de fluxo que contém arquivos essenciais para definir o fluxo no código estrutura de pastas. Essa estrutura de pastas organiza seu fluxo, facilitando transições mais suaves.

O Azure Machine Learning oferece um sistema de arquivos compartilhado para todos os usuários do espaço de trabalho. Ao criar um fluxo, uma pasta de fluxo correspondente é automaticamente gerada e armazenada lá, localizada no diretório Users/<username>/promptflow.

Estrutura de pastas de fluxo

Visão geral da estrutura de pastas de fluxo e dos principais arquivos que ela contém:

• flow.dag.yaml: esse arquivo de definição de fluxo primário, no formato YAML, inclui informações sobre entradas, saídas, nós, ferramentas e variantes usadas no fluxo. É essencial para criar e definir o fluxo de prompt.
• Arquivos de código-fonte (.py, .jinja2): a pasta de fluxo também inclui arquivos de código-fonte gerenciados pelo usuário, que são referidos pelas ferramentas/nós no fluxo.
  • Arquivos no formato Python (.py) podem ser referenciados pela ferramenta Python para definir a lógica Python personalizada.
  • Arquivos no formato Jinja 2 (.jinja2) podem ser referenciados pela ferramenta prompt ou ferramenta de LLM para definir o contexto do prompt.
• Arquivos que não são de origem: a pasta de fluxo também pode conter arquivos que não são de origem, como arquivos utilitários e arquivos de dados que podem ser incluídos nos arquivos de origem.

Depois que o fluxo for criado, você poderá navegar até a Página de Criação de Fluxo para exibir e operar os arquivos de fluxo no explorador de arquivos correto. Isso permite que você visualize, edite e gerencie seus arquivos. As modificações feitas nos arquivos são refletidas diretamente no armazenamento do compartilhamento de arquivo.

Com o "Modo de arquivo bruto" ativado, você pode visualizar e editar o conteúdo bruto dos arquivos no editor de arquivos, incluindo o flow.dag.yaml de arquivos de definição de fluxo e os arquivos de origem.

Como alternativa, você pode acessar todas as pastas de fluxo diretamente no bloco de anotações do Azure Machine Learning.

Prompt flow de controle de versão no repositório de código

Para verificar seu fluxo no repositório de código, você pode exportar facilmente a pasta de fluxo da página de criação de fluxo para o sistema local. Isso baixa um pacote contendo todos os arquivos do explorer para sua máquina local, que você pode então verificar em seu repositório de código.

Para obter mais informações sobre a integração do DevOps com o Azure Machine Learning, consulte a Integração do Git no Azure Machine Learning

Enviando execuções para a nuvem a partir do repositório local

Pré-requisitos

• Conclua o tutorial Criar recursos para começar se você ainda não tiver um workspace do Azure Machine Learning.

• Um ambiente Python no qual você instalou o SDK do Python do Azure Machine Learning v2 - instruções de instalação. Esse ambiente serve para definir e controlar seus recursos do Azure Machine Learning e é separado do ambiente usado em runtime. Para saber mais, confira como gerenciar runtime para engenharia de prompt flow.

Instalar o SDK de fluxo de prompt

pip install -r ../../examples/requirements.txt

Conectar-se ao workspace do Azure Machine Learning

CLI do Azure

az login

SDK do Python

import json

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

# azure version 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 in case DefaultAzureCredential not work
    credential = InteractiveBrowserCredential()

# Get a handle to workspace, it will use config.json in current and parent directory.
pf = PFClient.from_config(
    credential=credential,
)

CLI do Azure

Prepare o run.yml para definir a configuração para essa execução de fluxo na nuvem.

$schema: https://azuremlschemas.azureedge.net/promptflow/latest/Run.schema.json
flow: <path_to_flow>
data: <path_to_flow>/data.jsonl

column_mapping:
  url: ${data.url}

# define cloud resource
# if omitted, it will use the automatic runtime, you can also specify the runtime name, specify automatic will also use the automatic runtime.
runtime: <runtime_name> 


# define instance type only work for automatic runtime, will be ignored if you specify the runtime name.
# resources:
#   instance_type: <instance_type>

# overrides connections 
connections:
  classify_with_llm:
    connection: <connection_name>
    deployment_name: <deployment_name>
  summarize_text_content:
    connection: <connection_name>
    deployment_name: <deployment_name>

Você pode especificar o nome da conexão e da implantação para cada ferramenta no fluxo. Se você não especificar o nome da conexão e da implantação, ele usará a conexão e a implantação que está no arquivo flow.dag.yaml. Para formatar conexões:

...
connections:
  <node_name>:
    connection: <connection_name>
      deployment_name: <deployment_name>
...

pfazure run create --file run.yml

SDK do Python

# load flow
flow = "<path_to_flow>"
data = "<path_to_flow>/data.jsonl"


# define cloud resource
runtime = <runtime_name>
# define instance type
# resources = {"instance_type": <instance_type>}

# overrides connections 
connections = {"classify_with_llm":
                  {"connection": <connection_name>,
                  "deployment_name": <deployment_name>},
               "summarize_text_content":
                  {"connection": <connection_name>,
                  "deployment_name": <deployment_name>}
                }
# create run
base_run = pf.run(
    flow=flow,
    data=data,
    runtime=runtime, # if omitted, it will use the automatic runtime, you can also specify the runtime name, specif automatic will also use the automatic runtime.
#    resources = resources, # only work for automatic runtime, will be ignored if you specify the runtime name.
    column_mapping={
        "url": "${data.url}"
    }, 
    connections=connections,  

)
print(base_run)

CLI do Azure

Prepare o run_evaluation.yml para definir a configuração para esse fluxo de avaliação executado na nuvem.

$schema: https://azuremlschemas.azureedge.net/promptflow/latest/Run.schema.json
flow: <path_to_flow>
data: <path_to_flow>/data.jsonl
run: <id of web-classification flow run>
column_mapping:
  groundtruth: ${data.answer}
  prediction: ${run.outputs.category}

# define cloud resource
# if omitted, it will use the automatic runtime, you can also specify the runtime name, specif automatic will also use the automatic runtime.
runtime: <runtime_name> 


# define instance type only work for automatic runtime, will be ignored if you specify the runtime name.
# resources:
#   instance_type: <instance_type>

# overrides connections 
connections:
  classify_with_llm:
    connection: <connection_name>
    deployment_name: <deployment_name>
  summarize_text_content:
    connection: <connection_name>
    deployment_name: <deployment_name>

pfazure run create --file run_evaluation.yml

SDK do Python

# load flow
flow = "<path_to_flow>"
data = "<path_to_flow>/data.jsonl"

# define cloud resource
runtime = <runtime_name>
# define instance type
# resources = {"instance_type": <instance_type>}

# overrides connections 
connections = {"classify_with_llm":
                  {"connection": <connection_name>,
                  "deployment_name": <deployment_name>},
               "summarize_text_content":
                  {"connection": <connection_name>,
                  "deployment_name": <deployment_name>}
                }

# create evaluation run
eval_run = pf.run(
    flow=flow
    data=data,
    run=base_run,
    column_mapping={
        "groundtruth": "${data.answer}",
        "prediction": "${run.outputs.category}",
    },
    runtime=runtime, # if omitted, it will use the automatic runtime, you can also specify the runtime name, specif automatic will also use the automatic runtime.
#    resources = resources, # only work for automatic runtime, will be ignored if you specify the runtime name.
    connections=connections
)

Exibir resultados de execução no espaço de trabalho do Azure Machine Learning

A execução do fluxo de envio para a nuvem retornará a URL do portal da execução. Você pode abrir o uri exibir os resultados de execução no portal.

Você também pode usar o comando a seguir para exibir os resultados das execuções.

Transmitir os logs

CLI do Azure

pfazure run stream --name <run_name>

SDK do Python

pf.stream("<run_name>")

Exibir saídas de execução

CLI do Azure

pfazure run show-details --name <run_name>

SDK do Python

details = pf.get_details(eval_run)
details.head(10)

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

CLI do Azure

pfazure run show-metrics --name <evaluation_run_name>

SDK do Python

pf.get_metrics("evaluation_run_name")

Importante

Para obter mais informações, você pode consultar a documentação da CLI de prompt flow do Azure.

Desenvolvimento iterativo a partir de ajustes finos

Desenvolvimento e teste locais

Durante o desenvolvimento iterativo, à medida que você refina e ajusta seu fluxo ou prompts, pode ser benéfico realizar várias iterações localmente no seu repositório de código. A versão da comunidade, Extensão do VS Code do prompt flow e SDK local do prompt flow e CLI é fornecida para facilitar o desenvolvimento e os testes locais puros sem a associação do Azure.

Extensão do VS Code do fluxo do prompt

Com a extensão do VS Code do prompt flow instalada, você pode criar facilmente seu fluxo localmente no editor do VS Code, fornecendo uma experiência de interface do usuário semelhante à da nuvem.

Para usar a extensão:

1. Abra uma pasta de fluxo de prompt no VS Code Desktop.
2. Abra o arquivo ''flow.dag.yaml'' no modo de exibição do bloco de anotações.
3. Use o editor visual para fazer as alterações necessárias no seu fluxo, como ajustar os prompts em variantes ou adicionar mais ferramentas.
4. Para testar seu fluxo, selecione o botão Executar fluxo na parte superior do editor visual. Isso dispara um teste de fluxo.

SDK e CLI local do prompt flow

Se você preferir usar Jupyter, PyCharm, Visual Studio ou outros IDEs, poderá modificar diretamente a definição de YAML no arquivo flow.dag.yaml.

Em seguida, você pode disparar uma execução única de fluxo para teste usando o SDK ou a CLI do prompt flow.

CLI do Azure

Supondo que você esteja no diretório de trabalho <path-to-the-sample-repo>/examples/flows/standard/

pf flow test --flow web-classification  # "web-classification" is the directory name

SDK do Python

O valor de retorno de função test é as saídas de fluxo/nó.

from promptflow import PFClient

pf_client = PFClient()

flow_path = "web-classification"  # "web-classification" is the directory name

# Test flow
flow_inputs = {"url": "https://www.youtube.com/watch?v=o5ZQyXaAv1g", "answer": "Channel", "evidence": "Url"}  # The inputs of the flow.
flow_result = pf_client.test(flow=flow_path, inputs=inputs)
print(f"Flow outputs: {flow_result}")

# Test node in the flow
node_name = "fetch_text_content_from_url"  # The node name in the flow.
node_inputs = {"url": "https://www.youtube.com/watch?v=o5ZQyXaAv1g"}  # The inputs of the node.
node_result = pf_client.test(flow=flow_path, inputs=node_inputs, node=node_name)
print(f"Node outputs: {node_result}")

Isso permite que você faça e teste alterações rapidamente, sem precisar atualizar o repositório de código principal todas as vezes. Quando estiver satisfeito com os resultados de seus testes locais, você poderá transferir para enviando execuções para a nuvem a partir do repositório local para executar execuções de experimentos na nuvem.

Para obter mais detalhes e orientações sobre como usar as versões locais, confira a comunidade GitHub do prompt flow.

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

Como alternativa, você tem a opção de voltar para a interface do usuário do estúdio, usando os recursos e a experiência da nuvem para fazer alterações no fluxo na página de criação do fluxo.

Para continuar desenvolvendo e trabalhando com a versão mais atualizada dos arquivos de fluxo, você pode acessar o terminal no notebook e extrair as alterações mais recentes dos arquivos de fluxo do repositório.

Além disso, se você preferir continuar a trabalhar na interface do usuário do estúdio, poderá importar diretamente uma pasta de fluxo local como um novo fluxo de rascunho. Isso permite que você faça uma transição perfeita entre o desenvolvimento local e na nuvem.

Integração de CI/CD

CI: o fluxo de disparo é executado no pipeline de CI

Depois de desenvolver e testar com sucesso seu fluxo e fazer check-in como a versão inicial, você estará pronto para a próxima iteração de ajuste e teste. Nesse estágio, você pode disparar execuções de fluxo, incluindo testes em lote e execuções de avaliação, usando a CLI do prompt flow. Isso pode servir como um fluxo de trabalho automatizado em seu pipeline de Integração Contínua (CI).

Ao longo do ciclo de vida de suas iterações de fluxo, várias operações podem ser automatizadas:

• Executar o prompt flow após uma pull request
• Execução da avaliação do fluxo de prompts solicitada para garantir que os resultados sejam de alta qualidade
• Registro de modelos de fluxo de prompt
• Implantação de modelos de fluxo imediato

Para obter um guia abrangente sobre um pipeline de MLOps de ponta a ponta que executa um fluxo de classificação da Web, confira Configurar LLMOps de ponta a ponta com o prompt flow e o GitHub, e o projeto de demonstração do GitHub.

CD: implantação contínua

A última etapa para ir para a produção é implantar seu fluxo como um ponto de extremidade online no Azure Machine Learning. Isso 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 com CLI e SDK.

Colaboração no desenvolvimento de fluxo na produção

No contexto do desenvolvimento de um aplicativo baseado em LLM com o prompt flow, a colaboração entre os membros da equipe costuma ser essencial. Os membros da equipe podem estar envolvidos na criação e no teste do mesmo fluxo, trabalhando em diversas facetas do fluxo ou fazendo alterações e aprimoramentos iterativos simultaneamente.

Essa colaboração exige uma abordagem eficiente e simplificada para compartilhar código, rastrear modificações, gerenciar versões e integrar essas alterações no projeto final.

A introdução do SDK/CLI do prompt flow e da Extensão do Visual Studio Code, como parte da experiência de código do prompt flow facilita a colaboração no desenvolvimento do fluxo em seu repositório de código. É recomendável utilizar um repositório de código baseado em nuvem, como o GitHub ou o Azure DevOps, para acompanhar alterações, gerenciar versões e integrar essas modificações ao projeto final.

Melhor prática para o desenvolvimento colaborativo

1. Criação e teste único de seu fluxo localmente – Repositório de código e Extensão VSC

   • A primeira etapa desse processo colaborativo envolve o uso de um repositório de código como base para o código do seu projeto, que inclui o código do prompt flow.
     • Esse repositório centralizado permite a organização eficiente, o acompanhamento de todas as alterações de código e a colaboração entre os membros da equipe.
   • Depois que o repositório é configurado, os membros da equipe podem usar a extensão do VSC para criação local e teste de entrada única do fluxo.
     • Esse ambiente de desenvolvimento integrado padronizado promove a colaboração entre vários membros que trabalham em diferentes aspectos do fluxo.

2. Teste e avaliação de lotes experimentais baseados em nuvem – CLI/SDK do prompt flow e interface do usuário do portal do workspace

   • Após a fase de desenvolvimento e teste local, os desenvolvedores de fluxo podem usar a CLI ou o SDK do pfazure para enviar execuções em lote e execuções de avaliação dos arquivos de fluxo locais para a nuvem.
     • Essa ação fornece uma maneira de os resultados que consomem recursos da nuvem serem armazenados de forma persistente e gerenciados de forma eficiente com uma interface do usuário do portal no workspace do Azure Machine Learning. Essa etapa permite o consumo de recursos da nuvem, incluindo computação e armazenamento, e um ponto de extremidade adicional para implantações.
   • Após os envios para a nuvem, os membros da equipe podem acessar a interface do usuário do portal da nuvem para exibir os resultados e gerenciar os experimentos com eficiência.
     • Esse workspace na nuvem fornece um local centralizado para reunir e gerenciar todo o histórico de execuções, logs, instantâneos, resultados abrangentes, incluindo as entradas e saídas no nível da instância.
     • Na lista de execuções que registra todo o histórico de execuções durante o desenvolvimento, os membros da equipe podem comparar facilmente os resultados de diferentes execuções, auxiliando na análise da qualidade e nos ajustes necessários.

3. Desenvolvimento iterativo local ou implantação da interface do usuário em uma única etapa para produção

   • Após a análise dos experimentos, os membros da equipe podem retornar ao repositório de código para outro desenvolvimento e ajuste fino. As execuções seguintes podem ser enviadas para a nuvem de forma iterativa.
     • Essa abordagem iterativa garante um aprimoramento consistente até que a equipe esteja satisfeita com a qualidade pronta para a produção.
   • Quando a equipe estiver totalmente confiante na qualidade do fluxo, ele poderá ser implantado sem problemas por meio de um assistente de interface do usuário como um ponto de extremidade online no Azure Machine Learning. Quando a equipe estiver totalmente confiante na qualidade do fluxo, ele poderá ser facilmente transferido para a produção por meio de um assistente de implantação da interface do usuário como um ponto de extremidade online em um ambiente de nuvem robusto.
     • Essa implantação em um ponto de extremidade online pode ser baseada em um instantâneo de execução, permitindo um serviço estável e seguro, alocação adicional de recursos e rastreamento de uso, além de monitoramento de registros na nuvem.

Por que recomendamos o uso do repositório de código para o desenvolvimento colaborativo

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

Quando for necessário compartilhar fluxos em diferentes ambientes, é recomendável usar um repositório de código baseado em nuvem, como o GitHub ou o Azure Repos. Isso permite que você acesse a versão mais recente do seu código de qualquer local e fornece ferramentas para colaboração e gerenciamento de código.

Seguindo essa melhor prática, as equipes podem criar um ambiente colaborativo contínuo, eficiente e produtivo para o desenvolvimento do prompt flow.

Próximas etapas

• Configurar LLMOps de ponta a ponta com o prompt flow e o GitHub
• Documentação da CLI do fluxo do Prompt para o Azure