Condividi tramite

Creare ed eseguire le pipeline di Machine Learning con Azure Machine Learning SDK

  • Articolo

SI APPLICA A:Python SDK azureml v1

Questo articolo illustra come creare ed eseguire pipeline di MachineLearning usando Azure Machine Learning SDK. Usare le pipeline di Machine Learning per creare un flusso di lavoro che unisce varie fasi di Machine Learning. Pubblicare quindi la pipeline per l'accesso o la condivisione in un secondo momento con altri utenti. Tenere traccia delle pipeline di Machine Learning per verificare le prestazioni del modello nel mondo reale e rilevare la deriva dei dati. Le pipeline di Machine Learning sono ideali per scenari di assegnazione dei punteggi batch, usando vari calcoli, riutilizzando i passaggi anziché riesecuzione e condividendo i flussi di lavoro di Machine Learning con altri utenti.

Questo articolo non è un'esercitazione. Per indicazioni sulla creazione della prima pipeline, vedere Esercitazione: Creare una pipeline di Azure Machine Learning per l'assegnazione dei punteggi batch o Usare Machine Learning automatizzato in una pipeline di Azure Machine Learning in Python.

Anche se è possibile usare un tipo diverso di pipeline denominato Azure Pipeline per l'automazione CI/CD delle attività di Machine Learning, tale tipo di pipeline non viene archiviato nell'area di lavoro. Confrontare queste diverse pipeline.

Le pipeline di Machine Learning create sono visibili ai membri dell'area di lavoro di Azure Machine Learning.

Le pipeline di Machine Learning vengono eseguite su destinazioni di calcolo (vedere Informazioni sulle destinazioni di calcolo in Azure Machine Learning). Le pipeline possono leggere e scrivere dati da e verso percorsi di Archiviazione di Azure supportati.

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare. Provare la versione gratuita o a pagamento di Azure Machine Learning.

Prerequisiti

Per iniziare, collegare l'area di lavoro:

import azureml.core
from azureml.core import Workspace, Datastore

ws = Workspace.from_config()

Configurare le risorse di Machine Learning

Creare le risorse necessarie per eseguire una pipeline di Machine Learning:

  • Configurare un archivio dati che verrà usato per accedere ai dati necessari nei passaggi della pipeline.

  • Configurare un Dataset oggetto in modo che punti a dati persistenti che si trovano in un archivio dati o che sono accessibili in . Configurare un OutputFileDatasetConfig oggetto per i dati temporanei passati tra i passaggi della pipeline.

  • Configurare le destinazioni di calcolo in cui verranno eseguiti i passaggi della pipeline.

Configurare un archivio dati

Un archivio dati contiene i dati a cui accede la pipeline. Ogni area di lavoro ha un archivio dati predefinito. È possibile registrare più archivi dati.

Quando si crea l'area di lavoro, File di Azure e archiviazione BLOB di Azure sono collegati all'area di lavoro. Un archivio dati predefinito viene registrato per connettersi all'archivio BLOB di Azure. Per altre informazioni, vedere Decidere quando usare BLOB di Azure, File di Azure o Dischi di Azure.

# Default datastore 
def_data_store = ws.get_default_datastore()

# Get the blob storage associated with the workspace
def_blob_store = Datastore(ws, "workspaceblobstore")

# Get file storage associated with the workspace
def_file_store = Datastore(ws, "workspacefilestore")

I passaggi in genere usano i dati e producono dati di output. Un passaggio può creare dati, ad esempio un modello, una directory con modello e file dipendenti o dati temporanei. Questi dati sono quindi disponibili per altri passaggi successivi nella pipeline. Per altre informazioni sulla connessione della pipeline ai dati, vedere gli articoli How to Access Data (Come accedere ai dati ) e How to Register Datasets (Come registrare i set di dati).

Configurare i dati con Dataset oggetti e OutputFileDatasetConfig

Il modo preferito per fornire dati a una pipeline è un oggetto Dataset . L'oggetto Dataset punta ai dati che si trovano in o sono accessibili da un archivio dati o da un URL Web. La Dataset classe è astratta, quindi si creerà un'istanza di ( FileDataset che fa riferimento a uno o più file) o un oggetto TabularDataset creato da uno o più file con colonne delimitate di dati.

Si crea un Dataset oggetto usando metodi come from_files o from_delimited_files.

from azureml.core import Dataset

my_dataset = Dataset.File.from_files([(def_blob_store, 'train-images/')])

