Integrare il prompt flow con DevOps per applicazioni basate su LLM

Questo articolo illustra l'integrazione del prompt flow con DevOps per applicazioni basate su LLM in Azure Machine Learning. Il prompt flow offre un'esperienza code-first semplice e facile da usare per lo sviluppo di flussi e l'iterazione con l'intero flusso di lavoro di sviluppo di applicazioni basate su LLM.

Fornisce SDK e interfaccia della riga di comando del prompt flow, un'estensione di VS Code e la nuova interfaccia utente di esplorazione delle cartelle di flusso per facilitare lo sviluppo di flussi in locale, l'attivazione in locale di esecuzioni del flusso ed esecuzioni di valutazione e i flussi di transizione da ambienti locali a quelli cloud (area di lavoro Azure Machine Learning).

In questa documentazione viene spiegato come combinare efficacemente le funzionalità di esperienza di scrittura del codice del prompt flow e DevOps per migliorare i flussi di lavoro di sviluppo delle applicazioni basate su LLM.

Introduzione dell'esperienza code-first nel prompt flow

Quando si sviluppano applicazioni con LLM, è prassi avere un processo di progettazione di applicazioni standardizzato che include repository di codice e pipeline CI/CD. Questa integrazione agevola un processo di sviluppo semplificato, il controllo della versione e la collaborazione tra i membri del team.

Per gli sviluppatori esperti nello sviluppo di codice che sono alla ricerca di un processo di iterazione LLMOps più efficiente, l'esperienza di scrittura del codice del prompt flow offre le funzionalità chiave e i vantaggi seguenti:

• Controllo delle versioni del flusso nel repository di codice. È possibile definire il flusso in formato YAML, che può rimanere allineato ai file di origine a cui si fa riferimento in una struttura di cartelle.
• Integrazione dell'esecuzione del flusso con la pipeline CI/CD. È possibile attivare le esecuzioni del flusso usando l'interfaccia della riga di comando o l'SDK del prompt flow, che possono essere integrate senza problemi nella pipeline CI/CD e nel processo di recapito.
• Transizione agevole dall'ambiente locale a quello cloud. È possibile esportare facilmente la cartella del flusso nel repository locale o di codice per il controllo della versione, lo sviluppo in locale e la condivisione. Analogamente, la cartella del flusso può essere importata facilmente nel cloud per ulteriori operazioni di creazione, test e distribuzione nelle risorse cloud.

Accesso alla definizione del codice del prompt flow

Ogni prompt flow è associato a una struttura di cartelle del flusso che contiene file essenziali per definire il flusso nella struttura di cartelle del codice. Questa struttura di cartelle consente di organizzare il flusso, rendendo più agevoli le transizioni.

Azure Machine Learning offre un file system condiviso per tutti gli utenti dell'area di lavoro. Durante la creazione di un flusso viene generata automaticamente una cartella di flusso corrispondente e che viene archiviata in tale posizione nella directory Users/<username>/promptflow.

Struttura delle cartelle del flusso

Panoramica della struttura delle cartelle del flusso e dei file di chiave in essa contenuti:

• flow.dag.yaml: questo file di definizione del flusso primario, in formato YAML, include informazioni su input, output, nodi, strumenti e varianti usati nel flusso. È integrale per la creazione e la definizione del prompt flow.
• File del codice sorgente (.py, .jinja2): la cartella del flusso include anche file di codice sorgente gestiti dall'utente, a cui fanno riferimento gli strumenti/nodi nel flusso.
  • Lo strumento Python può fare riferimento ai file in formato Python (.py) per definire la logica Python personalizzata.
  • Lo strumento prompt o LLM può fare riferimento ai file in formato Jinja 2 (.jinja2) per definire il contesto del prompt.
• File non di origine: la cartella del flusso può contenere anche file non di origine, ad esempio file di utilità e file di dati che possono essere inclusi nei file di origine.

Dopo aver creato il flusso, è possibile passare alla pagina di creazione del flusso per visualizzare e gestire i file di flusso nello strumento di esplorazione file corretto. In questo modo è possibile visualizzare, modificare e gestire i file. Tutte le modifiche apportate ai file sono subito disponibili nello spazio di archiviazione della condivisione file.

Quando l'opzione "Raw file mode" (Modalità file non elaborati) è attivata, è possibile visualizzare e modificare il contenuto non elaborato dei file nell'editor di file, incluso il file di definizione del flusso flow.dag.yaml e i file di origine.

In alternativa, è possibile accedere a tutte le cartelle del flusso direttamente nel notebook di Azure Machine Learning.

Controllo delle versioni del prompt flow nel repository di codice

Per archiviare il flusso nel repository di codice, è possibile esportare facilmente nel sistema locale la cartella del flusso dalla pagina di creazione del flusso. Nel computer locale verrà scaricato un pacchetto contenente tutti i file presenti in Esplora risorse e sarà quindi possibile archiviarlo nel repository del codice.

Per altre informazioni sull'integrazione di DevOps con Azure Machine Learning, vedere Integrazione di Git in Azure Machine Learning.

Invio di esecuzioni al cloud dal repository locale

Prerequisiti

• Completare la procedura Creare risorse per iniziare se non si ha già un'area di lavoro di Azure Machine Learning.

• Un ambiente Python in cui è stato installato Azure Machine Learning Python SDK v2 - istruzioni di installazione. Questo ambiente viene usato per definire e controllare le risorse di Azure Machine Learning ed è separato dall'ambiente usato in fase di esecuzione. Per altre informazioni, vedere l'articolo su come gestire il runtime per la progettazione del prompt flow.

Installare l'SDK del prompt flow

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

Connettersi all'area di lavoro di Azure Machine Learning

Interfaccia della riga di comando di Azure

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

Interfaccia della riga di comando di Azure

Preparare il file run.yml per definire la configurazione per questa esecuzione del flusso nel cloud.

$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 omitted, it will use the automatic runtime, you can also specify the runtime name, specify automatic will also use the automatic runtime.
runtime: <runtime_name> 


# define instance type only work for automatic runtime, will be ignored if you specify the runtime name.
# resources:
#   instance_type: <instance_type>

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

È possibile specificare il nome di connessione e distribuzione per ogni strumento nel flusso. Se non si specifica il nome di connessione e distribuzione, verrà usata l'unica connessione e distribuzione presente nel file flow.dag.yaml. Per definire il formato delle connessioni:

...
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
runtime = <runtime_name>
# define instance type
# resources = {"instance_type": <instance_type>}

# 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,
    runtime=runtime, # if omitted, it will use the automatic runtime, you can also specify the runtime name, specif automatic will also use the automatic runtime.
#    resources = resources, # only work for automatic runtime, will be ignored if you specify the runtime name.
    column_mapping={
        "url": "${data.url}"
    }, 
    connections=connections,  

)
print(base_run)

Interfaccia della riga di comando di Azure

Preparare il file run_evaluation.yml per definire la configurazione per questa esecuzione del flusso di valutazione nel cloud.

$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 omitted, it will use the automatic runtime, you can also specify the runtime name, specif automatic will also use the automatic runtime.
runtime: <runtime_name> 


# define instance type only work for automatic runtime, will be ignored if you specify the runtime name.
# resources:
#   instance_type: <instance_type>

# 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
runtime = <runtime_name>
# define instance type
# resources = {"instance_type": <instance_type>}

# 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}",
    },
    runtime=runtime, # if omitted, it will use the automatic runtime, you can also specify the runtime name, specif automatic will also use the automatic runtime.
#    resources = resources, # only work for automatic runtime, will be ignored if you specify the runtime name.
    connections=connections
)

Visualizzare i risultati nell'area di lavoro di Azure Machine Learning

Inviando l'esecuzione del flusso al cloud verrà restituito l'URL del portale dell'esecuzione. È possibile aprire l'URL per visualizzare i risultati dell'esecuzione nel portale.

È anche possibile usare il comando seguente per visualizzare i risultati delle esecuzioni.

Eseguire lo streaming dei log

Interfaccia della riga di comando di Azure

pfazure run stream --name <run_name>

Python SDK

pf.stream("<run_name>")

Visualizzare gli output delle esecuzioni

Interfaccia della riga di comando di Azure

pfazure run show-details --name <run_name>

Python SDK

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

Visualizzare le metriche dell'esecuzione di valutazione

Interfaccia della riga di comando di Azure

pfazure run show-metrics --name <evaluation_run_name>

Python SDK

pf.get_metrics("evaluation_run_name")

Importante

Per altre informazioni, fare riferimento alla documentazione dell'interfaccia della riga di comando del prompt flow per Azure.

Sviluppo iterativo dall'ottimizzazione

Sviluppo e test in locale

Durante lo sviluppo iterativo, mentre si perfezionano e si mettono a punto il flusso o i prompt, potrebbe essere utile eseguire più iterazioni in locale all'interno del repository di codice. Per facilitare le attività di sviluppo e test in locale senza binding di Azure, vengono fornite la versione della community, l'estensione di VS Code per prompt flow, oltre a SDK e interfaccia della riga di comando locali per prompt flow.

Estensione di VS Code per prompt flow

Quando è installata l'estensione di VS Code per prompt flow, è possibile creare facilmente il flusso in locale dall'editor di VS Code, offrendo un'esperienza di interfaccia utente simile a quella nel cloud.

