Eseguire il training di modelli scikit-learn su larga scala con Azure Machine Learning (SDK v1)

Articolo
03/28/2024

Questo articolo illustra come eseguire script di training scikit-learn con Azure Machine Learning.

Gli script di esempio in questo articolo vengono usati per classificare le immagini dei fiori iris e creare un modello di Machine Learning basato sul set di dati Iris di scikit-learn.

Che si stia eseguendo il training di un modello di Machine Learning scikit-learn dal principio o si stia portando un modello esistente nel cloud, è possibile usare Azure Machine Learning per aumentare il numero di processi di training open source usando risorse di calcolo in un cloud elastico. Con Azure Machine Learning è possibile infatti compilare, distribuire, controllare la versione e monitorare modelli di livello di produzione.

Prerequisiti

È possibile eseguire questo codice in un'istanza di ambiente di calcolo di Azure Machine Learning o nel proprio Jupyter Notebook:

Istanza di calcolo di Azure Machine Learning
- Completare Avvio rapido: Iniziare a usare il servizio Azure Machine Learning per creare un'istanza di ambiente di calcolo. Ogni istanza di ambiente di calcolo include un server di notebook dedicato, precaricato con l'SDK, e il repository dei notebook di esempio.
- Selezionare la scheda Notebook nello studio di Azure Machine Learning. Nella cartella di training degli esempi è possibile accedere a un notebook completato ed espanso passando a questa directory: cartella how-to-use-azureml > ml-frameworks > scikit-learn > train-hyperparameter-tune-deploy-with-sklearn.
- Per completare questa esercitazione, è possibile usare il codice precompilato presente nella cartella di training degli esempi.
Creare un server Jupyter Notebook ed eseguire il codice nelle sezioni seguenti.
- Installare Azure Machine Learning SDK (>= 1.13.0).
- Creare un file di configurazione dell'area di lavoro.

Configurare l'esperimento

In questa sezione si configurerà l'esperimento di training caricando i pacchetti Python necessari, inizializzando un'area di lavoro, definendo l'ambiente di training e preparando lo script di training.

Inizializzare un'area di lavoro

L'area di lavoro di Azure Machine Learning è la risorsa di primo livello per il servizio. Fornisce una posizione centralizzata per lavorare con tutti gli artefatti creati. In Python SDK è possibile accedere agli artefatti dell'area di lavoro creando un oggetto workspace.

Creare un oggetto workspace dal file config.json creato nella sezione dei prerequisiti.

from azureml.core import Workspace

ws = Workspace.from_config()

Preparare gli script

In questa esercitazione, lo script di trainingtrain_iris.py è già disponibile. In pratica, si dovrebbe essere in grado di eseguire in Azure Machine Learning qualsiasi script di training personalizzato così com'è, senza dover modificare il codice.

Nota

Lo script di training fornito illustra come registrare alcune metriche nell'esecuzione di Azure Machine Learning usando l'oggetto Run all'interno dello script.
Lo script di training fornito usa dati di esempio ottenuti dalla funzione iris = datasets.load_iris(). Per usare e accedere ai propri dati, vedere l'articolo su come eseguire il training con set di dati per riuscire a rendere disponibili i dati durante il training.

Definire l'ambiente

Per definire l'ambiente di Azure Machine Learning che incapsula le dipendenze dello script di training, è possibile definire un ambiente personalizzato o usare un ambiente di Azure Machine Learning curato.

Usare un ambiente curato

Se non si vuole definire un ambiente personalizzato, Azure Machine Learning offre ambienti curati predefiniti (facoltativo).

Se si desidera usare un ambiente curato, è possibile eseguire il comando seguente:

from azureml.core import Environment

sklearn_env = Environment.get(workspace=ws, name='AzureML-Tutorial')

Creare un ambiente personalizzato

È possibile anche creare un ambiente personalizzato. Definire le dipendenze Conda in un file YAML; in questo esempio il file è denominato conda_dependencies.yml.

dependencies:
  - python=3.7
  - scikit-learn
  - numpy
  - pip:
    - azureml-defaults

Creare un ambiente di Azure Machine Learning da questa specifica di ambiente Conda. Verrà creato un pacchetto dell'ambiente in un contenitore Docker in fase di esecuzione.

from azureml.core import Environment

sklearn_env = Environment.from_conda_specification(name='sklearn-env', file_path='conda_dependencies.yml')

Per altre informazioni sulla creazione e l'utilizzo di ambienti, vedere Creare e usare ambienti software in Azure Machine Learning.

Configurare e inviare un'esecuzione di training

Creare un oggetto ScriptRunConfig

Creare un oggetto ScriptRunConfig per specificare i dettagli di configurazione del processo di training, tra cui script di training, ambiente da usare e destinazione di calcolo in cui eseguirlo. Qualsiasi argomento dello script di training verrà passato tramite la riga di comando, se specificato nel parametro arguments.