I dati intermedi (o l'output di un passaggio) sono rappresentati da un oggetto OutputFileDatasetConfig . output_data1 viene prodotto come output di un passaggio. Facoltativamente, questi dati possono essere registrati come set di dati chiamando register_on_complete. Se si crea un OutputFileDatasetConfig oggetto in un passaggio e lo si usa come input per un altro passaggio, la dipendenza dei dati tra i passaggi crea un ordine di esecuzione implicito nella pipeline.

OutputFileDatasetConfig gli oggetti restituiscono una directory e per impostazione predefinita scrive l'output nell'archivio dati predefinito dell'area di lavoro.

from azureml.data import OutputFileDatasetConfig

output_data1 = OutputFileDatasetConfig(destination = (datastore, 'outputdataset/{run-id}'))
output_data_dataset = output_data1.register_on_complete(name = 'prepared_output_data')

Importante

I dati intermedi archiviati con OutputFileDatasetConfig non vengono eliminati automaticamente da Azure. È consigliabile eliminare i dati intermedi a livello di codice alla fine di un'esecuzione della pipeline, usare un archivio dati con un criterio di conservazione dei dati breve o eseguire regolarmente la pulizia manuale.

Suggerimento

Caricare solo i file rilevanti per il processo in questione. Anche se viene specificato il riutilizzo, eventuali modifiche apportate ai file all'interno della directory dei dati verranno considerate motivi per ripetere il passaggio alla successiva esecuzione della pipeline.

Configurare una destinazione di calcolo

In Azure Machine Learning il termine calcolo (o destinazione di calcolo) si riferisce ai computer o ai cluster che eseguono i passaggi di calcolo nella pipeline di Machine Learning. Vedere Destinazioni di calcolo per il training del modello per un elenco completo delle destinazioni di calcolo e Creare destinazioni di calcolo per informazioni su come crearle e collegarle all'area di lavoro. Il processo di creazione e collegamento di una destinazione di calcolo è lo stesso che si sta eseguendo il training di un modello o l'esecuzione di un passaggio della pipeline. Dopo aver creato e collegato la destinazione di calcolo, usare l'oggetto ComputeTarget nel passaggio pipeline.

Importante

L'esecuzione di operazioni di gestione sulle destinazioni di calcolo non è supportata dai processi remoti. Poiché le pipeline di Machine Learning vengono inviate come processo remoto, non usare le operazioni di gestione in destinazioni di calcolo all'interno della pipeline.

Ambiente di calcolo di Azure Machine Learning

È possibile creare un ambiente di calcolo di Azure Machine Learning per eseguire i passaggi. Il codice per altre destinazioni di calcolo è simile, con parametri leggermente diversi, a seconda del tipo.

from azureml.core.compute import ComputeTarget, AmlCompute

compute_name = "aml-compute"
vm_size = "STANDARD_NC6"
if compute_name in ws.compute_targets:
    compute_target = ws.compute_targets[compute_name]
    if compute_target and type(compute_target) is AmlCompute:
        print('Found compute target: ' + compute_name)
else:
    print('Creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size=vm_size,  # STANDARD_NC6 is GPU-enabled
                                                                min_nodes=0,
                                                                max_nodes=4)
    # create the compute target
    compute_target = ComputeTarget.create(
        ws, compute_name, provisioning_config)

    # Can poll for a minimum number of nodes and for a specific timeout.
    # If no min node count is provided it will use the scale settings for the cluster
    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=20)

    # For a more detailed view of current cluster status, use the 'status' property
    print(compute_target.status.serialize())

Configurare l'ambiente di esecuzione del training

Il passaggio successivo consiste nel verificare che l'esecuzione del training remoto abbia tutte le dipendenze necessarie per i passaggi di training. Le dipendenze e il contesto di runtime vengono impostati creando e configurando un RunConfiguration oggetto .

from azureml.core.runconfig import RunConfiguration
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core import Environment 

aml_run_config = RunConfiguration()
# `compute_target` as defined in "Azure Machine Learning compute" section above
aml_run_config.target = compute_target

USE_CURATED_ENV = True
if USE_CURATED_ENV :
    curated_environment = Environment.get(workspace=ws, name="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu")
    aml_run_config.environment = curated_environment
else:
    aml_run_config.environment.python.user_managed_dependencies = False
    
    # Add some packages relied on by data prep step
    aml_run_config.environment.python.conda_dependencies = CondaDependencies.create(
        conda_packages=['pandas','scikit-learn'], 
        pip_packages=['azureml-sdk', 'azureml-dataset-runtime[fuse,pandas]'], 
        pin_sdk_version=False)

