Treinamento de modelo em computação sem servidor

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

Você não precisa mais criar e gerenciar computação para treinar seu modelo de forma escalá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 modelos com 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 infraestrutura de computação ou 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 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 de núcleos no nível de assinatura e espaço de trabalho e aplicar políticas do Azure.

A computação sem servidor pode ser usada para ajustar modelos no catálogo de modelos, como 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áveis. 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 cobrança é o mesmo que a 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, aplicação de patches e 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 há necessidade de criar clusters repetidamente para cada tamanho de VM necessário, usando as mesmas configurações e replicando para cada espaço de trabalho.
• Você pode otimizar os custos especificando os recursos exatos que cada trabalho precisa em tempo de execução 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 de que um trabalho precisaria.
• Redução das etapas envolvidas para executar um trabalho
• Para simplificar ainda mais o envio de trabalhos, você pode ignorar os recursos completamente. O Azure Machine Learning padroniza a contagem de instâncias 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 que os trabalhos comecem a ser executados em alguns casos.
• A identidade do usuário e a identidade gerenciada atribuída ao usuário do espaço de trabalho são suportadas para o envio de trabalho.
• Com o isolamento de rede gerenciado, você pode simplificar e automatizar sua configuração de isolamento de rede. A rede virtual do cliente também é suportada
• Controle de administrador 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:

  • Sintonizar LLAMA 2
  • Ajuste o LLAMA 2 usando vários nós

• Ao criar seu próprio cluster de computação, você usa seu nome no trabalho de comando, como compute="cpu-cluster". Com serverless, você pode ignorar a criação de um cluster de computação e omitir o parâmetro para, em vez disso, usar serverless compute compute. Quando compute não é especificado para um trabalho, o trabalho é executado em computação sem servidor. Omita o nome de computação em seus trabalhos de CLI ou SDK para usar computação sem servidor nos seguintes tipos de trabalho e, opcionalmente, forneça recursos de que um trabalho precisaria em termos de contagem de instâncias e tipo de instância:

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

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

• Ao enviar um trabalho de treinamento no estúdio (visualização), selecione Serverless como o tipo de computação.

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

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

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

Considerações de desempenho

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

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

Otimização de redução de escala: quando um cluster de computação está sendo reduzido, um novo trabalho precisa esperar que a redução aconteça e, em seguida, aumentar a escala antes que o trabalho possa ser executado. Com a computação sem servidor, você não precisa esperar pela redução da escala e seu trabalho pode começar a ser executado em outro cluster/nó (supondo que você tenha uma cota).

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

Quota

Ao enviar o trabalho, você ainda precisa de cota de computação suficiente do Azure Machine Learning para prosseguir (espaço de trabalho e cota de 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 VM:

• Se você tiver alguma cota para o tamanho/família da VM, mas não a cota suficiente para o número de instâncias, verá um erro. O erro recomenda diminuir o número de instâncias para um número válido com base no seu limite de cota ou solicitar um aumento de cota para essa família de VMs ou alterar o tamanho da VM
• Se você não tiver uma cota para o tamanho da VM especificado, verá um erro. O erro recomenda selecionar um tamanho de VM diferente para o qual você tem cota ou cota de solicitação para essa família de VMs
• Se você tiver cota suficiente para a família VM para 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 cota no portal do Azure, você verá o nome "Serverless" para ver toda a cota consumida por trabalhos sem servidor.

Suporte de identidade e passagem de credenciais

• Passagem de credenciais de usuário: a computação sem servidor suporta totalmente a passagem de credenciais de usuário. O token de usuário do usuário que está enviando o trabalho é usado para acesso ao armazenamento. Essas credenciais são da sua ID do Microsoft Entra.

  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 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 de CLI mostram variações do arquivo 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 acessar segredos, consulte Usar segredos de credenciais de autenticação em trabalhos do Azure Machine Learning.

  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(),
  )
  # 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 identidade gerenciada atribuída pelo usuário, consulte anexar identidade gerenciada atribuída ao usuário.

Configurar propriedades para trabalhos de comando

Se nenhum destino de computação for especificado para trabalhos de comando, varredura e AutoML, o padrão de computação será computação sem servidor. Por exemplo, para este trabalho de comando:

Python SDK

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

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

• Nó único 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.
• Máquina virtual da CPU, que é determinada com base na cota, 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:

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

• 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 a camada de trabalho, use queue_settings para escolher entre VMs dedicadas (job_tier: Standard) e Baixa prioridade(jobtier: 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), 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 usar. Não há necessidade de especificar configurações de rede virtual, pois o isolamento de rede gerenciado no nível do espaço de trabalho é usado automaticamente.

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, 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
• Modelo de comboio

Trabalho do AutoML

Não há necessidade de especificar computação para trabalhos de AutoML. Os recursos podem ser especificados opcionalmente. 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 uma tarefa NLP sem tipo de instância, o tamanho da VM da GPU será selecionado automaticamente. É possível enviar o trabalho AutoML por meio de CLIs, SDK ou Studio. Para enviar trabalhos AutoML com computação sem servidor no estúdio, primeiro habilite o recurso Enviar um trabalho de treinamento no estúdio (visualização) no painel de visualização.

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.

Próximos passos

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

• Início rápido
• Modelo de comboio
• Sintonizar LLAMA 2