Integrera prompt flow med LLM-baserat program DevOps

I den här artikeln får du lära dig mer om integrering av promptflöde med LLM-baserade program DevOps i Azure Machine Learning. Prompt Flow erbjuder en utvecklarvänlig och lättanvänd kod-första upplevelse för flödesutveckling och iterering med hela ditt LLM-baserade arbetsflöde för programutveckling.

Det ger ett SDK för promptflöde och CLI, ett VS-kodtillägg och det nya användargränssnittet för flödesmapputforskaren för att underlätta den lokala utvecklingen av flöden, lokal utlösande av flödeskörningar och utvärderingskörningar samt övergång av flöden från lokala till molnbaserade miljöer (Azure Machine Learning-arbetsyta).

Den här dokumentationen fokuserar på hur du effektivt kombinerar funktionerna i promptflödeskoden och DevOps för att förbättra dina LLM-baserade arbetsflöden för programutveckling.

Introduktion av kod-första upplevelsen i promptflöde

När du utvecklar program med HJÄLP av LLM är det vanligt att ha en standardiserad programutvecklingsprocess som innehåller kodlagringsplatser och CI/CD-pipelines. Den här integreringen möjliggör en effektiv utvecklingsprocess, versionskontroll och samarbete mellan teammedlemmar.

För utvecklare med erfarenhet av kodutveckling som söker en effektivare LLMOps-iterationsprocess kan du få följande viktiga funktioner och fördelar med funktionen för snabbflödeskod:

• Flödesversioner i kodlagringsplatsen. Du kan definiera ditt flöde i YAML-format, som kan hållas i linje med de refererade källfilerna i en mappstruktur.
• Integrera flödeskörning med CI/CD-pipeline. Du kan utlösa flödeskörningar med hjälp av CLI eller SDK för promptflödet, som sömlöst kan integreras i CI/CD-pipelinen och leveransprocessen.
• Smidig övergång från lokal till moln. Du kan enkelt exportera flödesmappen till din lokala lagringsplats eller kodlagringsplats för versionskontroll, lokal utveckling och delning. På samma sätt kan flödesmappen enkelt importeras tillbaka till molnet för ytterligare redigering, testning och distribution i molnresurser.

Åtkomst till definition för promptflödeskod

Varje flöde är associerat med en flödesmappstruktur som innehåller viktiga filer för att definiera flödet i kodmappstrukturen. Den här mappstrukturen organiserar ditt flöde, vilket underlättar smidigare övergångar.

Azure Machine Learning erbjuder ett delat filsystem för alla arbetsyteanvändare. När du skapar ett flöde genereras och lagras en motsvarande flödesmapp automatiskt där, som finns i Users/<username>/promptflow katalogen.

Flödesmappstruktur

Översikt över flödesmappens struktur och de nyckelfiler som den innehåller:

• flow.dag.yaml: Den här primära flödesdefinitionsfilen i YAML-format innehåller information om indata, utdata, noder, verktyg och varianter som används i flödet. Det är en integrerad del för att redigera och definiera promptflödet.
• Källkodsfiler (.py, .jinja2): Flödesmappen innehåller även användarhanterade källkodsfiler som refereras till av verktygen/noderna i flödet.
  • Filer i Python-format (.py) kan refereras av python-verktyget för att definiera anpassad Python-logik.
  • Filer i Jinja 2-format (.jinja2) kan refereras av promptverktyget eller LLM-verktyget för att definiera snabbkontexten.
• Icke-källfiler: Flödesmappen kan också innehålla icke-källfiler, till exempel verktygsfiler och datafiler som kan ingå i källfilerna.

När flödet har skapats kan du navigera till sidan Flödesredigering för att visa och använda flödesfilerna i rätt utforskare. På så sätt kan du visa, redigera och hantera dina filer. Ändringar som görs i filerna återspeglas direkt i filresurslagringen.

Med "Raw File Mode" aktiverat kan du visa och redigera råinnehållet i filerna i filredigeraren, inklusive flödesdefinitionsfilen flow.dag.yaml och källfilerna.

Du kan också komma åt alla flödesmappar direkt i Azure Machine Learning-notebook-filen.

Versionshanteringspromptflöde i kodlagringsplatsen