Il codice precedente mostra due opzioni per la gestione delle dipendenze. Come presentato, con USE_CURATED_ENV = True, la configurazione è basata su un ambiente curato. Gli ambienti curati sono "prebaked" con librerie comuni dipendenti e possono essere più veloci per portare online. Gli ambienti curati hanno immagini Docker predefinite nel Registro Contenitori Microsoft. Per altre informazioni, vedere Ambienti curati di Azure Machine Learning.

Il percorso eseguito se si modifica USE_CURATED_ENV in False mostra il modello per impostare in modo esplicito le dipendenze. In questo scenario verrà creata e registrata una nuova immagine Docker personalizzata in un Registro Azure Container all'interno del gruppo di risorse. Vedere Introduzione ai registri contenitori Docker privati in Azure. La compilazione e la registrazione di questa immagine possono richiedere alcuni minuti.

Creare i passaggi della pipeline

Dopo aver creato la risorsa di calcolo e l'ambiente, è possibile definire i passaggi della pipeline. Esistono molti passaggi predefiniti disponibili tramite Azure Machine Learning SDK, come è possibile vedere nella documentazione di riferimento per il azureml.pipeline.steps pacchetto. La classe più flessibile è PythonScriptStep, che esegue uno script Python.

from azureml.pipeline.steps import PythonScriptStep
dataprep_source_dir = "./dataprep_src"
entry_point = "prepare.py"
# `my_dataset` as defined above
ds_input = my_dataset.as_named_input('input1')

# `output_data1`, `compute_target`, `aml_run_config` as defined above
data_prep_step = PythonScriptStep(
    script_name=entry_point,
    source_directory=dataprep_source_dir,
    arguments=["--input", ds_input.as_download(), "--output", output_data1],
    compute_target=compute_target,
    runconfig=aml_run_config,
    allow_reuse=True
)

Il codice precedente mostra un tipico passaggio della pipeline iniziale. Il codice di preparazione dei dati si trova in una sottodirectory (in questo esempio, "prepare.py" nella directory "./dataprep.src"). Come parte del processo di creazione della pipeline, questa directory viene compressa e caricata in compute_target e il passaggio esegue lo script specificato come valore per script_name.

I arguments valori specificano gli input e gli output del passaggio. Nell'esempio precedente i dati di base sono il my_dataset set di dati. I dati corrispondenti verranno scaricati nella risorsa di calcolo perché il codice lo specifica come as_download(). Lo script prepare.py esegue le attività di trasformazione dei dati appropriate per l'attività a portata di mano e restituisce i dati in output_data1, di tipo OutputFileDatasetConfig. Per altre informazioni, vedere Spostamento dei dati in e tra i passaggi della pipeline di Machine Learning (Python). Il passaggio verrà eseguito nel computer definito da compute_target, usando la configurazione aml_run_config.

Il riutilizzo dei risultati precedenti (allow_reuse) è fondamentale quando si usano pipeline in un ambiente collaborativo, poiché l'eliminazione di riesecuzioni non necessarie offre flessibilità. Il riutilizzo è il comportamento predefinito quando i script_name, gli input e i parametri di un passaggio rimangono invariati. Quando il riutilizzo è consentito, i risultati dell'esecuzione precedente vengono immediatamente inviati al passaggio successivo. Se allow_reuse è impostato su False, verrà sempre generata una nuova esecuzione per questo passaggio durante l'esecuzione della pipeline.

È possibile creare una pipeline con un singolo passaggio, ma quasi sempre si sceglie di suddividere il processo complessivo in diversi passaggi. Ad esempio, potrebbero essere presenti passaggi per la preparazione dei dati, il training, il confronto dei modelli e la distribuzione. Ad esempio, si potrebbe immaginare che, dopo quanto data_prep_step specificato in precedenza, il passaggio successivo potrebbe essere il training:

train_source_dir = "./train_src"
train_entry_point = "train.py"

training_results = OutputFileDatasetConfig(name = "training_results",
    destination = def_blob_store)

    
train_step = PythonScriptStep(
    script_name=train_entry_point,
    source_directory=train_source_dir,
    arguments=["--prepped_data", output_data1.as_input(), "--training_results", training_results],
    compute_target=compute_target,
    runconfig=aml_run_config,
    allow_reuse=True
)

Il codice precedente è simile al codice nel passaggio di preparazione dei dati. Il codice di training si trova in una directory separata da quella del codice di preparazione dei dati. L'output OutputFileDatasetConfig del passaggio di preparazione dei dati viene output_data1 usato come input per il passaggio di training. Viene creato un nuovo OutputFileDatasetConfig oggetto training_results per contenere i risultati per un confronto o un passaggio di distribuzione successivo.

Per altri esempi di codice, vedere come compilare una pipeline di Machine Learning in due passaggi e come scrivere di nuovo i dati negli archivi dati al termine dell'esecuzione.

