Integrera prompt flow med DevOps för LLM-baserade program

Artikel
11/02/2024

Azure Machine Learning prompt flow är en utvecklarvänlig och lättanvänd kod-första metod för att utveckla och iterera flöden för stor språkmodell (LLM)-baserad programutveckling. Prompt flow tillhandahåller ett SDK och CLI, ett Visual Studio Code-tillägg och ett flödesredigeringsgränssnitt. De här verktygen underlättar utveckling av lokala flöde, lokal flödeskörning och utvärderingskörningsutlösare samt övergång av flöden mellan lokala och molnbaserade arbetsytemiljöer.

Du kan kombinera funktionen för snabbflöde och kod med utvecklaråtgärder (DevOps) för att förbättra dina LLM-baserade arbetsflöden för programutveckling. Den här artikeln fokuserar på att integrera prompt flow och DevOps for Azure Machine Learning LLM-baserade program.

Följande diagram visar interaktionen mellan utveckling av lokala och molnbaserade promptflöden med DevOps.

Förutsättningar

En Azure Machine Learning-arbetsyta. Information om hur du skapar en finns i Skapa resurser för att komma igång.
En lokal Python-miljö med Azure Machine Learning Python SDK v2 installerad, skapad genom att följa anvisningarna i Komma igång.

Kommentar

Den här miljön är separat från miljön som beräkningssessionen använder för att köra flödet, som du definierar som en del av flödet. Mer information finns i Hantera beräkningssession för promptflöde i Azure Machine Learning-studio.
Visual Studio Code med Python- och Prompt-flödestillägg installerade.

Använda en kod-första upplevelse i promptflöde

Utveckling av LLM-baserade program följer vanligtvis en standardiserad programutvecklingsprocess som innehåller källkodslagringsplatser och ci/CD-pipelines (kontinuerlig integrering/kontinuerlig distribution). Den här processen främjar effektiv utveckling, versionskontroll och samarbete mellan teammedlemmar.

Genom att integrera DevOps med funktionen för snabbflödeskod får kodutvecklare en effektivare GenAIOps- eller LLMOps-iterationsprocess med följande viktiga funktioner och fördelar:

Flödesversioner i kodlagringsplatsen. Du kan definiera flödesfiler i YAML-format och de ligger i linje med refererade källfiler i samma mappstruktur.
Flödeskörningsintegrering med CI/CD-pipelines. Du kan sömlöst integrera promptflöde i dina CI/CD-pipelines och leveransprocesser med hjälp av cli- eller SDK-kommandotolken för att automatiskt utlösa flödeskörningar.
Smidig övergång mellan lokalt och moln. Du kan enkelt exportera din flödesmapp till din lokala eller överordnade kodlagringsplats för versionskontroll, lokal utveckling och delning. Du kan också enkelt importera flödesmappen tillbaka till Azure Machine Learning för ytterligare redigering, testning och distribution med hjälp av molnresurser.

Åtkomst till flödeskod för fråga

Varje promptflöde har en flödesmappstruktur som innehåller viktiga kodfiler som definierar flödet. Mappstrukturen organiserar ditt flöde, vilket underlättar smidigare övergångar mellan lokalt och moln.

Azure Machine Learning tillhandahåller ett delat filsystem för alla arbetsyteanvändare. När flödet skapas genereras en motsvarande flödesmapp automatiskt och lagras i katalogen Användare/<användarnamn>/promptflow .

Arbeta med flödeskodfiler

När du har skapat ett flöde i Azure Machine Learning-studio kan du visa, redigera och hantera flödesfilerna i avsnittet Filer på flödesredigeringssidan. Alla ändringar du gör i filerna återspeglas direkt i filresurslagringen.

Flödesmappen för ett LLM-baserat flöde innehåller följande nyckelfiler.

flow.dag.yaml är den primära flödesdefinitionsfilen i YAML-format. Den här filen är integrerad i redigering och definition av promptflödet. Filen innehåller information om indata, utdata, noder, verktyg och varianter som flödet använder.
Användarhanterade källkodsfiler i Python-format (.py) eller Jinja 2-format (.jinja2) konfigurerar verktygen och noderna i flödet. Python-verktyget använder Python-filer för att definiera anpassad Python-logik. Prompt-verktyget och LLM-verktyget använder Jinja 2-filer för att definiera snabbkontext.
Icke-källfiler som verktyg och datafiler kan ingå i flödesmappen tillsammans med källfilerna.

