Treinar modelos com o SDK do Python do Azure Machine Learning (v1)

APLICA-SE A: SDK do Python do AzureML v1

Saiba como anexar recursos de computação do Azure ao seu workspace do Azure Machine Learning com o SDK v1. Em seguida, você pode usar esses recursos como metas de computação de treinamento e inferência em suas tarefas de aprendizado de máquina.

Neste artigo, saiba como configurar seu workspace para usar estes recursos de computação:

• Seu computador local
• Máquinas virtuais remotas
• Pools do Apache Spark (da plataforma Azure Synapse Analytics)
• Azure HDInsight
• Lote do Azure
• Azure Databricks – usado como um destino de computação de treinamento somente em pipelines de aprendizado de máquina
• Análise Azure Data Lake
• Azure Container Instance
• Kubernetes do Azure Machine Learning

Para usar destinos de computação gerenciados pelo Azure Machine Learning, confira:

• Instância de computação do Azure Machine Learning
• Cluster de computação do Azure Machine Learning
• Cluster do Serviço de Kubernetes do Azure

Pré-requisitos

• Um Workspace do Azure Machine Learning. Para obter mais informações, consulte Criar recursos de workspace.

• A extensão da CLI do Azure para o serviço do Machine Learning, o SDK do Azure Machine Learning Python ou a extensão do Azure Machine Learning Visual Studio Code.

Limitações

• Não crie vários anexos simultâneos para a mesma computação do seu workspace. Por exemplo, anexe um cluster do Serviço de Kubernetes do Azure a um workspace usando dois nomes diferentes. Cada novo anexo interromperá os anexos existentes anteriores.

  Se você quiser reanexar um destino de computação, por exemplo, para alterar o TLS ou outra configuração de cluster, primeiro deverá remover o anexo existente.

O que é um destino de computação?

Com o Azure Machine Learning, você pode treinar seu modelo em uma variedade de recursos ou ambientes, coletivamente denominados destinos de computação. Um destino de computação pode ser um computador local ou um recurso de nuvem, como Computação do Azure Machine Learning, Azure HDInsight ou uma máquina virtual remota. Você também pode criar destinos de computação para a implantação de modelo conforme descrito em "Onde e como implantar seus modelos".

Computador local

Quando você usa seu computador local para o treinamento, não é necessário criar um destino de computação. Basta enviar a execução de treinamento do seu computador local.

Ao usar o computador local para inferência, você deve ter o Docker instalado. Para executar a implantação, use LocalWebservice.deploy_configuration() para definir a porta que será usada pelo serviço Web. Em seguida, use o processo de implantação normal, conforme descrito em Implantar modelos com o Azure Machine Learning.

Máquinas virtuais remotas

O Azure Machine Learning também dá suporte à anexação de uma máquina virtual do Azure. A VM deve ser uma DSVM (Máquina Virtual de Ciência de Dados). A VM oferece uma opção selecionada de ferramentas e estruturas para desenvolvimento do aprendizado de máquina de todo o ciclo de vida. Para saber mais sobre como usar a DSVM com o Azure Machine Learning, consulte Configurar um ambiente de desenvolvimentopara o Azure Machine Learning.

1. Criar: o Azure Machine Learning não pode criar uma VM remota para você. Em vez disso, você deve criar o recurso e anexá-lo ao seu workspace do Azure Machine Learning. Para saber mais sobre como criar uma DSVM, confira Provisionar a Máquina Virtual de Ciência de Dados para Linux (Ubuntu).

   Aviso

   O Azure Machine Learning dá suporte apenas a máquinas virtuais que executam o Ubuntu. Para criar uma VM ou escolher uma VM existente, selecione uma VM que usa o Ubuntu.

   O Azure Machine Learning também exige que a máquina virtual tenha um endereço IP público.

2. Anexar: anexe a DSVM ao espaço de trabalho usando o Azure Machine Learning Studio.

   Aviso

   Não crie vários anexos simultâneos para a mesma DSVM do seu workspace. Cada novo anexo interromperá os anexos existentes anteriores.

3. Configurar: Crie uma configuração de execução para o destino de computação da DSVM. O Docker e o conda são usados para criar e configurar o ambiente de treinamento na DSVM.

   from azureml.core import ScriptRunConfig
   from azureml.core.environment import Environment
   from azureml.core.conda_dependencies import CondaDependencies
   
   # Create environment
   myenv = Environment(name="myenv")
   
   # Specify the conda dependencies
   myenv.python.conda_dependencies = CondaDependencies.create(conda_packages=['scikit-learn'])
   
   # If no base image is explicitly specified the default CPU image "azureml.core.runconfig.DEFAULT_CPU_IMAGE" will be used
   # To use GPU in DSVM, you should specify the default GPU base Docker image or another GPU-enabled image:
   # myenv.docker.enabled = True
   # myenv.docker.base_image = azureml.core.runconfig.DEFAULT_GPU_IMAGE
   
   # Configure the run configuration with the Linux DSVM as the compute target and the environment defined above
   src = ScriptRunConfig(source_directory=".", script="train.py", compute_target=compute, environment=myenv) 
   

