Condividi tramite

Eseguire il training di un modello usando un'immagine Docker personalizzata

  • Articolo

SI APPLICA A:Python SDK azureml v1

Questo articolo illustra come usare un'immagine Docker personalizzata quando viene eseguito il training di modelli con Azure Machine Learning. Gli script di esempio in questo articolo verranno usati per classificare immagini degli animali domestici creando una rete neurale convoluzionale.

Azure Machine Learning fornisce un'immagine Docker predefinita di base. È anche possibile usare gli ambienti di Azure Machine Learning per specificare un'immagine di base differente, ad esempio una delle immagini di base di Azure Machine Learning o un'immagine personalizzata. Le immagini di base personalizzate consentono di gestire attentamente le dipendenze e mantenere un maggiore controllo sulle versioni dei componenti durante l'esecuzione dei processi di training.

Prerequisiti

Eseguire il codice in uno di questi ambienti:

Configurare un esperimento di training

In questa sezione viene configurato un esperimento di training inizializzando un'area di lavoro, definendo l'ambiente e configurando una destinazione di calcolo.

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 l’uso di tutti gli artefatti creati. Nell’SDK Python è possibile accedere agli artefatti dell'area di lavoro creando un oggetto Workspace.

Creare un oggetto Workspace dal file config.json creato come prerequisito.

from azureml.core import Workspace

ws = Workspace.from_config()

Definire l'ambiente

Creare un oggetto Environment.

from azureml.core import Environment

fastai_env = Environment("fastai2")

L'immagine di base specificata nel codice seguente supporta la libreria fast.ai, che consente funzionalità di Deep Learning distribuite. Per altre informazioni, vedere il repository Docker Hub fast.ai.

Quando si usa un'immagine Docker personalizzata, è possibile che l'ambiente Python sia già configurato correttamente. In tal caso, impostare il flag user_managed_dependencies su True per usare l'ambiente Python predefinito dell'immagine personalizzata. Per impostazione predefinita, Azure Machine Learning genera un ambiente Conda con le dipendenze specificate. Il servizio esegue lo script in tale ambiente anziché usare tutte le librerie di Python installate nell'immagine di base.

fastai_env.docker.base_image = "fastdotai/fastai2:latest"
fastai_env.python.user_managed_dependencies = True

Usare un registro contenitori privato (facoltativo)

Per usare un'immagine da un registro contenitori privato che non è presente nell'area di lavoro, usare docker.base_image_registry per specificare l'indirizzo del repository e un nome utente e una password:

# Set the container registry information.
fastai_env.docker.base_image_registry.address = "myregistry.azurecr.io"
fastai_env.docker.base_image_registry.username = "username"
fastai_env.docker.base_image_registry.password = "password"

Usare un Dockerfile personalizzato (facoltativo)

È possibile anche usare un Dockerfile personalizzato. Usare questo approccio se è necessario installare pacchetti non Python come dipendenze. Ricordarsi di impostare l'immagine di base su None.

# Specify Docker steps as a string. 
dockerfile = r"""
FROM mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:20210615.v1
RUN echo "Hello from custom container!"
"""

# Set the base image to None, because the image is defined by Dockerfile.
fastai_env.docker.base_image = None
fastai_env.docker.base_dockerfile = dockerfile

# Alternatively, load the string from a file.
fastai_env.docker.base_image = None
fastai_env.docker.base_dockerfile = "./Dockerfile"

Importante

Azure Machine Learning supporta solo immagini Docker che forniscono il software seguente:

  • Ubuntu 18.04 o versione successiva.
  • Conda 4.7.# o versione successiva.
  • Python 3.7+.
  • Una shell conforme a POSIX disponibile in /bin/sh è necessaria in qualunque immagine del contenitore usata per il training.

Per altre informazioni sulla creazione e la gestione di ambienti di Azure Machine Learning, vedere Creare e usare ambienti software.

Creare o collegare una destinazione di calcolo

È necessario creare una destinazione di calcolo per il training del modello. In questa esercitazione si crea AmlCompute come risorsa di calcolo di training.

La creazione di AmlCompute richiede alcuni minuti. Se la risorsa AmlCompute è già presente nell'area di lavoro, questo codice ignora il processo di creazione.

Come per altri servizi di Azure, esistono limiti per determinate risorse (ad esempio AmlCompute) associate al servizio Azure Machine Learning. Per altre informazioni, vedere Limiti predefiniti e come richiedere una quota più elevata.

from azureml.core.compute import ComputeTarget, AmlCompute
from azureml.core.compute_target import ComputeTargetException

# Choose a name for your cluster.
cluster_name = "gpu-cluster"

try:
    compute_target = ComputeTarget(workspace=ws, name=cluster_name)
    print('Found existing compute target.')
except ComputeTargetException:
    print('Creating a new compute target...')
    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_NC6',
                                                           max_nodes=4)

    # Create the cluster.
    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    compute_target.wait_for_completion(show_output=True)

# Use get_status() to get a detailed status for the current AmlCompute.
print(compute_target.get_status().serialize())

Importante

Usare SKU CPU per la generazione dell’immagine nell’ambiente di calcolo.

Configurare il processo di training

Per questa esercitazione, usare lo script di training train.py in GitHub. In pratica, è possibile usare qualunque script di training personalizzato ed eseguirlo così com’è con Azure Machine Learning.

Creare una risorsa ScriptRunConfig per configurare il processo per l'esecuzione nella destinazione di calcolo desiderata.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory='fastai-example',
                      script='train.py',
                      compute_target=compute_target,
                      environment=fastai_env)

Inviare il processo di training

Quando si invia un'esecuzione di training usando un oggetto ScriptRunConfig, il metodo submit restituisce un oggetto di tipo ScriptRun. L'oggetto ScriptRun restituito consente di accedere a livello programmatico alle informazioni sull'esecuzione del training.

from azureml.core import Experiment

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

Avviso

Script di training delle esecuzioni di Azure Machine Learning tramite la copia dell'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 archivio dati.

Passaggi successivi

In questo articolo è stato eseguito il training di un modello usando un'immagine Docker personalizzata. Per altre informazioni su Azure Machine Learning, vedere questi altri articoli: