Intégrer le flux d’invite à DevOps pour les applications basées sur LLM

Dans cet article, vous allez découvrir l’intégration du flux d’invite à l’application DevOps basée sur LLM dans Azure Machine Learning. Le flux d’invite offre une expérience Code First conviviale pour le développeur et facile à utiliser pour le développement et l’itération de flux avec l’ensemble de votre flux de travail de développement d’applications basées sur LLM.

Il fournit un SDK et une interface CLI de flux d’invite, une extension VS Code et la nouvelle interface utilisateur de l’explorateur de dossiers de flux pour faciliter le développement local des flux, le déclenchement local des exécutions de flux et les exécutions d’évaluation, ainsi que la transition des flux d’environnements locaux vers des environnements cloud (espace de travail Azure Machine Learning).

Cette documentation se concentre sur la façon de combiner efficacement les fonctionnalités de l’expérience de code de flux d’invite et de DevOps pour améliorer vos flux de travail de développement d’applications basées sur LLM.

Présentation de l’expérience Code First dans le flux d’invite

Lors du développement d’applications à l’aide de LLM, il est courant d’avoir un processus d’ingénierie d’application standardisé qui inclut des référentiels de code et des pipelines CI/CD. Cette intégration permet de simplifier le processus de développement, le contrôle de version et la collaboration entre les membres de l’équipe.

Pour les développeurs expérimentés dans le développement de code qui recherchent un processus d’itération LLMOps plus efficace, l’expérience de code de flux d’invite vous permet de bénéficier des fonctionnalités clés et des avantages suivants :

• Contrôle de version de flux dans le référentiel de code. Vous pouvez définir votre flux au format YAML, qui peut rester aligné sur les fichiers sources référencés dans une structure de dossiers.
• Intégration de l’exécution de flux avec le pipeline CI/CD. Vous pouvez déclencher des exécutions de flux à l’aide de l’interface CLI ou du SDK de flux d’invite, qui peuvent être intégrés en toute transparence à votre pipeline CI/CD et à votre processus de livraison.
• Transition en douceur d’un environnement local vers le cloud. Vous pouvez facilement exporter votre dossier de flux vers votre référentiel local ou de code pour le contrôle de version, le développement local et le partage. De même, le dossier de flux peut être importé sans effort dans le cloud pour d’autres opérations de création, de test et de déploiement dans les ressources cloud.

Accès à la définition de code de flux d’invite

Chaque flux, chaque flux d’invite est associé à une structure de dossiers de flux qui contient des fichiers essentiels pour définir le flux dans la structure des dossiers de code. Cette structure de dossiers organise votre flux, facilitant ainsi les transitions plus fluides.

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

Structure des dossiers de flux

Vue d’ensemble de la structure des dossiers de flux et des fichiers clés qu’elle contient :

• flow.dag.yaml : ce fichier de définition de flux principal, au format YAML, inclut des informations sur les entrées, les sorties, les nœuds, les outils et les variantes utilisés dans le flux. Il est essentiel pour la création et la définition du flux d’invite.
• Fichiers de code source (.py, .jinja2) : le dossier de flux inclut également des fichiers de code source gérés par l’utilisateur, qui sont référencés par les outils/nœuds du flux.
  • Les fichiers au format Python (.py) peuvent être référencés par l’outil Python pour définir une logique Python personnalisée.
  • Les fichiers au format Jinja 2 (.jinja2) peuvent être référencés par l’outil d’invite ou l’outil LLM pour définir le contexte d’invite.
• Fichiers non sources: le dossier de flux peut également contenir des fichiers non sources tels que des fichiers utilitaires et des fichiers de données qui peuvent être inclus dans les fichiers sources.

Une fois le flux créé, vous pouvez accéder à la page de création de flux pour afficher et utiliser les fichiers de flux dans l’explorateur de fichiers approprié. Cela vous permet d’afficher, de modifier et de gérer vos fichiers. Toutes les modifications apportées aux fichiers sont directement reflétées dans le stockage de partage de fichiers.

