Créer une application de conversation personnalisée en Python en utilisant le SDK du flux d’invite

Dans ce guide de démarrage rapide, nous allons vous guider tout au long de la configuration de votre environnement de développement local avec le Kit de développement logiciel (SDK) de flux d’invite. Nous écrivons une invite, nous l’exécutons dans le cadre de votre code d’application, suivons les appels LLM en cours et exécutons une évaluation de base sur les sorties du LLM.

Prérequis

Avant de pouvoir suivre ce guide de démarrage rapide, créez les ressources dont vous avez besoin pour votre application :

• Un hub AI Studio pour vous connecter à des ressources externes.
• Un projet pour organiser vos artefacts de projet et partager des traces et des exécutions d’évaluation.
• Un modèle de conversation Azure OpenAI déployé (gpt-35-turbo ou gpt-4)

Suivez Démarrage rapide avec les terrains de jeu AI Studio pour créer ces ressources si vous ne l’avez pas déjà fait. Vous pouvez également créer ces ressources en suivant l’article Kit de développement logiciel (SDK) pour créer un hub et un projet.

Accorder l’accès à l’appel de Azure OpenAI Service à l’aide de votre identité

Pour utiliser les meilleures pratiques de sécurité, au lieu des clés API, nous utilisons Microsoft Entra ID pour s’authentifier auprès d’Azure OpenAI à l’aide de votre identité utilisateur.

Vous ou votre administrateur devez accorder à votre identité utilisateur le rôle utilisateur OpenAI Cognitive Services sur la ressource Azure AI Services que vous utilisez. Ce rôle vous permet d’appeler Azure OpenAI Service à l’aide de votre identité utilisateur.

Pour vous accorder l’accès à la ressource Azure AI Services que vous utilisez :

1. Dans AI Studio, accédez à votre projet et sélectionnez Paramètres dans le volet gauche.

2. Dans la section Ressources connectées, sélectionnez le nom de connexion avec le type AIServices.

   

   Remarque

   Si vous ne voyez pas la connexion AIServices, utilisez plutôt la connexion Azure OpenAI.

3. Dans la page détails de la ressource, sélectionnez le lien sous le titre Ressource pour ouvrir la ressource des services IA dans le portail Azure.

   

4. Dans la page de gauche du portail Azure, sélectionnez Contrôle d’accès (IAM)>+ Ajouter>Ajouter une attribution de rôle.

5. Recherchez le rôle utilisateur OpenAI Cognitive Services, puis sélectionnez-le. Sélectionnez ensuite Suivant.

   

6. Sélectionnez Utilisateur, groupe ou principal de service. Puis, sélectionnez Sélectionner des membres.

7. Dans le volet Sélectionner des membres qui s’ouvre, recherchez le nom de l’utilisateur pour lequel vous souhaitez ajouter l’attribution de rôle. Sélectionnez l’utilisateur, puis Sélectionner.

   

8. Passez à l’Assistant et sélectionnez Vérifier + affecter pour ajouter l’attribution de rôle.

Installer Azure CLI et se connecter

Vous installez l'interface Azure CLI et vous vous connectez depuis votre environnement de développement local, afin de pouvoir utiliser vos informations d'identification pour appeler le service Azure OpenAI.

Dans la plupart des cas, vous pouvez installer Azure CLI à partir de votre terminal à l’aide de la commande suivante :

winget install -e --id Microsoft.AzureCLI

curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

brew update && brew install azure-cli

Vous pouvez suivre les instructions Comment installer l’interface de ligne de commande Azure si ces commandes ne fonctionnent pas pour votre système d’exploitation ou configuration particulier.

Après avoir installé Azure CLI, connectez-vous à l’aide de la commande az login et connectez-vous à l’aide du navigateur :

az login

Nous créons maintenant notre application et appelons Azure OpenAI Service à partir du code.

Créer un environnement Python

Tout d’abord, nous devons créer un environnement Python que nous pouvons utiliser pour installer les packages du Kit de développement logiciel (SDK) de flux d’invite. N’installez pas de packages dans votre installation globale de Python. Vous devez toujours utiliser un environnement virtuel ou conda lors de l’installation de packages Python. Sinon, vous pouvez interrompre votre installation globale de Python.

Si nécessaire, installez Python

Nous vous recommandons d’utiliser Python 3.10 ou version ultérieure, mais l’utilisation d’au moins Python 3.8 est requise. Si vous n’avez pas installé une version appropriée de Python, vous pouvez suivre les instructions du didacticiel Python VS Code pour le moyen le plus simple d’installer Python sur votre système d’exploitation.

