Criar e executar pipelines de aprendizado de máquina usando componentes com o SDK de aprendizado de máquina v2

APLICA-SE A:Python SDK azure-ai-ml v2 (atual)

Neste artigo, você aprenderá a criar um pipeline do Azure Machine Learning usando o SDK do Python do Azure Machine Learning v2 para concluir uma tarefa de classificação de imagem que contém três etapas: preparar dados, treinar um modelo de classificação de imagem e pontuar o modelo. Os pipelines de Machine Learning otimizam seu fluxo de trabalho com velocidade, portabilidade e reutilização, para que você possa se concentrar no aprendizado de máquina em vez de infraestrutura e automação.

O exemplo de pipeline treina uma rede neuronal convolucional pequena Keras para classificar imagens no conjunto de dados Fashion MNIST. O pipeline tem esta aparência:

Neste artigo, você conclui as seguintes tarefas:

• Prepare os dados de entrada para o trabalho de pipeline.
• Crie três componentes para preparar os dados, treinar uma imagem e pontuar o modelo.
• Crie um pipeline a partir dos componentes.
• Obtenha acesso a um espaço de trabalho com computação.
• Envie o trabalho de pipeline.
• Analise a saída dos componentes e a rede neural treinada.
• (Opcional) Registre o componente para reutilização e compartilhamento adicionais no espaço de trabalho.

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

Pré-requisitos

• Uma área de trabalho do Azure Machine Learning. Se você não tiver um, conclua o tutorial Criar recursos.

• Um ambiente Python no qual você instalou o SDK do Python do Azure Machine Learning v2. Para obter instruções de instalação, consulte Introdução. Esse ambiente serve para definir e controlar seus recursos do Azure Machine Learning e é separado do ambiente usado em tempo de execução para treinamento.

• Um clone do repositório de exemplos.

  Para executar os exemplos de treinamento, primeiro clone o repositório de exemplos e vá para o sdk diretório:

  git clone --depth 1 https://github.com/Azure/azureml-examples
  cd azureml-examples/sdk
  

Iniciar uma sessão interativa do Python

Este artigo usa o SDK Python do Azure Machine Learning para criar e controlar um pipeline do Azure Machine Learning. O artigo foi escrito com base na suposição de que você executará os trechos de código interativamente em um ambiente Python REPL ou em um notebook Jupyter.

Este artigo é baseado no notebook image_classification_keras_minist_convnet.ipynb, que podes encontrar no diretório sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet do repositório de exemplos do Azure Machine Learning.

Importar bibliotecas necessárias

Importe todas as bibliotecas do Azure Machine Learning necessárias para este artigo:

# import required libraries
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

from azure.ai.ml import MLClient
from azure.ai.ml.dsl import pipeline
from azure.ai.ml import load_component

Preparar dados de entrada para seu trabalho de pipeline

Precisa preparar os dados de entrada para o processo de classificação de imagem.

Fashion MNIST é um conjunto de dados de imagens de moda que é dividido em 10 classes. Cada imagem é uma imagem em tons de cinza com dimensões de 28 x 28. Existem 60.000 imagens de treinamento e 10.000 imagens de teste. Como um problema de classificação de imagem, o Fashion MNIST é mais desafiador do que o clássico banco de dados de dígitos manuscritos MNIST. É distribuído na mesma forma binária compactada que o banco de dados de dígitos manuscritos original.

Ao definir um Input, você cria uma referência ao local da fonte de dados. Os dados permanecem em sua localização existente, portanto, nenhum custo de armazenamento extra é incorrido.

Criar componentes para a construção do pipeline

A tarefa de classificação de imagem pode ser dividida em três etapas: preparar dados, treinar o modelo e pontuar o modelo.

Um componente do Azure Machine Learning é uma parte de código independente que conclui uma etapa em um pipeline de aprendizado de máquina. Neste artigo, você cria três componentes para a tarefa de classificação de imagem:

• Prepare dados para treinamento e teste-os.
• Treine uma rede neural para classificação de imagens usando dados de treinamento.
• Avaliar o modelo com dados de teste.

Para cada componente, você precisa concluir estas etapas:

1. Prepare o script Python que contém a lógica de execução.

2. Defina a interface do componente.

3. Adicione outros metadados do componente, incluindo o ambiente de tempo de execução e o comando para executar o componente.

A próxima seção mostra como criar os componentes de duas maneiras. Para os dois primeiros componentes, você usa uma função Python. Para o terceiro componente, você usa a definição YAML.

Criar o componente de preparação de dados

