Intégrer Prompt flow à DevOps pour les applications basées sur des LLM

Le flux d’invite Azure Machine Learning est une méthode de développement Code-First, conviviale et facile à utiliser pour développer et répéter des flux pour le développement d’applications basée sur des grands modèles de langage (LLM). Prompt flow fournit un Kit de développement logiciel (SDK) et une interface CLI, une extension Visual Studio Code et une interface utilisateur de création de flux. Ces outils facilitent le développement de flux local, le déclenchement de l’exécution de flux locaux et de l’exécution d’évaluations, et la transition de flux entre des environnements d’espace de travail local et cloud.

Vous pouvez combiner l’expérience de Prompt flow et les capacités du code avec des opérations de développement (DevOps) pour améliorer vos workflows de développement d’applications basés sur des LLM. Cet article se concentre sur l’intégration de Prompt flow et de DevOps pour des applications Azure Machine Learning basées sur des LLM.

Le diagramme suivant montre l’interaction du développement de flux d’invite local et cloud avec DevOps.

Prérequis

• Un espace de travail Azure Machine Learning. Pour en créer un, consultez Créer des ressources pour commencer.

• Un environnement Python local avec le Kit de développement logiciel (SDK) Python Azure Machine Learning v2 installé, créé en suivant les instructions de Prise en main.

  Remarque

  Cet environnement est distinct de l’environnement que la session de calcul utilise pour exécuter le flux, que vous définissez dans le cadre du flux. Pour plus d’informations, consultez Gérer une session de calcul de flux d’invite dans Azure Machine Learning studio.

• Visual Studio Code avec les extensions Python et Prompt flow installées.

  

Utiliser une expérience Code-First dans un flux d’invite

Le développement d’applications basées sur des LLM suit généralement un processus d’ingénierie des applications standardisé qui inclut des référentiels de code source et des pipelines d’intégration continue/déploiement continu (CI/CD). Ce processus favorise la simplification du développement, du contrôle de version et de la collaboration entre les membres de l’équipe.

L’intégration de DevOps à l’expérience du code des flux d’invite offre aux développeurs de code un processus d’itération GenAIOps ou LLMOps plus efficace, avec les fonctionnalités et avantages principaux suivants :

• Contrôle de version du flux dans le référentiel de code. Vous pouvez définir des fichiers de flux au format YAML, qui restent alignés avec les fichiers sources référencés dans la même structure de dossiers.

• Intégration de l’exécution de flux avec des pipelines CI/CD. Vous pouvez intégrer de façon fluide un flux d’invite à vos pipelines CI/CD et à votre processus de livraison en utilisant l’interface CLI ou le Kit de développement logiciel (SDK) du flux d’invite pour déclencher automatiquement des exécutions du flux.

• Transition fluide entre l’environnement local et le cloud. Vous pouvez exporter facilement votre dossier de flux vers votre référentiel de code local ou en amont pour le contrôle de version, le développement local et le partage. Vous pouvez aussi réimporter facilement le dossier de flux dans Azure Machine Learning pour poursuivre la création, les tests et le déploiement en utilisant des ressources cloud.

Accéder au code du flux d’invite

Chaque flux d’invite a une structure de dossiers de flux contenant les fichiers de code essentiels qui définissent le flux. Cette structure de dossiers organise votre flux, facilitant ainsi des transitions plus fluides entre un environnement local et le cloud.

Azure Machine Learning fournit un système de fichiers partagé pour tous les utilisateurs d’un espace de travail. Lors de la création d’un flux, un dossier de flux correspondant est généré automatiquement et stocké dans le répertoire Users/<nom_utilisateur>/promptflow.

Utiliser des fichiers de code de flux

Une fois que vous avez créé un flux dans Azure Machine Learning studio, vous pouvez visualiser, modifier et gérer les fichiers de flux dans la section Fichiers de la page de création de flux. Les modifications que vous apportez aux fichiers sont reflétées directement dans le stockage du partage de fichiers.

Le dossier de flux d’un flux basé sur un LLM contient les fichiers clés suivants.

• flow.dag.yaml est le fichier de définition de flux principal au format YAML. Ce fichier est une partie intégrante de la création et de la définition du flux d’invite. Le fichier inclut des informations sur les entrées, les sorties, les nœuds, les outils et les variantes utilisés par le flux.

