Integre o fluxo de prompt com o DevOps de aplicativos baseados em LLM

Neste artigo, você aprenderá sobre a integração do fluxo de prompt com o aplicativo baseado em LLM DevOps no Azure Machine Learning. O Prompt flow oferece uma experiência code-first amigável e fácil de usar para 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 a nuvem (espaço de trabalho do Azure Machine Learning).

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

Introdução da experiência code-first no fluxo de prompt

Ao desenvolver aplicativos usando LLM, é comum ter um processo de engenharia de aplicativos 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 imediato:

• 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.
• Integre a execução de 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 integrada ao seu pipeline de CI/CD e processo de entrega.
• Transição suave do local para a nuvem. Você pode exportar facilmente 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 criação, teste e implantação em recursos de nuvem.

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

Cada fluxo, cada fluxo de prompt, está associado a uma estrutura de pasta de fluxo que contém arquivos essenciais para definir o fluxo na estrutura de pastas de código. Esta estrutura de pastas organiza o 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 Users/<username>/promptflow diretório.

Estrutura de pastas de fluxo

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

• flow.dag.yaml: Este 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 em formato Python (.py) podem ser referenciados pela ferramenta python para definir a lógica python personalizada.
  • Os arquivos no formato Jinja 2 (.jinja2) podem ser referenciados pela ferramenta prompt ou pela ferramenta LLM para definir o contexto do prompt.
• Arquivos não-fonte: A pasta de fluxo também pode conter arquivos não-fonte, 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. Isto permite-lhe visualizar, editar e gerir os seus ficheiros. Quaisquer modificações feitas nos arquivos são refletidas diretamente no armazenamento de compartilhamento de arquivos.

Com o "Modo de arquivo bruto" ativado, você pode visualizar e editar o conteúdo bruto dos arquivos no editor de arquivos, incluindo o arquivo flow.dag.yaml 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.

Fluxo de prompt de controle de versão no repositório de código

Para fazer check-in do 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 faz o download de um pacote contendo todos os arquivos do explorador para sua máquina local, que você pode 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 Integração do Git no Azure Machine Learning

O envio de execuções para a nuvem a partir do repositório local

Pré-requisitos

• Conclua a Criar recursos para começar se ainda não tiver um espaço de trabalho 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 tempo de execução. Para saber mais, veja como gerenciar o tempo de execução para engenharia de fluxo de prompt.

Instalar SDK de fluxo de prompt

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

Conectar-se ao espaço de trabalho do Azure Machine Learning

CLI do Azure

az login

Python SDK

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 que esse fluxo seja executado 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 única conexão e implantação no flow.dag.yaml arquivo. Para o formato das conexões:

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

pfazure run create --file run.yml

Python SDK

# 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 este 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

Python SDK

# 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 da 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>

Python SDK

pf.stream("<run_name>")

Ver saídas de execução

CLI do Azure

pfazure run show-details --name <run_name>

Python SDK

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

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

CLI do Azure

pfazure run show-metrics --name <evaluation_run_name>

Python SDK

pf.get_metrics("evaluation_run_name")

Importante

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

Desenvolvimento iterativo a partir de ajustes finos

Desenvolvimento local e testes

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

Fluxo de prompt VS Extensão de código

Com a extensão VS Code de fluxo de prompt instalada, você pode facilmente criar seu fluxo localmente a partir do editor de código VS, 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'' na visualizaçã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 desencadeia um teste de fluxo.

SDK local de fluxo de prompt & CLI

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

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

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

Python SDK

O valor de retorno da test função é o fluxo/saída do 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 a necessidade de atualizar o repositório de código principal a cada vez. Quando estiver satisfeito com os resultados dos testes locais, você poderá transferir para o envio de execuções para a nuvem a partir do repositório local para executar execuções experimentais na nuvem.

Para obter mais detalhes e orientações sobre como usar as versões locais, você pode consultar a comunidade GitHub de fluxo de prompt.

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 seu 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 bloco de anotações e extrair as alterações mais recentes dos arquivos de fluxo do repositório.

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

Integração de CI/CD

CI: O fluxo de gatilho é executado no pipeline de CI

Depois de desenvolver e testar com sucesso seu fluxo, e fazer check-in como a versão inicial, você está pronto para a próxima iteração 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 de fluxo de prompt. 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:

• Executando o fluxo de prompt após uma solicitação pull
• Execução de avaliação de fluxo imediata 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, consulte Configurar LLMOps de ponta a ponta com prompt Flow e 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 em 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.

Colaborando no desenvolvimento de fluxo na produção

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

Essa colaboração requer 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 de fluxo de prompt/CLI e da extensão de código do Visual Studio como parte da experiência de código do fluxo de prompt facilita a colaboração fácil no desenvolvimento de fluxo em seu repositório de código. É aconselhável utilizar um repositório de código baseado em nuvem, como o GitHub ou o Azure DevOps, para controlar alterações, gerenciar versões e integrar essas modificações no projeto final.

Melhores práticas 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 projeto, que inclui o código de fluxo de prompt.
     • Esse repositório centralizado permite uma 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 estiver configurado, os membros da equipe poderão usar a extensão VSC para criação local e teste de entrada única do fluxo.
     • Este ambiente de desenvolvimento integrado padronizado promove a colaboração entre vários membros que trabalham em diferentes aspetos do fluxo.

2. Teste e avaliação em lote experimental baseados em nuvem - fluxo de prompt CLI/SDK e interface do usuário do portal de espaço de trabalho

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

3. Desenvolvimento iterativo local ou implantação de interface do usuário em uma 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 subsequentes 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 produção.
   • Quando a equipe estiver totalmente confiante na qualidade do fluxo, ele poderá ser implantado perfeitamente 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 de interface do usuário como um ponto de extremidade on-line em um ambiente de nuvem robusto.
     • Essa implantação em um endpoint online pode ser baseada em um instantâneo de execução, permitindo um serviço estável e seguro, alocação de recursos e rastreamento de uso adicionais e monitoramento de logs na nuvem.

Por que recomendamos o uso do repositório de código para 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, confirmar as alterações no Git. Isso cria um registro contínuo de suas alterações e oferece a capacidade de reverter para versões anteriores, se necessário.

Quando o compartilhamento de fluxos entre diferentes ambientes é necessário, o uso de um repositório de código baseado em nuvem como o GitHub ou o Azure Repos é aconselhável. 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 prática recomendada, as equipes podem criar um ambiente colaborativo perfeito, eficiente e produtivo para o desenvolvimento rápido do fluxo.

Próximos passos

• Configure LLMOps de ponta a ponta com fluxo de prompt e GitHub
• Documentação da CLI de fluxo de prompt para o Azure