Integrieren des Eingabeaufforderungsflusses in DevOps für LLM-basierte Anwendungen

Azure Machine Learning Prompt-Flow ist eine entwickler- und benutzerfreundliche Code-first-Methode zum Entwickeln und Iterieren von Abläufen für die LLM (Large Language Model)-basierte Anwendungsentwicklung. Der Prompt-Flow stellt ein SDK, eine CLI, eine Visual Studio Code-Erweiterung und eine Benutzeroberfläche zur Flusserstellung bereit. Diese Tools erleichtern die lokale Flow-Entwicklung, das Triggern der lokalen Flow-Ausführung und der Evaluierungsläufe sowie den Übergang von Flows zwischen lokalen und Cloud-Workspace-Umgebungen.

Sie können die Funktionen für den Eingabeaufforderungsfluss und Code mit Entwicklervorgängen (DevOps) kombinieren, um Ihre LLM-basierten Anwendungsentwicklungsworkflows zu verbessern. Dieser Artikel konzentriert sich auf die Integration von Eingabeaufforderungsfluss und DevOps für Azure Machine Learning LLM-basierte Anwendungen.

Das folgende Diagramm zeigt die Interaktion der lokalen und cloudbasierten Eingabeaufforderungsflussentwicklung mit DevOps.

Voraussetzungen

• Ein Azure Machine Learning Arbeitsbereich. Informationen zum Erstellen finden Sie unter "Erstellen von Ressourcen für die ersten Schritte".

• Eine lokale Python Umgebung mit dem installierten Azure Machine Learning Python SDK v2, erstellt durch Befolgen der Anweisungen unter Getting started.

  Hinweis

  Diese Umgebung ist von der Umgebung getrennt, die die Computesitzung verwendet, um den Ablauf auszuführen, den Sie als Teil des Ablaufs definieren. Weitere Informationen finden Sie unter Manage prompt flow compute session in Azure Machine Learning Studio.

• Visual Studio Code mit den installierten Python- und Prompt-Flow-Erweiterungen.

  

Verwenden einer Code-first-Erfahrung im Eingabeaufforderungsfluss

Die Entwicklung von LLM-basierten Anwendungen folgt in der Regel einem standardisierten Anwendungstechnikprozess, der Quellcoderepositorys und fortlaufende Integrations-/fortlaufende Bereitstellungspipelinen (CI/CD) umfasst. Dieser Prozess fördert eine optimierte Entwicklung, Versionssteuerung und Zusammenarbeit zwischen Teammitgliedern.

Die Integration von DevOps in die Codeumgebung für den Eingabeaufforderungsfluss bietet Codeentwicklern einen effizienteren GenAIOps- oder LLMOps-Iterationsprozess mit den folgenden wichtigen Features und Vorteilen:

• Flow-Versionierung im Code-Repository. Sie können Flow-Dateien im YAML-Format definieren und bleiben mit referenzierten Quelldateien in derselben Ordnerstruktur synchronisiert.

• Integration des Flow-Laufs mit CI/CD-Pipelines. Sie können Prompt Flow nahtlos in Ihre CI/CD-Pipelines und den Bereitstellungsprozess integrieren, indem Sie das CLI oder das SDK verwenden, um automatisch Flow-Läufe auszulösen.

• Reibungsloser Übergang zwischen lokaler Umgebung und Cloud. Sie können Ihren Flow-Ordner ganz einfach in Ihr lokales oder upstream-Code-Repository exportieren, um Versionskontrolle, lokale Entwicklung und Freigabe zu ermöglichen. Sie können den Flussordner auch mühelos wieder in Azure Machine Learning importieren, um weitere Erstellungen, Tests und Bereitstellungen mithilfe von Cloudressourcen durchzuführen.

Zugriffsaufforderungsflusscode

Jeder Eingabeaufforderungsfluss verfügt über eine Flussordnerstruktur mit wesentlichen Codedateien, die den Fluss definieren. Die Ordnerstruktur organisiert Ihren Fluss und erleichtert einen reibungsloseren Übergang zwischen lokaler und Cloud.

