Compartilhar via

Crie e execute pipelines de machine learning com o SDK do Azure Machine Learning

  • Artigo

APLICA-SE ASDK do Python azureml v1

Neste artigo, você aprenderá a criar e executar pipelines de machine learning usando o SDK do Azure Machine Learning. Use pipelines de ML para criar um fluxo de trabalho que une várias fases de ML. Em seguida, publique esse pipeline para acessar ou compartilhar mais tarde com outras pessoas. Acompanhe os pipelines de ML para ver como seu modelo está sendo executado no mundo real e para detectar descompasso de dados. Os pipelines de ML são ideais para cenários de pontuação em lote, usando vários cenários, reutilizando etapas em vez de executá-las novamente e compartilhando fluxos de trabalho de ML com outras pessoas.

Este artigo não é um tutorial. Para saber as diretrizes de como criar seu primeiro pipeline, consulte Tutorial: criar um pipeline de Azure Machine Learning para pontuação de lote ou Usar o ML automatizado em um pipeline de Azure Machine Learning no Python.

Embora você possa usar um tipo diferente de pipeline chamado de pipeline do Azure para a automação de CI/CD de tarefas do Machine Learning, esse tipo de pipeline não é armazenado em seu espaço de trabalho. Compare esses pipelines diferentes.

Os pipelines de ML que você cria são visíveis para os membros do workspace do Azure Machine Learning.

Os pipelines de ML são executados em destinos de computação (consulte O que são destinos de computação no Azure Machine Learning). Pipelines podem ler e gravar dados de para locais de Armazenamento do Azure com suporte.

Caso não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga do Azure Machine Learning.

Pré-requisitos

Iniciar anexando seu espaço de trabalho:

import azureml.core
from azureml.core import Workspace, Datastore

ws = Workspace.from_config()

Configurar recursos de aprendizado de máquina

Criar os recursos necessários para executar um pipeline de ML:

  • Configurar um repositório de dados usado para acessar os dados necessários nas etapas de pipeline.

  • Configurar um objeto Dataset para apontar para dados persistentes que residem ou podem ser acessados em um armazenamento de dados. Configure um OutputFileDatasetConfig objeto para dados temporários passados entre etapas do pipeline.

  • Configure os destinos de computação em que suas etapas de pipeline serão executadas.

Configurar um repositório de dados

Um repositório de dados armazena os dados para o pipeline acessar. Cada workspace tem um repositório de dados padrão. É possível registrar mais armazenamentos de dados.

Quando você cria seu workspace, por padrão, os Arquivos do Azure e doarmazenamento de Blobs do Azure são anexados ao workspace. Um armazenamento de dados padrão é registrado para se conectar ao armazenamento de Blobs do Azure. Para saber mais, consulte Decidindo quando usar Arquivos do Azure, Blobs do Azure ou Discos do Azure.

# Default datastore 
def_data_store = ws.get_default_datastore()

# Get the blob storage associated with the workspace
def_blob_store = Datastore(ws, "workspaceblobstore")

# Get file storage associated with the workspace
def_file_store = Datastore(ws, "workspacefilestore")

As etapas geralmente consomem dados e produzem dados de saída. Uma etapa pode criar dados como um modelo, um diretório com o modelo e arquivos dependentes ou dados temporários. Esses dados então ficam disponíveis para outras etapas posteriores no pipeline. Para saber mais sobre como conectar seu pipeline a seus dados, confira os artigos Como acessar dados e Como registrar os conjunto de dados.

Configurar dados com objetos Dataset e OutputFileDatasetConfig

A forma preferencial de fornecer dados a um pipeline é com um objeto Conjunto de dados. O objeto Dataset aponta para dados que residem ou podem ser acessados de um armazenamento de dados ou URL da Web. A classe Dataset é abstrata, portanto, você criará uma instância de um FileDataset (referindo-se a um ou mais arquivos) ou de um TabularDataset que é criado por um ou mais arquivos com colunas delimitadas de dados.

Você cria um Dataset usando métodos como from_files ou from_delimited_files.

from azureml.core import Dataset

my_dataset = Dataset.File.from_files([(def_blob_store, 'train-images/')])

