Creare ed eseguire pipeline di Machine Learning usando componenti l'interfaccia della riga di comando di Azure Machine Learning

SI APPLICA A:estensione ML dell'interfaccia della riga di comando di Azure v2 (corrente)

Questo articolo illustra come creare ed eseguire pipeline di Machine Learning usando l'interfaccia della riga di comando di Azure e i componenti. È possibile creare pipeline senza usare componenti, ma i componenti offrono flessibilità e abilitano il riutilizzo. Le pipeline di Azure Machine Learning possono essere definite in YAML ed eseguite dalla CLI, create in Python o composte nel Designer di Azure Machine Learning Studio tramite un'interfaccia utente di trascinamento e rilascio. Questo articolo è incentrato sull'interfaccia della riga di comando.

Prerequisiti

• Una sottoscrizione di Azure. Se non se ne dispone, creare un account gratuito prima di iniziare. Provare la versione gratuita o a pagamento di Azure Machine Learning.

• Un'area di lavoro di Azure Machine Learning.

• Estensione dell'interfaccia della riga di comando di Azure per Machine Learning, installata e configurata.

• Un clone del repository di esempi. È possibile usare questi comandi per clonare il repository:

  git clone https://github.com/Azure/azureml-examples --depth 1
  cd azureml-examples/cli/jobs/pipelines-with-components/basics
  

Letture preliminari consigliate

• Cosa sono le pipeline di Azure Machine Learning?
• Che cos'è un componente di Azure Machine Learning?

Crea la tua prima pipeline con dei componenti

Prima di tutto, si creerà una pipeline con componenti usando un esempio. In questo modo si ottiene un'impressione iniziale dell'aspetto di una pipeline e di un componente in Azure Machine Learning.

Nella directory cli/jobs/pipelines-with-components/basics del repository azureml-examples, passare alla sottodirectory 3b_pipeline_with_data. In questa directory sono presenti tre tipi di file. Questi sono i file che è necessario creare quando si compila la propria pipeline.

• pipeline.yml. Questo file YAML definisce la pipeline di Machine Learning. Descrive come suddividere un'attività di Machine Learning completa in un flusso di lavoro con più passaggi. Si consideri, ad esempio, la semplice attività di Machine Learning dell'uso di dati cronologici per eseguire il training di un modello di previsione delle vendite. È possibile creare un flusso di lavoro sequenziale che contiene l'elaborazione dei dati, il training del modello e i passaggi di valutazione del modello. Ogni passaggio è un componente che dispone di un'interfaccia ben definita e che può essere sviluppato, testato e ottimizzato in modo indipendente. Il file YAML della pipeline definisce anche il modo in cui i sotto-passaggi si connettono ad altri passaggi della pipeline. Ad esempio, il passaggio di training del modello genera un file di modello e il file del modello viene passato a un passaggio di valutazione del modello.

• component.yml. Questi file YAML definiscono i componenti. Contengono le informazioni seguenti:

  • Metadati: nome, nome visualizzato, versione, descrizione, tipo e così via. I metadati consentono di descrivere e gestire il componente.
  • Interfaccia: input e output. Ad esempio, un componente di addestramento del modello accetta i dati di addestramento e il numero di epoche come input e genera un file di modello addestrato come output. Dopo aver definito l'interfaccia, i diversi team possono sviluppare e testare il componente in modo indipendente.
  • Comando, codice e ambiente: comando, codice e ambiente per eseguire il componente. Il comando è il comando shell per eseguire il componente. Il codice fa in genere riferimento a una directory del codice sorgente. L'ambiente può essere un ambiente di Azure Machine Learning (curato o creato dal cliente), un'immagine Docker o un ambiente conda.

• component_src. Si tratta delle directory del codice sorgente per componenti specifici. Contengono il codice sorgente eseguito nel componente. È possibile usare il linguaggio preferito, tra cui Python, R e altri. Il codice deve essere eseguito da un comando della shell. Il codice sorgente può richiedere alcuni input dalla riga di comando della shell per controllare la modalità di esecuzione di questo passaggio. Ad esempio, un passaggio di addestramento potrebbe richiedere dati di addestramento, tasso di apprendimento e numero di epoche per controllare il processo di addestramento. L'argomento di un comando della shell viene usato per passare input e output al codice.

A questo punto si creerà una pipeline usando l'esempio 3b_pipeline_with_data . Ogni file è illustrato più avanti nelle sezioni seguenti.

Per prima cosa, elencare le risorse di calcolo disponibili usando il comando seguente:

az ml compute list

Se non è disponibile, creare un cluster chiamato cpu-cluster eseguendo questo comando:

az ml compute create -n cpu-cluster --type amlcompute --min-instances 0 --max-instances 10