Lorsque le « Mode de fichier brut » est activé, vous pouvez afficher et modifier le contenu brut des fichiers dans l’éditeur de fichiers, y compris le fichier de définition de flux flow.dag.yaml et les fichiers sources.

Vous pouvez également accéder à tous les dossiers de flux directement dans le notebook Azure Machine Learning.

Contrôle de version du flux rapide dans le référentiel de code

Pour archiver votre flux dans votre référentiel de code, vous pouvez facilement exporter le dossier de flux de la page de création de flux vers votre système local. Cela télécharge un package contenant tous les fichiers de l’explorateur vers votre ordinateur local, que vous pouvez ensuite archiver dans votre référentiel de code.

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

Envoi d’exécutions dans le cloud à partir d’un référentiel local

Prérequis

• Terminez le Créer des ressources pour commencer si vous ne disposez pas déjà d’un espace de travail Azure Machine Learning.

• Un environnement Python dans lequel vous avez installé le SDK Azure Machine Learning Python v2. Instructions d’installation. Cet environnement est destiné à la définition et au contrôle de vos ressources Azure Machine Learning et est séparé de l’environnement utilisé lors de l’exécution. Pour en savoir plus, consultez Comment gérer l’exécution pour l’ingénierie du flux d’invite.

Installer le SDKde flux d’invite

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

Se connecter à un espace de travail Azure Machine Learning

Azure CLI

az login

Kit de développement logiciel (SDK) 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,
)

Azure CLI

Préparez le run.yml pour définir la configuration de cette exécution de flux dans le cloud.

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

Vous pouvez spécifier la connexion et le nom de déploiement pour chaque outil du flux. Si vous ne spécifiez pas le nom de connexion et de déploiement, il utilise la connexion et le déploiement sur le fichier flow.dag.yaml. Pour mettre en forme les connexions :

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

pfazure run create --file run.yml

Kit de développement logiciel (SDK) 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)

Azure CLI

Préparez le run_evaluation.yml pour définir la configuration de cette exécution de flux d’évaluation dans le cloud.

$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

Kit de développement logiciel (SDK) 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
)

Afficher les résultats d’exécution dans l’espace de travail Azure Machine Learning

Envoyer l’exécution de flux vers le cloud retourne l’URL du portail de l’exécution. Vous pouvez ouvrir l’URI, afficher les résultats de l’exécution dans le portail.

Vous pouvez également utiliser la commande suivante pour afficher les résultats des exécutions.

Diffuser en continu les journaux

Azure CLI

pfazure run stream --name <run_name>

Kit de développement logiciel (SDK) Python

pf.stream("<run_name>")

Afficher les sorties d’exécution

Azure CLI

pfazure run show-details --name <run_name>

Kit de développement logiciel (SDK) Python

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

Afficher les métriques de l’exécution de l’évaluation

Azure CLI

pfazure run show-metrics --name <evaluation_run_name>

Kit de développement logiciel (SDK) Python

pf.get_metrics("evaluation_run_name")

Important

Pour plus d’informations, vous pouvez consulter la documentation sur l’interface CLI du flux d’invite pour Azure.

Développement itératif à partir d’un réglage précis

Développement et test locaux

Lors du développement itératif, à mesure que vous affinez et ajustez votre flux ou vos invites, il peut être utile d’effectuer plusieurs itérations localement dans votre référentiel de code. La version de la communauté, l’extension VS Code du flux d’invite et l’interface CLI et le SDK local de flux d’invite sont fournis pour faciliter le développement et les tests purement locaux sans liaison Azure.

Extension VS Code de flux d’invite

Une fois l’extension VS Code du flux d’invite installée, vous pouvez facilement créer votre flux localement à partir de l’éditeur VS Code, ce qui offre une expérience d’interface utilisateur similaire à celle du cloud.

Pour utiliser l’extension :

1. Ouvrez un dossier de flux d’invite dans VS Code Desktop.
2. Ouvrez le fichier « flow.dag.yaml » en mode notebook.
3. Utilisez l’éditeur visuel pour apporter les modifications nécessaires à votre flux, par exemple paramétrer les invites dans des variantes ou ajouter d’autres outils.
4. Pour tester votre flux, sélectionnez le bouton Exécuter le flux en haut de l’éditeur visuel. Cela déclenche un test de flux.