• Les fichiers de code source gérés par l’utilisateur au format Python (.py) ou Jinja 2 (.jinja2) configurent les outils et les nœuds dans le flux. L’outil Python utilise des fichiers Python pour définir une logique Python personnalisée. L’outil de prompt et l’outil LLM utilisent des fichiers Jinja 2 pour définir le contexte du prompt.

• Les fichiers non-sources, tels que les fichiers d’utilitaire et les fichiers de données, peuvent être inclus dans le dossier de flux avec les fichiers sources.

Pour visualiser et modifier le code brut des fichiers flow.dag.yaml et des fichiers sources dans l’éditeur de fichiers, activez Mode Fichier brut.

Vous pouvez aussi accéder à et modifier tous vos dossiers et fichiers de flux depuis la page Notebooks d’Azure Machine Learning studio.

Télécharger et archiver le code de flux d’invite

Pour archiver votre flux dans votre référentiel de code, exportez le dossier de flux depuis Azure Machine Learning studio vers votre machine locale. Sélectionnez l’icône de téléchargement dans la section Fichiers de la page de création de flux pour télécharger un package ZIP contenant tous les fichiers du flux. Vous pouvez ensuite archiver ce fichier dans votre référentiel de code ou le décompresser pour travailler avec les fichiers localement.

Pour plus d’informations sur l’intégration de DevOps à Azure Machine Learning, consultez Intégration de Git pour Azure Machine Learning.

Développer et tester localement

Quand vous affinez et que vous optimisez votre flux ou vos prompts pendant un développement itératif, vous pouvez effectuer plusieurs itérations localement dans votre référentiel de code. La version de la communauté VS Code, l’extension Prompt flow de VS Code, et le Kit de développement logiciel (SDK) local et l’interface CLI de Prompt flow facilitent le développement et les tests purement locaux sans liaison avec Azure.

Travailler localement vous permet d’apporter des modifications et de les tester rapidement, sans devoir mettre à jour à chaque fois le référentiel de code principal. Pour plus d’informations et de conseils sur l’utilisation des versions locales, consultez Communauté GitHub Prompt flow.

Utiliser l’extension Prompt flow de VS Code

En utilisant l’extension Prompt flow de VS Code, vous pouvez créer facilement votre flux localement dans l’éditeur VS Code avec une expérience de l’interface utilisateur similaire à celle du cloud.

Pour modifier des fichiers localement dans VS Code avec l’extension Prompt flow :

1. Dans VS Code, avec l’extension Prompt flow activée, ouvrez un dossier de flux d’invite.

2. Ouvrez le fichier flow.dag.yaml et sélectionnez le lien Éditeur visuel en haut du fichier.

   

3. Utilisez l’éditeur visuel de Prompt flow pour apporter les modifications nécessaires à votre flux, par exemple optimiser les prompts dans des variantes ou ajouter plus de nœuds.

   

4. Pour tester votre flux, sélectionnez l’icône Exécuter en haut de l’éditeur visuel ou, pour tester n’importe quel nœud, sélectionnez l’icône Exécuter en haut du nœud.

   

Utiliser le Kit de développement logiciel (SDK) et l’interface CLI de Prompt flow

Si vous préférez travailler directement dans le code, ou utiliser Jupyter, PyCharm, Visual Studio ou un autre environnement de développement intégré (IDE), vous pouvez modifier directement le code YAML dans le fichier flow.dag.yaml.

Vous pouvez ensuite déclencher une exécution de flux unique pour le tester en utilisant l’interface CLI ou le Kit de développement logiciel (SDK) de Prompt flow dans le terminal, comme suit.

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

Les valeurs de retour sont les journaux et les sorties du test.

Envoyer des exécutions dans le cloud depuis un référentiel local

Une fois que vous êtes satisfait des résultats de vos tests locaux, vous pouvez utiliser l’interface CLI ou le Kit de développement logiciel (SDK) de Prompt flow pour envoyer des exécutions dans le cloud depuis le référentiel local. La procédure et le code suivants sont basés sur le projet de démonstration de classification web dans GitHub. Vous pouvez cloner le référentiel du projet ou télécharger le code du flux d’invite sur votre machine locale.

