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

APLICA-SE A: Python SDK azureml v1

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

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

• O seu computador local
• Máquinas virtuais remotas
• Pools do Apache Spark (com tecnologia do Azure Synapse Analytics)
• Azure HDInsight
• Azure Batch
• Azure Databricks - usado como um destino de computação de treinamento somente em pipelines de aprendizado de máquina
• Azure Data Lake Analytics
• Azure Container Instance
• Azure Machine Learning Kubernetes

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

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

Pré-requisitos

• Uma área de trabalho do Azure Machine Learning. Para obter mais informações, consulte Criar recursos de espaço de trabalho.

• A extensão da CLI do Azure para o serviço de Aprendizado de Máquina, o SDK Python do Azure Machine Learning ou a extensão de Código do Azure Machine Learning Visual Studio.

Limitações

• Não crie vários anexos simultâneos para a mesma computação a partir do seu espaço de trabalho. Por exemplo, anexar um cluster do Serviço Kubernetes do Azure a um espaço de trabalho usando dois nomes diferentes. Cada novo anexo quebrará o(s) anexo(s) existente(s) anterior(es).

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

O que é um destino de computação?

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

Computador local

Quando você usa seu computador local para treinamento, não há necessidade de criar um destino de computação. Basta enviar o treinamento executado a partir de sua máquina 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 o serviço Web usará. 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 suporta a anexação de uma Máquina Virtual do Azure. A VM tem de ser uma Máquina Virtual de Ciência de Dados (DSVM) do Azure. A VM oferece uma seleção selecionada de ferramentas e estruturas para o desenvolvimento de aprendizado de máquina de ciclo de vida completo. Para obter mais informações sobre como usar a DSVM com o Azure Machine Learning, consulte Configurar um ambiente de desenvolvimento.

1. Criar: o Azure Machine Learning não pode criar uma VM remota para você. Em vez disso, você deve criar a VM e anexá-la ao seu espaço de trabalho do Azure Machine Learning. Para obter informações sobre como criar uma DSVM, consulte Provisionar a máquina virtual de ciência de dados para Linux (Ubuntu).

   Aviso

   O Azure Machine Learning suporta apenas máquinas virtuais que executam o Ubuntu. Quando cria uma VM ou escolhe uma VM existente, tem de selecionar uma VM que utilize o Ubuntu.

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

2. Anexar: anexe a DSVM ao seu espaço de trabalho usando o estúdio do Azure Machine Learning.

   Aviso

   Não crie vários anexos simultâneos para a mesma DSVM a partir do seu espaço de trabalho. Cada novo anexo quebrará o(s) anexo(s) existente(s) anterior(es).

3. Configurar: crie uma configuração de execução para o destino de computação DSVM. Docker e 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) 
   

Conjuntos do Apache Spark

A integração do Azure Synapse Analytics com o Azure Machine Learning (visualização) permite anexar um pool do Apache Spark apoiado pelo Azure Synapse para exploração e preparação de dados interativos. Com essa integração, você pode ter uma computação dedicada para disputa de dados em escala. Para obter mais informações, consulte Como anexar pools do Apache Spark com tecnologia do Azure Synapse Analytics.

Azure HDInsight

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

1. Criar: o Aprendizado de Máquina do Azure não pode criar um cluster HDInsight para você. Em vez disso, tem de criar o cluster e, em seguida, anexá-lo à área de trabalho do Azure Machine Learning. Para obter mais informações, veja Criar um Cluster do Apache Spark no HDInsight.

   Aviso

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

   Ao criar o cluster, você deve especificar um nome de usuário e senha SSH. Anote esses valores, pois você precisa deles para usar o HDInsight como um destino de computação.

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

2. Anexar: anexe o cluster HDInsight ao seu espaço de trabalho usando o estúdio do Azure Machine Learning.

   Aviso

   Não crie vários anexos simultâneos para o mesmo HDInsight a partir do seu espaço de trabalho. Cada novo anexo quebrará o(s) anexo(s) existente(s) anterior(es).

3. Configurar: crie uma configuração de execução para o destino de computação 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
   

Azure Batch

O Azure Batch é usado para executar aplicativos de computação paralela e de alto desempenho (HPC) em grande escala de forma eficiente na nuvem. AzureBatchStep pode ser usado em um Pipeline de Aprendizado de Máquina do Azure para enviar trabalhos para um pool de máquinas do Azure Batch.

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

O Azure Databricks é um ambiente baseado no Apache Spark na nuvem do Azure. Pode ser utilizado como 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 de computação do Databricks: o nome que você deseja atribuir a este recurso de computação.
• Nome do espaço de trabalho Databricks: O nome do espaço de trabalho do Azure Databricks.
• Token de acesso Databricks: o token de acesso usado para autenticar no Azure Databricks. Para gerar um token de acesso, consulte o documento de 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, veja um bloco de notas de exemplo no GitHub.

Azure Data Lake Analytics

O Azure Data Lake Analytics é uma plataforma de análise de macrodados na cloud do Azure. Pode ser utilizado como destino de computação com um pipeline do Azure Machine Learning.

Crie uma conta do Azure Data Lake Analytics antes de o utilizar. Para criar este recurso, veja o documento Introdução ao Azure Data Lake Analytics.

Para anexar a Análise Data Lake 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: o nome que você deseja atribuir a este recurso de computação.
• Grupo de recursos: o grupo de recursos que contém a conta da Análise Data Lake.
• 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, veja um bloco de notas de exemplo no GitHub.

Azure Container Instance

As Instâncias de Contêiner do Azure (ACI) são criadas dinamicamente quando você implanta um modelo. Não é possível criar ou anexar ACI ao seu espaço de trabalho de qualquer outra forma. Para obter mais informações, consulte Implantar um modelo em instâncias de contêiner do Azure.

Kubernetes

O Azure Machine Learning oferece a opção de anexar seus próprios clusters Kubernetes para treinamento e inferência. Consulte Configurar cluster Kubernetes para o Azure Machine Learning.

Para desanexar um cluster Kubernetes do seu espaço de trabalho, use o seguinte método:

compute_target.detach()

Exemplos de blocos de notas

Veja estes blocos de anotações para exemplos de treinamento com vários alvos de computação:

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

Saiba como executar blocos de notas ao seguir o artigo Utilizar blocos de notas Jupyter para explorar este serviço.

Próximos passos

• Use o recurso de computação para configurar e enviar uma execução de treinamento.
• Tutorial: Treinar e implantar um modelo usa um destino de computação gerenciado para treinar um modelo.
• Saiba como ajustar hiperparâmetros de forma eficiente para criar modelos melhores.
• Depois de ter um modelo treinado, saiba como e onde implantar modelos.
• Usar o Azure Machine Learning com as Redes Virtuais do Azure