Il codice seguente configurerà un oggetto ScriptRunConfig per inviare il processo al computer locale per l'esecuzione.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory='.',
                      script='train_iris.py',
                      arguments=['--kernel', 'linear', '--penalty', 1.0],
                      environment=sklearn_env)

Se invece si desidera eseguire il processo in un cluster remoto, è possibile specificare la destinazione di calcolo desiderata in corrispondenza del parametro compute_target di ScriptRunConfig.

from azureml.core import ScriptRunConfig

compute_target = ws.compute_targets['<my-cluster-name>']
src = ScriptRunConfig(source_directory='.',
                      script='train_iris.py',
                      arguments=['--kernel', 'linear', '--penalty', 1.0],
                      compute_target=compute_target,
                      environment=sklearn_env)

Inviare l'esecuzione

from azureml.core import Experiment

run = Experiment(ws,'Tutorial-TrainIRIS').submit(src)
run.wait_for_completion(show_output=True)

Avviso

Azure Machine Learning esegue gli script di training copiando l'intera directory di origine. Se si dispone di dati sensibili che non si desidera caricare, usare un file .ignore oppure evitare di includerli nella directory di origine. Accedere invece ai dati usando un set di dati di Azure Machine Learning.

Cosa accade durante l'esecuzione?

Il processo di esecuzione si articola nelle fasi seguenti:

Preparazione: viene creata un'immagine Docker in base all'ambiente definito. L'immagine viene caricata nel registro contenitori dell'area di lavoro e memorizzata nella cache per le esecuzioni successive. Vengono inoltre trasmessi i log alla cronologia di esecuzione ed è possibile visualizzarli per monitorare lo stato di avanzamento. Se invece viene specificato un ambiente curato, verrà usata l'immagine memorizzata nella cache in cui è stato eseguito il backup dell'ambiente curato.
Ridimensionamento: il cluster tenta di aumentare le prestazioni se, per completare l'esecuzione, il cluster Batch per intelligenza artificiale richiede più nodi di quelli attualmente disponibili.
Esecuzione: tutti gli script disponibili nella cartella degli script vengono caricati nella destinazione di calcolo, gli archivi dati vengono montati o copiati e l'oggetto script viene eseguito. Gli output di stdout e la cartella ./logs vengono trasmessi alla cronologia di esecuzione e possono essere usati per monitorare l'esecuzione.
Post-elaborazione: la cartella ./outputs dell'esecuzione viene copiata nella cronologia di esecuzione.

Salvare e registrare il modello

Dopo aver eseguito il training del modello, è possibile salvarlo e registrarlo nell'area di lavoro. Con la registrazione dei modelli è possibile archiviare i modelli e creare le relative versioni nell'area di lavoro per semplificare la gestione e la distribuzione dei modelli.

Aggiungere il codice seguente allo script di training, train_iris.py, per salvare il modello.

import joblib

joblib.dump(svm_model_linear, 'model.joblib')

Registrare il modello nell'area di lavoro con il codice seguente. Specificando i parametri model_framework, model_framework_version e resource_configuration, diventa disponibile la distribuzione del modello senza codice. La distribuzione di un modello senza codice consente di distribuire direttamente il modello come servizio Web dal modello registrato e l'oggetto ResourceConfiguration definisce la risorsa di calcolo per il servizio Web.

from azureml.core import Model
from azureml.core.resource_configuration import ResourceConfiguration

model = run.register_model(model_name='sklearn-iris', 
                           model_path='outputs/model.joblib',
                           model_framework=Model.Framework.SCIKITLEARN,
                           model_framework_version='0.19.1',
                           resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5))

Distribuzione

Il modello appena registrato può essere distribuito esattamente come qualsiasi altro modello registrato in Azure Machine Learning. La procedura per la distribuzione contiene una sezione sulla registrazione dei modelli, ma è possibile passare direttamente alla creazione di una destinazione di calcolo(how-to-deploy-and-where.md#choose-a-compute-target) per la distribuzione, poiché si dispone già di un modello registrato.

(Anteprima) Distribuzione di un modello senza codice

Importante

Questa funzionalità è attualmente in anteprima pubblica. Questa versione di anteprima viene fornita senza contratto di servizio e, pertanto, non è consigliabile usarla per carichi di lavoro di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate.

Per altre informazioni, vedere le Condizioni supplementari per l'uso delle anteprime di Microsoft Azure.

Anziché la tradizionale route di distribuzione, per scikit-learn è possibile anche usare la funzionalità di distribuzione senza codice (anteprima). La distribuzione di modelli senza codice è supportata per tutti i tipi di modelli scikit-learn predefiniti. Registrando il modello come illustrato in precedenza, ovvero con i parametri model_framework, model_framework_version e resource_configuration, è sufficiente usare la funzione statica deploy() per distribuire il modello.

web_service = Model.deploy(ws, "scikit-learn-service", [model])