Per usare l'estensione:

1. Aprire una cartella di prompt flow in VS Code Desktop.
2. Aprire il file "flow.dag.yaml" nella visualizzazione notebook.
3. Usare l'editor visivo per apportare le modifiche necessarie al flusso, ad esempio ottimizzare i prompt nelle varianti o aggiungere altri strumenti.
4. Per testare il flusso, selezionare il pulsante Esegui flusso in alto nell'editor visivo. Verrà attivato un test del flusso.

SDK e interfaccia della riga di comando locale del prompt flow

Se si preferisce usare Jupyter, PyCharm, Visual Studio o altri IDE, è possibile modificare direttamente la definizione YAML nel file flow.dag.yaml.

È quindi possibile attivare una singola esecuzione del flusso per il test usando l'SDK o l'interfaccia della riga di comando del prompt flow.

Interfaccia della riga di comando di Azure

Supponendo che la directory di lavoro sia <path-to-the-sample-repo>/examples/flows/standard/

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

Python SDK

Il valore restituito della funzione test corrisponde agli output di flusso/nodo.

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

In questo modo è possibile apportare modifiche e testarle rapidamente senza dover aggiornare ogni volta il repository di codice principale. Una volta soddisfatti dei risultati dei test locali, è possibile passare a inviare le esecuzioni al cloud dal repository locale per eseguire gli esperimenti nel cloud.

Per altre informazioni e indicazioni sull'uso delle versioni locali, è possibile fare riferimento alla community GitHub sul prompt flow.

Tornare all'interfaccia utente di Studio per lo sviluppo continuo

In alternativa, è possibile tornare all'interfaccia utente di Studio, usando le risorse e l'esperienza cloud per apportare modifiche al flusso nella pagina di creazione del flusso.

Per continuare a sviluppare e usare la versione più aggiornata dei file di flusso, è possibile accedere al terminale nel notebook ed eseguire il pull delle modifiche più recenti dei file di flusso dal repository.

Inoltre, se si preferisce continuare a lavorare nell'interfaccia utente di Studio, è possibile importare direttamente una cartella del flusso locale come nuovo flusso bozza. Questo consente di eseguire facilmente la transizione tra lo sviluppo in locale e nel cloud.

Integrazione CI/CD

CI: attivare le esecuzioni del flusso nella pipeline CI

Dopo aver sviluppato e testato correttamente il flusso e averlo archiviato come versione iniziale, è possibile passare alla successiva iterazione di ottimizzazione e test. In questa fase è possibile attivare le esecuzioni del flusso, incluse le esecuzioni di test e valutazione in batch, usando l'interfaccia della riga di comando del prompt flow. Questa potrebbe fungere da flusso di lavoro automatizzato nella pipeline di integrazione continua (CI).

Durante tutto il ciclo di vita delle iterazioni del flusso, è possibile automatizzare diverse operazioni:

• Esecuzione del prompt flow dopo una richiesta pull
• Esecuzione della valutazione del prompt flow per garantire la qualità elevata dei risultati
• Registrazione dei modelli di prompt flow
• Distribuzione dei modelli di prompt flow

Per una guida completa su una pipeline MLOps end-to-end che esegue un flusso di classificazione Web, vedere l'articolo su come configurare LLMOps end-to-end con prompt flow e GitHub e il progetto demo in GitHub.

CD: distribuzione continua

L'ultima operazione da eseguire per il passaggio all'ambiente di produzione consiste nel distribuire il flusso come endpoint online in Azure Machine Learning. In questo modo è possibile integrare il flusso nell'applicazione e renderlo disponibile per l'uso.

Per altre informazioni su come distribuire il flusso, vedere Distribuire flussi nell'endpoint online gestito di Azure Machine Learning per l'inferenza in tempo reale con l'interfaccia della riga di comando e l'SDK.

Collaborazione allo sviluppo di flussi nell'ambiente di produzione

Nel contesto dello sviluppo di un'applicazione basata su LLM con prompt flow la collaborazione tra i membri del team è spesso un fattore cruciale. I membri del team potrebbero essere coinvolti nello stesso processo di creazione e test del flusso, lavorando su diversi facet del flusso o apportando contemporaneamente miglioramenti e modifiche iterative.

Tale collaborazione richiede un approccio efficiente e semplificato alla condivisione del codice, al rilevamento delle modifiche, alla gestione delle versioni e all'integrazione di tali modifiche nel progetto finale.

L'introduzione di SDK/interfaccia della riga di comando del prompt flow e dell'estensione di Visual Studio Code nell'ambito dell'esperienza di scrittura del codice del prompt flow semplifica la collaborazione nello sviluppo del flusso all'interno del repository di codice. È consigliabile usare un repository di codice basato sul cloud, ad esempio GitHub o Azure DevOps, per tenere traccia delle modifiche, gestire le versioni e integrare queste modifiche nel progetto finale.

