Treinamento de modelo na computação sem servidor

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

Você não precisa criar e gerenciar a computação para treinar seu modelo de maneira escalonável. Em vez disso, você pode enviar seu trabalho para um tipo de destino 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 é sob demanda e totalmente gerenciada. O Azure Machine Learning cria, dimensiona e gerencia a computação para você. Ao usar a computação sem servidor para treinar modelos, você pode se concentrar na criação de modelos de machine learning e não precisa aprender sobre a infraestrutura de computação ou configurá-la.

Você pode especificar os recursos necessários para o trabalho. 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 os custos ao especificar 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 workspace e aplicando políticas do Azure.

Você pode usar a computação sem servidor para ajustar modelos no catálogo de modelos. Você pode usá-lo para executar todos os tipos de trabalhos usando o Azure Machine Learning Studio, o SDK do Python e a CLI do Azure. Você também pode usar a computação sem servidor para criar imagens de ambiente e para cenários de painel de IA responsáveis. Os trabalhos sem servidor consomem a mesma cota que a cota de computação do Azure Machine Learning. Você pode escolher a camada padrão (dedicada) ou VMs spot (de baixa prioridade). A identidade gerenciada e a identidade do usuário têm suporte para trabalhos sem servidor. O modelo de cobrança é o mesmo que o modelo para serviços de computação do Azure Machine Learning.

Vantagens da computação sem servidor

• O Azure Machine Learning gerencia a criação, configuração, dimensionamento, exclusão e aplicação de patch de infraestrutura de computação para reduzir a sobrecarga de gerenciamento.
• Você não precisa aprender sobre computação, vários tipos de computação ou propriedades relacionadas.
• Você não precisa criar clusters repetidamente para cada tamanho de VM necessário, usando as mesmas configurações e replicando para cada workspace.
• Você pode otimizar os custos especificando os recursos exatos que cada trabalho precisa no runtime para o tipo de instância (tamanho da VM) e a contagem de instâncias. Você também pode monitorar as métricas de utilização do trabalho para otimizar os recursos de que um trabalho precisa.
• Menos etapas são necessárias para executar um trabalho.
• Para simplificar ainda mais o envio de trabalho, você pode ignorar completamente os recursos. O Azure Machine Learning usa como padrão a contagem de instâncias e escolhe um tipo de instância levando em conta fatores como cota, custo, desempenho e tamanho do disco.
• Em alguns cenários, os tempos de espera antes de os trabalhos começarem a ser executados são reduzidos.
• A identidade do usuário e a identidade gerenciada atribuída a usuários pelo workspace são compatíveis para envio de trabalhos.
• Com o isolamento de rede gerenciado, você pode simplificar e automatizar a configuração do isolamento de rede. Também há suporte para redes virtuais do cliente.
• O controle administrativo está disponível por meio de políticas de cota e do Azure.

Como usar a computação sem servidor

• Ao criar seu próprio cluster de computação, use o nome dele no trabalho de comando. Por exemplo, compute="cpu-cluster". Com o serverless, você pode ignorar a criação de um cluster de computação e omitir o compute parâmetro para, em vez disso, usar a computação sem servidor. Quando compute não for especificado para um trabalho, este será executado na computação sem servidor. Omita o nome da computação em seus trabalhos da CLI do Azure ou do SDK do Python para usar a computação sem servidor nos seguintes tipos de trabalho e, opcionalmente, forneça recursos necessários para a contagem de instâncias e o tipo de instância:

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

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

• Ao enviar um trabalho de treinamento no estúdio, selecione Sem servidor como o tipo de computação.

• Ao usar o designer do Azure Machine Learning, selecione Sem servidor como a computação padrão.

Considerações sobre o desempenho

A computação sem servidor pode aumentar a velocidade do treinamento das seguintes maneiras:

Evite erros de cota insuficiente. Ao criar seu próprio cluster de computação, você é responsável por determinar o tamanho da VM e a contagem de nós. Quando seu trabalho for executado, se você não tiver cota suficiente para o cluster, o trabalho falhará. A computação sem servidor usa informações sobre a sua cota para selecionar um tamanho de VM apropriado por padrão.

Otimização de redução vertical. Quando um cluster de computação está reduzindo, uma nova tarefa precisa aguardar o cluster reduzir e, depois, escalar verticalmente para que a tarefa possa ser executada. Com a computação sem servidor, você não precisa esperar por reduzir a escala. Seu trabalho pode começar a ser executado em outro cluster/nó (supondo que você tenha cota).

Otimização com cluster ocupado. Quando um trabalho está em execução em um cluster de computação e outro trabalho é enviado, seu trabalho é enfileirado por trás do trabalho em execução no momento. Com a computação sem servidor, seu trabalho pode começar a ser executado em outro nó/cluster (supondo que você tenha cota).

