Criar e executar gasodutos de aprendizagem automática com Azure Machine Learning SDK

Neste artigo, aprende-se a criar e executar gasodutos de aprendizagem automática utilizando o Azure Machine Learning SDK. Utilize ML oleodutos para criar um fluxo de trabalho que cosa várias fases ML. Em seguida, publique o oleoduto para mais tarde aceder ou partilhar com outros. Acompanhe ML oleodutos para ver como o seu modelo está a funcionar no mundo real e para detetar a deriva de dados. ML os oleodutos são ideais para cenários de pontuação de lotes, usando vários cálculos, reutilizando passos em vez de os re-repetir, e partilhando fluxos de trabalho ML com outros.

Este artigo não é um tutorial. Para obter orientações sobre a criação do seu primeiro oleoduto, consulte Tutorial: Construa um Azure Machine Learning oleoduto para pontuação de lotes ou utilize ML automatizados num gasoduto Azure Machine Learning em Python.

Embora possa utilizar um tipo diferente de oleoduto chamado Gasoduto Azure para automatização de CI/CD de tarefas ML, esse tipo de gasoduto não está armazenado no seu espaço de trabalho. Compare estes diferentes oleodutos.

Os ML oleodutos que cria são visíveis para os membros do seu espaço de trabalhoAzure Machine Learning.

ML os gasodutos executam em alvos de computação (ver quais são os alvos de cálculo em Azure Machine Learning). Os oleodutos podem ler e escrever dados de e para locais suportados do Azure Armazenamento.

Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga de Azure Machine Learning.

Pré-requisitos

Comece por anexar o seu espaço de trabalho:

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

ws = Workspace.from_config()

Criar recursos de aprendizagem automática

Criar os recursos necessários para executar um gasoduto ML:

  • Crie uma datastore utilizada para aceder aos dados necessários nas etapas do gasoduto.

  • Configure um Dataset objeto para apontar para dados persistentes que vivem ou estão acessíveis numa datastore. Configure um OutputFileDatasetConfig objeto para dados temporários passados entre as etapas do gasoduto.

  • Desaponte os alvos de cálculo nos quais os seus passos de gasoduto irão funcionar.

Criar uma data-tore

Uma loja de dados armazena os dados para o pipeline aceder. Cada espaço de trabalho tem uma datastore padrão. Pode registar mais datastores.

Quando cria o seu espaço de trabalho, os Ficheiros Azure e o armazenamento Azure Blob estão ligados ao espaço de trabalho. Está registada uma loja de dados predefinida para ligar ao armazenamento da Azure Blob. Para saber mais, consulte decidir quando utilizar ficheiros Azure, Blobs Azure ou Discos 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 produção. Um passo pode criar dados como um modelo, um diretório com modelos e ficheiros dependentes, ou dados temporários. Estes dados estão então disponíveis para outros passos mais tarde no oleoduto. Para saber mais sobre a ligação do seu pipeline aos seus dados, consulte os artigos Como Aceder aos Dados e Como Registar Conjuntos de Dados.

Configurar dados com Dataset e OutputFileDatasetConfig objetos

A forma preferida de fornecer dados a um pipeline é um objeto dataset. O Dataset objeto aponta para dados que vivem dentro ou estão acessíveis a partir de uma datastore ou em um URL web. A Dataset classe é abstrata, por isso vai criar um exemplo de um FileDataset (referindo-se a um ou mais ficheiros) ou de um TabularDataset que é criado por um ou mais ficheiros com colunas de dados delimitadas.

Cria-se um Dataset método de utilização 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 intermédios (ou saída de um passo) são representados por um objeto OutputFileDatasetConfig. output_data1 é produzido como a saída de um passo. Opcionalmente, estes dados podem ser registados como um conjunto de dados através da chamada register_on_complete . Se criar um OutputFileDatasetConfig passo num passo e usá-lo como entrada para outro passo, essa dependência de dados entre etapas cria uma ordem de execução implícita no oleoduto.