Pools do Apache Spark

A integração entre o Azure Synapse Analytics e o Azure Machine Learning (versão prévia) permite anexar um pool de Apache Spark apoiado pelo Azure Synapse para exploração e preparação interativas de dados. Com essa integração, você poderá ter um cálculo dedicado para a estruturação de dados em escala. Para obter mais informações, consulte Como anexar os pools do Apache Spark da plataforma Azure Synapse Analytics.

Azure HDInsight

O Azure HDInsight é uma plataforma popular para análise de dados. A plataforma fornece o Apache Spark, que pode ser usado para o treinamento do seu modelo.

1. Criar: o Azure Machine Learning não pode criar um cluster do HDInsight para você. Em vez disso, você deve criar o recurso e anexá-lo ao seu workspace do Azure Machine Learning. Para obter mais informações, confira Criar um cluster do Spark no HDInsight.

   Aviso

   O Azure Machine Learning requer que o cluster HDInsight tenha um endereço IP público.

   Ao criar o cluster, especifique um nome de usuário SSH e senha. Observe esses valores, conforme necessário, ao usar o HDInsight como um destino de computação.

   Depois que o cluster é criado, conecte-o com o nome do host <clustername >-ssh.azurehdinsight.net, em que <clustername> é o nome que você forneceu para o cluster.

2. Anexar: anexe o cluster HDInsight ao espaço de trabalho usando o Azure Machine Learning Studio.

   Aviso

   Não crie vários anexos simultâneos para o mesmo HDInsight do seu workspace. Cada novo anexo interromperá os anexos existentes anteriores.

3. Configurar: Crie uma configuração de execução para o destino de computação da HDI.

   from azureml.core.runconfig import RunConfiguration
   from azureml.core.conda_dependencies import CondaDependencies
   
   
   # use pyspark framework
   run_hdi = RunConfiguration(framework="pyspark")
   
   # Set compute target to the HDI cluster
   run_hdi.target = hdi_compute.name
   
   # specify CondaDependencies object to ask system installing numpy
   cd = CondaDependencies()
   cd.add_conda_package('numpy')
   run_hdi.environment.python.conda_dependencies = cd
   

Lote do Azure

O Lote do Azure é usado para executar com eficiência aplicativos HPC (computação de alto desempenho) e paralelos em grande escala na nuvem. O AzureBatchStep pode ser usado em um Pipeline do Azure Machine Learning para enviar trabalhos a um pool de computadores do Lote do Azure.

Para anexar o Lote do Azure como um destino de computação, você deve usar o SDK do Azure Machine Learning e fornecer as seguintes informações:

• Nome de computação do Lote do Azure: Um nome amigável a ser usado para a computação no espaço de trabalho
• Nome da conta do Lote do Azure: O nome da conta do Lote do Azure
• Grupo de Recursos: O grupo de recursos que contém o a conta do Lote do Azure.

O código a seguir demonstra como anexar o Lote do Azure como um destino de computação:

from azureml.core.compute import ComputeTarget, BatchCompute
from azureml.exceptions import ComputeTargetException

# Name to associate with new compute in workspace
batch_compute_name = 'mybatchcompute'

# Batch account details needed to attach as compute to workspace
batch_account_name = "<batch_account_name>"  # Name of the Batch account
# Name of the resource group which contains this account
batch_resource_group = "<batch_resource_group>"

try:
    # check if the compute is already attached
    batch_compute = BatchCompute(ws, batch_compute_name)
except ComputeTargetException:
    print('Attaching Batch compute...')
    provisioning_config = BatchCompute.attach_configuration(
        resource_group=batch_resource_group, account_name=batch_account_name)
    batch_compute = ComputeTarget.attach(
        ws, batch_compute_name, provisioning_config)
    batch_compute.wait_for_completion()
    print("Provisioning state:{}".format(batch_compute.provisioning_state))
    print("Provisioning errors:{}".format(batch_compute.provisioning_errors))

print("Using Batch compute:{}".format(batch_compute.cluster_resource_id))

Azure Databricks

As Azure Databricks são um ambiente baseado em Apache Spark na nuvem do Azure. Ele pode ser usado como um destino de computação com um pipeline do Azure Machine Learning.

Para anexar o Azure Databricks como um destino de computação, forneça as seguintes informações:

• Nome da computação do Databricks: o nome que você deseja atribuir a este recurso de computação.
• Nome do workspace do Databricks: o nome do workspace do Databricks.
• Token de acesso do Databricks: o token de acesso usado para autenticar o Azure Databricks. Para gerar um token de acesso, consulte o documento Autenticação.

O código a seguir demonstra como anexar o Azure Databricks como um destino de computação com o SDK do Azure Machine Learning:

import os
from azureml.core.compute import ComputeTarget, DatabricksCompute
from azureml.exceptions import ComputeTargetException

databricks_compute_name = os.environ.get(
    "AML_DATABRICKS_COMPUTE_NAME", "<databricks_compute_name>")
databricks_workspace_name = os.environ.get(
    "AML_DATABRICKS_WORKSPACE", "<databricks_workspace_name>")
databricks_resource_group = os.environ.get(
    "AML_DATABRICKS_RESOURCE_GROUP", "<databricks_resource_group>")
databricks_access_token = os.environ.get(
    "AML_DATABRICKS_ACCESS_TOKEN", "<databricks_access_token>")

try:
    databricks_compute = ComputeTarget(
        workspace=ws, name=databricks_compute_name)
    print('Compute target already exists')
except ComputeTargetException:
    print('compute not found')
    print('databricks_compute_name {}'.format(databricks_compute_name))
    print('databricks_workspace_name {}'.format(databricks_workspace_name))
    print('databricks_access_token {}'.format(databricks_access_token))

    # Create attach config
    attach_config = DatabricksCompute.attach_configuration(resource_group=databricks_resource_group,
                                                           workspace_name=databricks_workspace_name,
                                                           access_token=databricks_access_token)
    databricks_compute = ComputeTarget.attach(
        ws,
        databricks_compute_name,
        attach_config
    )

    databricks_compute.wait_for_completion(True)

Para obter um exemplo mais detalhado, confira um exemplo de notebook no GitHub.

Análise Azure Data Lake

O Azure Data Lake Analytics é uma plataforma de análise de big data na nuvem do Azure. Ele pode ser usado como um destino de computação com um pipeline do Azure Machine Learning.

Crie uma conta do Azure Data Lake Analytics antes de usá-lo. Para criar este recurso, consulte o documento Introdução ao Google Analytics do Azure Data Lake.

Para anexar o Data Lake Analytics como um destino de computação, você deve usar o SDK do Aprendizado de Máquina do Azure e fornecer as seguintes informações:

• Nome da computa: o nome que você deseja atribuir a este recurso de computação.
• Grupo de recursos: o grupo de recursos que contém a conta do Data Lake Analytics.
• Nome da conta: o nome da conta do Data Lake Analytics.

O código a seguir demonstra como anexar o Data Lake Analytics como um destino de computação:

import os
from azureml.core.compute import ComputeTarget, AdlaCompute
from azureml.exceptions import ComputeTargetException


adla_compute_name = os.environ.get(
    "AML_ADLA_COMPUTE_NAME", "<adla_compute_name>")
adla_resource_group = os.environ.get(
    "AML_ADLA_RESOURCE_GROUP", "<adla_resource_group>")
adla_account_name = os.environ.get(
    "AML_ADLA_ACCOUNT_NAME", "<adla_account_name>")

try:
    adla_compute = ComputeTarget(workspace=ws, name=adla_compute_name)
    print('Compute target already exists')
except ComputeTargetException:
    print('compute not found')
    print('adla_compute_name {}'.format(adla_compute_name))
    print('adla_resource_id {}'.format(adla_resource_group))
    print('adla_account_name {}'.format(adla_account_name))
    # create attach config
    attach_config = AdlaCompute.attach_configuration(resource_group=adla_resource_group,
                                                     account_name=adla_account_name)
    # Attach ADLA
    adla_compute = ComputeTarget.attach(
        ws,
        adla_compute_name,
        attach_config
    )

    adla_compute.wait_for_completion(True)

Para obter um exemplo mais detalhado, confira um exemplo de notebook no GitHub.

Azure Container Instance

As ACI (Instâncias de Contêiner do Azure) são criadas dinamicamente quando você implanta um modelo. Não é possível criar nem anexar uma ACI ao workspace de nenhuma outra maneira. Para obter mais informações, confira o documento Implantar um modelo nas Instâncias de Contêiner do Azure.

Kubernetes

O Azure Machine Learning oferece as seguintes opções para anexar seus próprios clusters do Kubernetes para treinamento e inferência. Confira Configurar o cluster do Kubernetes para o Azure Machine Learning.

Para desanexar um cluster do Kubernetes do seu workspace, use um dos seguintes métodos:

compute_target.detach()

Exemplos de notebook

Veja estes notebooks para obter exemplos de treinamento com vários destinos de computação:

• how-to-use-azureml/training
• tutorials/img-classification-part1-training.ipynb

Saiba como executar notebooks seguindo o artigo Usar os notebooks do Jupyter para explorar esse serviço.

Próximas etapas

• Use o recurso de computação para configurar e enviar uma execução de treinamento.
• O Tutorial: Treinar e implantar um modelo usa um destino de computação gerenciado para treinar um modelo.
• Saiba como ajustar hiperparâmetros de modo eficiente para criar modelos melhores.
• Quando você tiver um modelo treinado, aprenda como e em que local implantar modelos.
• Usar o Azure Machine Learning com Redes Virtuais do Azure