Om du vill visa och redigera råkoden för flow.dag.yaml - och källfilerna i filredigeraren aktiverar du Raw-filläget.

Du kan också komma åt och redigera alla dina flödesmappar och filer från sidan Azure Machine Learning-studio Notebooks.

Ladda ned och checka in flödeskod för prompten

Om du vill kontrollera flödet till kodlagringsplatsen exporterar du flödesmappen från Azure Machine Learning-studio till den lokala datorn. Välj nedladdningsikonen i avsnittet Filer på flödesredigeringssidan för att ladda ned ett ZIP-paket som innehåller alla flödesfiler. Du kan sedan kontrollera filen på din kodlagringsplats eller packa upp den för att arbeta med filerna lokalt.

Skärmbild som visar nedladdningsikonen i Utforskaren.

Mer information om DevOps-integrering med Azure Machine Learning finns i Git-integrering för Azure Machine Learning.

Utveckla och testa lokalt

När du förfinar och finjusterar ditt flöde eller frågar under iterativ utveckling kan du utföra flera iterationer lokalt i din kodlagringsplats. VS Code-communityversionen, VS Code Prompt Flow-tillägget och det lokala SDK:et för promptflöde och CLI underlättar ren lokal utveckling och testning utan Azure-bindning.

När du arbetar lokalt kan du göra och testa ändringar snabbt, utan att behöva uppdatera huvudkodlagringsplatsen varje gång. Mer information och vägledning om hur du använder lokala versioner finns i GitHub-communityn för promptflöde.

Använda VS Code Prompt Flow-tillägget

Genom att använda tillägget Förfråga flödes-VS Code kan du enkelt skapa ditt flöde lokalt i VS Code-redigeraren med en liknande användargränssnittsupplevelse som i molnet.

Så här redigerar du filer lokalt i VS Code med tillägget Fråga flöde:

Öppna en flödesmapp i VS Code med promptflödestillägget aktiverat.
Öppna filen flow.dag.yaml och välj länken Visual Editor längst upp i filen.
Använd redigeraren för det visuella kommandotolken för att göra ändringar i ditt flöde, till exempel justera prompterna i varianter eller lägga till fler noder.
Om du vill testa flödet väljer du ikonen Kör överst i det visuella redigeraren eller testar en nod genom att välja ikonen Kör överst på noden.

Använda promptflödes-SDK och CLI

Om du föredrar att arbeta direkt i kod eller använda Jupyter, PyCharm, Visual Studio eller en annan integrerad utvecklingsmiljö (IDE) kan du ändra YAML-koden direkt i filen flow.dag.yaml .

Du kan sedan utlösa en enda flödeskörning för testning med hjälp av CLI eller SDK för promptflöde i terminalen enligt följande.

Azure CLI
Python SDK

Kör följande kod för att utlösa en körning från arbetskatalogen:

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

Returvärdena är testloggarna och utdata.

Skicka körningar till molnet från en lokal lagringsplats

När du är nöjd med resultatet av din lokala testning kan du använda CLI eller SDK för att skicka körningar till molnet från den lokala lagringsplatsen. Följande procedur och kod baseras på demoprojektet Webbklassificering i GitHub. Du kan klona projektlagringsplatsen eller ladda ned flödeskoden för fråga till den lokala datorn.

Installera SDK:et för promptflödet

Installera Azure Prompt Flow SDK/CLI genom att köra pip install promptflow[azure] promptflow-tools.

Om du använder demoprojektet hämtar du SDK och andra nödvändiga paket genom att installera requirements.txt med
pip install -r <path>/requirements.txt.

Ansluta till din Azure Machine Learning-arbetsyta

Azure CLI
Python SDK

az login

Importera nödvändiga bibliotek och paket, konfigurera autentiseringsuppgifter och få ett handtag till arbetsytan.

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

Förbered run.yml-filen 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-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>

Du kan ange anslutnings- och distributionsnamnet för varje verktyg i flödet som kräver en anslutning. Om du inte anger anslutnings- och distributionsnamnet använder verktyget anslutningen och distributionen i filen flow.dag.yaml . Använd följande kod för att formatera anslutningar:

...
connections:
  <node-name>:
    connection: <connection-name>
      deployment_name: <deployment-name>
...

Skapa körningen.

pfazure run create --file run.yml