Creare ora un processo della pipeline definito nel file pipeline.yml eseguendo il comando seguente. La destinazione di calcolo viene indicata nel file pipeline.yml come azureml:cpu-cluster. Se la destinazione di calcolo usa un nome diverso, ricordarsi di aggiornarla nel file pipeline.yml.

az ml job create --file pipeline.yml

Si dovrebbe ricevere un dizionario JSON con informazioni sul processo della pipeline, tra cui:

Passare all'URL services.Studio.endpoint per visualizzare una visualizzazione della pipeline:

Informazioni sul codice YAML di definizione della pipeline

Si esaminerà ora la definizione della pipeline nel file 3b_pipeline_with_data/pipeline.yml .

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

display_name: 3b_pipeline_with_data
description: Pipeline with 3 component jobs with data dependencies

settings:
  default_compute: azureml:cpu-cluster

outputs:
  final_pipeline_output:
    mode: rw_mount

jobs:
  component_a:
    type: command
    component: ./componentA.yml
    inputs:
      component_a_input: 
        type: uri_folder
        path: ./data

    outputs:
      component_a_output: 
        mode: rw_mount
  component_b:
    type: command
    component: ./componentB.yml
    inputs:
      component_b_input: ${{parent.jobs.component_a.outputs.component_a_output}}
    outputs:
      component_b_output: 
        mode: rw_mount
  component_c:
    type: command
    component: ./componentC.yml
    inputs:
      component_c_input: ${{parent.jobs.component_b.outputs.component_b_output}}
    outputs:
      component_c_output: ${{parent.outputs.final_pipeline_output}}
      #  mode: upload

Nella tabella seguente vengono descritti i campi usati più di frequente dello schema YAML della pipeline. Per altre informazioni, vedere lo schema YAML completo della pipeline.

L'esempio 3b_pipeline_with_data contiene una pipeline in tre passaggi.

• I tre passaggi sono definiti in jobs. Tutti e tre i passaggi sono di tipo command. La definizione di ogni passaggio si trova in un file corrispondente component*.yml . È possibile visualizzare i file YAML del componente nella directory 3b_pipeline_with_data . componentA.yml è descritto nella sezione successiva.
• Questa pipeline ha una dipendenza dai dati, che è comune nelle pipeline reali. Il componente A accetta l'input dei dati da una cartella locale in ./data (righe 18-21) e ne passa l'output al componente B (riga 29). È possibile fare riferimento all'output del componente A come ${{parent.jobs.component_a.outputs.component_a_output}}.
• default_compute definisce il calcolo predefinito per la pipeline. Se un componente in jobs definisce un calcolo diverso, vengono rispettate le impostazioni specifiche del componente.

Leggere e scrivere dati in una pipeline

Uno scenario comune consiste nel leggere e scrivere dati in una pipeline. In Azure Machine Learning si usa lo stesso schema per leggere e scrivere dati per tutti i tipi di processi (processi della pipeline, processi di comando e processi sweep). Di seguito sono riportati esempi di uso dei dati nelle pipeline per scenari comuni:

• Dati locali
• File Web con un URL pubblico
• archivio dati e percorso di Azure Machine Learning
• asset di dati di Azure Machine Learning

Informazioni sul codice YAML di definizione del componente

Ecco il file componentA.yml , un esempio di YAML che definisce un componente:

$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
type: command

name: component_a
display_name: componentA
version: 1

inputs:
  component_a_input:
    type: uri_folder

outputs:
  component_a_output:
    type: uri_folder

code: ./componentA_src

environment: 
  image: python

command: >-
  python hello.py --componentA_input ${{inputs.component_a_input}} --componentA_output ${{outputs.component_a_output}}

Questa tabella definisce i campi più usati del componente YAML. Per altre informazioni, vedere lo schema YAML completo del componente.

Nell'esempio in 3b_pipeline_with_data/componentA.yml, il componente A ha un input di dati e un output di dati, che può essere connesso ad altri passaggi della pipeline padre. Tutti i file nella sezione code del componente YAML verranno caricati in Azure Machine Learning al momento di invio del processo della pipeline. In questo esempio verranno caricati i file in ./componentA_src . (Riga 16 in componentA.yml. È possibile visualizzare il codice sorgente caricato nell'interfaccia utente di Studio: fare doppio clic sul passaggio componentA nel grafico e passare alla scheda Codice , come illustrato nello screenshot seguente. Si può notare che si tratta di uno script hello-world che esegue una semplice stampa e che scrive la data e l'ora correnti nel componentA_output percorso. Il componente accetta l'input e fornisce l'output tramite la riga di comando. È gestito in hello.py con argparse.

Input e output

L'input e l'output definiscono l'interfaccia di un componente. L'input e l'output possono essere valori letterali (di tipo string, numberinteger, o boolean) o un oggetto che contiene uno schema di input.

L'input dell'oggetto (di tipo uri_file, uri_folder, mltable, mlflow_model o custom_model) può connettersi ad altri passaggi del processo della pipeline principale per passare dati/modelli ad altri passaggi. Nel grafico della pipeline, l'input del tipo di oggetto viene visualizzato come un punto di connessione.

