Treinamento de modelo na computação sem servidor

  • Artigo

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:

  • 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

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.

    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-sklearn-1.0-ubuntu20.04-py38-cpu@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.

    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-sklearn-1.0-ubuntu20.04-py38-cpu@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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
)
# submit the command job
ml_client.create_or_update(job)

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.

    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 

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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    resources = ResourceConfiguration(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).

    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-sklearn-1.0-ubuntu20.04-py38-cpu@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-sklearn-1.0-ubuntu20.04-py38-cpu@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)

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

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.

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)

Trabalho de pipeline

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"

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