Training del modello in calcolo serverless (anteprima)

Articolo
07/27/2023

SI APPLICA A:Estensione dell'interfaccia della riga di comando di Azure v2 (corrente)Python SDK azure-ai-ml v2 (corrente)

Non è più necessario creare e gestire il calcolo per eseguire il training del modello in modo scalabile. Il processo può invece essere inviato a un nuovo tipo di destinazione di calcolo, denominato calcolo serverless. Il calcolo serverless è il modo più semplice per eseguire processi di training in Azure Machine Learning. Il calcolo serverless è un calcolo completamente gestito su richiesta. Viene creato, ridimensionato e gestito da Azure Machine Learning per l'utente. Tramite il training dei modelli con calcolo serverless, i professionisti di Machine Learning possono concentrarsi sulla creazione di modelli di Machine Learning e non devono conoscere l'infrastruttura di calcolo o configurarla.

Importante

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

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

I professionisti di Machine Learning possono specificare le risorse necessarie per il processo. Azure Machine Learning gestisce l'infrastruttura di calcolo e offre l'isolamento della rete gestita (anteprima) riducendo il carico per l'utente.

Le aziende possono anche ridurre i costi specificando risorse ottimali per ogni processo. Gli amministratori IT possono comunque applicare il controllo specificando le quote di core a livello di sottoscrizione e area di lavoro e applicano i criteri di Azure.

Il calcolo serverless può essere usato per eseguire comandi, sweep, autoML, pipeline, training distribuito e processi interattivi da studio di Azure Machine Learning, SDK e interfaccia della riga di comando. I processi serverless usano la stessa quota della quota di calcolo di Azure Machine Learning. È possibile scegliere il livello standard (dedicato) o le macchine virtuali spot (con priorità bassa). L'identità gestita e l'identità utente sono supportate per i processi serverless. Il modello di fatturazione è uguale al calcolo di Azure Machine Learning.

Vantaggi del calcolo serverless

Azure Machine Learning gestisce la creazione, la configurazione, la scalabilità, l'eliminazione, l'applicazione di patch, l'infrastruttura di calcolo riducendo il sovraccarico di gestione
Non è necessario conoscere le proprietà di calcolo, i vari tipi di calcolo e le proprietà correlate.
Non è necessario creare ripetutamente cluster per ogni dimensione della macchina virtuale necessaria, usando le stesse impostazioni e replicando per ogni area di lavoro.
È possibile ottimizzare i costi specificando le risorse esatte di ogni processo in fase di esecuzione in termini di tipo di istanza (dimensioni della macchina virtuale) e numero di istanze. È possibile monitorare le metriche di utilizzo del processo per ottimizzare le risorse necessarie per un processo.
Riduzione dei passaggi coinvolti per l'esecuzione di un processo
Per semplificare ulteriormente l'invio dei processi, è possibile ignorare completamente le risorse. Azure Machine Learning usa il conteggio delle istanze e sceglie un tipo di istanza (dimensioni della macchina virtuale) in base a fattori come quota, costo, prestazioni e dimensioni del disco.
Tempi di attesa inferiori prima dell'esecuzione del processo in alcuni casi.
L'identità utente e l'identità gestita assegnata dall'utente sono supportate per l'invio di processi.
Con isolamento network gestito è possibile semplificare e automatizzare la configurazione di isolamento della rete.
Amministrazione controllare tramite quota e criteri di Azure

Come usare il calcolo serverless