Installer le Kit de développement logiciel (SDK) de flux d’invite

Installez le Kit de développement logiciel (SDK)/interface CLI de Prompt flow Azure en exécutant pip install promptflow[azure] promptflow-tools.

Si vous utilisez le projet de démonstration, vous obtenez le Kit de développement logiciel (SDK) et d’autres packages nécessaires en installant requirements.txt avec
pip install -r <path>/requirements.txt.

Connectez-vous à votre espace de travail 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,
)

Charger le flux et créer une exécution

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

Créer une exécution de flux d’évaluation

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

Afficher les résultats de l’exécution

Le fait d’envoyer l’exécution de flux dans le cloud retourne l’URL cloud de l’exécution. Vous pouvez ouvrir l’URL pour voir les résultats de l’exécution dans Azure Machine Learning studio. Vous pouvez aussi exécuter les commandes CLI ou SDK suivantes pour voir les résultats de l’exécution.

Diffuser en continu les journaux

pfazure run stream --name <run-name>

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

Afficher les sorties d’exécution

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

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

Voir les mesures de l’exécution d’évaluation

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

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

Intégrer à DevOps

Une combinaison d’un environnement de développement local et d’un système de contrôle de version comme Git est généralement plus efficace pour le développement itératif. Vous pouvez apporter des modifications et tester votre code localement, puis commiter les modifications sur Git. Ce processus crée un enregistrement continu de vos modifications et offre la possibilité de revenir si nécessaire à des versions antérieures.

Quand vous avez besoin de partager des flux entre différents environnements, vous pouvez les envoyer (push) dans un référentiel de code basé sur le cloud, comme GitHub ou Azure Repos. Cette stratégie vous permet d’accéder à la version la plus récente du code depuis n’importe où, et elle fournit des outils de collaboration et de gestion du code.

En suivant ces pratiques, les équipes peuvent créer un environnement collaboratif fluide, efficace et productif pour le développement de flux d’invite.

Pour obtenir un exemple de pipeline LLMOps de bout en bout qui exécute un flux de classification web, consultez Configurer GenAIOps de bout en bout avec Prompt flow et GitHub et le projet de démonstration de classification web de GitHub.

Déclencher des exécutions de flux dans des pipelines CI

Une fois que vous avez développé et testé avec succès votre flux, et que vous l’avez archivé en tant que version initiale, vous êtes prêt pour les itérations d’optimisation et de test. À ce stade, vous pouvez déclencher des exécutions de flux, y compris des tests par lots et des exécutions d’évaluation, en utilisant l’interface CLI pour automatiser les étapes de votre pipeline CI.

Tout au long du cycle de vie de vos itérations du flux, vous pouvez utiliser l’interface CLI pour automatiser les opérations suivantes :

• Exécution du flux d’invite après une demande de tirage
• Exécution de l’évaluation du flux d’invite pour garantir que les résultats sont de haute qualité
• Inscription de modèles de flux d’invite
• Déploiement de modèles de flux d’invite

Utiliser l’interface utilisateur du studio pour le développement continu

À tout moment dans le développement d’un flux, vous pouvez revenir à l’interface utilisateur d’Azure Machine Learning studio et utiliser des ressources et des expériences cloud pour apporter des modifications à votre flux.

Pour continuer à développer et à travailler avec la version la plus récente des fichiers du flux, vous pouvez accéder à un terminal dans la page Notebook et extraire les fichiers du flux les plus récents de votre référentiel. Vous pouvez aussi importer directement un dossier de flux local en tant que nouveau brouillon de flux pour effectuer une transition fluide entre le développement local et le développement cloud.

Déployer le flux en tant que point de terminaison en ligne

La dernière étape pour passer en production consiste à déployer votre flux en tant que point de terminaison en ligne dans Azure Machine Learning. Ce processus vous permet d’intégrer votre flux dans votre application et de le rendre disponible pour l’utilisation. Pour plus d’informations sur le déploiement de votre flux, consultez Déployer des flux sur un point de terminaison en ligne managé Azure Machine Learning pour effectuer de l’inférence en temps réel.

Collaborer sur le développement de flux

