Integrar fluxo de prompts com DevOps para aplicações baseadas em LLM

O fluxo de pedidos do Azure Machine Learning é um método baseado principalmente em código, acessível e fácil de usar, para desenvolver e iterar fluxos para o desenvolvimento de aplicações baseadas em grandes modelos de linguagem (LLM). Prompt flow fornece um SDK, um CLI, uma extensão para o Visual Studio Code e uma interface de fluxo de autoria. Estas ferramentas facilitam o desenvolvimento de fluxos locais, a execução e avaliação de fluxos locais, o desencadeamento e a transição de fluxos entre ambientes de trabalho locais e na cloud.

Pode combinar a experiência do fluxo de prompts e as capacidades de código com operações de desenvolvimento (DevOps) para melhorar os seus fluxos de trabalho de desenvolvimento de aplicações baseados em LLM. Este artigo foca-se na integração de fluxo de prompt e DevOps para aplicações baseadas em LLM do Azure Machine Learning.

O diagrama seguinte mostra a interação do desenvolvimento de fluxo de prompts, tanto local como na cloud, com o DevOps.

Pré-requisitos

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

• Um ambiente Python local com o SDK Azure Machine Learning Python v2 instalado, criado seguindo as instruções em Getting started.

  Nota

  Este ambiente é separado do ambiente que a sessão de computação utiliza para executar o fluxo, que defines como parte do fluxo. Para mais informações, consulte Gerir a sessão de cálculo de fluxo de solicitações no Azure Machine Learning Studio.

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

  

Use uma experiência de código em fluxo de prompts

O desenvolvimento de aplicações baseadas em LLM geralmente segue um processo padronizado de engenharia de aplicações que inclui repositórios de código-fonte e pipelines de integração contínua/implementação contínua (CI/CD). Este processo promove um desenvolvimento simplificado, controlo de versões e colaboração entre os membros da equipa.

A integração do DevOps com o sistema de fluxo de execução de prompts oferece aos programadores um processo de iteração GenAIOps ou LLMOps mais eficiente, com as seguintes características e principais benefícios:

• Versionamento de fluxo no repositório de código. Podes definir ficheiros de fluxo em formato YAML, e eles mantêm-se alinhados com ficheiros fonte referenciados na mesma estrutura de pastas.

• Integração de execução de fluxo com pipelines CI/CD. Pode integrar sem problemas o fluxo de prompts nos seus pipelines de CI/CD e no processo de entrega, usando a CLI ou o SDK de fluxo de prompts para executar automaticamente fluxos de tarefas.

• Transição suave entre local e cloud. Podes facilmente exportar a tua pasta de fluxo para o repositório de código local ou upstream para controlo de versões, desenvolvimento local e partilha. Também pode importar facilmente a pasta de fluxo de volta para o Azure Machine Learning para autoria, testes e implementação adicionais usando recursos na cloud.

Código de fluxo de acesso rápido

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

O Azure Machine Learning fornece um sistema de ficheiros partilhado para todos os utilizadores do espaço de trabalho. Após a criação do fluxo, uma pasta de fluxo correspondente é automaticamente gerada e armazenada no diretório Users/<username>/promptflow.

Trabalho com ficheiros de código de fluxo

Depois de criares um fluxo no Estúdio do Azure Machine Learning, podes ver, editar e gerir os ficheiros de fluxo na secção Ficheiros da página de autoria de fluxos. Quaisquer modificações que faças aos ficheiros refletem-se diretamente no armazenamento de partilha de ficheiros.

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

• flow.dag.yaml é o ficheiro principal de definição de fluxo em formato YAML. Este ficheiro é fundamental para a autoria e configuração do fluxo de prompts. O ficheiro inclui informações sobre entradas, saídas, nós, ferramentas e variantes que o fluxo utiliza.

• Ficheiros de código-fonte geridos pelo utilizador em formato Python (.py) ou Jinja 2 (.jinja2) configuram as ferramentas e nós no fluxo. A ferramenta Python utiliza ficheiros Python para definir lógica Python personalizada. A ferramenta de prompts e a ferramenta LLM usam ficheiros Jinja 2 para definir o contexto do prompt.

• Ficheiros não-fonte, como utilidade e ficheiros de dados, podem ser incluídos na pasta de fluxo juntamente com os ficheiros de origem.

Para visualizar e editar o código bruto do flow.dag.yaml e dos ficheiros fonte no editor de ficheiros, ative o modo de ficheiro Raw.

Alternativamente, pode aceder e editar todas as pastas e ficheiros do fluxo a partir da página Estúdio do Azure Machine Learning Notebooks.

Faça o download e efetue o check-in do código de fluxo

Para verificar o seu fluxo no repositório de código, exporte a pasta de fluxo do Estúdio do Azure Machine Learning para a sua máquina local. Selecione o ícone de download na secção Ficheiros da página de autoria de fluxo para descarregar um pacote ZIP contendo todos os ficheiros de fluxo. Depois podes adicionar esse ficheiro ao teu repositório de código ou descompactá-lo para trabalhar com os ficheiros localmente.

Para mais informações sobre integração DevOps com Azure Machine Learning, veja integração Git para Azure Machine Learning.

Desenvolver e testar localmente

À medida que refina e ajusta o seu fluxo ou prompts durante o desenvolvimento iterativo, pode realizar múltiplas iterações localmente dentro do seu repositório de código. A versão da comunidade VS Code, a extensão de fluxo do VS Code Prompt e o SDK e CLI locais de fluxo de prompts facilitam o desenvolvimento e testes locais puros sem ligação ao Azure.

Trabalhar localmente permite-te fazer e testar alterações rapidamente, sem precisar de atualizar o repositório principal de código de cada vez. Para mais detalhes e orientações sobre o uso de versões locais, consulte a comunidade GitHub Prompt flow.

Use a extensão de fluxo do VS Code Prompt

Ao usar a extensão Prompt flow VS Code, pode facilmente criar o seu fluxo localmente no editor VS Code com uma experiência de interface semelhante à da cloud.

Para editar ficheiros localmente no VS Code com a extensão Prompt flow:

1. No VS Code, com a extensão Prompt flow ativada, abre uma pasta de prompt flow.

2. Abra o ficheiro flow.dag.yaml e selecione o link do editor Visual no topo do ficheiro.

   

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

   

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

   

Utilize o SDK de fluxo de instruções e a CLI

Se preferir trabalhar diretamente em código, ou usar Jupyter, PyCharm, Visual Studio ou outro ambiente de desenvolvimento integrado (IDE), pode modificar diretamente o código YAML no ficheiro flow.dag.yaml.

Pode então iniciar uma única execução de prompt flow para testes usando a CLI ou SDK 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 de retorno são os registos de teste e as saídas.

Submeter execuções de tarefa para a nuvem a partir de um repositório local

Quando estiver satisfeito com os resultados dos seus testes locais, pode usar a CLI ou SDK de prompt flow para submeter execuções à cloud a partir do repositório local. O procedimento e o código seguintes baseiam-se no projeto demo Web Classification em GitHub. Podes clonar o repositório do projeto ou descarregar o código de fluxo de prompt para a tua máquina local.

Instale o SDK de fluxo de prompts

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

Se estiveres a usar o projeto demo, obtém o SDK e outros pacotes necessários instalando requirements.txt com
pip install -r <path>/requirements.txt.

Ligue-se ao seu espaço de trabalho 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,
)

Envia o fluxo e cria 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)

Ver resultados das corridas

Ao submeter a execução do fluxo para a nuvem, a URL da execução na nuvem é retornada. Pode abrir o URL para ver os resultados da execução no Estúdio do Azure Machine Learning. Também pode executar os seguintes comandos CLI ou SDK para visualizar os resultados da execução.

Transmita os registos

pfazure run stream --name <run-name>

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

Ver saídas de execução

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

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

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

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

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

Integrar com DevOps

Uma combinação de um ambiente de desenvolvimento local e um sistema de controlo de versões como o Git é tipicamente mais eficaz para desenvolvimento iterativo. Podes fazer modificações e testar o teu código localmente, depois fazer commit das alterações no Git. Este processo cria um registo contínuo das suas alterações e oferece a possibilidade de reverter a versões anteriores, se necessário.

Quando precisares de partilhar fluxos entre diferentes ambientes, podes enviá-los para um repositório de código baseado na cloud como o GitHub ou o Repositórios do Azure. Esta estratégia permite-lhe aceder à versão mais recente do código a partir de qualquer localização e fornece ferramentas para colaboração e gestão de código.

Ao seguir estas práticas, as equipas podem criar um ambiente colaborativo fluido, eficiente e produtivo para o desenvolvimento rápido do fluxo.

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

Desencadear o fluxo em pipelines de Integração Contínua

Depois de desenvolveres e testares com sucesso o teu flow e o registares como versão inicial, estás pronto para ajustar e testar iterações. Nesta fase, pode desencadear execuções de fluxo, incluindo testes em lote e execuções de avaliação, usando a CLI de fluxo de prompt para automatizar passos no seu pipeline de CI.

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

• Executar o fluxo de prompt após um pull request
• Realizar uma avaliação rápida do fluxo para garantir que os resultados são de alta qualidade
• Registo de modelos de fluxo de prompt
• Implementação de modelos de fluxo prompt