Os dados intermediários (ou a saída de uma etapa) são representados por um objeto OutputFileDatasetConfig. output_data1 é produzido como a saída de uma etapa. Opcionalmente, esses dados podem ser registrados como um conjunto de dados chamando register_on_complete. Se você criar um OutputFileDatasetConfig em uma etapa e usá-lo como uma entrada para outra etapa, essa dependência de dados entre etapas criará uma ordem de execução implícita no pipeline.

Os OutputFileDatasetConfigobjetos retornam um diretório e, por padrão, gravam a saída no armazenamento de dados padrão do workspace.

from azureml.data import OutputFileDatasetConfig

output_data1 = OutputFileDatasetConfig(destination = (datastore, 'outputdataset/{run-id}'))
output_data_dataset = output_data1.register_on_complete(name = 'prepared_output_data')

Importante

Os dados armazenados intermediários usando o OutputFileDatasetConfig não são excluídos automaticamente pelo Azure. De maneira programática, você deve excluir os dados intermediários no final de uma execução de pipeline, usar um armazenamento de dados com uma política de retenção de dados curta ou fazer uma limpeza manual regularmente.

Dica

Carregue somente arquivos pertinentes para o trabalho em questão. Qualquer alteração nos arquivos do diretório de dados será vista como motivo para executar a etapa novamente na próxima vez que o pipeline for executado, mesmo que a reutilização seja especificada.

Configurar um destino de computação

No Azure Machine Learning, o termo computação (ou destino de computação) refere-se a computadores ou clusters que executam as etapas computacionais no pipeline de aprendizado de máquina. Consulte destinos de computação para treinamento do modelo para obter uma lista completa de destinos de computação e Criar destinos destino de computação para saber como criá-los e anexá-los ao seu workspace. O processo para criar e/ou anexar um destino de computação é o mesmo ao treinar um modelo ou executar uma etapa do pipeline. Depois de criar e anexar seu destino de computação, use o objeto ComputeTarget em na etapa do pipeline.

Importante

Não há suporte para operações de gerenciamento em destinos de computação de dentro de trabalhos remotos. Como os pipelines de aprendizado de máquina são enviados como um trabalho remoto, não use operações de gerenciamento em destinos de computação de dentro do pipeline.

Computação do Azure Machine Learning

Você pode criar uma computação do Azure Machine Learning para executar suas etapas. O código para outros destinos de computação é semelhante, com parâmetros um pouco diferentes, dependendo do tipo.

from azureml.core.compute import ComputeTarget, AmlCompute

compute_name = "aml-compute"
vm_size = "STANDARD_NC6"
if compute_name in ws.compute_targets:
    compute_target = ws.compute_targets[compute_name]
    if compute_target and type(compute_target) is AmlCompute:
        print('Found compute target: ' + compute_name)
else:
    print('Creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size=vm_size,  # STANDARD_NC6 is GPU-enabled
                                                                min_nodes=0,
                                                                max_nodes=4)
    # create the compute target
    compute_target = ComputeTarget.create(
        ws, compute_name, provisioning_config)

    # Can poll for a minimum number of nodes and for a specific timeout.
    # If no min node count is provided it will use the scale settings for the cluster
    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=20)

    # For a more detailed view of current cluster status, use the 'status' property
    print(compute_target.status.serialize())

Configurar o ambiente da execução de treinamento

A próxima etapa é verificar se a execução de treinamento remoto tem todas as dependências necessárias para as etapas de treinamento. As dependências e o contexto de tempo de execução são definidos ao criar e configurar um objeto RunConfiguration.

from azureml.core.runconfig import RunConfiguration
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core import Environment 

aml_run_config = RunConfiguration()
# `compute_target` as defined in "Azure Machine Learning compute" section above
aml_run_config.target = compute_target

USE_CURATED_ENV = True
if USE_CURATED_ENV :
    curated_environment = Environment.get(workspace=ws, name="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu")
    aml_run_config.environment = curated_environment
else:
    aml_run_config.environment.python.user_managed_dependencies = False
    
    # Add some packages relied on by data prep step
    aml_run_config.environment.python.conda_dependencies = CondaDependencies.create(
        conda_packages=['pandas','scikit-learn'], 
        pip_packages=['azureml-sdk', 'azureml-dataset-runtime[fuse,pandas]'], 
        pin_sdk_version=False)