Procedura consigliata per lo sviluppo collaborativo

1. Creazione e test singolo del flusso in locale - Repository di codice ed estensione VS Code

   • Il primo passaggio di questo processo collaborativo prevede l'uso di un repository di codice come base per il codice del progetto, che include il codice del prompt flow.
     • Questo repository centralizzato consente un'organizzazione efficiente, il rilevamento di tutte le modifiche apportate al codice e la collaborazione tra i membri del team.
   • Dopo aver configurato il repository, i membri del team possono usare l'estensione di VS Code per la creazione e il test di singoli input del flusso in locale.
     • Questo ambiente di sviluppo integrato standardizzato favorisce la collaborazione tra più membri che lavorano su diversi aspetti del flusso.

2. Test e valutazione in batch sperimentali basati sul cloud: interfaccia della riga di comando/SDK del prompt flow e interfaccia utente del portale dell'area di lavoro

   • Dopo la fase di sviluppo e test in locale, gli sviluppatori di flussi possono usare l'SDK o l'interfaccia della riga di comando pfazure per inviare esecuzioni in batch ed esecuzioni di valutazione dai file di flusso locali al cloud.
     • Questa azione consente di archiviare in modo persistente i risultati relativi all'utilizzo delle risorse cloud e di gestirli in modo efficiente con un'interfaccia utente del portale nell'area di lavoro di Azure Machine Learning. Questo passaggio consente di ottenere i dati relativi all'utilizzo delle risorse cloud, tra cui calcolo e archiviazione e altri endpoint per le distribuzioni.
   • Dopo l'invio al cloud, i membri del team possono accedere all'interfaccia utente del portale cloud per visualizzare i risultati e gestire gli esperimenti in modo efficiente.
     • Questa area di lavoro cloud offre una posizione centralizzata per raccogliere e gestire tutta la cronologia delle esecuzioni, i log, gli snapshot, i risultati completi, inclusi gli input e gli output a livello di istanza.
     • Nell'elenco di esecuzione, che registra tutta la cronologia di esecuzione a partire dallo sviluppo, i membri del team possono confrontare facilmente i risultati di diverse esecuzioni, per analizzare la qualità e apportare le modifiche necessarie.

3. Sviluppo iterativo locale in o distribuzione dell'interfaccia utente in un unico passaggio per l'ambiente di produzione

   • Dopo l'analisi degli esperimenti, i membri del team possono tornare al repository di codice per altre operazioni di sviluppo e ottimizzazione. Le esecuzioni successive possono quindi essere inviate al cloud in modo iterativo.
     • Questo approccio iterativo garantisce un miglioramento costante fino a quando il team non ritiene che la qualità sia adeguata per l'ambiente di produzione.
   • Quando il team è totalmente soddisfatto della qualità del flusso, è possibile distribuirlo senza problemi tramite una procedura guidata dell'interfaccia utente come endpoint online in Azure Machine Learning. Quando il team è totalmente soddisfatto della qualità del flusso, è possibile passarlo senza problemi nell'ambiente di produzione tramite una procedura guidata dell'interfaccia utente come endpoint online in un ambiente cloud affidabile.
     • Questa distribuzione in un endpoint online può essere basata su uno snapshot di esecuzione, consentendo una gestione stabile e sicura, un'ulteriore allocazione delle risorse e il rilevamento dell'utilizzo, nonché il monitoraggio dei log nel cloud.

Perché è consigliabile usare il repository di codice per lo sviluppo collaborativo

Per lo sviluppo iterativo risulta in genere più efficace combinare ambiente di sviluppo locale e sistema di controllo della versione, ad esempio Git. È infatti possibile apportare modifiche e testare il codice in locale, quindi eseguire il commit delle modifiche in Git. In questo modo viene creata una traccia continua delle modifiche apportate e, se necessario, è possibile ripristinare versioni precedenti.

Quando è richiesta la condivisione dei flussi in ambienti diversi, è consigliabile usare un repository di codice basato sul cloud, ad esempio GitHub o Azure Repos. In questo modo è possibile accedere alla versione più recente del codice da qualsiasi posizione e vengono forniti strumenti per la collaborazione e la gestione del codice.

Seguendo questa procedura consigliata, i team possono creare un ambiente collaborativo fluido, efficiente e produttivo per lo sviluppo di prompt flow.

Passaggi successivi

• Configurare LLMOps end-to-end con prompt flow e GitHub
• Documentazione dell'interfaccia della riga di comando del prompt flow per Azure