Integración del flujo de avisos con DevOps para aplicaciones basadas en LLM

El flujo de avisos de Azure Machine Learning es un método de desarrollo fácil de usar y amigable para el desarrollador, que permite crear e iterar flujos para el desarrollo de aplicaciones basadas en modelos de lenguaje (LLM) de gran tamaño. Prompt flow proporciona un SDK y CLI, una extensión de Visual Studio Code y una interfaz de usuario para la creación de flujos. Estas herramientas facilitan el desarrollo de flujos locales, la ejecución de flujos locales y la activación de ejecuciones de evaluación, así como la transición de flujos entre áreas de trabajo locales y en la nube.

Puede combinar la experiencia de flujo de avisos y las funcionalidades de código con operaciones de desarrollador (DevOps) para mejorar los flujos de trabajo de desarrollo de aplicaciones basados en LLM. Este artículo se centra en la integración del flujo de solicitudes y DevOps para aplicaciones basadas en LLM de Azure Machine Learning.

En el diagrama siguiente se muestra la interacción del desarrollo del flujo de avisos local y basado en la nube con DevOps.

Requisitos previos

• Un área de trabajo de Azure Machine Learning. Para crear uno, consulte Creación de recursos para empezar.

• Un entorno de Python local con el SDK de Azure Machine Learning Python v2 instalado, creado siguiendo las instrucciones de Introducción.

  Nota:

  Este entorno es independiente del entorno que usa la sesión de cálculo para ejecutar el flujo, la cual defines como parte del flujo. Para obtener más información, consulte Administrar sesión de proceso de flujo de avisos en Estudio de Azure Machine Learning.

• Visual Studio Code con las extensiones de flujo de Python y Prompt instaladas.

  

Uso de una experiencia orientada a código en el flujo de avisos

El desarrollo de aplicaciones basadas en LLM suele seguir un proceso estandarizado de ingeniería de aplicaciones que incluye repositorios de código fuente y canalizaciones de integración continua/implementación continua (CI/CD). Este proceso promueve el desarrollo simplificado, el control de versiones y la colaboración entre los miembros del equipo.

La integración de DevOps con la experiencia de código de flujo de avisos ofrece a los desarrolladores de código un proceso de iteración de GenAIOps o LLMOps más eficaz, con las siguientes características y ventajas clave:

• Flujo de versiones en el repositorio de código. Puede definir archivos de flujo en formato YAML y permanecen alineados con los archivos de origen referenciados en la misma estructura de carpetas.

• Integración de ejecuciones de flujo con la canalización de CI/CD. Puede integrar el flujo de avisos perfectamente en su proceso de entrega y canalización de CI/CD utilizando la CLI o el SDK de flujo de avisos para desencadenar ejecuciones de flujo automáticamente.

• Transición fluida entre local y en la nube. Puede exportar fácilmente su carpeta de flujo a su repositorio de código local o ascendente para el control de versiones, el desarrollo local y el uso compartido. También puede importar sin esfuerzo la carpeta de flujo en Azure Machine Learning para crear, probar e implementar más mediante recursos en la nube.

Acceder al código de flujo de avisos

Cada flujo de avisos tiene una estructura de carpetas de flujo que contiene archivos de código esenciales que definen el flujo. La estructura de carpetas organiza su flujo, facilitando transiciones más fluidas entre la local y la nube.

Azure Machine Learning proporciona un sistema de archivos compartido para todos los usuarios del área de trabajo. Al crear un flujo, se genera automáticamente una carpeta de flujo correspondiente y se almacena en el directorio Users/<username>/promptflow.

Trabajar con archivos de código de flujo

Una vez creado un flujo en Estudio de Azure Machine Learning, puede ver, editar y administrar los archivos de flujo en la sección Files de la página de creación de flujos. Cualquier modificación realizada en los archivos se refleja directamente en el recurso compartido de archivos.

La carpeta de flujo de un flujo basado en LLM contiene los siguientes archivos clave.