O código acima mostra duas opções para lidar com dependências. Conforme apresentado, com USE_CURATED_ENV = True, a configuração é baseada em um ambiente coletado. Os ambientes coletados são "pré-prontos" com bibliotecas interdependentes comuns e podem ser mais rápidos de colocar online. Os ambientes coletados têm imagens do Docker pré-criados no Registro de Contêiner da Microsoft. Para saber mais, consulte Ambientes coletados do Azure Machine Learning.

O caminho feito se você alterar USE_CURATED_ENV para False mostra o padrão para definir explicitamente suas dependências. Nesse cenário, uma nova imagem personalizada do Docker será criada e registrada em um Registro de Contêiner do Azure no seu grupo de recursos (consulte Introdução aos registros de contêiner do Docker particular no Azure). Criar e registrar essa imagem pode levar alguns minutos.

Construir suas etapas de pipeline

Depois de criar o recurso de computação e o ambiente, você estará pronto para definir as etapas de pipeline. Existem muitas etapas internas disponíveis por meio do SDK do Azure Machine Learning, como você pode ver na documentação de referência do azureml.pipeline.steps pacote. A classe mais flexível é PythonScriptStep, que executa um script do Python.

from azureml.pipeline.steps import PythonScriptStep
dataprep_source_dir = "./dataprep_src"
entry_point = "prepare.py"
# `my_dataset` as defined above
ds_input = my_dataset.as_named_input('input1')

# `output_data1`, `compute_target`, `aml_run_config` as defined above
data_prep_step = PythonScriptStep(
    script_name=entry_point,
    source_directory=dataprep_source_dir,
    arguments=["--input", ds_input.as_download(), "--output", output_data1],
    compute_target=compute_target,
    runconfig=aml_run_config,
    allow_reuse=True
)

O código acima mostra uma etapa inicial de pipeline típica. O código de preparação de dados está em um subdiretório (neste exemplo, "prepare.py" no diretório "./dataprep.src"). Como parte do processo de criação de pipeline, esse diretório é compactado e carregado no compute_target e a etapa executa o script especificado como o valor para script_name.

Os arguments valores especificam as entradas e saídas da etapa. No exemplo acima, os dados de linha de base são my_dataset o conjunto de dados. Os dados correspondentes serão baixados para o recurso de computação, uma vez que o código especifica como as_download(). O script prepare.py transforma os dados de quaisquer tarefas apropriadas para a tarefa em questão e gera a saída dos dados para output_data1, do tipo OutputFileDatasetConfig. Para saber mais, consulte Movendo dados para e entre as etapas de pipeline de ML (Python). A etapa será executada no computador definido pelo compute_target, usando a configuração aml_run_config.

A reutilização de resultados anteriores (allow_reuse) é fundamental ao usar pipelines em um ambiente de colaboração, pois eliminar novas execuções desnecessárias oferece agilidade. A reutilização é o comportamento padrão quando o script_name, as entradas e os parâmetros de uma etapa permanecem os mesmos. Quando a reutilização é permitida, os resultados da execução anterior são enviados imediatamente para a próxima etapa. Se False for definido para allow_reuse, uma nova execução sempre será gerada para essa etapa durante a execução do pipeline.

É possível criar um pipeline com uma única etapa, mas quase sempre você escolherá dividir todo o processo em várias etapas. Por exemplo, você pode ter etapas para preparação de dados, treinamento, comparação de modelo e implantação. Por exemplo, podemos imaginar que, após o data_prep_step especificado acima, a próxima etapa pode ser o treinamento:

train_source_dir = "./train_src"
train_entry_point = "train.py"

training_results = OutputFileDatasetConfig(name = "training_results",
    destination = def_blob_store)

    
train_step = PythonScriptStep(
    script_name=train_entry_point,
    source_directory=train_source_dir,
    arguments=["--prepped_data", output_data1.as_input(), "--training_results", training_results],
    compute_target=compute_target,
    runconfig=aml_run_config,
    allow_reuse=True
)

O código acima é semelhante ao código na etapa de preparação de dados. O código de treinamento está em um diretório separado do código de preparação de dados. A saída OutputFileDatasetConfig da etapa de preparação de dados output_data1 é usada como entrada para a etapa de treinamento. Um novo OutputFileDatasetConfig objeto training_results é criado para manter os resultados de uma comparação posterior ou etapa de implantação.

Para ver outros exemplos de código, confira como criar um pipeline de ML de duas etapas e como gravar dados nos repositórios após a conclusão da execução.