Om du vill checka in flödet till kodlagringsplatsen kan du enkelt exportera flödesmappen från flödesredigeringssidan till det lokala systemet. Detta laddar ned ett paket som innehåller alla filer från utforskaren till din lokala dator, som du sedan kan checka in på din kodlagringsplats.

Mer information om DevOps-integrering med Azure Machine Learning finns i Git-integrering i Azure Machine Learning

Skicka körningar till molnet från den lokala lagringsplatsen

Förutsättningar

• Slutför Skapa resurser för att komma igång om du inte redan har en Azure Machine Learning-arbetsyta.

• En Python-miljö där du har installerat Azure Machine Learning Python SDK v2 – installationsinstruktioner. Den här miljön är till för att definiera och kontrollera dina Azure Machine Learning-resurser och är skild från den miljö som används vid beräkningssessionen. Mer information finns i hantera beräkningssession för teknik för snabbflöde.

Installera prompt flow SDK

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

Anslut till Azure Machine Learning-arbetsytan

Azure CLI

az login

Python SDK

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

run.yml Förbered för att definiera konfigurationen för den här flödeskörningen i molnet.

$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 using serverless compute type
# resources:
#   instance_type: <instance_type> 

# if using compute instance compute type
# resources:
#   compute: <compute_instance_name> 

# overrides connections 
connections:
  classify_with_llm:
    connection: <connection_name>
    deployment_name: <deployment_name>
  summarize_text_content:
    connection: <connection_name>
    deployment_name: <deployment_name>

Du kan ange anslutnings- och distributionsnamnet för varje verktyg i flödet. Om du inte anger anslutnings- och distributionsnamnet används den enda anslutningen och distributionen i flow.dag.yaml filen. Så här formaterar du anslutningar:

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

pfazure run create --file run.yml

Python SDK

# load flow
flow = "<path_to_flow>"
data = "<path_to_flow>/data.jsonl"


# define cloud resource

# define instance type when using serverless compute type
# resources = {"instance_type": <instance_type>}

# specify the compute instance name when using compute instance compute type
# resources = {"compute": <compute_instance_name>}

# 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,
#    resources = resources,
    column_mapping={
        "url": "${data.url}"
    }, 
    connections=connections,  

)
print(base_run)

Azure CLI

run_evaluation.yml Förbered för att definiera konfigurationen för den här utvärderingsflödet som körs i molnet.

$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 using serverless compute type
# resources:
#   instance_type: <instance_type> 

# if using compute instance compute type
# resources:
#   compute: <compute_instance_name> 


# 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

Python SDK

# load flow
flow = "<path_to_flow>"
data = "<path_to_flow>/data.jsonl"

# define cloud resource

# define instance type when using serverless compute type
# resources = {"instance_type": <instance_type>}

# specify the compute instance name when using compute instance compute type
# resources = {"compute": <compute_instance_name>}

# 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}",
    },
#    resources = resources, 
    connections=connections
)

Visa körningsresultat i Azure Machine Learning-arbetsytan

Skicka flödeskörning till molnet returnerar portal-URL:en för körningen. Du kan öppna URI-vyn för körningsresultaten i portalen.

Du kan också använda följande kommando för att visa resultat för körningar.

Strömma loggarna

Azure CLI

pfazure run stream --name <run_name>

Python SDK

pf.stream("<run_name>")

Visa körningsutdata

Azure CLI

pfazure run show-details --name <run_name>

Python SDK

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

Visa mått för utvärderingskörning

Azure CLI

pfazure run show-metrics --name <evaluation_run_name>

Python SDK

pf.get_metrics("evaluation_run_name")

Viktigt!

Mer information finns i CLI-dokumentationen för promptflöde för Azure.

Iterativ utveckling från finjustering

Lokal utveckling och testning

Under iterativ utveckling, när du förfinar och finjusterar ditt flöde eller dina frågor, kan det vara fördelaktigt att utföra flera iterationer lokalt i din kodlagringsplats. Community-versionen, VS Code-tillägget för promptflöde och det lokala SDK:et för promptflöde och CLI tillhandahålls för att underlätta ren lokal utveckling och testning utan Azure-bindning.

Prompt flow VS Code-tillägg

När VS Code-tillägget för promptflöde har installerats kan du enkelt skapa ditt flöde lokalt från VS Code-redigeraren, vilket ger en liknande användargränssnittsupplevelse som i molnet.