O primeiro componente deste pipeline converte os arquivos de dados compactados de fashion_ds em dois arquivos .csv, um para treinamento e outro para avaliação. Você usa uma função Python para definir esse componente.

Se você estiver acompanhando o exemplo no repositório de exemplos do Azure Machine Learning, os arquivos de origem já estão disponíveis na prep pasta. Esta pasta contém dois arquivos para construir o componente: prep_component.py, que define o componente e conda.yaml, que define o ambiente de tempo de execução do componente.

Definir componente usando uma função Python

Usando a command_component() função como decorador, você pode facilmente definir a interface do componente, seus metadados e o código a ser executado a partir de uma função Python. Cada função Python decorada será transformada em uma única especificação estática (YAML) que o serviço de pipeline pode processar.

# Converts MNIST-formatted files at the passed-in input path to training data output path and test data output path
import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="prep_data",
    version="1",
    display_name="Prep Data",
    description="Convert data to CSV file, and split to training and test data",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def prepare_data_component(
    input_data: Input(type="uri_folder"),
    training_data: Output(type="uri_folder"),
    test_data: Output(type="uri_folder"),
):
    convert(
        os.path.join(input_data, "train-images-idx3-ubyte"),
        os.path.join(input_data, "train-labels-idx1-ubyte"),
        os.path.join(training_data, "mnist_train.csv"),
        60000,
    )
    convert(
        os.path.join(input_data, "t10k-images-idx3-ubyte"),
        os.path.join(input_data, "t10k-labels-idx1-ubyte"),
        os.path.join(test_data, "mnist_test.csv"),
        10000,
    )


def convert(imgf, labelf, outf, n):
    f = open(imgf, "rb")
    l = open(labelf, "rb")
    o = open(outf, "w")

    f.read(16)
    l.read(8)
    images = []

    for i in range(n):
        image = [ord(l.read(1))]
        for j in range(28 * 28):
            image.append(ord(f.read(1)))
        images.append(image)

    for image in images:
        o.write(",".join(str(pix) for pix in image) + "\n")
    f.close()
    o.close()
    l.close()

O código anterior define um componente com nome Prep Data de exibição usando o @command_component decorador:

• name é o identificador exclusivo do componente.

• version é a versão atual do componente. Um componente pode ter várias versões.

• display_name é um nome de exibição amigável do componente para a interface do usuário. Não é único.

• description geralmente descreve a tarefa que o componente pode concluir.

• environment Especifica o ambiente de tempo de execução para o componente. O ambiente deste componente especifica uma imagem do Docker e refere-se ao conda.yaml arquivo.

  O conda.yaml arquivo contém todos os pacotes usados para o componente:

  name: imagekeras_prep_conda_env
  channels:
    - defaults
  dependencies:
    - python=3.7.11
    - pip=20.0
    - pip:
      - mldesigner==0.1.0b4
  

• A prepare_data_component função define uma entrada para input_data e duas saídas para training_data e test_data. input_data é o caminho dos dados de entrada. training_data e test_data são caminhos de dados de saída para dados de treinamento e dados de teste.

• O componente converte os dados de input_data num training_data .csv para dados de treino e num test_data .csv para dados de teste.

Esta é a aparência de um componente na interface do estúdio.

• Um componente é um bloco em um gráfico de pipeline.
• input_data, training_datae test_data são portas do componente, que se conectam a outros componentes para streaming de dados.

Agora você preparou todos os arquivos de origem para o Prep Data componente.

Criar o componente para treino do modelo

Nesta seção, você criará um componente para treinar o modelo de classificação de imagem em uma função Python, como fez com o Prep Data componente.

Como a lógica de treinamento é mais complicada, você colocará o código de treinamento em um arquivo Python separado.

Os arquivos de origem desse componente estão na train pasta no repositório de exemplos do Azure Machine Learning. Esta pasta contém três arquivos para construir o componente:

• train.py Contém a lógica para treinar o modelo.
• train_component.py define a interface do componente e importa a função que está no train.py.
• conda.yaml Define o ambiente de tempo de execução do componente.

Obter um script que contém a lógica

O train.py arquivo contém uma função Python normal que executa a lógica para treinar uma rede neural Keras para classificação de imagem. Para visualizar o código, consulte o arquivo train.py no GitHub.

Definir o componente usando uma função Python

Depois de definir a função de treinamento, você pode usar @command_component no SDK do Azure Machine Learning v2 para encapsular sua função como um componente que pode ser usado nos pipelines do Azure Machine Learning:

import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="train_image_classification_keras",
    version="1",
    display_name="Train Image Classification Keras",
    description="train image classification with keras",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def keras_train_component(
    input_data: Input(type="uri_folder"),
    output_model: Output(type="uri_folder"),
    epochs=10,
):
    # avoid dependency issue, execution logic is in train() func in train.py file
    from train import train

    train(input_data, output_model, epochs)

O código anterior define um componente que tem nome Train Image Classification Keras para exibição usando @command_component.

• A keras_train_component função define uma entrada, input_data, para dados de treinamento de origem, uma entrada, epochsque especifica o número de épocas a serem usadas durante o treinamento, e uma saída, output_model, que especifica o caminho de saída para o arquivo de modelo. O valor padrão de epochs é 10. A lógica deste componente vem da função train() em train.py.

O componente de modelo de trem tem uma configuração um pouco mais complexa do que o componente de preparação de dados. O conda.yaml parece-se com isto:

name: imagekeras_train_conda_env
channels:
  - defaults
dependencies:
  - python=3.8
  - pip=20.2
  - pip:
    - mldesigner==0.1.0b12
    - azureml-mlflow==1.50.0
    - tensorflow==2.7.0
    - numpy==1.21.4
    - scikit-learn==1.0.1
    - pandas==1.3.4
    - matplotlib==3.2.2
    - protobuf==3.20.0

Agora você preparou todos os arquivos de origem para o Train Image Classification Keras componente.

Criar o componente de pontuação do modelo

Nesta seção, você cria um componente para pontuar o modelo treinado por meio da especificação e do script YAML.

Se você estiver acompanhando o exemplo no repositório de exemplos do Azure Machine Learning, os arquivos de origem já estão disponíveis na score pasta. Esta pasta contém três arquivos para construir o componente:

• score.py Contém o código-fonte do componente.
• score.yaml define a interface e outros detalhes do componente.
• conda.yaml Define o ambiente de tempo de execução do componente.

Obter um script que contém a lógica

O score.py arquivo contém uma função Python normal que executa a lógica do modelo de treinamento:

from tensorflow import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.utils import to_categorical
from keras.callbacks import Callback
from keras.models import load_model

import argparse
from pathlib import Path
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import mlflow


def get_file(f):

    f = Path(f)
    if f.is_file():
        return f
    else:
        files = list(f.iterdir())
        if len(files) == 1:
            return files[0]
        else:
            raise Exception("********This path contains more than one file*******")


def parse_args():
    # setup argparse
    parser = argparse.ArgumentParser()

    # add arguments
    parser.add_argument(
        "--input_data", type=str, help="path containing data for scoring"
    )
    parser.add_argument(
        "--input_model", type=str, default="./", help="input path for model"
    )

    parser.add_argument(
        "--output_result", type=str, default="./", help="output path for model"
    )

    # parse args
    args = parser.parse_args()

    # return args
    return args


def score(input_data, input_model, output_result):

    test_file = get_file(input_data)
    data_test = pd.read_csv(test_file, header=None)

    img_rows, img_cols = 28, 28
    input_shape = (img_rows, img_cols, 1)

    # Read test data
    X_test = np.array(data_test.iloc[:, 1:])
    y_test = to_categorical(np.array(data_test.iloc[:, 0]))
    X_test = (
        X_test.reshape(X_test.shape[0], img_rows, img_cols, 1).astype("float32") / 255
    )

    # Load model
    files = [f for f in os.listdir(input_model) if f.endswith(".h5")]
    model = load_model(input_model + "/" + files[0])

    # Log metrics of the model
    eval = model.evaluate(X_test, y_test, verbose=0)

    mlflow.log_metric("Final test loss", eval[0])
    print("Test loss:", eval[0])

    mlflow.log_metric("Final test accuracy", eval[1])
    print("Test accuracy:", eval[1])

    # Score model using test data
    y_predict = model.predict(X_test)
    y_result = np.argmax(y_predict, axis=1)

    # Output result
    np.savetxt(output_result + "/predict_result.csv", y_result, delimiter=",")


def main(args):
    score(args.input_data, args.input_model, args.output_result)


# run script
if __name__ == "__main__":
    # parse args
    args = parse_args()

    # call main function
    main(args)

O código em score.py usa três argumentos de linha de comando: input_data, input_modele output_result. O programa pontua o modelo de entrada usando dados de entrada e, em seguida, produz o resultado.

Definir o componente via YAML

Nesta seção, você aprenderá como criar uma especificação de componente no formato de especificação de componente YAML válido. Este ficheiro especifica as seguintes informações:

• Metadados. Nome, nome para exibição, versão, tipo e assim por diante.
• Interface. Entradas e saídas.
• Comando, código e ambiente. O comando, o código e o ambiente usados para executar o componente.

$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
type: command

name: score_image_classification_keras
display_name: Score Image Classification Keras
inputs:
  input_data: 
    type: uri_folder
  input_model:
    type: uri_folder
outputs:
  output_result:
    type: uri_folder
code: ./
command: python score.py --input_data ${{inputs.input_data}} --input_model ${{inputs.input_model}} --output_result ${{outputs.output_result}}
environment:
  conda_file: ./conda.yaml
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04

• name é o identificador exclusivo do componente. Seu nome de exibição é Score Image Classification Keras.
• Este componente tem duas entradas e uma saída.
• O caminho do código-fonte code é definido na seção. Quando o componente é executado na nuvem, todos os ficheiros desse caminho serão carregados como um instantâneo do componente.
• A command seção especifica o comando a ser executado quando o componente é executado.
• A environment seção contém uma imagem do Docker e um arquivo YAML conda. O arquivo de origem está no repositório de exemplo.

Agora você tem todos os arquivos de origem para o componente de pontuação do modelo.

Carregue os componentes para construir um circuito

Você pode importar o componente de preparação de dados e o componente de treinamento de modelo, que são definidos por funções Python, assim como funções Python normais.

O código a seguir importa as funções prepare_data_component() e keras_train_component() do ficheiro prep_component.py na pasta prep e do ficheiro train_component na pasta train, respectivamente.

%load_ext autoreload
%autoreload 2

# load component function from component python file
from prep.prep_component import prepare_data_component
from train.train_component import keras_train_component

# print hint of components
help(prepare_data_component)
help(keras_train_component)

Você pode usar a load_component() função para carregar o componente de pontuação, que é definido pelo YAML.

# load component function from yaml
keras_score_component = load_component(source="./score/score.yaml")

Construa seu pipeline

Você criou e carregou todos os componentes e dados de entrada para construir o pipeline. Agora podes compô-los num pipeline:

Nota

Para usar a computação sem servidor, adicione from azure.ai.ml.entities import ResourceConfiguration à parte superior do arquivo. Em seguida, substitua:

• default_compute=cpu_compute_target com default_compute="serverless".
• train_node.compute = gpu_compute_target com train_node.resources = "ResourceConfiguration(instance_type="Standard_NC6s_v3",instance_count=2).

# define a pipeline containing 3 nodes: Prepare data node, train node, and score node
@pipeline(
    default_compute=cpu_compute_target,
)
def image_classification_keras_minist_convnet(pipeline_input_data):
    """E2E image classification pipeline with keras using python sdk."""
    prepare_data_node = prepare_data_component(input_data=pipeline_input_data)

    train_node = keras_train_component(
        input_data=prepare_data_node.outputs.training_data
    )
    train_node.compute = gpu_compute_target

    score_node = keras_score_component(
        input_data=prepare_data_node.outputs.test_data,
        input_model=train_node.outputs.output_model,
    )


# create a pipeline
pipeline_job = image_classification_keras_minist_convnet(pipeline_input_data=mnist_ds)

O pipeline tem um recurso de computação cpu_compute_target padrão. Se você não especificar computação para um nó específico, esse nó será executado na computação padrão.

O pipeline tem uma entrada no nível do pipeline, pipeline_input_data. Você pode atribuir um valor à entrada de pipeline ao enviar um trabalho de pipeline.

O pipeline contém três nós: prepare_data_node, train_nodee score_node.

• O input_data de prepare_data_node usa o valor de pipeline_input_data.

• O input_data de train_node é a training_data saída de prepare_data_node.

• O input_data de score_node é a test_data saída de prepare_data_node, e o input_model é o output_model de train_node.

• Como train_node treina um modelo CNN, você pode especificar seu cálculo como o gpu_compute_target. Fazê-lo pode melhorar o desempenho do treino.

Envie seu trabalho de pipeline

Agora que construíste o pipeline, podes enviar a tarefa para o teu espaço de trabalho. Para enviar um trabalho, primeiro você precisa se conectar a um espaço de trabalho.

Obtenha acesso ao seu espaço de trabalho

Configurar credenciais

Você usará DefaultAzureCredential para obter acesso ao espaço de trabalho. DefaultAzureCredential deve ser capaz de lidar com a maioria dos cenários de autenticação do SDK do Azure.

Se DefaultAzureCredential não funcionar para você, consulte este exemplo de credencial de configuração e pacote de identidade.

