Training dei modelli in un ambiente di elaborazione serverless

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

Non è più necessario creare e gestire l'ambiente di calcolo per eseguire il training dei modelli in modo scalabile. Il processo può invece essere inviato a un nuovo tipo di destinazione di calcolo, denominato ambiente di elaborazione serverless. L'ambiente di elaborazione serverless rappresenta il modo più semplice per eseguire il training di processi in Azure Machine Learning. Quello dell'elaborazione serverless è un ambiente di calcolo su richiesta completamente gestito. Azure Machine Learning crea, ridimensiona e gestisce automaticamente l'ambiente di calcolo. Grazie al training dei modelli con l'ambiente di elaborazione serverless, i professionisti di Machine Learning possono concentrarsi sulla creazione di modelli di Machine Learning e non devono essere istruiti sull'infrastruttura di calcolo o configurarla.

I professionisti di Machine Learning possono specificare le risorse necessarie per il processo. Azure Machine Learning gestisce l'infrastruttura di calcolo e fornisce l'isolamento della rete gestita, riducendo il carico di lavoro.

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

Le risorse di calcolo serverless possono essere usate per ottimizzare i modelli nel catalogo dei modelli. Le risorse di calcolo serverless possono essere usate per eseguire tutti i tipi di processi da Azure Machine Learning Studio, SDK e interfaccia della riga di comando. È possibile usare l'ambiente di elaborazione serverless anche per la creazione delle immagini di ambiente e per scenari di dashboard di intelligenza artificiale responsabile. I processi serverless usano la stessa quota della quota di calcolo di Azure Machine Learning. È possibile scegliere macchine virtuali di livello standard (dedicate) o spot (con priorità bassa). Nei processi serverless sono supportate sia l'identità gestita che l'identità utente. Il modello di fatturazione è identico a quello dell'ambiente di calcolo di Azure Machine Learning.

Vantaggi dell'elaborazione serverless

• Azure Machine Learning gestisce la creazione, la configurazione, la scalabilità, l'eliminazione e l'applicazione di patch all'infrastruttura di calcolo, riducendo il sovraccarico di gestione
• Non è necessario conoscere le risorse di calcolo, i vari tipi di calcolo e le proprietà correlate
• Non è necessario creare ripetutamente cluster per ogni dimensione di macchina virtuale necessaria, usando le stesse impostazioni e replicando per ogni area di lavoro
• È possibile ottimizzare i costi specificando le risorse esatte necessarie per 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 necessari per eseguire un processo
• Per semplificare ulteriormente l'invio di processi, è possibile ignorare completamente le risorse. Azure Machine Learning usa per impostazione predefinita il numero di istanze e sceglie un tipo di istanza (dimensioni della macchina virtuale) in base a fattori quali quota, costo, prestazioni e dimensioni del disco
• Tempi di attesa più brevi prima dell'avvio dell'esecuzione dei processi in alcuni casi
• L'identità utente e l'identità gestita assegnata dall'utente dell'area di lavoro sono supportate per l'invio di processi
• Con l'isolamento network gestito è possibile semplificare e automatizzare la configurazione dell'isolamento rete. È supportata anche la rete virtuale del cliente.
• Controllo amministrativo tramite quota e criteri di Azure

Come usare l'ambiente di elaborazione serverless

• Quando si crea un cluster di elaborazione personalizzato, il nome del cluster viene usato nel processo di comando, ad esempio compute="cpu-cluster". Con l'ambiente serverless è possibile ignorare la creazione di un cluster di elaborazione e omettere il parametro compute, usando invece l'ambiente di elaborazione serverless. Quando non si specifica compute per un processo, questo viene eseguito nell'ambiente di elaborazione serverless. Omettere il nome di calcolo nei processi dell'interfaccia della riga di comando o dell'SDK per usare l'ambiente di elaborazione serverless nei tipi di processo seguenti e, facoltativamente, fornire le risorse necessarie per un processo in termini di numero e tipo di istanze:

  • Processi di comando, inclusi processi interattivi e training distribuito
  • Processi AutoML
  • Processi di sweeping
  • Processi paralleli

• Per i processi della pipeline tramite l'interfaccia della riga di comando usare default_compute: azureml:serverless per l'ambiente di calcolo predefinito a livello di pipeline. Per le attività della pipeline tramite SDK, usare default_compute="serverless". Vedere Processo della pipeline per un esempio.