Quota

Ao enviar um trabalho, você ainda precisa de cota de computação suficiente do Azure Machine Learning para prosseguir (cota em nível de espaço de trabalho e em nível de assinatura). 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 VMs:

• Se você tiver cota para o tamanho/família da VM, mas não tiver cota suficiente para o número de instâncias, aparecerá um erro. O erro recomenda que você diminua o número de instâncias para um número válido com base no limite de cota, solicite um aumento de cota para a família de VM ou altere o tamanho da VM.
• Se você não tiver cota para o tamanho da VM especificado, ocorre um erro. O erro recomenda que você selecione outro tamanho de VM para o qual tenha cota ou solicite um aumento de cota para a família de VM.
• Se você tiver cota suficiente para uma família de VM executar o trabalho sem servidor, mas outros trabalhos estiverem usando a cota, você receberá uma mensagem informando que seu trabalho deve aguardar em uma fila até que a cota esteja disponível.

Ao exibir seu uso e cotas no portal do Azure, você verá o nome Sem servidor para toda a cota consumida por trabalhos sem servidor.

Suporte à identidade e passagem de credenciais

• Passagem de credencial do usuário: a computação sem servidor dá suporte total à passagem de credencial do usuário. O token de usuário do usuário que envia o trabalho é usado para acesso ao armazenamento. Essas credenciais são da ID do Microsoft Entra.

  A computação sem servidor não dá suporte à identidade atribuída pelo sistema.

  • SDK do Python
  • CLI do 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)
  

• Identidade gerenciada atribuída pelo usuário: quando você tiver um workspace configurado com a identidade gerenciada atribuída pelo usuário, poderá usar essa identidade com o trabalho sem servidor para acesso ao armazenamento. Para obter informações sobre como acessar segredos, consulte Usar segredos de credencial de autenticação em trabalhos do Azure Machine Learning.

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

   • SDK do Python
   • CLI do 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)
   
   

   Busque a identidade atribuída pelo usuário na saída. Se ele estiver ausente, crie um novo workspace 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.

   • SDK do Python
   • CLI do 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)
   

Configurar propriedades para trabalhos de comando

Se nenhum destino de computação for especificado para trabalhos de comando, varredura e AutoML, a computação usará como padrão a computação sem servidor. Veja um exemplo:

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

A computação usa a computação sem servidor como padrão com:

• Um único nó, para este trabalho. O número padrão de nós é baseado no tipo de trabalho. Confira as seções a seguir para informações sobre outros tipos de trabalho.
• Uma máquina virtual de CPU. A VM é determinada com base na cota, desempenho, custo e tamanho do disco.
• Máquinas virtuais dedicadas.
• Local 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. Use esse parâmetro se você quiser um tamanho específico de CPU ou VM de GPU

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

  • SDK do Python
  • CLI do 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)
  

• Para alterar a camada de trabalho, use queue_settings para escolher entre VMs dedicadas (job_tier: Standard) e VMs de baixa prioridade (job_tier: Spot).

  • SDK do Python
  • CLI do 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)
  

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. Você não precisa especificar as configurações de rede virtual porque o isolamento de rede gerenciada no nível do workspace é usado 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 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 como usar a computação sem servidor para treinamento:

• Primeira olhada no Azure Machine Learning
• Treinar um modelo

Trabalho do AutoML

Você não precisa especificar a computação para tarefas AutoML. Opcionalmente, os recursos podem ser especificados. Se uma contagem de instâncias não for especificada, ela será definida por padrão com base nos parâmetros max_concurrent_trials e max_nodes. Se você enviar uma classificação de imagem AutoML ou tarefa NLP sem especificar um tipo de instância, o tamanho da VM de GPU será selecionado automaticamente. Você pode enviar trabalhos AutoML usando CLIs, o SDK do Python ou o estúdio.

# 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

Trabalho de 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}}

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

Configurar trabalhos de pipeline sem servidor com identidade gerenciada atribuída pelo usuário

Ao usar a computação sem servidor em trabalhos de pipeline, recomendamos que você defina a identidade do usuário em nível de etapa individual que será executado em uma computação, e não em nível do pipeline raiz. (Embora a configuração de identidade tenha suporte nos níveis de pipeline raiz e de etapa, a configuração de nível de etapa terá precedência se ambas estiverem definidas. No entanto, para pipelines que contêm componentes de pipeline, a identidade deve ser definida em etapas individuais que serão executadas. A identidade definida no nível do pipeline raiz ou do componente do pipeline não funcionará. Portanto, sugerimos definir a identidade no nível de etapa individual para fins de simplicidade.)

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"

$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

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

• Primeira olhada no Azure Machine Learning
• Treinar um modelo