Quando si crea un cluster di calcolo personalizzato, usare il nome nel processo di comando, ad esempio compute="cpu-cluster". Con serverless è possibile ignorare la creazione di un cluster di calcolo e omettere il parametro per usare invece il compute calcolo serverless. Quando compute non viene specificato per un processo, il processo viene eseguito nel calcolo serverless. Omettere il nome di calcolo nell'interfaccia della riga di comando o nei processi SDK per usare il calcolo serverless nei tipi di processo seguenti e, facoltativamente, specificare le risorse necessarie per il numero di istanze e il tipo di istanza:
- Processi di comando, inclusi processi interattivi e training distribuito
- Processi AutoML
- Processi di sweep
Per i processi della pipeline tramite l'interfaccia della riga di comando usare default_compute: azureml:serverless per il calcolo predefinito a livello di pipeline. Per i processi di pipeline tramite SDK usare default_compute="serverless". Per un esempio, vedere Processo della pipeline .
Per usare l'invio di processi serverless in studio di Azure Machine Learning, abilitare prima la funzionalità nella sezione Gestisci anteprime:
Quando si invia un processo di training in studio (anteprima), selezionare Serverless come tipo di calcolo.
Quando si usa Progettazione Azure Machine Learning, selezionare Serverless come calcolo predefinito.

Importante

Se si vuole usare il calcolo serverless con un'area di lavoro configurata per l'isolamento di rete, l'area di lavoro deve usare isolamento network gestito. Per altre informazioni, vedere Isolamento network gestito dell'area di lavoro.

Considerazioni sulle prestazioni

Il calcolo serverless consente di velocizzare il training nei modi seguenti:

Quota insufficiente: Quando si crea un cluster di calcolo personalizzato, si è responsabili della definizione delle dimensioni e del conteggio dei nodi delle macchine virtuali da creare. Quando il processo viene eseguito, se non si dispone di una quota sufficiente per il cluster il processo ha esito negativo. Il calcolo serverless usa informazioni sulla quota per selezionare per impostazione predefinita una dimensione della macchina virtuale appropriata.

Ottimizzazione ridimensionata: Quando un cluster di calcolo è in fase di ridimensionamento, un nuovo processo deve attendere che venga eseguito il ridimensionamento fino a quando il processo può essere eseguito. Con il calcolo serverless non è necessario attendere il ridimensionamento e il processo può iniziare a eseguire in un altro cluster/nodo (presupponendo che si disponga di quota).

Ottimizzazione occupato dal cluster: quando un processo è in esecuzione in un cluster di calcolo e viene inviato un altro processo, il processo viene accodato dietro il processo attualmente in esecuzione. Con il calcolo serverless si ottiene un altro nodo/un altro cluster per avviare l'esecuzione del processo (presupponendo che si disponga di quota).

Quota

Quando si invia il processo, è comunque necessaria una quota di calcolo di Azure Machine Learning sufficiente per procedere (sia quota a livello di area di lavoro che di sottoscrizione). Le dimensioni predefinite della macchina virtuale per i processi serverless sono selezionate in base a questa quota. Se si specificano le proprie dimensioni/famiglia di macchine virtuali:

Se si dispone di una quota per le dimensioni/famiglia di macchine virtuali, ma non è sufficiente per il numero di istanze, verrà visualizzato un errore. L'errore consiglia di ridurre il numero di istanze a un numero valido in base al limite di quota o richiedere un aumento della quota per la famiglia di macchine virtuali o la modifica delle dimensioni della macchina virtuale
Se non si dispone della quota per le dimensioni della macchina virtuale specificata, verrà visualizzato un errore. L'errore consiglia di selezionare una dimensione di macchina virtuale diversa per cui si dispone di quota o richiesta di quota per questa famiglia di macchine virtuali
Se si dispone di una quota sufficiente per la famiglia di macchine virtuali per l'esecuzione del processo serverless, ma attualmente utilizzata da altri processi, verrà visualizzato un messaggio che il processo deve attendere in una coda fino a quando non è disponibile la quota

Quando si visualizza l'utilizzo e la quota nella portale di Azure, verrà visualizzato il nome "Serverless" per visualizzare tutte le quote utilizzate dai processi serverless.

Supporto delle identità e passaggio delle credenziali