OutputFileDatasetConfig os objetos devolvem um diretório e, por predefinição, escreve a saída para a datastore predefinido do espaço de trabalho.

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 intermédios armazenados não OutputFileDatasetConfig são automaticamente eliminados pelo Azure. Deve eliminar programáticamente dados intermédios no final de uma execução de gasoduto, utilizar uma loja de dados com uma política de retenção de dados curta ou fazer regularmente limpeza manual.

Dica

Carregue apenas ficheiros relevantes para o trabalho em questão. Quaisquer alterações nos ficheiros no diretório de dados serão encaradas como motivo para voltar a executar o passo na próxima vez que o pipeline for executado, mesmo que a reutilização seja especificada.

Configurar um alvo de computação

Em Azure Machine Learning, o termo compute (ou meta de computação) refere-se às máquinas ou clusters que fazem os passos computacionais no seu pipeline de aprendizagem automática. Consulte metas de cálculo para formação de modelos para uma lista completa de alvos de computação e Crie metas de computação para como criá-los e anexá-los ao seu espaço de trabalho. O processo de criação e ou anexação de um alvo de computação é o mesmo quer esteja a treinar um modelo ou a fazer um passo de pipeline. Depois de criar e fixar o seu alvo de cálculo, utilize o ComputeTarget objeto no seu passo de pipeline.

Importante

Realizar operações de gestão em alvos de computação não é suportado a partir de trabalhos remotos. Como os pipelines de aprendizagem automática são enviados como um trabalho remoto, não utilize operações de gestão em destinos de computação a partir do pipeline.

Azure Machine Learning computação

Pode criar um cálculo Azure Machine Learning para executar os seus passos. O código para outros alvos de computação é semelhante, com parâmetros ligeiramente 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())

Configure o ambiente do treino

O próximo passo é garantir que o treino remoto tenha todas as dependências necessárias pelas etapas de treino. As dependências e o contexto de tempo de execução são definidos através da criação e configuração de um RunConfiguration objeto.

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. Como apresentado, USE_CURATED_ENV = True com, a configuração baseia-se num ambiente curado. Os ambientes curados são "pré-preparados" com bibliotecas interdependentes comuns e podem ser mais rápidos de chegar online. Ambientes curados têm imagens pré-construídas de Docker no Microsoft Container Registry. Para mais informações, consulte Azure Machine Learning ambientes com curadoria.

O caminho tomado se mudar USE_CURATED_ENV para False mostrar o padrão para definir explicitamente as suas dependências. Nesse cenário, será criada e registada uma nova imagem personalizada do Docker num Registo de Contentores Azure dentro do seu grupo de recursos (ver Introdução aos registos privados de contentores Docker em Azure). Construir e registar esta imagem pode demorar alguns minutos.

Construa os seus passos de oleoduto

Assim que tiver o recurso compute e o ambiente criados, está pronto para definir os passos do seu pipeline. Existem muitos passos incorporados disponíveis através do Azure Machine Learning SDK, como pode ver na documentação de referência do azureml.pipeline.steps pacote. A classe mais flexível é PythonScriptStep,que executa um script 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 um passo típico do gasoduto inicial. O seu código de preparação de dados está numa subdiretório (neste exemplo, "prepare.py" no "./dataprep.src" diretório). Como parte do processo de criação do gasoduto, este diretório é fechado e carregado para o compute_target e o passo executa o script especificado como o valor para script_name .

Os arguments valores especificam as entradas e saídas do passo. No exemplo acima, os dados de base são o my_dataset conjunto de dados. Os dados correspondentes serão descarregados para o recurso computacional uma vez que o código os especifica como as_download() . O script prepare.py faz quaisquer tarefas de transformação de dados adequadas à tarefa em questão e produz os dados para output_data1 , de tipo OutputFileDatasetConfig . Para obter mais informações, consulte a deslocação de dados para dentro e entre ML etapas de gasoduto (Python). O passo será executado na máquina definida compute_target por, utilizando a configuração aml_run_config .