• flow.dag.yaml es el archivo de definición de flujo principal en formato YAML. Este archivo es integral para la creación y la definición del flujo de avisos. El archivo incluye información sobre las entradas, salidas, nodos, herramientas y variantes que usa el flujo.

• Los archivos de código fuente administrados por el usuario en Python (.py) o Jinja 2 (.jinja2) configuran las herramientas y nodos del flujo. La herramienta Python usa archivos Python para definir la lógica de Python personalizada. La herramienta de avisos y la herramienta LLM usan archivos Jinja 2 para definir el contexto del aviso.

• Los archivos que no son de origen, como los archivos de utilidad y de datos, se pueden incluir en la carpeta de flujo junto con los archivos de origen.

Para ver y editar el código sin procesar del flow.dag.yaml y los archivos de código fuente en el editor de archivos, active el Modo de archivo sin formato.

Como alternativa, puede acceder a todas las carpetas y archivos de flujo desde la página Estudio de Azure Machine Learning Notebooks.

Descarga y comprobación del código de flujo de avisos

Para comprobar el flujo en el repositorio de código, exporte la carpeta de flujo de Estudio de Azure Machine Learning a la máquina local. Seleccione el icono de descarga de la sección Archivos de la página de creación de flujo para descargar un paquete ZIP que contenga todos los archivos de flujo. A continuación, puede comprobar ese archivo en el repositorio de código o descomprimirlo para trabajar con los archivos localmente.

Para obtener más información sobre la integración de DevOps con Azure Machine Learning, consulte Git integration for Azure Machine Learning.

Desarrollo y prueba localmente

A medida que perfecciona y ajusta el flujo o las indicaciones durante el desarrollo iterativo, puede llevar a cabo múltiples iteraciones localmente dentro de su repositorio de código. La versión de la comunidad de VS Code, la extensión de flujo de avisos de VS Code y la CLI y SDK local de flujo de avisos facilitan el desarrollo y las pruebas locales puras sin vinculación a Azure.

Trabajar localmente le permite realizar y probar cambios rápidamente, sin necesidad de actualizar cada vez el repositorio principal de código. Para obtener más detalles sobre cómo usar versiones locales, consulte la comunidad de GitHub 'Prompt flow' .

Uso de la extensión de flujo de avisos de VS Code

Al usar la extensión Flujo de avisos de VS Code, puede crear fácilmente el flujo localmente desde el editor de VS Code con una experiencia de interfaz de usuario similar a la de la nube.

Para editar archivos localmente en VS Code con la extensión Prompt Flow:

1. En VS Code con la extensión de flujo de avisos habilitada, abra una carpeta de flujo de avisos.

2. Abra el archivo flow.dag.yaml y seleccione el vínculo del editor visual en la parte superior del archivo.

   

3. Utilice el editor visual de flujo de avisos para realizar los cambios en su flujo, como ajustar los avisos en las variantes o agregar más nodos.

   

4. Para probar el flujo, seleccione el icono Ejecutar en la parte superior del editor visual o, para probar cualquier nodo, seleccione el icono Ejecutar en la parte superior del nodo.

   

Uso del SDK y la CLI de flujo de avisos

Si prefiere trabajar directamente en el código o usar Jupyter, PyCharm, Visual Studio u otro entorno de desarrollo integrado (IDE), puede modificar directamente el código YAML en el archivo flow.dag.yaml.

A continuación, puede desencadenar una sola ejecución de flujo para las pruebas mediante la CLI o el SDK de flujo de avisos en el terminal de la siguiente manera.

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}")

Los valores devueltos son los registros y salidas de prueba.

Enviar ejecuciones a la nube desde un repositorio local

Una vez que esté satisfecho con los resultados de las pruebas locales, puede usar la CLI o el SDK del flujo de avisos para enviar ejecuciones a la nube desde el repositorio local. El siguiente procedimiento y código se basan en el proyecto de demostración Web Classification en GitHub. Puede clonar el repositorio del proyecto o descargar el código de flujo de avisos en la máquina local.

