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
  • 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, 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
  • 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(),
  )
  # submit the command job
  ml_client.create_or_update(job)
  
  

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:

from azure.ai.ml import command
from azure.ai.ml import command 
from azure.ai.ml import MLClient # Handle to the workspace
from azure.identity import DefaultAzureCredential # Authentication package

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
)
# submit the command job
ml_client.create_or_update(job)

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

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
  • 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 Baixa prioridade(jobtier: 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 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.

from azure.ai.ml import command
from azure.ai.ml import MLClient      # Handle to the workspace
from azure.identity import DefaultAzureCredential     # Authentication package
from azure.ai.ml.entities import ResourceConfiguration
from azure.ai.ml.entities import UserIdentityConfiguration 

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
         identity=UserIdentityConfiguration(),
    queue_settings={
      "job_tier": "Standard"  
    }
)
job.resources = ResourceConfiguration(instance_type="Standard_E4s_v3", instance_count=1)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest
queue_settings:
   job_tier: Standard #Possible Values are Standard, Spot. Default is Standard.
identity:
  type: user_identity #Possible values are Managed, user_identity
resources:
  instance_count: 1
  instance_type: Standard_E4s_v3 

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.

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

Próximas etapas

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

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