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 mais criar e gerenciar a computação para treinar seu modelo de forma escalonável. Em vez disso, seu trabalho pode ser enviado para um novo 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 é uma computação sob demanda totalmente gerenciada. O Azure Machine Learning cria, dimensiona e gerencia a computação para você. Por meio do treinamento de modelo com a computação sem servidor, os profissionais de aprendizado de máquina podem se concentrar em sua experiência na criação de modelos de aprendizado de máquina e não precisam aprender sobre a infraestrutura de computação nem configurá-la.

Os profissionais de aprendizado de máquina podem especificar os recursos de que o trabalho precisa. O Azure Machine Learning gerencia a infraestrutura de computação e fornece isolamento de rede gerenciada, 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 de núcleos no nível da assinatura e do espaço de trabalho e aplicar as políticas do Azure.

A computação sem servidor pode ser usada para ajustar modelos no catálogo de modelos, como o LLAMA 2. A computação sem servidor pode ser usada para executar todos os tipos de trabalhos do Estúdio do Azure Machine Learning, SDK e CLI. A computação sem servidor também pode ser usada para criar imagens de ambiente e para cenários de painel de IA responsável. 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 é igual ao da computação do Azure Machine Learning.

Vantagens da computação sem servidor

• O Azure Machine Learning gerencia a criação, a configuração, o dimensionamento, a exclusão, a aplicação de patch, a infraestrutura de computação reduzindo a sobrecarga de gerenciamento
• Você não precisa aprender sobre computação, vários tipos de computação e propriedades relacionadas.
• Não é necessário 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 em runtime em termos de tipo de instância (tamanho da VM) e contagem de instâncias. Você pode monitorar as métricas de utilização do trabalho para otimizar os recursos necessários para um trabalho.
• Redução nas etapas envolvidas para executar um trabalho
• Para simplificar ainda mais o envio de trabalho, você pode ignorar completamente os recursos. O Azure Machine Learning usa a contagem de instâncias como padrão e escolhe um tipo de instância (tamanho da VM) com base em fatores como cota, custo, desempenho e tamanho do disco.
• Tempos de espera menores antes de os trabalhos começarem a ser executados em alguns casos.
• A identidade do usuário e a identidade gerenciada atribuída pelo usuário do workspace têm suporte 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 a rede virtual do cliente
• Controle administrativo por meio de cota e políticas do Azure

Como usar a computação sem servidor

• Você pode ajustar modelos de base, como LLAMA 2, usando notebooks, como mostrado abaixo:

  • Ajuste fino LLAMA 2
  • Ajustar LLAMA 2 usando vários nós

• Ao criar seu próprio cluster de cálculo, você usa seu nome no trabalho de comando, como compute="cpu-cluster". Usando o sem servidor, você pode ignorar a criação de um cluster de computação e omitir o parâmetro compute para 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 de CLI ou SDK para usar a computação sem servidor nos seguintes tipos de trabalho e, como opção, forneça recursos necessários para um trabalho em termos de contagem de instâncias e 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 por meio da CLI, use default_compute: azureml:serverless para a computação padrão no nível do pipeline. Para trabalhos de pipelines por meio do SDK, use default_compute="serverless". Confira Trabalho de pipeline para obter um exemplo.

• Ao enviar um trabalho de treinamento no estúdio (versão prévia), 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.

• Você pode usar a computação sem servidor para o painel de IA responsável

  • Cenário de classificação de imagem AutoML com o painel RAI

Considerações sobre o desempenho

A computação sem servidor pode ajudar a acelerar seu treinamento das seguintes formas:

Cota insuficiente: ao criar seu próprio cluster de cálculo, você será responsável por descobrir qual tamanho de VM e contagem de nós criar. Se você não tiver cota suficiente para o cluster quando o trabalho for executado, ele 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 estiver sendo reduzido verticalmente, um novo trabalho precisará esperar que a redução vertical ocorra e, depois, escalar verticalmente antes que o trabalho possa ser executado. Com a computação sem servidor, você não precisa esperar a redução vertical, e o trabalho pode começar a ser executado em outro cluster/nó (supondo que você tenha cota).

