Treinamento de modelo em computação sem servidor

APLICA-SE A:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

Não precisa de criar e gerir computação para treinar o seu modelo de forma escalável. Pode, em vez disso, submeter o seu trabalho a um tipo de alvo de computação chamado computação sem servidor. A computação sem servidor é a maneira mais fácil de executar trabalhos de treinamento no Azure Machine Learning. A computação sem servidor é uma computação sob demanda totalmente gerenciada. O Azure Machine Learning cria, dimensiona e gerencia a computação para você. Quando usa computação serverless para treinar modelos, pode focar-se em construir modelos de aprendizagem automática sem ter de aprender sobre infraestrutura de computação ou configurá-la.

Podes especificar os recursos que o trabalho precisa. O Azure Machine Learning gerencia a infraestrutura de computação e fornece isolamento de rede gerenciado, reduzindo a carga sobre você.

As empresas também podem reduzir custos especificando os recursos ideais para cada trabalho. Os administradores de TI ainda podem aplicar o controle especificando a cota principal nos níveis de assinatura e espaço de trabalho e aplicando políticas do Azure.

Pode usar computação serverless para afinar modelos no catálogo de modelos. Podes usá-lo para executar todo o tipo de trabalhos usando o Azure Machine Learning Studio, o SDK Python e a CLI do Azure. Também pode usar computação sem servidor para criar imagens de ambiente e em cenários responsáveis de painéis de IA. Os trabalhos sem servidor consomem a mesma quota que a quota de computação do Azure Machine Learning. Você pode escolher VMs padrão (dedicadas) de camada ou spot (de baixa prioridade). A identidade gerenciada e a identidade do usuário são suportadas para trabalhos sem servidor. O modelo de faturação é o mesmo do modelo para computação em Azure Machine Learning.

Vantagens da computação sem servidor

• O Azure Machine Learning gere a criação, configuração, escalabilidade, eliminação e atualização de infraestruturas computacionais para reduzir a sobrecarga de gestão.
• Não precisas de aprender sobre computação, vários tipos de computação ou propriedades relacionadas.
• Não precisas de criar clusters repetidamente para cada tamanho de VM que precisas, usando as mesmas definições e replicando para cada espaço de trabalho.
• Podes otimizar custos especificando os recursos exatos de que cada trabalho precisa em tempo de execução, por tipo de instância (tamanho da VM) e número de instâncias. Também pode monitorizar as métricas de utilização do trabalho para otimizar os recursos que o trabalho necessita.
• São necessários menos passos para executar um trabalho.
• Para simplificar ainda mais o envio de trabalhos, você pode ignorar os recursos completamente. O Azure Machine Learning define por defeito a contagem de instâncias e escolhe um tipo de instância tendo em conta fatores como quota, custo, desempenho e tamanho do disco.
• Em alguns cenários, os tempos de espera antes de as tarefas começarem a funcionar são reduzidos.
• Identidade de utilizador e identidade gerida atribuída pelo utilizador no espaço de trabalho são suportadas para envio de trabalhos.
• Com o isolamento de rede gerenciado, você pode simplificar e automatizar sua configuração de isolamento de rede. Também são suportadas redes virtuais para clientes.
• O controlo administrativo está disponível através de quotas e políticas Azure.

Como usar a computação sem servidor

• Quando crias o teu próprio cluster de computação, usas o nome dele no trabalho de comando. Por exemplo, compute="cpu-cluster". Com serverless, podes evitar a criação de um cluster de computação e omitir o parâmetro compute para usar computação serverless. Quando compute não é especificado para um trabalho, o trabalho é executado em computação sem servidor. Omita o nome de computação nos jobs do Azure CLI ou Python SDK para usar computação serverless nos seguintes tipos de jobs, e opcionalmente poderás fornecer os recursos que o job necessita para número de instâncias e tipos de instância:

  • Tarefas de comando, incluindo trabalhos interativos e treinamento distribuído
  • Trabalhos de AutoML
  • Varrer trabalhos
  • Trabalhos paralelos

• Para trabalhos de pipeline via Azure CLI, use default_compute: azureml:serverless para computação padrão ao nível do pipeline. Para trabalhos de pipeline via o Python SDK, use default_compute="serverless". Consulte Trabalho de pipeline para obter um exemplo.