Läs in flödet, definiera resurser och anslutningar och skapa körningen.

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)

Skapa en utvärderingsflödeskörning

Azure CLI
Python SDK

Förbered run_evaluation.yml-filen 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-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>

Skapa utvärderingskörningen.

pfazure run create --file run_evaluation.yml

Läs in utvärderingsflödet och skapa körningen.

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)

Visa körningsresultat

Om du skickar flödeskörningen till molnet returneras körningens moln-URL. Du kan öppna URL:en för att visa körningsresultatet i Azure Machine Learning-studio. Du kan också köra följande CLI- eller SDK-kommandon för att visa körningsresultat.

Strömma loggarna

Azure CLI
Python SDK

pfazure run stream --name <run-name>

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

Visa körningsutdata

Azure CLI
Python SDK

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

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

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

Azure CLI
Python SDK

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

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

Integrera med DevOps

En kombination av en lokal utvecklingsmiljö och ett versionskontrollsystem som Git är vanligtvis mest effektivt för iterativ utveckling. Du kan göra ändringar och testa koden lokalt och sedan checka in ändringarna i Git. Den här processen skapar en löpande post för 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 kan du skicka dem till en molnbaserad kodlagringsplats som GitHub eller Azure Repos. Med den här strategin kan du komma åt den senaste kodversionen från valfri plats och tillhandahåller verktyg för samarbete och kodhantering.

Genom att följa dessa metoder kan team skapa en sömlös, effektiv och produktiv samarbetsmiljö för snabb flödesutveckling.

Till exempel LLMOps-pipelines från slutpunkt till slutpunkt som kör webbklassificeringsflöden finns i Konfigurera från slutpunkt till slutpunkt GenAIOps med prompten Flow och GitHub och demoprojektet GitHub Web Classification.

Utlösarflöde körs i CI-pipelines

När du har utvecklat och testat ditt flöde och checkar in det som den första versionen är du redo för justering och testning av iterationer. I det här skedet kan du utlösa flödeskörningar, inklusive batchtestnings- och utvärderingskörningar, med hjälp av cli-kommandotolken för att automatisera stegen i din CI-pipeline.

Under hela livscykeln för dina flödes-iterationer kan du använda CLI för att automatisera följande åtgärder:

Köra kommandotolken 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
Registrera promptflödesmodeller
Distribuera promptflödesmodeller

Använda studiogränssnittet för kontinuerlig utveckling

När som helst i flödesutvecklingen kan du gå tillbaka till Azure Machine Learning-studio användargränssnittet och använda molnresurser och upplevelser för att göra ändringar i ditt flöde.

Om du vill fortsätta utveckla och arbeta med de senaste versionerna av flödesfilerna kan du komma åt en terminal på sidan Notebook och hämta de senaste flödesfilerna från lagringsplatsen. Eller så kan du direkt importera en lokal flödesmapp som ett nytt utkastflöde för sömlös övergång mellan lokal utveckling och molnutveckling.

Distribuera flödet som en onlineslutpunkt

Det sista steget i att gå till produktion är att distribuera ditt flöde som en onlineslutpunkt i Azure Machine Learning. Med den här processen 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.

Samarbeta om flödesutveckling

Samarbete mellan teammedlemmar kan vara viktigt när du utvecklar ett LLM-baserat program med promptflöde. Teammedlemmar kanske redigerar och testar samma flöde, arbetar med olika fasetter i flödet eller gör iterativa ändringar och förbättringar samtidigt. Det här samarbetet kräver en effektiv och effektiv metod för att dela kod, spåra ändringar, hantera versioner och integrera ändringar i det slutliga projektet.

Prompt flow SDK/CLI och VS Code Prompt Flow-tillägget underlättar enkelt samarbete om kodbaserad flödesutveckling i en källkodslagringsplats. Du kan använda ett molnbaserat källkontrollsystem som GitHub eller Azure Repos för att spåra ändringar, hantera versioner och integrera dessa ändringar i det slutliga projektet.

Följ metodtips för samarbetsutveckling

Konfigurera en centraliserad kodlagringsplats.

Det första steget i samarbetsprocessen är att konfigurera en kodlagringsplats som bas för projektkod, inklusive promptflödeskod. Den här centraliserade lagringsplatsen möjliggör effektiv organisation, ändringsspårning och samarbete mellan teammedlemmar.
Skapa och testa ditt flöde lokalt i VS Code med tillägget Fråga flöde.