A reutilização dos resultados anteriores allow_reuse () é fundamental quando se utilizam gasodutos num ambiente colaborativo, uma vez que eliminar repetições desnecessárias oferece agilidade. A reutilização é o comportamento padrão quando o script_name, as entradas e os parâmetros de um passo permanecem os mesmos. Quando a reutilização é permitida, os resultados da execução anterior são imediatamente enviados para o passo seguinte. Se allow_reuse estiver programado para , uma nova False execução será sempre gerada para este passo durante a execução do gasoduto.

É possível criar um oleoduto com um único passo, mas quase sempre escolherá dividir o seu processo global em vários passos. Por exemplo, pode ter passos para a preparação de dados, treino, comparação de modelos e implantação. Por exemplo, podemos imaginar que depois do data_prep_step acima especificado, o próximo passo pode ser o treino:

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 formação encontra-se num diretório separado do código de preparação de dados. A OutputFileDatasetConfig saída do passo de preparação de dados, é usada como output_data1 entrada para o passo de treino. Um novo OutputFileDatasetConfig objeto é criado para manter os training_results resultados para uma comparação posterior ou passo de implementação.

Para outros exemplos de código, consulte como construir um oleoduto de dois ML e como escrever dados para as datastores após a conclusãodo prazo.

Depois de definir os seus passos, constrói o oleoduto utilizando alguns ou todos esses passos.

Nota

Nenhum ficheiro ou dados é carregado para Azure Machine Learning quando define os passos ou constrói o pipeline. Os ficheiros são carregados quando liga para 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])

Utilize um conjunto de dados

Conjuntos de dados criados a partir do armazenamento de Azure Blob, Ficheiros Azure, Azure Data Lake Armazenamento Gen1, Azure Data Lake Armazenamento Gen2, Base de Dados SQL do Azure e Azure Database for PostgreSQL podem ser usados como entrada para qualquer passo de pipeline. Pode escrever output para um DataTransferStep, DatabricksStep,ou se pretender escrever dados para uma loja de dados específica, utilize outputFileDatasetConfig.

Importante

A produção de dados de volta para uma datastore que utiliza OutputFileDatasetConfig é suportada apenas para Azure Blob, Azure File share, ADLS Gen 1 e Gen 2 datastores.

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
)

Em seguida, recupere o conjunto de dados no seu pipeline utilizando o dicionário 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 Run.get_context() a pena destacar a linha. Esta função recupera uma Run representação do atual ensaio experimental. Na amostra acima, utilizamo-la para recuperar um conjunto de dados registado. Outro uso comum do Run objeto é recuperar tanto a experiência em si como o espaço de trabalho em que a experiência reside:

# Within a PythonScriptStep

ws = Run.get_context().experiment.workspace

Para obter mais detalhes, incluindo formas alternativas de passar e aceder aos dados, consulte os dados de deslocação para dentro e entre ML etapas de gasoduto (Python).

reutilização Colocação em Cache &

Para otimizar e personalizar o comportamento dos seus oleodutos, pode fazer algumas coisas em torno do caching e reutilização. Por exemplo, pode optar por:

  • Desligue a reutilização predefinida da saída de marcha por passo, regulando durante a allow_reuse=False definição do passo. A reutilização é fundamental quando se utilizam gasodutos num ambiente colaborativo, uma vez que eliminar corridas desnecessárias oferece agilidade. No entanto, pode optar por não reutilizar.
  • Forçar a regeneração da saída para todos os passos em uma corrida com pipeline_run = exp.submit(pipeline, regenerate_outputs=True)

Por predefinição, allow_reuse para os passos está ativado e source_directory o especificado na definição de passo é hashed. Assim, se o guião para um dado passo permanecer o mesmo ( script_name entradas e parâmetros), e nada mais no source_directory mudou, a saída de um passo anterior é reutilizado, o trabalho não é submetido ao cálculo, e os resultados da execução anterior estão imediatamente disponíveis para o passo seguinte.

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'])

Nota

Se os nomes das entradas de dados mudarem, o passo será reexecutado, mesmo que os dados subjacentes não mudem. Tem de definir explicitamente o name campo dos dados de entrada data.as_input(name=...) (). Se não definir explicitamente este valor, o name campo será definido como um guia aleatório e os resultados do passo não serão reutilizados.