Créer un environnement virtuel

Si Python 3.10, ou une version ultérieure est déjà installé, vous pouvez créer un environnement virtuel à l’aide des commandes suivantes :

py -3 -m venv .venv
.venv\scripts\activate

python3 -m venv .venv
source .venv/bin/activate

python3 -m venv .venv
source .venv/bin/activate

L'activation de l'environnement Python signifie que lorsque vous exécutez python ou pip depuis la ligne de commande, vous utilisez alors l'interpréteur Python contenu dans le dossier .venv de votre application.

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

Dans cette section, nous utilisons le flux d’invite pour générer notre application. Flux d’invite est une suite d'outils de développement conçus pour rationaliser le cycle de développement de bout en bout des applications d'IA basées sur le LLM, depuis l'idéation, le prototypage, les tests, l'évaluation jusqu'au déploiement et à la surveillance de la production.

Utilisez pip pour installer le Kit de développement logiciel (SDK) de flux d’invite dans l’environnement virtuel que vous avez créé.

pip install promptflow
pip install azure-identity

Le Kit de développement logiciel (SDK) de flux d’invite prend une dépendance sur plusieurs packages, que vous pouvez choisir d’installer séparément si vous ne souhaitez pas tous les installer :

• promptflow-core: contient le runtime de flux d’invite principal utilisé pour l’exécution du code LLM
• promptflow-tracing: bibliothèque légère utilisée pour émettre des traces OpenTelemetry dans des normes
• promptflow-devkit: contient le lit de test de flux d’invite et les outils de visionneuse de trace pour les environnements de développement locaux
• openai: bibliothèques clientes pour l’utilisation de Azure OpenAI service
• python-dotenv: utilisé pour définir des variables d’environnement en les lisant à partir de fichiers .env

Configurer vos variables d’environnement

Votre point de terminaison et votre nom de déploiement des services IA sont requis pour appeler Azure OpenAI Service à partir de votre code. Dans ce guide de démarrage rapide, vous enregistrez ces valeurs dans un fichier .env, qui est un fichier qui contient des variables d’environnement que votre application peut lire. Vous trouverez ces valeurs dans le terrain de jeu de conversation AI Studio.

1. Créez un fichier .env et collez le code suivant :

   AZURE_OPENAI_ENDPOINT=endpoint_value
   AZURE_OPENAI_CHAT_DEPLOYMENT=chat_deployment_name
   AZURE_OPENAI_API_VERSION=api_version
   

2. Accédez au terrain de jeu de conversation à l’intérieur de votre projet AI Studio. Tout d’abord, vérifiez que la conversation fonctionne avec votre modèle en envoyant un message au LLM.

3. Recherchez le nom du déploiement Azure OpenAI dans le terrain de jeu de conversation. Sélectionnez le déploiement dans la liste déroulante et pointez sur le nom du déploiement pour l’afficher. Dans cet exemple, le nom du déploiement est gpt-35-turbo-16k.

   

4. Dans le fichier .env, remplacez chat_deployment_name par le nom du déploiement de l’étape précédente. Dans cet exemple, nous utilisons le nom de déploiement gpt-35-turbo-16k.

5. Sélectionnez le bouton <> Afficher le code et copiez la valeur du point de terminaison et celle de la version de l’API.

   

6. Dans le fichier .env, remplacez endpoint_value par la valeur du point de terminaison et api_version par la version de l’API (comme « 2024-02-15-preview ») toutes deux copiées depuis la boîte de dialogue à l’étape précédente.

Créer une invite de conversation de base et une application

Créez d’abord un fichier Prompty, qui est le format de modèle d’invite pris en charge par le flux d’invite.

Créez un fichier chat.prompty et copiez-y le code suivant :

---
name: Chat Prompt
description: A basic prompt that uses the chat API to answer questions
model:
    api: chat
    configuration:
        type: azure_openai
    parameters:
        max_tokens: 256
        temperature: 0.2
inputs:
    chat_input:
        type: string
    chat_history:
        type: list
        is_chat_history: true
        default: []
outputs:   
  response:
    type: string
sample:
    chat_input: What is the meaning of life?
---
system:
You are an AI assistant who helps people find information.

{% for item in history %}
{{item.role}}:
{{item.content}}
{% endfor %}

user:
{{chat_input}}