Use a interface do Studio para desenvolvimento contínuo

Em qualquer fase do desenvolvimento de fluxos, podes voltar à interface do Estúdio do Azure Machine Learning e usar recursos e experiências cloud para fazer alterações ao teu fluxo.

Para continuar a desenvolver e trabalhar com as versões mais atualizadas dos ficheiros de fluxo, pode aceder a um terminal na página do Bloco de Notas e extrair os ficheiros de fluxo mais recentes do seu repositório. Ou pode importar diretamente uma pasta de fluxo local como um novo rascunho de fluxo para fazer uma transição fluida entre desenvolvimento local e nuvem.

Implementar o fluxo como um endpoint online

O último passo para a produção é implementar o seu fluxo como um endpoint online no Azure Machine Learning. Este processo permite-lhe integrar o seu fluxo na aplicação e torná-lo disponível para uso. Para mais informações sobre como implementar o seu fluxo, consulte Implementar fluxos para o endpoint online gerido do Azure Machine Learning para inferência em tempo real.

Colaborar no desenvolvimento de fluxos

A colaboração entre os membros da equipa pode ser essencial ao desenvolver uma aplicação baseada em LLM com fluxo rápido. Os membros da equipa podem estar a criar e testar o mesmo fluxo, a trabalhar em diferentes aspetos do fluxo ou a fazer alterações e melhorias iterativas em simultâneo. Esta colaboração requer uma abordagem eficiente e simplificada na partilha de código, acompanhamento de modificações, gestão de versões e integração de alterações no projeto final.

O SDK/CLI do Prompt Flow e a extensão Prompt Flow para o VS Code facilitam a colaboração no desenvolvimento de fluxos de código dentro de um repositório de código-fonte. Pode usar um sistema de controlo de versões baseado na cloud como o GitHub ou o Repositórios do Azure para acompanhar alterações, gerir versões e integrar essas modificações no projeto final.

Siga as melhores práticas de desenvolvimento colaborativo

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

   O primeiro passo do processo colaborativo envolve configurar um repositório de código como base para o código do projeto, incluindo o código do fluxo de prompts. Este repositório centralizado permite uma organização eficiente, acompanhamento de alterações e colaboração entre os membros da equipa.

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

   Uma vez configurado o repositório, os membros da equipa podem usar VS Code com a extensão Prompt flow para autoria local e testes de entrada única do fluxo. O ambiente integrado de desenvolvimento padronizado promove a colaboração entre múltiplos membros que trabalham em diferentes aspetos do fluxo.

   

3. Use o pfazure CLI ou SDK para submeter execuções em lote e execuções de avaliação dos fluxos locais para a nuvem.

   Após o desenvolvimento e testes locais, os membros da equipa podem usar o CLI/SDK do Prompt Flow para submeter e avaliar execuções em lote e avaliações para a nuvem. Este processo permite o uso de computação em nuvem, armazenamento persistente de resultados, criação de endpoints para implementações e gestão eficiente na interface do estúdio.

   

4. Visualize e gere os resultados das execuções na interface de trabalho do Estúdio do Azure Machine Learning Workspace.

   Depois de submeterem as corridas para a cloud, os membros da equipa podem aceder à interface do estúdio para ver os resultados e gerir experiências de forma eficiente. O espaço de trabalho na cloud oferece um local centralizado para recolher e gerir o histórico de execuções, logs, snapshots, resultados abrangentes e entradas e saídas ao nível da instância.

   

5. Use a lista de Corridas que regista todo o histórico de corridas para comparar facilmente os resultados de diferentes corridas, ajudando na análise de qualidade e nos ajustes necessários.

   

6. Continue a utilizar o desenvolvimento iterativo local.

   Após analisar os resultados das experiências, os membros da equipa podem regressar ao ambiente local e ao repositório de código para mais desenvolvimento e afinamento, submetendo iterativamente execuções subsequentes para a cloud. Esta abordagem iterativa assegura melhorias consistentes até que a equipa fique satisfeita com a qualidade da produção.

7. Use a implementação em um passo para a produção no estúdio.

   Uma vez que a equipa esteja totalmente confiante na qualidade do fluxo, pode implementá-lo de forma fluida como um endpoint online num ambiente cloud robusto. A implementação como endpoint online pode basear-se num snapshot de execução, permitindo um serviço estável e seguro, alocação adicional de recursos e acompanhamento de utilização, e monitorização de registos na cloud.

   

   O assistente Estúdio do Azure Machine Learning Deploy ajuda-te a configurar facilmente o teu deployment.

   

Conteúdo relacionado

• configurar GenAIOps de ponta a ponta com fluxo de prompts e GitHub
• Documentação Prompt Flow CLI para Azure