Depois de definir suas etapas, você pode criar o pipeline usando algumas ou todas essas etapas.

Observação

Não é carregado nenhum arquivo ou dado para o Azure Machine Learning quando você define as etapas ou cria o pipeline. Os arquivos são carregados quando você chama Experiment.submit().

# list of steps to run (`compare_step` definition not shown)
compare_models = [data_prep_step, train_step, compare_step]

from azureml.pipeline.core import Pipeline

# Build the pipeline
pipeline1 = Pipeline(workspace=ws, steps=[compare_models])

Usar um conjunto de dados

Os conjuntos de dados criados do Armazenamento de Blobs do Azure, Arquivos do Azure, Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2, Banco de Dados SQL do Azure e Banco de Dados do Azure para PostgreSQL podem ser usados como entrada em qualquer etapa de pipeline. Você pode gravar a saída em um DataTransferStep, DatabricksStep ou usar OutputFileDatasetConfig se desejar gravar dados em um armazenamento de dados específico.

Importante

Só há suporte para gravar dados de saída em um armazenamento de dados usando OutputFileDatasetConfig para os blobs do Azure, do compartilhamento de arquivos do Azure e armazenamento de dados do ADLS Gen 1 e Gen 2.

dataset_consuming_step = PythonScriptStep(
    script_name="iris_train.py",
    inputs=[iris_tabular_dataset.as_named_input("iris_data")],
    compute_target=compute_target,
    source_directory=project_folder
)

Então, você recupera o conjunto de dados no seu pipeline usando o dicionário de Run.input_datasets.

# iris_train.py
from azureml.core import Run, Dataset

run_context = Run.get_context()
iris_dataset = run_context.input_datasets['iris_data']
dataframe = iris_dataset.to_pandas_dataframe()

Vale a pena destacar a linha Run.get_context(). Essa função recupera um Run que representa a execução experimental atual. No exemplo acima, usamos isso para recuperar um conjunto de dados registrado. Outro uso comum do objeto Run é para recuperar o experimento em si e o workspace no qual o experimento reside:

# Within a PythonScriptStep

ws = Run.get_context().experiment.workspace

Para saber mais detalhes, incluindo as maneiras alternativas de passar e acessar dados, consulte Movendo dados para e entre as etapas de pipeline de ML (Python).

Cache & Reutilização

Para otimizar e personalizar o comportamento de seus pipelines, você pode fazer algo em relação ao cache e a reutilização. Por exemplo, você pode escolher:

  • Desativar a reutilização padrão da saída da etapa de execução definindo allow_reuse=False durante a definição da etapa. A reutilização é fundamental ao usar pipelines em um ambiente de colaboração, pois eliminar execuções desnecessárias oferece agilidade. No entanto, você pode recusar a reutilização.
  • Forçar a regeneração de saída para todas as etapas em uma execução com pipeline_run = exp.submit(pipeline, regenerate_outputs=True)

Por padrão, allow_reuse as etapas são habilitadas e o source_directory especificado na definição da etapa tem um hash. Portanto, se o script de alguma etapa permanecer igual (script_name, entradas e os parâmetros) e nada mais no source_directory tiver sido alterado, a saída de uma etapa anterior será reutilizada, o trabalho não será enviado para a computação e os resultados da execução anterior estarão imediatamente disponíveis para a próxima etapa.

step = PythonScriptStep(name="Hello World",
                        script_name="hello_world.py",
                        compute_target=aml_compute,
                        source_directory=source_directory,
                        allow_reuse=False,
                        hash_paths=['hello_world.ipynb'])

Observação

Se os nomes das entradas de dados forem alterados, a etapa será executada novamente, mesmo se os dados subjacentes não forem alterados. Você deve definir explicitamente o campo name dos dados de entrada (data.as_input(name=...)). Se você não definir explicitamente esse valor, o campo name será definido como um GUID aleatório, e os resultados da etapa não serão reutilizados.

Enviar o pipeline

Quando você envia o pipeline, o Azure Machine Learning verifica as dependências para cada etapa e carrega um instantâneo do diretório de origem especificado. Se nenhum diretório de origem for especificado, o diretório local atual será carregado. O instantâneo também é armazenado como parte do experimento em seu workspace.

Importante