Le credenziali utente passano tramite : il calcolo serverless supporta completamente il passaggio delle credenziali utente. Il token utente dell'utente che invia il processo viene usato per l'accesso all'archiviazione. Queste credenziali provengono da Azure Active Directory.

Python SDK
Interfaccia della riga di comando di Azure

from azure.ai.ml import command
from azure.ai.ml import MLClient     # Handle to the workspace
from azure.identity import DefaultAzureCredential     # Authentication package
from azure.ai.ml.entities import ResourceConfiguration
from azure.ai.ml.entities import UserIdentityConfiguration 

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
        identity=UserIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest
identity:
  type: user_identity

Identità gestita assegnata dall'utente : quando si dispone di un'area di lavoro configurata con l'identità gestita assegnata dall'utente, è possibile usare tale identità con il processo serverless per l'accesso all'archiviazione.

Python SDK
Interfaccia della riga di comando di Azure

from azure.ai.ml import command
from azure.ai.ml import MLClient     # Handle to the workspace
from azure.identity import DefaultAzureCredential    # Authentication package
from azure.ai.ml.entities import ResourceConfiguration
from azure.ai.ml.entities import ManagedIdentityConfiguration

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
        identity= ManagedIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest
identity:
  type: managed

Per informazioni sull'associazione dell'identità gestita assegnata dall'utente, vedere collegare l'identità gestita assegnata dall'utente.

Configurare le proprietà per i processi di comando

Se non viene specificata alcuna destinazione di calcolo per i processi command, sweep e AutoML, il calcolo viene predefinito per il calcolo serverless. Ad esempio, per questo processo di comando:

Python SDK
Interfaccia della riga di comando di Azure

from azure.ai.ml import command
from azure.ai.ml import command 
from azure.ai.ml import MLClient # Handle to the workspace
from azure.identity import DefaultAzureCredential # Authentication package

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest

Le impostazioni predefinite di calcolo per il calcolo serverless con:

Nodo singolo per questo processo. Il numero predefinito di nodi è basato sul tipo di processo. Per altri tipi di processo, vedere le sezioni seguenti.
Macchina virtuale CPU, determinata in base a quote, prestazioni, costi e dimensioni del disco.
Macchine virtuali dedicate
Località dell'area di lavoro

È possibile eseguire l'override di queste impostazioni predefinite. Se si vuole specificare il tipo di macchina virtuale o il numero di nodi per il calcolo serverless, aggiungere resources al processo:

instance_type per scegliere una macchina virtuale specifica. Usare questo parametro se si desidera una specifica dimensione di MACCHINA virtuale CPU/GPU

instance_count per specificare il numero di nodi.

Python SDK
Interfaccia della riga di comando di Azure

from azure.ai.ml import command 
from azure.ai.ml import MLClient # Handle to the workspace
from azure.identity import DefaultAzureCredential # Authentication package
from azure.ai.ml.entities import ResourceConfiguration 

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    resources = ResourceConfiguration(instance_type="Standard_NC24", instance_count=4)
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest
resources:
  instance_count: 4
  instance_type: Standard_NC24

Per modificare il livello di processo, usare queue_settings per scegliere tra macchine virtuali dedicate (job_tier: Standard) e Priorità bassa(jobtier: Spot).

Python SDK
Interfaccia della riga di comando di Azure

from azure.ai.ml import command
from azure.ai.ml import MLClient    # Handle to the workspace
from azure.identity import DefaultAzureCredential    # Authentication package
credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    queue_settings={
      "job_tier": "spot"  
    }
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
component: ./train.yml 
queue_settings:
   job_tier: Standard #Possible Values are Standard (dedicated), Spot (low priority). Default is Standard.

Esempio per tutti i campi con processi di comando

Ecco un esempio di tutti i campi specificati, inclusa l'identità che il processo deve usare. Non è necessario specificare le impostazioni di rete virtuale come livello di area di lavoro isolamento network gestito verranno usate automaticamente.

Python SDK
Interfaccia della riga di comando di Azure