Dopo la definizione dei passaggi, si crea la pipeline usando alcuni o tutti i passaggi definiti.

Nota

Non vengono caricati file o dati in Azure Machine Learning quando si definiscono i passaggi o si compila la pipeline. I file vengono caricati quando si chiama Experiment.submit()..

# list of steps to run (`compare_step` definition not shown)
compare_models = [data_prep_step, train_step, compare_step]

from azureml.pipeline.core import Pipeline

# Build the pipeline
pipeline1 = Pipeline(workspace=ws, steps=[compare_models])

Uso di un set di dati

Set di dati creati da Archiviazione BLOB di Azure, File di Azure, Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2, database Azure SQL e Database di Azure per PostgreSQL può essere usato come input per qualsiasi passaggio della pipeline. È possibile scrivere output in un DataTransferStep, DatabricksStep o se si desidera scrivere dati in un archivio dati specifico, usare OutputFileDatasetConfig.

Importante

L'operazione di riscrittura dei dati di output in un archivio dati usando OutputFileDatasetConfig è supportata solo per gli archivi dati BLOB di Azure, di condivisione file di Azure e ADLS Gen1 e Gen2.

dataset_consuming_step = PythonScriptStep(
    script_name="iris_train.py",
    inputs=[iris_tabular_dataset.as_named_input("iris_data")],
    compute_target=compute_target,
    source_directory=project_folder
)

È quindi possibile recuperare il set di dati nella pipeline usando il dizionario Run.input_datasets .

# iris_train.py
from azureml.core import Run, Dataset

run_context = Run.get_context()
iris_dataset = run_context.input_datasets['iris_data']
dataframe = iris_dataset.to_pandas_dataframe()

La linea Run.get_context() vale la pena evidenziare. Questa funzione recupera un oggetto Run che rappresenta l'esecuzione sperimentale corrente. Nell'esempio precedente viene usato per recuperare un set di dati registrato. Un altro uso comune dell'oggetto Run consiste nel recuperare sia l'esperimento stesso che l'area di lavoro in cui risiede l'esperimento:

# Within a PythonScriptStep

ws = Run.get_context().experiment.workspace

Per altri dettagli, inclusi modi alternativi per passare e accedere ai dati, vedere Spostamento dei dati in e tra i passaggi della pipeline di Machine Learning (Python).

Riutilizzo della memorizzazione nella cache &

Per ottimizzare e personalizzare il comportamento delle pipeline, è possibile eseguire alcune operazioni relative alla memorizzazione nella cache e al riutilizzo. Ad esempio, è possibile scegliere di:

  • Disattivare il riutilizzo predefinito dell'output dell'esecuzione del passaggio impostando allow_reuse=False durante la definizione del passaggio. Il riutilizzo è fondamentale quando si usano pipeline in un ambiente collaborativo perché l'eliminazione delle esecuzioni non necessarie offre agilità. Tuttavia, è possibile rifiutare esplicitamente il riutilizzo.
  • Forzare la rigenerazione dell'output per tutti i passaggi in un'esecuzione con pipeline_run = exp.submit(pipeline, regenerate_outputs=True)

Per impostazione predefinita, allow_reuse per i passaggi è abilitato e l'oggetto source_directory specificato nella definizione del passaggio viene sottoposto a hashing. Pertanto, se lo script per un determinato passaggio rimane lo stesso (script_name, gli input e i parametri) e nient'altro in source_directory è stato modificato, l'output di un'esecuzione precedente viene riutilizzato, il processo non viene inviato al calcolo e i risultati dell'esecuzione precedente sono immediatamente disponibili per il passaggio successivo.

step = PythonScriptStep(name="Hello World",
                        script_name="hello_world.py",
                        compute_target=aml_compute,
                        source_directory=source_directory,
                        allow_reuse=False,
                        hash_paths=['hello_world.ipynb'])

Nota

Se i nomi degli input di dati cambiano, il passaggio verrà rieseguito, anche se i dati sottostanti non cambiano. È necessario impostare in modo esplicito il name campo dei dati di input (data.as_input(name=...)). Se questo valore non viene impostato in modo esplicito, il name campo verrà impostato su un GUID casuale e i risultati del passaggio non verranno riutilizzati.

Inviare la pipeline

Quando si invia la pipeline, Azure Machine Learning controlla le dipendenze per ogni passaggio e carica uno snapshot della directory di origine specificata. Se la directory di origine non è specificata, viene caricata la directory locale corrente. Lo snapshot viene archiviato anche come parte dell'esperimento nell'area di lavoro.

Importante