Para evitar que arquivos desnecessários sejam incluídos no instantâneo, faça uma opção Ignorar arquivo (.gitignore ou .amlignore) no diretório. Adicione os arquivos e diretórios a serem excluídos para esse arquivo. Para obter mais informações sobre a sintaxe a ser usada dentro desse arquivo, consulte sintaxe e padrões para .gitignore. O arquivo .amlignore usa a mesma sintaxe. Se ambos os arquivos existirem, o arquivo .amlignore será usado e o arquivo .gitignore não será usado.

Para obter mais informações, veja cópias de sombra.

from azureml.core import Experiment

# Submit the pipeline to be run
pipeline_run1 = Experiment(ws, 'Compare_Models_Exp').submit(pipeline1)
pipeline_run1.wait_for_completion()

Quando você executar um pipeline pela primeira vez, o Azure Machine Learning:

  • Baixa o instantâneo do projeto para o destino de computação do armazenamento de Blobs associado ao workspace.

  • Cria uma imagem do Docker correspondente a cada etapa no pipeline.

  • Baixa a imagem do Docker para cada etapa para o destino de computação do registro de contêiner.

  • Configura o acesso a objetos Dataset e OutputFileDatasetConfig. Para o modo de acesso as_mount(), o FUSE é usado para fornecer acesso virtual. Se não houver suporte para a montagem ou se o usuário especificado acessar como as_upload(), os dados serão copiados para o destino de computação.

  • Executa a etapa no destino de computação especificado na definição da etapa.

  • Cria artefatos como logs, stdout e stderr, métricas e saída especificados pela etapa. Esses artefatos serão carregados e mantidos no armazenamento de dados padrão do usuário.

Diagrama de execução de um experimento como um pipeline

Para saber mais, consulte a Classe de experimentode referência.

Usar parâmetros de pipeline para argumentos alterados no momento da inferência

Às vezes, os argumentos para etapas individuais em um pipeline estão relacionados ao período de desenvolvimento e treinamento: coisas como taxas de treinamento e dinâmica ou caminhos para arquivos de dados ou de configuração. No entanto, quando um modelo for implantado, você desejará passar dinamicamente os argumentos sobre os quais você está fazendo inferência (ou seja, a consulta que criou o modelo para responder!). Você deve fazer esses tipos de parâmetros de pipeline de argumentos. Para fazer isso no Python, use a classe azureml.pipeline.core.PipelineParameter, conforme mostrado no seguinte snippet de código:

from azureml.pipeline.core import PipelineParameter

pipeline_param = PipelineParameter(name="pipeline_arg", default_value="default_val")
train_step = PythonScriptStep(script_name="train.py",
                            arguments=["--param1", pipeline_param],
                            target=compute_target,
                            source_directory=project_folder)

Como os ambientes do Python funcionam com parâmetros de pipeline

Conforme discutido em Configurar o ambiente da execução de treinamento, o estado do ambiente e as dependências da biblioteca do Python são especificados usando um objetoEnvironment. Em geral, você pode especificar um Environment existente fazendo referência a seu nome ou a uma versão:

aml_run_config = RunConfiguration()
aml_run_config.environment.name = 'MyEnvironment'
aml_run_config.environment.version = '1.0'

No entanto, se você optar por usar objetos PipelineParameter para definir variáveis dinamicamente no runtime para as etapas do pipeline, não poderá usar essa técnica de fazer referência a um Environment existente. Em vez disso, se você quiser usar objetosPipelineParameter, deverá definir o campo environment do RunConfiguration para um objeto Environment. É sua responsabilidade garantir que esse um deles Environment tenha suas dependências em pacotes externos do Python definidos corretamente.

Exibir resultados de um pipeline

Confira a lista de todos os seus pipelines e seus detalhes de execução no estúdio:

  1. Entre no Estúdio do Azure Machine Learning.

  2. Exibir o seu workspace.

  3. À esquerda, selecione Pipelines para ver todas as execuções de pipeline. lista de pipelines do aprendizado de máquina

  4. Selecione um pipeline específico para ver os resultados da execução.

Acompanhamento e integração do Git

Quando você inicia uma execução de treinamento em que o diretório de origem é um repositório Git local, as informações sobre o repositório são armazenadas no histórico de execuções. Para obter mais informações, confira Integração do Git com o Azure Machine Learning.

Próximas etapas