from azure.ai.ml import command
from azure.ai.ml import MLClient      # Handle to the workspace
from azure.identity import DefaultAzureCredential     # Authentication package
from azure.ai.ml.entities import ResourceConfiguration
from azure.ai.ml.entities import UserIdentityConfiguration 

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
         identity=UserIdentityConfiguration(),
    queue_settings={
      "job_tier": "Standard"  
    }
)
job.resources = ResourceConfiguration(instance_type="Standard_E4s_v3", instance_count=1)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest
queue_settings:
   job_tier: Standard #Possible Values are Standard, Spot. Default is Standard.
identity:
  type: user_identity #Possible values are Managed, user_identity
resources:
  instance_count: 1
  instance_type: Standard_E4s_v3

Vedere altri esempi di training con calcolo serverless in:

Processo AutoML

Non è necessario specificare il calcolo per i processi AutoML. Le risorse possono essere specificate facoltativamente. Se il numero di istanze non viene specificato, viene impostato come predefinito in base ai parametri max_concurrent_trials e max_nodes. Se si invia una classificazione di immagini AutoML o un'attività NLP senza tipo di istanza, verrà automaticamente selezionata una dimensione della macchina virtuale GPU. È possibile inviare il processo AutoML tramite CLI, SDK o Studio. Per inviare processi AutoML con calcolo serverless in Studio, abilitare prima l'esperienza guidata per l'invio di processi di training con funzionalità di calcolo serverless nel pannello di anteprima e quindi inviare un processo di training in Studio (anteprima).

Python SDK
Interfaccia della riga di comando di Azure

Se si vuole specificare il tipo o il numero di istanze, usare la ResourceConfiguration classe .

# Create the AutoML classification job with the related factory-function.
from azure.ai.ml.entities import ResourceConfiguration 

classification_job = automl.classification(
    experiment_name=exp_name,
    training_data=my_training_data_input,
    target_column_name="y",
    primary_metric="accuracy",
    n_cross_validations=5,
    enable_model_explainability=True,
    tags={"my_custom_tag": "My custom value"},
)

# Limits are all optional
classification_job.set_limits(
    timeout_minutes=600,
    trial_timeout_minutes=20,
    max_trials=max_trials,
    # max_concurrent_trials = 4,
    # max_cores_per_trial: -1,
    enable_early_termination=True,
)

# Training properties are optional
classification_job.set_training(
    blocked_training_algorithms=[ClassificationModels.LOGISTIC_REGRESSION],
    enable_onnx_compatible_models=True,
)

# Serverless compute resources used to run the job
classification_job.resources = 
ResourceConfiguration(instance_type="Standard_E4s_v3", instance_count=6)

Se si vuole specificare il tipo o il numero di istanze, aggiungere una resources sezione.

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl
experiment_name: dpv2-cli-automl-classifier-experiment
description: A Classification job using bank marketing
# Serverless compute is used to run this AutoML job. 
# Through serverless compute, Azure Machine Learning takes care of creating, scaling, deleting, patching and managing compute, along with providing managed network isolation, reducing the burden on you.

task: classification
log_verbosity: debug
primary_metric: accuracy

target_column_name: "y"

#validation_data_size: 0.20
#n_cross_validations: 5
#test_data_size: 0.1

training_data:
  path: "./training-mltable-folder"
  type: mltable
validation_data:
  path: "./validation-mltable-folder"
  type: mltable
test_data:
  path: "./test-mltable-folder"
  type: mltable

limits:
  timeout_minutes: 180
  max_trials: 40
  max_concurrent_trials: 5
  trial_timeout_minutes: 20
  enable_early_termination: true
  exit_score: 0.92

featurization:
  mode: custom
  transformer_params:
    imputer:
      - fields: ["job"]
        parameters:
          strategy: most_frequent
  blocked_transformers:
    - WordEmbedding