Azure Machine Learning bietet ein gemeinsames Dateisystem für alle Benutzer des Arbeitsbereichs an. Beim Erstellen des Flusses wird automatisch ein entsprechender Flussordner generiert und im Verzeichnis "Users/<username>/promptflow " gespeichert.

Arbeiten mit Flusscodedateien

Nachdem Sie einen Fluss in Azure Machine Learning Studio erstellt haben, können Sie die Flussdateien im Abschnitt Files der Ablauferstellungsseite anzeigen, bearbeiten und verwalten. Alle Änderungen, die Sie an den Dateien vornehmen, spiegeln sich direkt im Dateifreigabespeicher wider.

Der Flussordner für einen LLM-basierten Fluss enthält die folgenden Schlüsseldateien.

• flow.dag.yaml ist die primäre Flussdefinitionsdatei im YAML-Format. Diese Datei ist integraler Bestandteil der Erstellung und Definition des Eingabeaufforderungsflusses. Die Datei enthält Informationen zu Eingaben, Ausgaben, Knoten, Tools und Varianten, die der Fluss verwendet.

• Vom Benutzer verwaltete Quellcodedateien in Python Format (.py) oder Jinja 2 (.jinja2) konfigurieren die Tools und Knoten im Fluss. Das Python Tool verwendet Python Dateien, um benutzerdefinierte Python Logik zu definieren. Das Eingabeaufforderungstool und das LLM-Tool verwenden Jinja 2-Dateien, um den Eingabeaufforderungskontext zu definieren.

• Nicht-Ressourcendateien wie Hilfsprogramm- und Datendateien können zusammen mit den Quelldateien in den Flussordner aufgenommen werden.

Um den rohen Code der Flow.dag.yaml - und Quelldateien im Datei-Editor anzuzeigen und zu bearbeiten, aktivieren Sie den Raw-Dateimodus.

Alternativ können Sie auf alle Flussordner und -dateien über die Seite Azure Machine Learning Studio Notebooks zugreifen und diese bearbeiten.

Herunterladen und Einchecken des Eingabeaufforderungsflusscodes

Um Den Fluss in Ihr Code-Repository zu überprüfen, exportieren Sie den Flussordner von Azure Machine Learning Studio auf Ihren lokalen Computer. Wählen Sie im Abschnitt "Dateien " der Seite "Flusserstellung" das Downloadsymbol aus, um ein ZIP-Paket mit allen Flussdateien herunterzuladen. Anschließend können Sie diese Datei in Ihrem Code-Repository überprüfen oder entpacken, um mit den Dateien lokal zu arbeiten.

Weitere Informationen zur DevOps-Integration mit Azure Machine Learning finden Sie unter Git-Integration für Azure Machine Learning.

Lokal entwickeln und testen

Beim Verfeinern und Optimieren des Flusses oder der Eingabeaufforderungen während der iterativen Entwicklung können Sie mehrere Iterationen lokal in Ihrem Coderepository durchführen. Die VS Code Community-Version, VS Code Prompt Flow Erweiterung und das Prompt Flow Local SDK und CLI erleichtern rein lokale Entwicklung und Testen ohne Azure-Bindung.

Wenn Sie lokal arbeiten, können Sie Änderungen schnell vornehmen und testen, ohne jedes Mal das Hauptcode-Repository aktualisieren zu müssen. Weitere Informationen und Anleitungen zur Verwendung lokaler Versionen finden Sie im Prompt Flow GitHub Community.

Verwendung der VS Code Prompt-Flow-Erweiterung

Mithilfe der Erweiterung "Prompt Flow VS Code" können Sie Ihren Fluss ganz einfach lokal im VS Code-Editor mit einer ähnlichen Benutzeroberfläche wie in der Cloud erstellen.

So bearbeiten Sie Dateien lokal in VS Code mit der Prompt Flow-Erweiterung.

1. Öffnen Sie in VS Code mit aktivierter Prompt Flow-Erweiterung einen Prompt Flow-Ordner.

2. Öffnen Sie die Datei "flow.dag.yaml ", und wählen Sie oben in der Datei den Link "Visual Editor " aus.

   

3. Verwenden Sie den visuellen Editor für den Eingabeaufforderungsfluss, um Änderungen an Ihrem Fluss vorzunehmen, z. B. das Optimieren der Eingabeaufforderungen in Varianten oder das Hinzufügen weiterer Knoten.

   

4. Um Ihren Ablauf zu testen, wählen Sie das Symbol "Ausführen" oben im visuellen Editor aus. Um einen beliebigen Knoten zu testen, wählen Sie das Symbol "Ausführen" oben am Knoten aus.

   

Verwenden Sie das Prompt Flow SDK und die CLI

Wenn Sie es vorziehen, direkt im Code zu arbeiten oder Jupyter, PyCharm, Visual Studio oder eine andere integrierte Entwicklungsumgebung (IDE) zu verwenden, können Sie den YAML-Code direkt in der Datei flow.dag.yaml ändern.

Anschließend können Sie einen einzelnen Ablauf zum Testen auslösen, indem Sie die Prompt-Flow CLI oder das SDK im Terminal verwenden.

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

Die Rückgabewerte sind die Testprotokolle und Ausgaben.

Übermitteln von Ausführungen aus einem lokalen Repository an die Cloud

Sobald Sie mit den Ergebnissen Ihrer lokalen Tests zufrieden sind, können Sie die Prompt-Flow-CLI oder das SDK verwenden, um Runs aus dem lokalen Repository in die Cloud einzureichen. Das folgende Verfahren und code basieren auf dem Demoprojekt Webklassifizierung in GitHub. Sie können das Projekt-Repository klonen oder den Aufforderungsflusscode auf Ihren lokalen Computer herunterladen.

Installation des Prompt Flow-SDK

Installieren Sie das Azure Prompt Flow SDK/CLI, indem Sie pip install promptflow[azure] promptflow-tools ausführen.

Wenn Sie das Demoprojekt verwenden, rufen Sie das SDK und andere erforderliche Pakete ab, indem Sie requirements.txt installieren.
pip install -r <path>/requirements.txt.

Herstellen einer Verbindung mit Ihrem Azure Machine Learning-Arbeitsbereich

az login

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

Laden Sie den Ablauf hoch und erstellen Sie einen Durchlauf.

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

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

pfazure run create --file run.yml

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)

Erstellen eines Auswertungsflusses

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

pfazure run create --file run_evaluation.yml

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)

Anzeigen von Ausführungsergebnissen

Das Übermitteln des Ablaufs an die Cloud gibt die Cloud-URL der Ausführung zurück. Sie können die URL öffnen, um die Ausführungsergebnisse in Azure Machine Learning Studio anzuzeigen. Sie können auch die folgenden CLI- oder SDK-Befehle ausführen, um die Ausführungsergebnisse anzuzeigen.

Protokolle streamen

pfazure run stream --name <run-name>

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

Ergebnisse der Ausführung anzeigen

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

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

Anzeigen von Auswertungsausführungsmetriken

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

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

Mit DevOps integrieren

Eine Kombination aus einer lokalen Entwicklungsumgebung und einem Versionssteuerungssystem wie Git ist in der Regel am effektivsten für die iterative Entwicklung. Sie können Änderungen vornehmen und Ihren Code lokal testen und dann die Änderungen an Git übernehmen. Dieser Prozess erstellt einen fortlaufenden Datensatz Ihrer Änderungen und bietet die Möglichkeit, bei Bedarf auf frühere Versionen zurückgesetzt zu werden.