Nous allons maintenant créer un fichier Python qui utilise ce modèle d’invite. Créez un fichier chat.py et collez-y le code suivant :

import os
from dotenv import load_dotenv
load_dotenv()

from promptflow.core import Prompty, AzureOpenAIModelConfiguration

model_config = AzureOpenAIModelConfiguration(
    azure_deployment=os.getenv("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT")
)

prompty = Prompty.load("chat.prompty", model={'configuration': model_config})
result = prompty(
    chat_history=[
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."}
    ],
    chat_input="Do other Azure AI services support this too?")

print(result)

À présent à partir de votre console, exécutez le code Python :

python chat.py

Vous devez maintenant voir la sortie de l’exécution de l’invite :

Yes, other Azure AI services also support various capabilities and features. Some of the Azure AI services include Azure Cognitive Services, Azure Machine Learning, Azure Bot Service, and Azure Databricks. Each of these services offers different AI capabilities and can be used for various use cases. If you have a specific service or capability in mind, feel free to ask for more details.

Suivre l’exécution de votre code de conversation

Maintenant, examinons comment le suivi de flux d’invite peut fournir des insights sur les différents appels LLM qui se produisent dans nos scripts Python.

Au début de votre fichier chat.py, ajoutez le code suivant pour activer le suivi de flux d’invite :

from promptflow.tracing import start_trace
start_trace()

Réexécutez votre chat.py :

python chat.py

Cette fois, vous voyez un lien dans la sortie pour afficher une trace de flux d’invite de l’exécution :

Starting prompt flow service...
Start prompt flow service on port 23333, version: 1.10.1.
You can stop the prompt flow service with the following command:'pf service stop'.
Alternatively, if no requests are made within 1 hours, it will automatically stop.
You can view the trace detail from the following URL:
http://localhost:23333/v1.0/ui/traces/?#collection=aistudio-python-quickstart&uiTraceId=0x59e8b9a3a23e4e8893ec2e53d6e1e521

Si vous sélectionnez ce lien, vous verrez alors la trace montrant les étapes de l'exécution du programme, ce qui a été transmis au LLM et la réponse produite.

Le suivi de flux d’invite vous permet également de suivre des appels de fonction spécifiques et des traces de journal dans AI Studio. Pour plus d’informations, veillez à consulter Comment utiliser le suivi dans le Kit de développement logiciel (SDK) de flux d’invite.

Évaluer votre invite

Nous allons maintenant montrer comment utiliser des évaluateurs de flux d’invite pour générer des métriques qui peuvent noter la qualité de la conversation sur une échelle comprise entre 0 et 5. Nous exécutons à nouveau l'invite, mais cette fois nous stockons les résultats dans un tableau contenant la conversation complète, puis nous le transmettons à ChatEvaluator pour noter.

Tout d’abord, installez le promptflow-evals package:

pip install promptflow-evals

Copiez maintenant le code suivant dans un fichier evaluate.py :

import os
from dotenv import load_dotenv
load_dotenv()

from promptflow.core import Prompty, AzureOpenAIModelConfiguration
from promptflow.evals.evaluators import ChatEvaluator

model_config = AzureOpenAIModelConfiguration(
    azure_deployment=os.getenv("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT")
)

chat_history=[
    {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
    {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."}
]
chat_input="Do other Azure AI services support this too?"

prompty = Prompty.load("chat.prompty", model={'configuration': model_config})
response = prompty(chat_history=chat_history, chat_input=chat_input)

conversation = chat_history
conversation += [
    {"role": "user", "content": chat_input},
    {"role": "assistant", "content": response}
]

chat_eval = ChatEvaluator(model_config=model_config)
score = chat_eval(conversation=conversation)

print(score)

Exécutez le script evaluate.py :

python evaluate.py

Vous devez voir une sortie semblable à ceci :

{'gpt_coherence': 5.0, 'gpt_fluency': 5.0, 'evaluation_per_turn': {'gpt_coherence': {'score': [5.0, 5.0]}, 'gpt_fluency': {'score': [5.0, 5.0]}}}

Il semble que nous ayons obtenu un score de 5 pour la cohérence et la fluidité des réponses du LLM dans cette conversation !

Pour plus d’informations sur l’utilisation des évaluateurs de flux d’invite, notamment sur la façon de créer vos propres évaluateurs personnalisés et de consigner les résultats de l’évaluation dans AI Studio, veillez à consulter Évaluer votre application à l’aide du Kit de développement logiciel (SDK) de flux d’invite.

Étape suivante