La collaboration entre les membres de l’équipe peut s’avérer essentielle quand il s’agit de développer une application basée sur des LLM avec Prompt flow. Les membres de l’équipe peuvent créer et tester le même flux, travailler sur différentes facettes du flux, ou apporter simultanément des modifications et des améliorations itératives. Cette collaboration nécessite une approche efficace et fluide du partage du code, du suivi des modifications, de la gestion des versions et de l’intégration des changements dans le projet final.

Le Kit de développement logiciel (SDK)/l’interface CLI de Prompt flow et l’extension Prompt flow de VS Code facilitent la collaboration sur le développement de flux basés sur le code au sein d’un référentiel de code source. Vous pouvez utiliser un système de contrôle de code source basé sur le cloud, comme GitHub ou Azure Repos, pour suivre les modifications, gérer les versions et intégrer ces modifications dans le projet final.

Suivre les meilleures pratiques du développement collaboratif

1. Configurez un référentiel de code centralisé.

   La première étape de ce processus collaboratif implique la configuration d’un référentiel de code comme base pour le code du projet, y compris le code du flux d’invite. Ce référentiel centralisé permet une organisation efficace, le suivi des modifications de code et la collaboration entre les membres de l’équipe.

2. Créez et testez votre flux seul localement dans VS Code avec l’extension Prompt flow.

   Une fois le référentiel configuré, les membres de l’équipe peuvent utiliser VS Code avec l’extension Prompt flow pour créer localement et tester le flux avec une seule entrée. L’environnement de développement intégré standardisé favorise la collaboration entre plusieurs membres qui travaillent sur différents aspects du flux.

   

3. Utilisez l’interface CLI ou le Kit de développement logiciel (SDK) pfazure pour envoyer des exécutions par lots et des exécutions d’évaluation depuis des flux locaux vers le cloud.

   Après le développement et le test en local, les membres de l’équipe peuvent utiliser l’interface CLI/le Kit de développement logiciel (SDK) de Prompt flow pour envoyer et évaluer des exécutions par lots et d’évaluation dans le cloud. Ce processus permet l’utilisation du calcul cloud, le stockage persistants des résultats, la création de points de terminaison pour les déploiements et une gestion efficace dans l’interface utilisateur du studio.

   

4. Visualisez et gérez les résultats des exécutions dans l’interface utilisateur de l’espace de travail Azure Machine Learning studio.

   Après avoir envoyé les exécutions au cloud, les membres de l’équipe peuvent accéder à l’interface utilisateur du studio pour voir les résultats et gérer efficacement les expériences. L’espace de travail cloud fournit un emplacement centralisé pour collecter et gérer l’historique des exécutions, les journaux, les instantanés et les résultats complets, ainsi que les entrées et les sorties au niveau de l’instance.

   

5. Utilisez la liste Exécutions, qui enregistre l’historique de toutes les exécutions, pour comparer facilement les résultats de différentes exécutions, ce qui facilite l’analyse de la qualité et les ajustements nécessaires.

   

6. Continuez à utiliser le développement itératif local.

   Après avoir analysé les résultats des expériences, les membres de l’équipe peuvent revenir à l’environnement local et au référentiel de code pour poursuivre le développement et l’optimisation, et envoyer de façon itérative les exécutions suivantes au cloud. Cette approche itérative garantit des améliorations constantes jusqu’à ce que l’équipe soit satisfaite de la qualité de la production.

7. Utilisez un déploiement en production en une seule étape dans le studio.

   Quand l’équipe a entièrement confiance dans la qualité du flux, elle peut le déployer facilement en tant que point de terminaison en ligne dans un environnement cloud robuste. Le déploiement en tant que point de terminaison en ligne peut être basé sur un instantané d’exécution, ce qui permet un service stable et sécurisé, l’allocation de ressources supplémentaires et un suivi de l’utilisation, ainsi qu’une surveillance des journaux dans le cloud.

   

   L’Assistant Déploiement d’Azure Machine Learning studio vous aide à configurer facilement votre déploiement.

   

Contenu connexe

• Configurer GenAIOps de bout en bout avec un flux d’invite et GitHub
• Documentation sur l’Interface CLI de flux rapide pour Azure