• Quando submeteres um trabalho de formação no estúdio, escolhe Serverless como tipo de computação.

• Ao usar o designer Azure Machine Learning, selecione Serverless como computação predefinida.

Considerações de desempenho

A computação serverless pode aumentar a velocidade do seu treino das seguintes formas:

Evite falhas insuficientes de quotas. Quando crias o teu próprio cluster de computação, és responsável por determinar o tamanho da VM e o número de nós. Quando o teu trabalho é executado, se não tiveres quota suficiente para o cluster, o trabalho falha. A computação sem servidor usa informações sobre sua cota para selecionar um tamanho de VM apropriado por padrão.

Otimização em escala reduzida. Quando um cluster de computação está a reduzir a escala, uma nova tarefa tem de esperar que o cluster reduza a escala e depois aumente a escala antes que a tarefa possa ser executada. Com computação serverless, não precisa esperar pela redução da escala. O teu trabalho pode começar a correr noutro cluster/nó (assumindo que tens uma quota).

Otimização de cluster-ocupado. Quando um trabalho está a correr num cluster de computação e outro trabalho é submetido, o seu trabalho fica em fila atrás do trabalho atualmente em execução. Com computação serverless, o teu trabalho pode começar a correr noutro nó/cluster (assumindo que tens uma quota).

Quota

Quando submetes um trabalho, ainda precisas de uma quota de computação de Azure Machine Learning suficiente para avançar (tanto a nível de espaço de trabalho como a quota de subscrição). O tamanho padrão da VM para trabalhos sem servidor é selecionado com base nessa cota. Se você especificar seu próprio tamanho/família de VM:

• Se tiver alguma quota para o tamanho/família da sua VM, mas não tiver quota suficiente para o número de instâncias, receberá uma mensagem de erro. O erro recomenda que diminua o número de instâncias para um número válido com base no limite da sua quota, peça um aumento da quota para a família de VMs ou altere o tamanho da VM.
• Se você não tiver uma cota para o tamanho da VM especificado, verá um erro. O erro recomenda que selecione um tamanho de VM diferente para o qual tenha uma quota ou solicitar quota para a família de máquinas virtuais.
• Se tiver uma quota suficiente para uma família de VMs executar a tarefa serverless, mas outras tarefas estiverem a usar essa quota, recebe uma mensagem a dizer que a sua tarefa deve esperar numa fila até que a quota se torne disponível.

Quando vê a sua utilização e quotas no portal Azure, vê o nome Serverless para todas as quotas consumidas por tarefas "serverless".

Suporte de identidade e passagem de credenciais

• Passagem de credenciais do utilizador: A computação serverless suporta totalmente a passagem de credenciais do utilizador. O token de utilizador do utilizador que submeteu o trabalho é usado para acesso ao armazenamento. Estas credenciais provêm do Microsoft Entra ID.

  A computação serverless não suporta identidade atribuída ao sistema.

  Python SDK

  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)
  

  CLI do Azure

  Crie um ficheiro chamado hello.yaml que contenha o seguinte:

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

  Submeta o trabalho usando este comando:

  az ml job create --file hello.yaml --resource-group my-resource-group --workspace-name my-workspace
  

  Os restantes exemplos de CLI do Azure mostram variações do ficheiro hello.yaml. Execute cada um deles da mesma maneira.

• Identidade gerenciada atribuída pelo usuário: quando você tem um espaço de trabalho configurado com identidade gerenciada atribuída pelo usuário, pode usar essa identidade com o trabalho sem servidor para acesso ao armazenamento. Para informações sobre o acesso a segredos, consulte Usar segredos de credenciais de autenticação em empregos Azure Machine Learning.

1. Verifique a configuração da identidade do espaço de trabalho.

   Python SDK

   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)
   
   

   CLI do Azure

   az ml workspace show --name <workspace-sname>  --resource-group <resource-group-name>
   

   Verifique a identidade atribuída pelo utilizador na saída. Se estiver faltando, crie um novo espaço de trabalho com uma identidade gerenciada atribuída pelo usuário seguindo as instruções em Configurar a autenticação entre o Azure Machine Learning e outros serviços.

