Skapa en anpassad chattapp i Python med hjälp av promptflödes-SDK:n

I den här snabbstarten går vi igenom hur du konfigurerar din lokala utvecklingsmiljö med promptflödes-SDK:et. Vi skriver en uppmaning, kör den som en del av din appkod, spårar LLM-anropen som görs och kör en grundläggande utvärdering av utdata från LLM.

Förutsättningar

Innan du kan följa den här snabbstarten skapar du de resurser som du behöver för ditt program:

• En AI Studio-hubb för anslutning till externa resurser.
• Ett projekt för att organisera projektartefakter och dela spårningar och utvärderingskörningar.
• En distribuerad Azure OpenAI-chattmodell (gpt-35-turbo eller gpt-4)

Slutför snabbstarten för AI Studio Playground för att skapa dessa resurser om du inte redan har gjort det. Du kan också skapa dessa resurser genom att följa SDK-guiden för att skapa en hubb- och projektartikel .

Bevilja åtkomst för att anropa Azure OpenAI-tjänsten med hjälp av din identitet

I stället för API-nycklar använder vi Microsoft Entra-ID för att autentisera med Azure OpenAI med hjälp av din användaridentitet.

Du eller administratören måste ge din användaridentitet rollen Cognitive Services OpenAI-användare för den Azure AI Services-resurs som du använder. Den här rollen ger dig möjlighet att anropa Azure OpenAI-tjänsten med hjälp av din användaridentitet.

Så här ger du dig själv åtkomst till den Azure AI Services-resurs som du använder:

1. I AI Studio går du till projektet och väljer Inställningar i det vänstra fönstret.

2. I avsnittet Anslutna resurser väljer du anslutningsnamnet med typen AIServices.

   

   Kommentar

   Om du inte ser AIServices-anslutningen använder du Azure OpenAI-anslutningen i stället.

3. På sidan resursinformation väljer du länken under resursrubriken för att öppna AI-tjänstresursen i Azure Portal.

   

4. På den vänstra sidan i Azure Portal väljer du Åtkomstkontroll (IAM)>+ Lägg till>rolltilldelning.

5. Sök efter Rollen Cognitive Services OpenAI-användare och välj den sedan. Välj sedan Nästa.

   

6. Välj Användare, grupp eller tjänstens huvudnamn. Välj sedan Välj medlemmar.

7. I fönstret Välj medlemmar som öppnas söker du efter namnet på den användare som du vill lägga till rolltilldelningen för. Välj användaren och välj sedan Välj.

   

8. Fortsätt genom guiden och välj Granska + tilldela för att lägga till rolltilldelningen.

Installera Azure CLI och logga in

Du installerar Azure CLI och loggar in från din lokala utvecklingsmiljö, så att du kan använda dina autentiseringsuppgifter för att anropa Azure OpenAI-tjänsten.

I de flesta fall kan du installera Azure CLI från terminalen med hjälp av följande kommando:

winget install -e --id Microsoft.AzureCLI

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

brew update && brew install azure-cli

Du kan följa anvisningarna Så här installerar du Azure CLI om dessa kommandon inte fungerar för ditt operativsystem eller din installation.

När du har installerat Azure CLI loggar du in med az login kommandot och loggar in med webbläsaren:

az login

Nu skapar vi vår app och anropar Azure OpenAI-tjänsten från kod.

Skapa en ny Python-miljö

Först måste vi skapa en ny Python-miljö som vi kan använda för att installera SDK-paketen för promptflöde. Installera INTE paket i din globala Python-installation. Du bör alltid använda en virtuell miljö eller conda-miljö när du installerar Python-paket, annars kan du avbryta din globala installation av Python.

Installera Python om det behövs

Vi rekommenderar att du använder Python 3.10 eller senare, men minst Python 3.8 krävs. Om du inte har en lämplig version av Python installerad kan du följa anvisningarna i VS Code Python-självstudien för det enklaste sättet att installera Python på operativsystemet.

Skapa en virtuell miljö

Om du redan har Python 3.10 eller senare installerat kan du skapa en virtuell miljö med hjälp av följande kommandon:

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

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

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

När du aktiverar Python-miljön innebär det att när du kör python eller pip från kommandoraden använder du sedan Python-tolken .venv som finns i mappen för ditt program.

Installera SDK:et för promptflödet

I det här avsnittet använder vi promptflöde för att skapa vårt program. Prompt Flow är en uppsättning utvecklingsverktyg som utformats för att effektivisera utvecklingscykeln från slutpunkt till slutpunkt för LLM-baserade AI-program, från idésättning, prototyper, testning, utvärdering till produktionsdistribution och övervakning.