try:
    credential = DefaultAzureCredential()
    # Check if given credential can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential not work
    credential = InteractiveBrowserCredential()

Obter um identificador para um espaço de trabalho que tenha computação

Crie um MLClient objeto para gerenciar os serviços do Azure Machine Learning. Se você usar computação sem servidor, não precisará criar esses cálculos.

# Get a handle to workspace
ml_client = MLClient.from_config(credential=credential)

# Retrieve an already attached Azure Machine Learning Compute.
cpu_compute_target = "cpu-cluster"
print(ml_client.compute.get(cpu_compute_target))
gpu_compute_target = "gpu-cluster"
print(ml_client.compute.get(gpu_compute_target))

Importante

Este trecho de código espera que o arquivo JSON de configuração do espaço de trabalho seja salvo no diretório atual ou em seu pai. Para obter mais informações sobre como criar um espaço de trabalho, consulte Criar recursos do espaço de trabalho. Para obter mais informações sobre como salvar a configuração em um arquivo, consulte Criar um arquivo de configuração de espaço de trabalho.

Enviar o trabalho de pipeline para o espaço de trabalho

Agora que você tem um identificador para seu espaço de trabalho, você pode enviar seu trabalho de pipeline:

pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="pipeline_samples"
)
pipeline_job

O código anterior envia esse trabalho de pipeline de classificação de imagem para um experimento chamado pipeline_samples. Ele cria automaticamente o experimento se ele não existir. pipeline_input_data utiliza fashion_ds.

A chamada para submeter a experiência é finalizada rapidamente. Produz resultados semelhantes a este:

Experimentação	Nome	Tipo	Situação	Página Detalhes
pipeline_samples	sharp_pipe_4gvqx6h1fb	gasoduto	Preparação	Link para o estúdio de Aprendizado de Máquina do Azure.

Você pode monitorar a execução do pipeline selecionando o link. Ou você pode bloqueá-lo até que ele seja concluído executando este código:

# wait until the job completes
ml_client.jobs.stream(pipeline_job.name)

Importante

A primeira execução do pipeline leva cerca de 15 minutos. Todas as dependências são baixadas, uma imagem do Docker é criada e o ambiente Python é provisionado e criado. Executar o pipeline novamente leva significativamente menos tempo porque esses recursos são reutilizados em vez de criados. No entanto, o tempo de execução total do pipeline depende da carga de trabalho dos scripts e dos processos executados em cada etapa do pipeline.

Verifique as saídas e depure seu pipeline na interface do usuário

Você pode selecionar o Link to Azure Machine Learning studio, que é a página de detalhes da tarefa do seu pipeline. Verá o diagrama de pipeline:

Você pode verificar os logs e saídas de cada componente clicando com o botão direito do mouse no componente ou selecionando o componente para abrir seu painel de detalhes. Para saber mais sobre como depurar seu pipeline na interface do usuário, consulte Usar o estúdio de Aprendizado de Máquina do Azure para depurar falhas de pipeline.

(Opcional) Registrar componentes no espaço de trabalho

Na seção anterior, você criou um pipeline usando três componentes para concluir uma tarefa de classificação de imagem. Você também pode registrar componentes em seu espaço de trabalho para que eles possam ser compartilhados e reutilizados dentro do espaço de trabalho. O exemplo a seguir mostra como registrar o componente de preparação de dados:

try:
    # try get back the component
    prep = ml_client.components.get(name="prep_data", version="1")
except:
    # if not exists, register component using following code
    prep = ml_client.components.create_or_update(prepare_data_component)

# list all components registered in workspace
for c in ml_client.components.list():
    print(c)

Você pode usar ml_client.components.get() para obter um componente registrado por nome e versão. Você pode usar ml_client.components.create_or_update() para registrar um componente que foi carregado anteriormente de uma função Python ou YAML.

Próximos passos

• Para obter mais exemplos de como criar pipelines usando o SDK de aprendizado de máquina, consulte o repositório de exemplo.
• Para obter informações sobre como usar a interface do usuário do estúdio para enviar e depurar um pipeline, consulte Criar e executar pipelines de aprendizado de máquina usando componentes com o estúdio do Azure Machine Learning.
• Para obter informações sobre como usar a CLI do Azure Machine Learning para criar componentes e pipelines, consulte Criar e executar pipelines de aprendizado de máquina usando componentes com a CLI do Azure Machine Learning.
• Para obter informações sobre como implantar pipelines na produção usando pontos de extremidade em lote, consulte Como implantar pipelines com pontos de extremidade em lote.