2. Use sua identidade gerenciada atribuída pelo usuário em seu trabalho.

   Python SDK

   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)
   

   CLI do Azure

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

Configurar propriedades para trabalhos de comando

Se não for especificado um destino de computação para trabalhos de comando, varrimento e AutoML, o recurso de computação por padrão é *serverless*. Aqui está um exemplo:

Python SDK

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)

CLI do Azure

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

O padrão de computação é computação sem servidor com:

• Um único nó para este trabalho. O número padrão de nós é baseado no tipo de trabalho. Consulte as seções a seguir para outros tipos de trabalho.
• Uma máquina virtual de CPU. A VM é determinada com base na quota, desempenho, custo e tamanho do disco.
• Máquinas virtuais dedicadas.
• Localização do espaço de trabalho.

Você pode substituir esses padrões. Se você quiser especificar o tipo de VM ou o número de nós para computação sem servidor, adicione resources ao seu trabalho:

• Use instance_type para escolher uma VM específica. Usa este parâmetro se quiseres um tamanho específico de CPU ou GPU VM

• Use instance_count para especificar o número de nós.

  Python SDK

  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)
  

  CLI do Azure

  $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 
  

• Para alterar o nível de trabalho, use queue_settings para escolher entre VMs dedicadas (job_tier: Standard) e VMs de baixa prioridade (job_tier: Spot).

  Python SDK

  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)
  

  CLI do Azure

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

Exemplo para todos os campos com trabalhos de comando

Aqui está um exemplo que mostra todos os campos especificados, incluindo a identidade que o trabalho deve usar. Não precisas de especificar definições de rede virtual porque o isolamento de rede gerido ao nível do espaço de trabalho é automaticamente usado.

Python SDK

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)

CLI do Azure

$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 and Spot. The default is Standard.
identity:
  type: user_identity # Possible values are Managed and user_identity.
resources:
  instance_count: 1
  instance_type: Standard_E4s_v3 

Aqui estão mais dois exemplos de utilização de computação serverless para treino:

• Primeira análise ao Azure Machine Learning
• Preparar um modelo

Trabalho do AutoML

Não precisas de especificar computação para trabalhos de AutoML. Os recursos podem ser opcionalmente especificados. Se a contagem de instâncias não for especificada, é definida por predefinição com base nos parâmetros max_concurrent_trials e max_nodes. Se submeter uma tarefa de classificação de imagem ou NLP em AutoML sem especificar um tipo de instância, o tamanho da VM da GPU é automaticamente selecionado. Podes submeter trabalhos de AutoML usando CLIs, o SDK Python ou o Studio.

Python SDK

Se você quiser especificar o tipo ou a contagem de instâncias, use a 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)

CLI do Azure

Se desejar especificar o tipo ou a contagem de instâncias, adicione uma resources seção.

$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

Trabalho de pipeline

Python SDK

Para um trabalho de pipeline, especifique "serverless" como seu tipo de computação padrão para usar computação sem servidor.

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

CLI do Azure

Para um trabalho de pipeline, especifique azureml:serverless como seu tipo de computação padrão para usar computação sem servidor.

$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}}

Você também pode definir computação sem servidor como a computação padrão no Designer.

Configurar trabalhos de pipeline serverless com identidade gerida atribuída pelo utilizador

Quando utiliza computação serverless em trabalhos de pipeline, recomendamos que defina a identidade do utilizador ao nível individual do passo que será executado num cálculo, em vez de ao nível do pipeline raiz. (Embora a definição de identidade seja suportada tanto ao nível do pipeline raiz como ao nível de passos, a definição de nível de passo tem precedência se ambos estiverem definidos. No entanto, para pipelines que contêm componentes de pipeline, a identidade deve ser definida em passos individuais que serão executados. Identidade definida ao nível do pipeline raiz ou componente do pipeline não funciona. Por isso, sugerimos definir a identidade ao nível do passo individual para simplificar.)

Python SDK

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": "managed"}
    return {"train_output": train_job.outputs}

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

CLI do Azure

$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: managed

Conteúdo relacionado

Veja mais exemplos de treinamento com computação sem servidor:

• Primeira análise ao Azure Machine Learning
• Preparar um modelo