Använd pip för att installera SDK:et för promptflödet i den virtuella miljö som du skapade.

pip install promptflow
pip install azure-identity

SDK:t för promptflöde är beroende av flera paket, som du kan välja att installera separat om du inte vill att alla ska installeras:

• promptflow-core: innehåller den körning av kärnpromptflödet som används för att köra LLM-kod
• promptflow-tracing: lättviktsbibliotek som används för att generera OpenTelemetry-spårningar i standarder
• promptflow-devkit: innehåller testbädden för promptflöde och spårningsvisningsverktyg för lokala utvecklingsmiljöer
• openai: klientbibliotek för att använda Azure OpenAI-tjänsten
• python-dotenv: används för att ange miljövariabler genom att läsa dem från .env filer

Konfigurera miljövariabler

Din AI-tjänstslutpunkt och distributionsnamn krävs för att anropa Azure OpenAI-tjänsten från din kod. I den här snabbstarten sparar du dessa värden i en .env fil, vilket är en fil som innehåller miljövariabler som programmet kan läsa. Du hittar dessa värden i AI Studio-chattlekplatsen.

1. Skapa en .env fil och klistra in följande kod:

   AZURE_OPENAI_ENDPOINT=endpoint_value
   AZURE_OPENAI_CHAT_DEPLOYMENT=chat_deployment_name
   AZURE_OPENAI_API_VERSION=api_version
   

2. Gå till chattlekplatsen i ditt AI Studio-projekt. Kontrollera först att chatten fungerar med din modell genom att skicka ett meddelande till LLM.

3. Hitta Azure OpenAI-distributionsnamnet i chattlekplatsen. Välj distributionen i listrutan och hovra över distributionsnamnet för att visa den. I det här exemplet är distributionsnamnet gpt-35-turbo-16k.

   

4. .env I filen ersätter du chat_deployment_name med namnet på distributionen från föregående steg. I det här exemplet använder vi distributionsnamnet gpt-35-turbo-16k.

5. <> Välj knappen Visa kod och kopiera slutpunktsvärdet och API-versionsvärdet.

   

6. .env I filen ersätter du endpoint_value med slutpunktsvärdet och ersätter api_version med DEN API-version som kopierats från dialogrutan i föregående steg (till exempel "2024-02-15-preview").

Skapa en grundläggande chattprompt och app

Skapa först en Prompty-fil , vilket är formatet för promptmallen som stöds av promptflödet.

Skapa en chat.prompty fil och kopiera följande kod till den:

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

Nu ska vi skapa en Python-fil som använder den här promptmallen. Skapa en chat.py fil och klistra in följande kod i den:

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)

Kör nu Python-koden från konsolen:

python chat.py

Nu bör du se utdata från att köra prompty:

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.

Spåra körningen av chattkoden

Nu tar vi en titt på hur snabbflödesspårning kan ge insikter om de olika LLM-anrop som sker i våra Python-skript.

I början av chat.py filen lägger du till följande kod för att aktivera snabbflödesspårning:

from promptflow.tracing import start_trace
start_trace()

Kör igen chat.py :

python chat.py

Den här gången visas en länk i utdata för att visa en snabbflödesspårning av körningen:

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

Om du väljer den länken visas sedan spårningen som visar stegen i programkörningen, vad som skickades till LLM och svarsutdata.

Med snabbflödesspårning kan du också spåra specifika funktionsanrop och loggspårningar till AI Studio. Mer information finns i Så här använder du spårning i SDK för promptflöde.

Utvärdera din fråga

Nu ska vi visa hur vi kan använda frågeflödesutvärderingar för att generera mått som kan bedöma konversationens kvalitet på en skala från 0 till 5. Vi kör kommandotolken igen, men den här gången lagrar vi resultaten i en matris som innehåller hela konversationen och skickar sedan den till en ChatEvaluator för att göra poäng.

promptflow-evals packageInstallera först :

pip install promptflow-evals

Kopiera nu följande kod till en evaluate.py fil:

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)

Kör skriptet evaluate.py :

python evaluate.py

Du bör se utdata som ser ut så här:

{'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]}}}

Ser ut som vi fick 5 för konsekvens och flyt av LLM svar på den här konversationen!

Mer information om hur du använder utvärderare för promptflöde, inklusive hur du gör egna anpassade utvärderare och loggar utvärderingsresultat till AI Studio, finns i Utvärdera din app med hjälp av SDK för promptflöde.

Gå vidare