Gli input dei valori letterali (string, number, integer, boolean) sono i parametri che è possibile passare al componente in fase di esecuzione. È possibile aggiungere un valore predefinito di input letterali nel default campo . Per i tipi number e integer, è anche possibile aggiungere valori minimi e massimi utilizzando i campi min e max. Se il valore di input è minore del valore minimo o superiore al massimo, la pipeline non riesce alla convalida. La convalida viene eseguita prima di inviare un lavoro della pipeline, consentendo di risparmiare tempo. La convalida funziona per la CLI, il Python SDK e l'interfaccia utente di Designer. Lo screenshot seguente mostra un esempio di convalida nell'interfaccia utente di Progettazione. Analogamente, è possibile definire i valori consentiti nei enum campi.

Se si vuole aggiungere un input a un componente, è necessario apportare modifiche in tre posizioni:

• Campo inputs nel file YAML del componente.
• Campo command nel file YAML del componente.
• Nel codice sorgente del componente per gestire l'input della riga di comando.

Queste posizioni sono contrassegnate con caselle verdi nella schermata precedente.

Per altre informazioni su input e output, vedere Gestire input e output per componenti e pipeline.

Ambienti

L'ambiente è l'ambiente in cui viene eseguito il componente. Potrebbe trattarsi di un ambiente di Azure Machine Learning (curato, personalizzato o registrato), di un'immagine Docker o di un ambiente Conda. Vedere gli esempi seguenti:

• Risorsa ambientale di Azure Machine Learning registrata. Viene fatto riferimento all'ambiente nel componente con la sintassi azureml:<environment-name>:<environment-version>.
• Immagine Docker pubblica.
• File Conda. Il file conda deve essere usato insieme a un'immagine di base.

Registrare un componente per il riutilizzo e la condivisione

Anche se alcuni componenti sono specifici di una particolare pipeline, il vero vantaggio dei componenti deriva dal riutilizzo e dalla condivisione. È possibile registrare un componente nell'area di lavoro di Machine Learning per renderlo disponibile per il riutilizzo. I componenti registrati supportano il controllo delle versioni automatico in modo da poter aggiornare il componente, ma assicurarsi che le pipeline che richiedono una versione precedente continueranno a funzionare.

Nel repository azureml-examples passare alla cli/jobs/pipelines-with-components/basics/1b_e2e_registered_components directory .

Per registrare un componente, usare il comando az ml component create:

az ml component create --file train.yml
az ml component create --file score.yml
az ml component create --file eval.yml

Dopo aver eseguito questi comandi fino al completamento, è possibile visualizzare i componenti in lo Studio, in Assets>Componenti:

Selezionare un componente. Vengono visualizzate informazioni dettagliate per ogni versione del componente.

La scheda Dettagli mostra informazioni di base, ad esempio il nome del componente, chi l'ha creato e la versione. Sono disponibili campi modificabili per Tag e Descrizione. È possibile usare i tag per aggiungere parole chiave di ricerca. Il campo description supporta la formattazione Markdown. È consigliabile usarlo per descrivere le funzionalità del componente e l'uso di base.

Nella scheda Processi viene visualizzata la cronologia di tutti i processi che usano il componente.

Usare componenti registrati in un file YAML del processo della pipeline

A questo punto si userà 1b_e2e_registered_components come esempio di come usare il componente registrato nella pipeline YAML. Passare alla 1b_e2e_registered_components directory e aprire il pipeline.yml file. Le chiavi e i valori nei campi inputs e outputs sono simili a quelli già descritti. L'unica differenza significativa è il valore del campo component nelle voci di jobs.<job_name>.component. Il component valore è nel formato azureml:<component_name>:<component_version>. La train-job definizione, ad esempio, specifica che deve essere usata la versione più recente del componente my_train registrato:

type: command
component: azureml:my_train@latest
inputs:
  training_data: 
    type: uri_folder 
    path: ./data      
  max_epocs: ${{parent.inputs.pipeline_job_training_max_epocs}}
  learning_rate: ${{parent.inputs.pipeline_job_training_learning_rate}}
  learning_rate_schedule: ${{parent.inputs.pipeline_job_learning_rate_schedule}}
outputs:
  model_output: ${{parent.outputs.pipeline_job_trained_model}}
services:
  my_vscode:

Gestire i componenti

È possibile controllare i dettagli del componente e gestire i componenti usando l'interfaccia della riga di comando v2. Usare az ml component -h per ottenere istruzioni dettagliate sui comandi dei componenti. Nella tabella seguente sono elencati tutti i comandi disponibili. Vedere altri esempi nelle informazioni di riferimento dell'interfaccia della riga di comando di Azure.

Passo successivo

• Prova l'esempio del componente CLI v2