Criar e executar pipelines de machine learning usando componentes com o SDK do Machine Learning v2

APLICA-SE A: SDK do Python azure-ai-ml v2 (versão 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 do Machine Learning otimizam seu fluxo de trabalho com velocidade, portabilidade e reutilização, para que você possa se concentrar no machine learning em vez de infraestrutura e automação.

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

Neste artigo, você concluirá as seguintes tarefas:

• Preparar 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 uma linha de montagem a partir dos componentes.
• Obtenha acesso a um espaço de trabalho que tenha recursos de processamento.
• Envie o trabalho de pipeline.
• Revise a saída dos componentes e da rede neural treinada.
• (Opcional) Registre o componente para reutilizar e compartilhar ainda mais dentro do workspace.

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

Pré-requisitos

• Um espaço 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 runtime 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 do Python do Azure Machine Learning para criar e controlar um pipeline do Azure Machine Learning. O artigo é escrito com base na suposição de que você executará os snippets de código interativamente em um ambiente de REPL do Python ou em um Jupyter Notebook.

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

Importe as 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 o trabalho de pipeline

É necessário preparar os dados de entrada para o pipeline 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 de 28 por 28. Há 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 banco de dados de dígito manuscrito clássico do MNIST. Ele é distribuído no mesmo formato binário compactado que o banco de dados de dígito manuscrito original.

Ao definir um Input, você criará uma referência ao local da fonte de dados. Os dados permanecem na localização existente, portanto, nenhum custo de armazenamento extra é gerado.

Criar componentes para construir o 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 é um código independente que conclui uma etapa em um pipeline de machine learning. Neste artigo, você criará três componentes para a tarefa de classificação de imagem:

• Prepare os dados para treinamento e teste-os.
• Treine uma rede neural para classificação de imagem usando dados de treinamento.
• Pontuar o modelo usando 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 runtime 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 nesse 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á estarã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 runtime do componente.

Definir componente usando uma função python

Usando a command_component() função como decorador, você pode definir facilmente a interface do componente, seus metadados e o código a ser executado a partir de uma função python. Cada função do Python decorada será transformada em uma única especificação estática (YAML) que o serviço de pipeline poderá 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 o 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 interface do usuário. Não é exclusivo.

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

• environment especifica o ambiente de runtime do componente. O ambiente desse 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 função prepare_data_component define uma entrada para input_data e duas saídas para training_data e test_data. input_data é o caminho de 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 em um training_data .csv para treinar dados e em um test_data .csv para testar dados.

É assim que um componente aparece na interface do usuário do Studio:

• 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 de modelo de treinamento

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 train desse componente estão na 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á em train.py.
• conda.yaml define o ambiente de runtime do componente.

Obter um script que contenha 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 exibir 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 em 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 o nome Train Image Classification Keras de exibição usando @command_component.

• A keras_train_component função define uma entrada, input_datapara 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_modelque especifica o caminho de saída para o arquivo de modelo. O valor padrão de epochs é 10. A lógica desse componente é da train() função em train.py.

O componente de modelo de treinamento tem uma configuração um pouco mais complexa do que o componente de dados de preparação. O conda.yaml tem esta aparência:

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ê criará 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á estarã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 runtime do componente.

Obter um script que contenha 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 recebe três argumentos de linha de comando: input_data, input_model, e output_result. O programa pontua o modelo de entrada usando dados de entrada e, em seguida, gera o resultado.

Definir o componente por meio do YAML

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

• Metadados. Nome, nome de 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. O nome de exibição é Score Image Classification Keras.
• Este componente tem duas entradas e uma saída.
• O caminho do código-fonte é definido na code seção. Quando o componente for executado na nuvem, todos os arquivos desse caminho serão carregados como o 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.

Carregar os componentes para criar um pipeline

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

O código a seguir importa as funções prepare_data_component() e keras_train_component() do arquivo prep_component.py na pasta prep e do arquivo 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 por YAML.

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

Compilar o pipeline

Você criou e carregou todos os componentes e os dados de entrada necessários para construir o pipeline. Agora é possível compô-los em um pipeline:

Observação

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 uma computação padrão cpu_compute_target. Se você não especificar a computação para um nó específico, esse nó será executado na computação padrão.

O pipeline tem uma entrada de nível de pipeline, pipeline_input_data. É possível atribuir um valor à entrada do 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 é output_model de train_node.

• Como train_node treina um modelo CNN, você pode especificar sua computação como o gpu_compute_target. Isso pode melhorar o desempenho do treinamento.

Enviar o trabalho de pipeline

Agora que você construiu o pipeline, pode enviar o trabalho para o espaço de trabalho. Para enviar um trabalho, primeiro você precisa se conectar a um workspace.

Obter acesso ao workspace

Configurar credenciais

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

Se DefaultAzureCredential não funcionar para você, veja este exemplo de configuração de credenciais e o pacote identity.

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 a 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 no diretório pai. Para obter mais informações sobre como criar um workspace, consulte Criar recursos de workspace. Para obter mais informações sobre como salvar a configuração em um arquivo, consulte Criar um arquivo de configuração do workspace.

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

Agora que você tem um identificador para o espaço de trabalho, você poderá enviar o 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 usa fashion_ds.

A chamada para enviar o experimento é concluída rapidamente. Ele produz uma saída semelhante a esta:

Experimento	Nome	Tipo	Situação	Página de detalhes
pipeline_samples	sharp_pipe_4gvqx6h1fb	linha de produção	Preparando	Link para o estúdio do Azure Machine Learning

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 de 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 serem criados. No entanto, o tempo de execução total do pipeline depende da carga de trabalho de seus scripts e dos processos executados em cada etapa de pipeline.

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

Você poderá selecionar Link to Azure Machine Learning studio, que é a página de detalhes do trabalho do pipeline. Você visualizará o grafo de pipeline:

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

(Opcional) Registrar componentes na área 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 workspace para que eles possam ser compartilhados e reutilizados no workspace. 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óximas etapas

• Para obter mais exemplos de como criar pipelines usando o SDK de machine learning, 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 machine learning 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 machine learning usando componentes com a CLI do Azure Machine Learning.
• Para obter informações sobre como implantar pipelines em produção usando pontos de extremidade em lotes, consulte Como implantar pipelines com pontos de extremidade em lote.