Enviar o oleoduto

Ao submeter o pipeline, Azure Machine Learning verifica as dependências de cada passo e envia uma imagem do diretório de origem especificado. Se não for especificado nenhum diretório de origem, o diretório local atual é carregado. O instantâneo também é armazenado como parte da experiência no seu espaço de trabalho.

Importante

Para evitar que ficheiros desnecessários sejam incluídos no instantâneo, faça um ficheiro de ignorar .gitignore .amlignore (ou) no diretório. Adicione os ficheiros e os diretórios a excluir neste ficheiro. Para obter mais informações sobre a sintaxe a utilizar dentro deste ficheiro, consulte sintaxe e padrões para .gitignore . O .amlignore ficheiro usa a mesma sintaxe. Se ambos os ficheiros existirem, o .amlignore ficheiro é utilizado e o ficheiro não é .gitignore utilizado.

Para mais informações, consulte Snapshots.

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 se faz um oleoduto pela primeira vez, Azure Machine Learning:

  • Descarrega o instantâneo do projeto para o alvo do cálculo a partir do armazenamento Blob associado ao espaço de trabalho.

  • Constrói uma imagem docker correspondente a cada passo no oleoduto.

  • Descarrega a imagem do Docker para cada passo para o alvo do cálculo a partir do registo do contentor.

  • Configura o acesso a Dataset OutputFileDatasetConfig e objetos. Para as_mount() o modo de acesso, o FUSE é utilizado para fornecer acesso virtual. Se a montagem não for suportada ou se o utilizador especificar o acesso como as_upload() , os dados são copiados para o alvo do cálculo.

  • Corre o passo no alvo do cálculo especificado na definição do passo.

  • Cria artefactos, tais como troncos, estalidos e stderr, métricas e saídas especificadas pelo passo. Estes artefactos são então carregados e mantidos na loja de dados predefinidos do utilizador.

Diagrama de executar uma experiência como um oleoduto

Para mais informações, consulte a referência da classe Experiment.

Utilize parâmetros de gasoduto para argumentos que mudam no tempo de inferência

Por vezes, os argumentos para passos individuais dentro de um oleoduto relacionam-se com o período de desenvolvimento e formação: coisas como taxas de formação e dinâmica, ou caminhos para dados ou ficheiros de configuração. No entanto, quando um modelo é implementado, vai querer passar dinamicamente os argumentos sobre os quais está a inferenar (isto é, a consulta que construiu o modelo para responder!). Deve fazer este tipo de parâmetros de pipeline de argumentos. Para isso em Python, use a azureml.pipeline.core.PipelineParameter classe, como mostrado no seguinte corte 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 python funcionam com parâmetros de pipeline

Como discutido anteriormente em Configure o ambiente do treino, oestado ambiente e as dependências da biblioteca Python são especificados usando um Environment objeto. Geralmente, pode especificar uma existente Environment referindo-se ao seu nome e, opcionalmente, uma versão:

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

No entanto, se optar por utilizar PipelineParameter objetos para definir dinamicamente variáveis em tempo de execução para os seus passos de pipeline, não pode utilizar esta técnica de se referir a um existente Environment . Em vez disso, se pretender utilizar PipelineParameter objetos, tem de definir environment o campo do objeto para um RunConfiguration Environment objeto. É da sua responsabilidade assegurar que tal um Environment tem as suas dependências em pacotes externos python devidamente definidos.

Ver resultados de um oleoduto

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

  1. Inscreva-se no Azure Machine Learning estúdio.

  2. Veja o seu espaço de trabalho.

  3. À esquerda, selecione Pipelines para ver todos os seus gasodutos. lista de oleodutos de aprendizagem automática

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

Rastreio e integração de Git

Quando se inicia uma corrida de treinamento onde o diretório de origem é um repositório local de Git, a informação sobre o repositório é armazenada na história da execução. Para mais informações, consulte a integração de Git para Azure Machine Learning.

Passos seguintes