Instalar el SDK de flujo de comandos

Instale el SDK/CLI de flujo de comandos de Azure ejecutando pip install promptflow[azure] promptflow-tools.

Si usa el proyecto de demostración, obtenga el SDK y otros paquetes necesarios mediante la instalación de requirements.txt con
pip install -r <path>/requirements.txt.

Conexión al área de trabajo de 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,
)

Carga del flujo y creación de una ejecución

$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)

Cree una ejecución de flujo de evaluación

$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)

Visualización de los resultados de las ejecuciones

Enviar la ejecución de flujo a la nube devuelve la dirección URL de la ejecución en la nube. Puede abrir la dirección URL para ver los resultados de la ejecución en Estudio de Azure Machine Learning. También puede ejecutar los siguientes comandos de la CLI o SDK para ver los resultados de la ejecución.

Transmisión de los registros

pfazure run stream --name <run-name>

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

Ver resultados de la ejecución

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

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

Ver las métricas de ejecución de la evaluación

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

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

Integración con DevOps

Una combinación de un entorno de desarrollo local y un sistema de control de versiones, como Git, suele ser lo más eficaz para el desarrollo iterativo. Puede realizar modificaciones y probar el código localmente y, a continuación, confirmar los cambios en Git. Este proceso crea un registro continuo de los cambios y ofrece la posibilidad de revertir a versiones anteriores si es necesario.

Cuando necesite compartir flujos en distintos entornos, puede insertarlos en un repositorio de código basado en la nube, como GitHub o Azure Repos. Esta estrategia le permite acceder a la versión más reciente del código desde cualquier ubicación y proporciona herramientas para la colaboración y la administración de código.

Al seguir estos procedimientos, los equipos pueden crear un entorno de colaboración fluido, eficiente y productivo para el desarrollo ágil de flujos de trabajo.

Para ver canalizaciones de LLMOps de un extremo a otro que ejecutan flujos de clasificación web, consulte Configurar GenAIOps de extremo a extremo con flujo de avisos y GitHub. y el proyecto de demostración de clasificación web de GitHub.

El flujo de desencadenador se ejecuta en la canalizaciones de CI

Una vez que desarrolle y pruebe con éxito su flujo, y lo registre como versión inicial, estará listo para las siguientes iteraciones de ajuste y prueba. En esta fase, puede desencadenar ejecuciones de flujo, incluidas las pruebas por lotes y las ejecuciones de evaluación, mediante el uso de la CLI de flujo de avisos para automatizar los pasos de su canalización de IC.

A lo largo del ciclo de vida de las iteraciones de flujo, puede usar la CLI para automatizar las siguientes operaciones:

• Ejecución del flujo de avisos después de una solicitud de incorporación de cambios
• Ejecución de la evaluación del flujo de solicitud para asegurarse de que los resultados son de alta calidad
• Registro de modelos de flujo de avisos
• Implementación de modelos de flujo rápido

Usar la interfaz de usuario del estudio para el desarrollo continuo

En cualquier momento del desarrollo de flujo, puede volver a la interfaz de usuario de Estudio de Azure Machine Learning y usar recursos y experiencias en la nube para realizar cambios en el flujo.

Para seguir desarrollando y trabajando con la versión más actualizada de los archivos de flujo, puede acceder al terminal de la página de Notebook y extraer los últimos archivos de flujo de su repositorio. O bien, puede importar directamente una carpeta de flujo local como un nuevo flujo de borrador para realizar la transición sin problemas entre el desarrollo local y en la nube.

Desplegar el flujo como un punto de conexión en línea

El último paso para ir a producción es implementar el flujo como punto de conexión en línea en Azure Machine Learning. Este proceso le permite integrar su flujo en su aplicación y hacer que esté disponible para su uso. Para obtener más información sobre cómo desplegar el flujo, consulte Desplegar flujos en el punto de conexión en línea gestionado de Azure Machine Learning para inferencia en tiempo real.

Colaboración en el desarrollo de flujos