training:
  enable_model_explainability: true
  allowed_training_algorithms:
    - gradient_boosting
    - logistic_regression
# Resources to run this serverless job
resources:
  instance_type="Standard_E4s_v3"
  instance_count=5

Processo della pipeline

Python SDK
Interfaccia della riga di comando di Azure

Per un processo della pipeline, specificare "serverless" come tipo di calcolo predefinito per usare il calcolo serverless.

# Construct pipeline
@pipeline()
def pipeline_with_components_from_yaml(
    training_input,
    test_input,
    training_max_epochs=20,
    training_learning_rate=1.8,
    learning_rate_schedule="time-based",
):
    """E2E dummy train-score-eval pipeline with components defined via yaml."""
    # Call component obj as function: apply given inputs & parameters to create a node in pipeline
    train_with_sample_data = train_model(
        training_data=training_input,
        max_epochs=training_max_epochs,
        learning_rate=training_learning_rate,
        learning_rate_schedule=learning_rate_schedule,
    )

    score_with_sample_data = score_data(
        model_input=train_with_sample_data.outputs.model_output, test_data=test_input
    )
    score_with_sample_data.outputs.score_output.mode = "upload"

    eval_with_sample_data = eval_model(
        scoring_result=score_with_sample_data.outputs.score_output
    )

    # Return: pipeline outputs
    return {
        "trained_model": train_with_sample_data.outputs.model_output,
        "scored_data": score_with_sample_data.outputs.score_output,
        "evaluation_report": eval_with_sample_data.outputs.eval_output,
    }


pipeline_job = pipeline_with_components_from_yaml(
    training_input=Input(type="uri_folder", path=parent_dir + "/data/"),
    test_input=Input(type="uri_folder", path=parent_dir + "/data/"),
    training_max_epochs=20,
    training_learning_rate=1.8,
    learning_rate_schedule="time-based",
)

# set pipeline to use serverless compute
pipeline_job.settings.default_compute = "serverless"

Per un processo della pipeline, specificare azureml:serverless come tipo di calcolo predefinito per usare il calcolo serverless.

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
display_name: 1b_e2e_registered_components
description: E2E dummy train-score-eval pipeline with registered components
# Serverless compute is used to run this pipeline job. 
# Through serverless compute, Azure Machine Learning takes care of creating, scaling, deleting, patching and managing compute, along with providing managed network isolation, reducing the burden on you.
inputs:
  pipeline_job_training_max_epocs: 20
  pipeline_job_training_learning_rate: 1.8
  pipeline_job_learning_rate_schedule: 'time-based'

outputs: 
  pipeline_job_trained_model:
    mode: upload
  pipeline_job_scored_data:
    mode: upload
  pipeline_job_evaluation_report:
    mode: upload

settings:
 default_compute: azureml:serverless

jobs:
  train_job:
    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:
        type: vs_code
      my_jupyter_lab:
        type: jupyter_lab
      my_tensorboard:
        type: tensor_board
        log_dir: "outputs/tblogs"
    #  my_ssh:
    #    type: tensor_board
    #    ssh_public_keys: <paste the entire pub key content>
    #    nodes: all # Use the `nodes` property to pick which node you want to enable interactive services on. If `nodes` are not selected, by default, interactive applications are only enabled on the head node.

  score_job:
    type: command
    component: azureml:my_score@latest
    inputs:
      model_input: ${{parent.jobs.train_job.outputs.model_output}}
      test_data: 
        type: uri_folder 
        path: ./data
    outputs:
      score_output: ${{parent.outputs.pipeline_job_scored_data}}

  evaluate_job:
    type: command
    component: azureml:my_eval@latest
    inputs:
      scoring_result: ${{parent.jobs.score_job.outputs.score_output}}
    outputs:
      eval_output: ${{parent.outputs.pipeline_job_evaluation_report}}

È anche possibile impostare il calcolo serverless come calcolo predefinito in Designer.

Passaggi successivi