Interface CLI et SDK local de flux d’invite

Si vous préférez utiliser Jupyter, PyCharm, Visual Studio ou d’autres IDE, vous pouvez modifier directement la définition YAML dans le fichier flow.dag.yaml.

Vous pouvez ensuite déclencher une seule exécution du flux pour les tests à l’aide du SDK ou de l’interface CLI du flux d’invite.

Azure CLI

En supposant que vous êtes dans le répertoire de travail <path-to-the-sample-repo>/examples/flows/standard/

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

Kit de développement logiciel (SDK) Python

La valeur de retour de la fonction test est les sorties du flux/nœud.

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

Cela vous permet d’apporter et de tester des modifications rapidement, sans avoir à mettre à jour le référentiel de code principal à chaque fois. Une fois que vous êtes satisfait des résultats de vos tests locaux, vous pouvez passer à l’envoi d’exécutions vers le cloud à partir d’un référentiel local pour effectuer des exécutions d’essai dans le cloud.

Pour plus d’informations et de conseils sur l’utilisation des versions locales, vous pouvez vous référer à la communauté GitHub du flux d’invite.

Retour à l’interface utilisateur studio pour le développement continu

Vous avez également la possibilité de revenir à l’interface utilisateur studio, en utilisant les ressources et l’expérience cloud pour apporter des modifications à votre flux dans la page de création de flux.

Pour continuer à développer et à utiliser la version la plus récente des fichiers de flux, vous pouvez accéder au terminal dans le notebook et extraire les dernières modifications des fichiers de flux à partir de votre dépôt.

En outre, si vous préférez continuer à travailler dans l’interface utilisateur studio, vous pouvez importer directement un dossier de flux local en tant que nouveau flux brouillon. Cela vous permet de passer en toute transparence entre le développement local et le développement cloud.

Intégration CI/CD

CI : Déclencher des exécutions de flux dans le pipeline CI

Une fois que vous avez correctement développé et testé votre flux et que vous l’avez archivé en tant que version initiale, vous êtes prêt pour l’itération de réglage et de test suivante. À ce stade, vous pouvez déclencher des exécutions de flux, notamment des tests par lot et des exécutions d’évaluation, à l’aide de l’interface CLI du flux d’invite. Cela peut servir de flux de travail automatisé dans votre pipeline d’intégration continue (CI).

Tout au long du cycle de vie de vos itérations de flux, plusieurs opérations peuvent être automatisées :

• 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

Pour obtenir un guide complet sur un pipeline MLOps de bout en bout qui exécute un flux de classification web, consultez Configurer LLMOps de bout en bout avec le flux d’invite et GitHub, ainsi que le projet de démonstration GitHub.

CD : Déploiement continu

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. Cela vous permet d’intégrer votre flux à 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 obtenir une inférence en temps réel avec l’interface CLI et le SDK.

Collaboration au développement de flux en production

Dans le cadre du développement d’une application basée sur LLM avec le flux d’invite, la collaboration entre les membres de l’équipe est souvent essentielle. Les membres de l’équipe peuvent être impliqués dans le même processus de création et de test de flux, que ce soit en travaillant sur diverses facettes du flux ou en apportant simultanément des modifications et des améliorations itératives.

Cette collaboration nécessite une approche efficace et simplifiée dans différents domaines : partage de code, suivi des modifications, gestion des versions et intégration des modifications au projet final.

L’introduction du SDK/de l’interface CLI et de l’extension Visual Studio Code du flux d’invite dans le cadre de l’expérience de programmation du flux d’invite facilite la collaboration pour développer des flux dans votre dépôt de code. Il est conseillé d’utiliser un référentiel de code basé sur le cloud, tel que GitHub ou Azure DevOps, pour le suivi des modifications, la gestion des versions et l’intégration des modifications dans le projet final.

Meilleure pratique relative au développement collaboratif

1. Création de votre flux et réalisation d’un test unique localement – Référentiel de code et extension VSC

   • La première étape de ce processus collaboratif consiste à utiliser un dépôt de code comme base pour le code de votre projet, qui inclut le code du flux d’invite.
     • Ce référentiel centralisé permet une organisation efficace, le suivi de toutes les modifications de code et la collaboration entre les membres de l’équipe.
   • Une fois le référentiel configuré, les membres de l’équipe peuvent utiliser l’extension VSC pour la création locale et le test d’entrée unique du flux.
     • Cet environnement de développement intégré standardisé favorise la collaboration entre plusieurs membres d’une équipe qui travaillent sur différents aspects du flux.

2. Tests par lot et évaluation expérimentaux basés sur le cloud – CLI/SDK du flux d’invite et interface utilisateur du portail de l’espace de travail

   • Après la phase de développement et de test au niveau local, les développeurs de flux peuvent utiliser l’interface CLI ou le SDK pfazure pour envoyer des exécutions par lots et des exécutions d’évaluation à partir des fichiers de flux locaux au cloud.
     • Cette action permet non seulement de consommer des ressources cloud, mais aussi de stocker les résultats de manière persistante et de les gérer efficacement avec une interface utilisateur de type portail dans l’espace de travail Azure Machine Learning. Cette étape permet de consommer des ressources cloud, notamment le calcul et le stockage, et fournit un autre point de terminaison pour les déploiements.
   • Lorsque vous publiez des soumissions sur le cloud, les membres de l’équipe peuvent accéder à l’interface utilisateur du portail cloud pour afficher les résultats et gérer efficacement les expériences.
     • Cet 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, notamment les entrées et sorties au niveau de l’instance.
     • Dans la liste des exécutions qui enregistre l’historique des exécutions pendant le développement, les membres de l’équipe peuvent facilement comparer les résultats de différentes exécutions, facilitant ainsi l’analyse de la qualité et les ajustements qui s’imposent.

3. Développement itératif local ou déploiement d’interface utilisateur en une étape pour la production

   • Après l’analyse des expériences, les membres de l’équipe peuvent revenir au référentiel de code pour un autre développement et réglage précis. Les exécutions suivantes peuvent ensuite être soumises au cloud de manière itérative.
     • Cette approche itérative garantit des améliorations continues jusqu’à ce que l’équipe soit satisfaite de la qualité et décide de passer en production.
   • Lorsque l’équipe a entière confiance dans la qualité du flux, elle peut le déployer en toute transparence via un Assistant avec interface utilisateur en tant que point de terminaison en ligne dans Azure Machine Learning. Lorsque l’équipe a entière confiance dans la qualité du flux, elle peut facilement le transférer en production via un Assistant de déploiement avec interface utilisateur en tant que point de terminaison en ligne dans un environnement cloud robuste.
     • Ce déploiement sur un point de terminaison en ligne peut être basé sur un instantané d’exécution, permettant un service stable et sécurisé, une allocation des ressources plus poussée, le suivi de l’utilisation ainsi que la surveillance des journaux dans le cloud.

Raisons pour lesquelles nous recommandons d’utiliser le référentiel de code pour le développement collaboratif

Pour le développement itératif, il est généralement plus efficace de combiner un environnement de développement local et un système de gestion de version tel que Git. Vous pouvez apporter des modifications et tester votre code localement, puis commiter les modifications sur Git. Un enregistrement continu de vos modifications est ainsi créé, ce qui vous permet de revenir aux versions antérieures si nécessaire.

Si vous devez partager des flux entre différents environnements, il est conseillé d’utiliser un référentiel de code basé sur le cloud comme GitHub ou Azure Repos. Vous pouvez ainsi accéder à la version la plus récente de votre code à partir de n’importe quel emplacement et tirer profit d’outils de collaboration et de gestion du code.

En suivant cette bonne pratique, les équipes peuvent créer un environnement collaboratif transparent, efficace et productif pour développer avec le flux d’invite.

Étapes suivantes

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