Wenn Sie Workflows in verschiedenen Umgebungen freigeben müssen, können Sie sie in ein cloudbasiertes Code-Repository wie GitHub oder Azure Repos pushen. Mit dieser Strategie können Sie von jedem Ort aus auf die neueste Codeversion zugreifen und erhalten Zugang zu Tools für die Zusammenarbeit und Codeverwaltung.

Mithilfe dieser Methoden können Teams eine nahtlose, effiziente und produktive Zusammenarbeitsumgebung für die effiziente Workflow-Entwicklung erstellen.

Beispielsweise finden Sie End-to-End-LLMOps-Pipelines, die Webklassifizierungsflüsse ausführen, unter End-to-End-GenAIOps mit Prompt Flow und GitHub einrichten und dem GitHub Web Classification demo project.

Triggerflussläufe in CI-Pipelines

Nachdem Sie Ihren Flow erfolgreich entwickelt und getestet und als erste Version eingecheckt haben, können Sie Iterationen optimieren und testen. In dieser Phase können Sie Ablaufläufe auslösen, einschließlich Batchtests und Auswertungsläufen, indem Sie die Eingabeaufforderungsfluss-CLI verwenden, um Schritte in Ihrer CI-Pipeline zu automatisieren.

Während des gesamten Lebenszyklus Ihrer Flussiterationen können Sie die CLI verwenden, um die folgenden Vorgänge zu automatisieren:

• Ausführen des Eingabeaufforderungsflusses nach einer Pullanforderung
• Ausführen der Bewertung des Prompt-Flusses, um sicherzustellen, dass die Ergebnisse hochwertig sind
• Registration von Promptflow-Modellen
• Bereitstellen von Prompt-Flow-Modellen

Verwenden der Studio-Benutzeroberfläche für die kontinuierliche Entwicklung

An jedem Punkt in der Flussentwicklung können Sie zur Azure Machine Learning Studio UI zurückkehren und Cloudressourcen und Erfahrungen verwenden, um Änderungen an Ihrem Fluss vorzunehmen.

Um die Entwicklung mit den aktuellsten Versionen der Flussdateien fortzusetzen und damit zu arbeiten, können Sie auf ein Terminal auf der Seite "Notizbuch" zugreifen und die neuesten Flussdateien aus Ihrem Repository herunterladen. Oder Sie können einen lokalen Flussordner direkt als neuen Entwurfsfluss importieren, um nahtlos zwischen lokaler und Cloudentwicklung zu wechseln.

Bereitstellen des Workflows als Online-Endpunkt

Der letzte Schritt bei der Produktion besteht darin, Ihren Flow als Onlineendpunkt in Azure Machine Learning bereitzustellen. Mit diesem Prozess können Sie Ihren Fluss in Ihre Anwendung integrieren und ihn zur Verwendung zur Verfügung stellen. Weitere Informationen zum Bereitstellen Ihres Flows finden Sie unter Deploy flows to Azure Machine Learning managed online endpoint for real-time inference.

Zusammenarbeiten an der Workflow-Entwicklung

** Die Zusammenarbeit zwischen Teammitgliedern kann bei der Entwicklung einer LLM-basierten Anwendung mit Prompt-Flow unerlässlich sein. Teammitglieder können denselben Fluss erstellen und testen, an verschiedenen Facetten des Flusses arbeiten oder iterative Änderungen und Verbesserungen gleichzeitig vornehmen. Diese Zusammenarbeit erfordert einen effizienten und optimierten Ansatz für die Freigabe von Code, das Nachverfolgen von Änderungen, das Verwalten von Versionen und die Integration von Änderungen in das endgültige Projekt.

Das Prompt flow SDK/CLI und die VS Code Prompt Flow-Erweiterung erleichtern die Zusammenarbeit bei der codebasierten Flussentwicklung innerhalb eines Quellcode-Repositorys. Sie können ein cloudbasiertes Quellcodeverwaltungssystem wie GitHub oder Azure Repos verwenden, um Änderungen zu verfolgen, Versionen zu verwalten und diese Änderungen in das endgültige Projekt zu integrieren.