Så här använder du tillägget:

1. Öppna en promptflödesmapp i VS Code Desktop.
2. Öppna filen flow.dag.yaml i notebook-vyn.
3. Använd den visuella redigeraren för att göra nödvändiga ändringar i ditt flöde, till exempel justera anvisningarna i varianter eller lägga till fler verktyg.
4. Om du vill testa flödet väljer du knappen Kör flöde överst i det visuella redigeringsprogrammet. Detta utlöser ett flödestest.

Lokal SDK för promptflöde och CLI

Om du föredrar att använda Jupyter, PyCharm, Visual Studio eller andra IDE:er kan du ändra YAML-definitionen direkt i flow.dag.yaml filen.

Du kan sedan utlösa en flödeskörning för testning med antingen CLI för promptflöde eller SDK.

Azure CLI

Förutsatt att du är i arbetskatalogen <path-to-the-sample-repo>/examples/flows/standard/

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

Python SDK

Returvärdet för test funktionen är flödes-/nodutdata.

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

På så sätt kan du göra och testa ändringar snabbt, utan att behöva uppdatera huvudkodlagringsplatsen varje gång. När du är nöjd med resultatet av din lokala testning kan du sedan överföra till att skicka körningar till molnet från den lokala lagringsplatsen för att utföra experimentkörningar i molnet.

Mer information och vägledning om hur du använder de lokala versionerna finns i GitHub-communityn för promptflöde.

Gå tillbaka till studiogränssnittet för kontinuerlig utveckling

Du kan också välja att gå tillbaka till studiogränssnittet med hjälp av molnresurserna och upplevelsen för att göra ändringar i flödet på flödesredigeringssidan.

Om du vill fortsätta utveckla och arbeta med den senaste versionen av flödesfilerna kan du komma åt terminalen i notebook-filen och hämta de senaste ändringarna av flödesfilerna från lagringsplatsen.

Om du föredrar att fortsätta arbeta i studiogränssnittet kan du dessutom direkt importera en lokal flödesmapp som ett nytt utkastflöde. På så sätt kan du sömlöst övergå mellan lokal utveckling och molnutveckling.

CI/CD-integrering

CI: Utlösarflödeskörningar i CI-pipeline

När du har utvecklat och testat flödet och checkat in det som den första versionen är du redo för nästa justering och testning av iterationen. I det här skedet kan du utlösa flödeskörningar, inklusive batchtestning och utvärderingskörningar, med hjälp av cli-kommandotolken. Detta kan fungera som ett automatiserat arbetsflöde i din CI-pipeline (Continuous Integration).

Under hela livscykeln för dina flödes-iterationer kan flera åtgärder automatiseras:

• Köra promptflöde efter en pull-begäran
• Köra utvärdering av promptflöde för att säkerställa att resultaten är av hög kvalitet
• Registrering av promptflödesmodeller
• Distribution av promptflödesmodeller

En omfattande guide om en MLOps-pipeline från slutpunkt till slutpunkt som kör ett webbklassificeringsflöde finns i Konfigurera LLMOps från slutpunkt till slutpunkt med prompten Flow och GitHub och GitHub-demoprojektet.

CD: Kontinuerlig distribution

Det sista steget för att gå till produktion är att distribuera ditt flöde som en onlineslutpunkt i Azure Machine Learning. På så sätt kan du integrera flödet i ditt program och göra det tillgängligt för användning.

Mer information om hur du distribuerar ditt flöde finns i Distribuera flöden till Azure Machine Learning-hanterad onlineslutpunkt för slutsatsdragning i realtid med CLI och SDK.

Samarbete kring flödesutveckling i produktion

När du utvecklar ett LLM-baserat program med snabbflöde är samarbete mellan teammedlemmar ofta viktigt. Teammedlemmar kan vara engagerade i samma flödesredigering och testning, arbeta med olika aspekter av flödet eller göra iterativa ändringar och förbättringar samtidigt.

Ett sådant samarbete kräver en effektiv och effektiv metod för att dela kod, spåra ändringar, hantera versioner och integrera dessa ändringar i det slutliga projektet.