När lagringsplatsen har konfigurerats kan gruppmedlemmar använda VS Code med tillägget Fråga flöde för lokal redigering och testning av enskilda indata för flödet. Den standardiserade integrerade utvecklingsmiljön främjar samarbete mellan flera medlemmar som arbetar med olika aspekter av flödet.
pfazure Använd CLI eller SDK för att skicka batchkörningar och utvärderingskörningar från lokala flöden till molnet.

Efter lokal utveckling och testning kan teammedlemmar använda CLI/SDK för promptflöde för att skicka och utvärdera batch- och utvärderingskörningar till molnet. Den här processen möjliggör användning av molnberäkning, lagring av beständiga resultat, skapande av slutpunkter för distributioner och effektiv hantering i studiogränssnittet.
Visa och hantera körningsresultat i användargränssnittet för Azure Machine Learning-studio arbetsyta.

När de har skickat körningar till molnet kan teammedlemmar komma åt studiogränssnittet för att visa resultaten och hantera experiment effektivt. Molnarbetsytan är en central plats för insamling och hantering av körningshistorik, loggar, ögonblicksbilder, omfattande resultat och instansnivåindata och utdata.
Använd listan Körningar som registrerar all körningshistorik för att enkelt jämföra resultatet av olika körningar, med hjälp av kvalitetsanalys och nödvändiga justeringar.
Fortsätt att använda lokal iterativ utveckling.

Efter att ha analyserat resultatet av experiment kan teammedlemmar återgå till den lokala miljön och kodlagringsplatsen för mer utveckling och finjustering och iterativt skicka efterföljande körningar till molnet. Den här iterativa metoden säkerställer en konsekvent förbättring tills teamet är nöjda med produktionskvaliteten.
Använd enstegsdistribution till produktion i studion.

När teamet är helt säkra på flödets kvalitet kan de sömlöst distribuera det som en onlineslutpunkt i en robust molnmiljö. Distribution som en onlineslutpunkt kan baseras på en körningsögonblicksbild som möjliggör stabil och säker servering, ytterligare resursallokering och användningsspårning samt loggövervakning i molnet.

Guiden Azure Machine Learning-studio Deploy hjälper dig att enkelt konfigurera distributionen.

Dela via

Integrera prompt flow med DevOps för LLM-baserade program

Förutsättningar

Använda en kod-första upplevelse i promptflöde

Åtkomst till flödeskod för fråga

Arbeta med flödeskodfiler

Ladda ned och checka in flödeskod för prompten

Utveckla och testa lokalt

Använda VS Code Prompt Flow-tillägget

Använda promptflödes-SDK och CLI

Skicka körningar till molnet från en lokal lagringsplats

Installera SDK:et för promptflödet

Ansluta till din Azure Machine Learning-arbetsyta

Ladda upp flödet och skapa en körning

Skapa en utvärderingsflödeskörning

Visa körningsresultat

Strömma loggarna

Visa körningsutdata

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

Integrera med DevOps

Utlösarflöde körs i CI-pipelines

Använda studiogränssnittet för kontinuerlig utveckling

Distribuera flödet som en onlineslutpunkt

Samarbeta om flödesutveckling

Följ metodtips för samarbetsutveckling

Feedback

Ytterligare resurser

Dela via

Integrera prompt flow med DevOps för LLM-baserade program

Förutsättningar

Använda en kod-första upplevelse i promptflöde

Åtkomst till flödeskod för fråga

Arbeta med flödeskodfiler

Ladda ned och checka in flödeskod för prompten

Utveckla och testa lokalt

Använda VS Code Prompt Flow-tillägget

Använda promptflödes-SDK och CLI

Skicka körningar till molnet från en lokal lagringsplats

Installera SDK:et för promptflödet

Ansluta till din Azure Machine Learning-arbetsyta

Ladda upp flödet och skapa en körning

Skapa en utvärderingsflödeskörning

Visa körningsresultat

Strömma loggarna

Visa körningsutdata

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

Integrera med DevOps

Utlösarflöde körs i CI-pipelines

Använda studiogränssnittet för kontinuerlig utveckling

Distribuera flödet som en onlineslutpunkt

Samarbeta om flödesutveckling

Följ metodtips för samarbetsutveckling

Relaterat innehåll

Feedback

Ytterligare resurser