La colaboración entre los miembros del equipo puede ser esencial al desarrollar una aplicación basada en modelos de lenguaje (LLM) con flujo de prompts. Los miembros del equipo pueden crear y probar el mismo flujo, trabajando en diferentes facetas del flujo o realizando cambios iterativos y mejoras simultáneamente. Esta colaboración requiere un enfoque eficaz y simplificado para compartir código, realizar el seguimiento de modificaciones, administrar versiones e integrar cambios en el proyecto final.

El SDK/CLI de flujo de avisos y la extensión de flujo de avisos de VS Code facilitan la colaboración sencilla en el desarrollo de flujos basados en código dentro de un repositorio de código fuente. Puede usar un sistema de control de código fuente basado en la nube, como GitHub o Azure Repos para realizar un seguimiento de los cambios, administrar versiones e integrar estas modificaciones en el proyecto final.

Seguir el procedimiento recomendado para el desarrollo colaborativo

1. Configure un repositorio de código centralizado.

   El primer paso de este proceso de colaboración implica el uso de un repositorio de código como base para el código del proyecto, que incluye el código de flujo de avisos. Este repositorio centralizado permite una organización eficaz, el seguimiento de cambios y la colaboración entre los miembros del equipo.

2. Redacta y prueba de forma individual tu flujo localmente en VS Code con la extensión Prompt flow.

   Una vez configurado el repositorio, los miembros del equipo pueden usar VS Code con la extensión Prompt flow para la autoría local y las pruebas de un único input del flujo. El entorno de desarrollo integrado estandarizado promueve la colaboración entre varios miembros que trabajan en distintos aspectos del flujo.

   

3. Use la CLI o el SDK de pfazure para enviar ejecuciones por lotes y ejecuciones de evaluación desde flujos locales a la nube.

   Después del desarrollo y las pruebas locales, los miembros del equipo pueden usar la CLI o el SDK del flujo de comandos para enviar y evaluar procesos por lotes y de evaluación en la nube. Este proceso permite el uso de proceso en la nube, el almacenamiento de resultados persistentes, la creación de puntos de conexión para implementaciones y la administración eficaz en la interfaz de usuario de Studio.

   

4. Vea y administre los resultados de ejecución en la interfaz de usuario del área de trabajo de Estudio de Azure Machine Learning.

   Después de enviar ejecuciones a la nube, los miembros del equipo pueden acceder a la interfaz de usuario de Studio para ver los resultados y administrar experimentos de forma eficaz. El área de trabajo en la nube proporciona una ubicación centralizada para recopilar y administrar el historial de ejecución, los registros, las instantáneas, los resultados completos y las entradas y salidas del nivel de instancia.

   

5. Use la lista Ejecuciones que registra todo el historial de ejecuciones para comparar fácilmente los resultados de diferentes ejecuciones, facilitando el análisis de calidad y los ajustes necesarios.

   

6. Siga usando el desarrollo iterativo local.

   Después de analizar los resultados de los experimentos, los miembros del equipo pueden volver al entorno local y al repositorio de código para obtener más desarrollo y ajuste, y enviar iterativamente ejecuciones posteriores a la nube. Este enfoque iterativo garantiza una mejora coherente hasta que el equipo esté satisfecho con la calidad para producción.

7. Utilice la implementación en un solo paso en producción en el Studio.

   Una vez que el equipo está totalmente seguro de la calidad del flujo, se puede implementar sin problemas como punto de conexión en línea en un entorno en la nube sólido. La implementación como punto de conexión en línea se puede basar en una instantánea de ejecución, lo que permite ofrecer servicios estables y seguros, realizar un seguimiento adicional del uso y la asignación de recursos y realizar la supervisión de registros en la nube.

   

   El asistente Estudio de Azure Machine Learning Deploy ayuda a configurar fácilmente la implementación.

   

Contenido relacionado

• Configurar GenAIOps de extremo a extremo con flujo de avisos y GitHub
• Documentación de la CLI del flujo de avisos para Azure