• Quando si invia un processo di training nello studio (anteprima), selezionare Serverless come tipo di ambiente di calcolo.

• Quando si usa la finestra di progettazione di Azure Machine Learning, selezionare Serverless come ambiente di calcolo predefinito.

Considerazioni sulle prestazioni

L'elaborazione serverless consente di velocizzare il training nei modi seguenti:

Quota insufficiente: quando si crea un cluster di elaborazione personalizzato, si è responsabili della definizione delle dimensioni della macchina virtuale e del numero di nodi da creare. Quando il processo viene eseguito, se la quota non è sufficiente per il cluster, il processo non riesce. L'ambiente di elaborazione serverless usa le informazioni sulla quota per selezionare le dimensioni della macchina virtuale appropriate per impostazione predefinita.

Ottimizzazione riduzione delle prestazioni: Quando un cluster di calcolo viene ridimensionato, un nuovo processo deve attendere che si verifichi una riduzione delle prestazioni e quindi aumentare le prestazioni prima che il processo possa essere eseguito. Con l'ambiente di calcolo serverless non è necessario attendere la riduzione e il processo può essere eseguito in un altro cluster/nodo (purché sia disponibile quota sufficiente).

Ottimizzazione del cluster impegnato: Quando un processo è in esecuzione in un cluster di calcolo e viene inviato un altro processo, il tuo processo viene accodato dietro al processo attualmente in esecuzione. Con l'ambiente di calcolo serverless si ottiene un altro nodo/cluster per avviare l'esecuzione del processo (purché sia disponibile quota sufficiente).

Quota

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

• Se si ha una certa quota per dimensioni/famiglia delle macchine virtuali, che però non è sufficiente per il numero di istanze, viene 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 ha quota sufficiente per le dimensioni specificate delle macchine virtuali, viene visualizzato un errore. Nel messaggio di errore si consiglia di selezionare dimensioni diverse per le macchine virtuali per le quali non si ha una quota sufficiente o di richiedere una quota per questa famiglia di macchine virtuali.
• Se è disponibile una quota sufficiente per l'esecuzione del processo serverless da parte della famiglia di macchine virtuali, ma altri processi usano la quota, viene visualizzato un messaggio che indica che il processo deve attendere in una coda fino a quando non è disponibile la quota.

Quando si visualizza i dati relativi a utilizzo e quota nel portale di Azure, è possibile osservare il nome "Serverless" per vedere tutte le quote usate dai processi serverless.

Supporto delle identità e pass-through delle credenziali

• Passaggio delle credenziali utente: il sistema di calcolo serverless supporta completamente il passaggio delle credenziali utente. Per l'accesso allo spazio di archiviazione viene usato il token utente dell'utente che invia il processo. Queste credenziali provengono da Microsoft Entra ID.

  • 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://registries/azureml/environments/sklearn-1.5/labels/latest",
          identity=UserIdentityConfiguration(),
  )
  # submit the command job
  ml_client.create_or_update(job)
  

• 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. Per accedere ai segreti, vedere Usare i segreti delle credenziali di autenticazione nei processi di Azure Machine Learning.

1. Verificate la configurazione dell'identità dell'area di lavoro.

   • Python SDK
   • Interfaccia della riga di comando di Azure

   from azure.ai.ml import MLClient
   from azure.identity import DefaultAzureCredential
   
   subscription_id = "<your-subscription-id>"
   resource_group = "<your-resource-group>"
   workspace = "<your-workspace-name>"
   
   ml_client = MLClient(
       DefaultAzureCredential(),
       subscription_id,
       resource_group,
       workspace
   )
   
   # Get workspace details
   ws = ml_client.workspaces.get(name=workspace)
   print(ws)
   
   

   Cercare le identità assegnate dall'utente nell'output. Se manca, creare una nuova area di lavoro con un'identità gestita assegnata dall'utente seguendo le istruzioni riportate in Configurare l'autenticazione tra Azure Machine Learning e altri servizi.

2. Usare l'identità gestita assegnata all'utente nel proprio lavoro.

   • 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://registries/azureml/environments/sklearn-1.5/labels/latest",
       identity= ManagedIdentityConfiguration(client_id="<workspace-uami-client-id>"),
   )
   # submit the command job
   ml_client.create_or_update(job)
   