Befolgen bewährter Methoden für die gemeinsame Entwicklung

1. Richten Sie ein zentrales Code-Repository ein.

   Der erste Schritt des gemeinsamen Prozesses umfasst das Einrichten eines Code-Repositorys als Basis für Projektcode, einschließlich des Eingabeaufforderungsflusscodes. Dieses zentrale Repository ermöglicht eine effiziente Organisation, Änderungsnachverfolgung und Zusammenarbeit zwischen Teammitgliedern.

2. Autorisieren und testen Sie Ihren Flow lokal in VS Code mit der Prompt-Flow-Erweiterung.

   Nachdem das Repository eingerichtet wurde, können Teammitglieder VS Code mit der Prompt Flow-Erweiterung für die lokale Entwicklung und Einzeltests des Flows mit Eingaben verwenden. Die standardisierte integrierte Entwicklungsumgebung fördert die Zusammenarbeit zwischen mehreren Mitgliedern, die an verschiedenen Aspekten des Flusses arbeiten.

   

3. Verwenden Sie die CLI oder das pfazure SDK, um Batchläufe und Auswertungen von lokalen Flüssen an die Cloud zu übermitteln.

   Nach der lokalen Entwicklung und Tests können Teammitglieder das Prompt Flow CLI/SDK verwenden, um Batch- und Auswertungsläufe an die Cloud zu übermitteln. Dieser Prozess ermöglicht die Cloud-Computenutzung, beständigen Ergebnisspeicher, Endpunkterstellung für Bereitstellungen und effiziente Verwaltung in der Studio-Benutzeroberfläche.

   

4. Anzeigen und Verwalten von Ausführungsergebnissen in der benutzeroberfläche des Azure Machine Learning Studio Arbeitsbereichs.

   Nachdem sie die Ausführung an die Cloud übermittelt haben, können Teammitglieder auf die Studio-Benutzeroberfläche zugreifen, um die Ergebnisse anzuzeigen und Experimente effizient zu verwalten. Der Cloudarbeitsbereich bietet einen zentralen Ort zum Sammeln und Verwalten von Ausführungsverlauf, Protokollen, Momentaufnahmen, umfassenden Ergebnissen und Eingaben und Ausgaben auf Instanzebene.

   

5. Verwenden Sie die Liste Läufe, in der der gesamte Verlauf aller Ausführungen aufgezeichnet wird, um die Ergebnisse verschiedener Läufe einfach zu vergleichen, was bei der Qualitätsanalyse und den notwendigen Anpassungen unterstützt.

   

6. Verwenden Sie weiterhin die lokale iterative Entwicklung.

   Nach der Analyse der Ergebnisse von Experimenten können Teammitglieder zur lokalen Umgebung und zum Coderepository zurückkehren, um mehr Entwicklung und Feinabstimmung zu erzielen, und anschließende Ausführungen werden iterativ an die Cloud übermittelt. Dieser iterative Ansatz sorgt für eine konsistente Verbesserung, bis das Team mit der Qualität der Produktion zufrieden ist.

7. Verwenden Sie die Ein-Schritt-Bereitstellung für die Produktion im Studio.

   Sobald das Team voll auf die Qualität des Flusses vertraut ist, kann es nahtlos als Onlineendpunkt in einer robusten Cloudumgebung bereitgestellt werden. Die Bereitstellung als Onlineendpunkt kann auf einer Momentaufnahme der Ausführung basieren, sodass stabile und sichere Bereitstellung, weitere Ressourcenzuweisungen und Nutzungsnachverfolgung und Protokollüberwachung in der Cloud möglich sind.

   

   Der Azure Machine Learning Studio Deploy Assistent hilft Ihnen, Ihre Bereitstellung einfach zu konfigurieren.

   

Verwandte Inhalte

• Einrichten von End-to-End-GenAIOps mit Promptfluss und GitHub
• Prompt Flow CLI-Dokumentation für Azure