Per evitare che i file non necessari vengano inclusi nello snapshot, impostare un file ignorato (.gitignore o .amlignore) nella directory . Aggiungere i file e le directory da escludere. Per altre informazioni sulla sintassi da usare all'interno di questo file, vedere sintassi e modelli per .gitignore. Il .amlignore file usa la stessa sintassi. Se esistono entrambi i file, il .amlignore file viene usato e il .gitignore file non è usato.

Per altre informazioni, vedere Snapshot.

from azureml.core import Experiment

# Submit the pipeline to be run
pipeline_run1 = Experiment(ws, 'Compare_Models_Exp').submit(pipeline1)
pipeline_run1.wait_for_completion()

Quando si esegue una pipeline per la prima volta, Azure Machine Learning:

  • Scarica lo snapshot del progetto nella destinazione di calcolo dalla risorsa di archiviazione BLOB associata all'area di lavoro.

  • Crea un'immagine Docker corrispondente a ogni passaggio nella pipeline.

  • Scarica l'immagine Docker per ogni passaggio nella destinazione di calcolo dal registro contenitori.

  • Configura l'accesso a Dataset oggetti e OutputFileDatasetConfig . Per as_mount() la modalità di accesso, FUSE viene usato per fornire l'accesso virtuale. Se il montaggio non è supportato o se l'utente ha specificato l'accesso come as_upload(), i dati verranno invece copiati nella destinazione di calcolo.

  • Esegue il passaggio nella destinazione di calcolo specificata nella definizione del passaggio.

  • Crea gli artefatti, ad esempio i log, stdout e stderr, le metriche e l'output specificati dal passaggio. Questi artefatti vengono quindi caricati e conservati nell'archivio dati predefinito dell'utente.

Diagramma dell'esecuzione di un esperimento come pipeline

Per altre informazioni, vedere le informazioni di riferimento sulla classe Experiment .

Usare i parametri della pipeline per gli argomenti che cambiano in fase di inferenza

In alcuni casi, gli argomenti dei singoli passaggi all'interno di una pipeline si riferiscono al periodo di sviluppo e di training, ad esempio velocità di training e slancio, o percorsi di dati o file di configurazione. Quando un modello viene distribuito, tuttavia, è necessario passare dinamicamente gli argomenti su cui si esegue l'inferenza, ovvero la query creata per rispondere al modello. È consigliabile impostare questi tipi di parametri della pipeline di argomenti. A tale scopo, usare la azureml.pipeline.core.PipelineParameter classe , come illustrato nel frammento di codice seguente:

from azureml.pipeline.core import PipelineParameter

pipeline_param = PipelineParameter(name="pipeline_arg", default_value="default_val")
train_step = PythonScriptStep(script_name="train.py",
                            arguments=["--param1", pipeline_param],
                            target=compute_target,
                            source_directory=project_folder)

Funzionamento degli ambienti Python con i parametri della pipeline

Come illustrato in precedenza in Configurare le dipendenze dell'ambiente, dello stato dell'ambiente e della libreria Python vengono specificate usando un Environment oggetto . In genere, è possibile specificare un esistente Environment facendo riferimento al nome e, facoltativamente, a una versione:

aml_run_config = RunConfiguration()
aml_run_config.environment.name = 'MyEnvironment'
aml_run_config.environment.version = '1.0'

Tuttavia, se si sceglie di usare PipelineParameter oggetti per impostare in modo dinamico le variabili in fase di esecuzione per i passaggi della pipeline, non è possibile usare questa tecnica per fare riferimento a un oggetto esistente Environment. Se invece si desidera utilizzare PipelineParameter oggetti, è necessario impostare il environment campo dell'oggetto RunConfiguration su un Environment oggetto . È responsabilità dell'utente assicurarsi che tale Environment oggetto abbia dipendenze da pacchetti Python esterni impostati correttamente.

Visualizzare i risultati di una pipeline

Vedere l'elenco di tutte le pipeline e i relativi dettagli di esecuzione in Studio:

  1. Accedere ad Azure Machine Learning Studio.

  2. Visualizzare l'area di lavoro.

  3. A sinistra selezionare Pipeline per visualizzare tutte le esecuzioni della pipeline. elenco di pipeline di Machine Learning

  4. Selezionare una pipeline specifica per visualizzare i risultati dell'esecuzione.

Rilevamento e integrazione di Git

Quando si avvia un'esecuzione di training in cui la directory di origine è un repository Git locale, le informazioni sul repository vengono archiviate nella cronologia di esecuzione. Per altre informazioni, vedere Integrazione di Git con Azure Machine Learning.

Passaggi successivi