Configurare le proprietà per processi di comando

Se non viene specificata alcuna destinazione di calcolo per i processi di comando, sweep e AutoML, per impostazione predefinita le risorse di calcolo vengono calcolate senza server. Ad esempio, per questo processo di comando:

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://registries/azureml/environments/sklearn-1.5/labels/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

Per impostazione predefinita l'ambiente di calcolo diventa un ambiente di elaborazione serverless con:

• Nodo singolo per questo processo. Il numero predefinito di nodi è basato sul tipo di processo. Vedere le sezioni seguenti per altri tipi di processo.
• Macchina virtuale CPU, determinata in base a quota, prestazioni, costi e dimensioni del disco.
• Macchine virtuali dedicate
• Posizione 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 l'ambiente di elaborazione serverless, aggiungere resources al processo:

• instance_type per scegliere una macchina virtuale specifica. Usare questo parametro se si vuole indicare una specifica dimensione della 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 JobResourceConfiguration 
  
  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://registries/azureml/environments/sklearn-1.5/labels/latest",
      resources = JobResourceConfiguration(instance_type="Standard_NC24", instance_count=4)
  )
  # submit the command job
  ml_client.create_or_update(job)
  

• Per modificare il livello di processo, usare queue_settings per scegliere tra macchine virtuali dedicate (job_tier: Standard) e Priorità bassa (job_tier: 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://registries/azureml/environments/sklearn-1.5/labels/latest",
      queue_settings={
        "job_tier": "spot"  
      }
  )
  # submit the command job
  ml_client.create_or_update(job)
  

Esempio per tutti i cambi con processi di comando

Ecco un esempio di tutti i campi specificati, inclusa l'identità da usare nel processo. Non è necessario specificare le impostazioni di rete virtuale dal momento che l'isolamento network gestito a livello di area di lavoro viene usato automaticamente.

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://registries/azureml/environments/sklearn-1.5/labels/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: library/python: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 

Visualizzare altri esempi di training con calcolo serverless:

• Avvio rapido
• Eseguire il training del modello

Processo AutoML

Non è necessario specificare l'ambiente di calcolo per i processi AutoML. Facoltativamente, è possibile specificare le risorse. Se il numero di istanze non viene specificato, per impostazione predefinita viene impostato in base ai parametri max_concurrent_trials e max_nodes. Se si invia una classificazione immagini AutoML o un'attività NLP senza tipo di istanza, le dimensioni delle macchine virtuali GPU vengono selezionate automaticamente. È possibile inviare processi AutoML tramite CLI, SDK o Studio. Per inviare processi AutoML con elaborazione serverless in Studio, abilitare prima la funzionalità di invio di un processo di training in Studio (anteprima) nel pannello di anteprima.

# 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)

$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

# 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"

$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 l'ambiente di elaborazione serverless come ambiente di calcolo predefinito nella finestra di progettazione.

Configurare processi di pipeline serverless con identità gestita assegnata dall'utente

Quando si utilizza il calcolo serverless nei processi della pipeline, è consigliabile impostare l'identità dell'utente a livello del singolo passaggio che verrà eseguito su un'unità di calcolo, anziché a livello di intera pipeline. Mentre l'impostazione identity è supportata sia a livello di pipeline radice che di passaggio, l'impostazione a livello di passaggio ha la precedenza se entrambi sono impostati. Tuttavia, per le pipeline contenenti componenti della pipeline, l'identità deve essere impostata su singoli passaggi che verranno eseguiti. L'identità impostata a livello di pipeline radice o componente della pipeline non funzionerà. È quindi consigliabile impostare l'identità a livello di singolo passaggio per semplicità.

def my_pipeline():
    train_job = train_component(
        training_data=Input(type="uri_folder", path="./data")
    )
    # Set managed identity for the job
    train_job.identity = {"type": "user_identity"}
    return {"train_output": train_job.outputs}

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

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
description: E2E dummy train-score-eval pipeline with registered components
settings:
    default_compute: azureml:serverless
jobs:
 train_job:
   type: command
   component: azureml:my_train@latest
inputs:
   training_data: 
     type: uri_folder 
      path: ./data   
 identity:
   type: user_identity

Passaggi successivi

Visualizzare altri esempi di training con calcolo serverless:

• Avvio rapido
• Eseguire il training del modello