Introduktionen av SDK/CLI för promptflödet och Visual Studio Code-tillägget som en del av kodupplevelsen i promptflödet underlättar enkelt samarbete om flödesutveckling i din kodlagringsplats. Det är lämpligt att använda en molnbaserad kodlagringsplats, till exempel GitHub eller Azure DevOps, för att spåra ändringar, hantera versioner och integrera dessa ändringar i det slutliga projektet.

Bästa praxis för samarbetsutveckling

1. Redigering och enkel testning av ditt flöde lokalt – Kodlagringsplats och VSC-tillägg

   • Det första steget i den här samarbetsprocessen handlar om att använda en kodlagringsplats som bas för din projektkod, som innehåller promptflödeskoden.
     • Den här centraliserade lagringsplatsen möjliggör effektiv organisation, spårning av alla kodändringar och samarbete mellan teammedlemmar.
   • När lagringsplatsen har konfigurerats kan gruppmedlemmar använda VSC-tillägget för lokal redigering och enkel indatatestning av flödet.
     • Den här standardiserade integrerade utvecklingsmiljön främjar samarbete mellan flera medlemmar som arbetar med olika aspekter av flödet.

2. Molnbaserad experimentell batchtestning och utvärdering – CLI/SDK för promptflöde och användargränssnitt för arbetsyteportalen

   • Efter den lokala utvecklings- och testfasen kan flödesutvecklare använda pfazure CLI eller SDK för att skicka batchkörningar och utvärderingskörningar från de lokala flödesfilerna till molnet.
     • Den här åtgärden är ett sätt att använda molnresurser, vilket gör att resultatet lagras beständigt och effektivt med ett portalgränssnitt på Azure Machine Learning-arbetsytan. Det här steget möjliggör förbrukning av molnresurser, inklusive beräkning och lagring och ytterligare slutpunkt för distributioner.
   • Efter inlämningar till molnet kan teammedlemmar komma åt molnportalens användargränssnitt för att visa resultaten och hantera experimenten effektivt.
     • Den här molnarbetsytan ger en central plats för att samla in och hantera all körningshistorik, loggar, ögonblicksbilder, omfattande resultat, inklusive instansnivåindata och utdata.
     • I körningslistan som registrerar all körningshistorik från under utvecklingen kan teammedlemmar enkelt jämföra resultatet av olika körningar, med hjälp av kvalitetsanalys och nödvändiga justeringar.

3. Lokal iterativ utveckling eller enstegsdistribution av användargränssnittet för produktion

   • Efter analys av experiment kan teammedlemmar återgå till kodlagringsplatsen för en annan utveckling och finjustering. Efterföljande körningar kan sedan skickas till molnet på ett iterativt sätt.
     • Den här iterativa metoden säkerställer en konsekvent förbättring tills teamet är nöjda med den kvalitet som är redo för produktion.
   • När teamet är helt säkra på flödets kvalitet kan det distribueras sömlöst via en användargränssnittsguide som en onlineslutpunkt i Azure Machine Learning. När teamet är helt säkra på flödets kvalitet kan det smidigt övergå till produktion via en distributionsguide för användargränssnittet som en onlineslutpunkt i en robust molnmiljö.
     • Den här distributionen på en onlineslutpunkt kan baseras på en körningsögonblicksbild, vilket möjliggör stabil och säker servering, ytterligare resursallokering och användningsspårning samt loggövervakning i molnet.

Därför rekommenderar vi att du använder kodlagringsplatsen för samarbetsutveckling

För iterativ utveckling är en kombination av en lokal utvecklingsmiljö och ett versionskontrollsystem, till exempel Git, vanligtvis effektivare. Du kan göra ändringar och testa koden lokalt och sedan checka in ändringarna i Git. Detta skapar en löpande post av dina ändringar och ger möjlighet att återgå till tidigare versioner om det behövs.

När du behöver dela flöden i olika miljöer rekommenderar vi att du använder en molnbaserad kodlagringsplats som GitHub eller Azure Repos. På så sätt kan du komma åt den senaste versionen av koden från valfri plats och tillhandahåller verktyg för samarbete och kodhantering.

Genom att följa den här bästa praxisen kan team skapa en sömlös, effektiv och produktiv samarbetsmiljö för snabb flödesutveckling.

Nästa steg

• Konfigurera LLMOps från slutpunkt till slutpunkt med promptflöde och GitHub
• Cli-dokumentation för promptflöde för Azure