Otimização de cluster ocupado: quando um trabalho estiver em execução em um cluster de cálculo e outro trabalho for enviado, seu trabalho ficará na fila atrás do trabalho em execução no momento. Com a computação sem servidor, você obtém outro nó/cluster para começar a executar o trabalho (supondo que você tenha cota).

Quota

Ao enviar o trabalho, você ainda precisa ter cota de computação suficiente do Azure Machine Learning para continuar (cota de nível de assinatura e workspace). 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 alguma cota para o tamanho/família da VM, mas não tiver cota suficiente para o número de instâncias, ocorre um erro. O erro recomenda diminuir o número de instâncias para um número válido com base no limite de cota, solicitar um aumento de cota para essa família de VMs ou alterar o tamanho da VM
• Se você não tiver cota para o tamanho da VM especificado, ocorre um erro. O erro recomenda selecionar um tamanho de VM diferente para o qual você tenha cota ou solicitar cota para essa família de VMs
• Se você tiver cota suficiente para que a família de VMs execute 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 cota no portal do Azure, você vê o nome "Sem servidor" para exibir toda a cota consumida por trabalhos sem servidor.

Suporte de identidade e passagem de credenciais

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

  SDK do Python

  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 arquivo chamado hello.yaml com o seguinte conteúdo:

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

  Envie o trabalho com o seguinte comando:

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

  O restante dos exemplos da CLI mostram variações do arquivo hello.yaml. Execute cada um deles da mesma maneira.

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

  SDK do Python

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

---

Para obter informações sobre como anexar a identidade gerenciada atribuída pelo usuário, confira Anexar identidade gerenciada atribuída pelo usuário.

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á a computação sem servidor como padrão. Por exemplo, para esse trabalho de comando:

SDK do Python

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)

CLI do Azure

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

• Nó único para esse 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.
• Máquina virtual de CPU, que é determinada com base em cota, desempenho, custo e tamanho do disco.
• Máquinas virtuais dedicadas
• Localização do workspace

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:

• instance_type para escolher uma VM específica. Use esse parâmetro se quiser um tamanho específico de VM de CPU/GPU

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

  SDK do Python

  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 a camada de trabalho, use queue_settings para escolher entre VMs dedicadas (job_tier: Standard) e Baixa prioridade(jobtier: Spot).

  SDK do Python

  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), Spot (low priority). Default is Standard.
  

Exemplo para todos os campos com trabalhos de comando

Aqui está um exemplo de todos os campos especificados, incluindo a identidade que o trabalho deve utilizar. Não é preciso especificar as configurações de rede virtual, porque o isolamento de rede gerenciada no nível do workspace é usado automaticamente.

SDK do Python

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

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

• Início Rápido
• Treinar Modelo

Trabalho do AutoML

Não é preciso especificar a computação para trabalhos AutoML. Como opção, os recursos podem ser especificados. Se a contagem de instâncias não for especificada, ela será padronizada com base nos parâmetros max_concurrent_trials e max_nodes. Se você enviar uma classificação de imagem AutoML ou tarefa NLP sem nenhum tipo de instância, o tamanho da VM da GPU será selecionado automaticamente. É possível enviar o trabalho do AutoML por meio de CLIs, SDK ou Estúdio. Para enviar trabalhos AutoML com computação sem servidor no estúdio, primeiro habilite o recurso enviar um trabalho de treinamento no estúdio (versão prévia) no painel de visualização.

SDK do Python

Caso queira especificar o tipo ou a contagem de instâncias, use a classe ResourceConfiguration.

# 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

Caso queira especificar o tipo ou a contagem de instâncias, adicione a seção resources.

$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

SDK do Python

Para um trabalho de pipeline, especifique "serverless" como o tipo de computação padrão para usar a 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 o tipo de computação padrão para usar a 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 a computação sem servidor como a computação padrão no Designer.

Próximas etapas

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

• Início Rápido
• Treinar Modelo
• Ajuste fino LLAMA 2