Criar componentes

Os componentes permitem criar scripts reutilizáveis que podem ser facilmente compartilhados entre usuários no mesmo espaço de trabalho do Azure Machine Learning. Você também pode usar componentes para criar um pipeline do Azure Machine Learning.

Usar um componente

Há duas razões principais pelas quais você usaria componentes:

• Para construir uma cadeia de processamento.
• Para partilhar código pronto a utilizar.

Crie componentes ao preparar código experimental para fluxos de trabalho de produção reproduzíveis.

No Azure Machine Learning, você pode criar um componente para armazenar código (em seu idioma preferido) no espaço de trabalho. Idealmente, você projeta um componente para executar uma ação específica que seja relevante para seu fluxo de trabalho de aprendizado de máquina.

Por exemplo, um componente pode consistir em um script Python que normaliza seus dados, treina um modelo de aprendizado de máquina ou avalia um modelo.

Os componentes podem ser facilmente compartilhados com outros usuários do Azure Machine Learning, que podem reutilizar componentes em seus próprios pipelines do Azure Machine Learning.

Criar um componente

Um componente consiste em três partes:

• Metadados: Inclui o nome do componente, versão, etc.
• Interface: Inclui os parâmetros de entrada esperados (como um conjunto de dados ou hiperparâmetro) e a saída esperada (como métricas e artefatos).
• Comando, código e ambiente: Especifica como executar o código.

Para criar um componente, você precisa de dois arquivos:

• Um script que contém o fluxo de trabalho que você deseja executar.
• Um arquivo YAML para definir os metadados, interface e comando, código e ambiente do componente.

Você pode criar o arquivo YAML ou usar a command_component() função como decorador para criar o arquivo YAML.

Por exemplo, você pode ter um script prep.py Python que prepara os dados removendo valores ausentes e normalizando os dados:

# import libraries
import argparse
import pandas as pd
import numpy as np
from pathlib import Path
from sklearn.preprocessing import MinMaxScaler

# setup arg parser
parser = argparse.ArgumentParser()

# add arguments
parser.add_argument("--input_data", dest='input_data',
                    type=str)
parser.add_argument("--output_data", dest='output_data',
                    type=str)

# parse args
args = parser.parse_args()

# read the data
df = pd.read_csv(args.input_data)

# remove missing values
df = df.dropna()

# normalize the data    
scaler = MinMaxScaler()
num_cols = ['feature1','feature2','feature3','feature4']
df[num_cols] = scaler.fit_transform(df[num_cols])

# save the data as a csv
output_df = df.to_csv(
    (Path(args.output_data) / "prepped-data.csv"), 
    index = False
)

Para criar um componente para o prep.py script, defina um ficheiro YAML chamado prep.yml:

$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
name: prep_data
display_name: Prepare training data
version: 1
type: command
inputs:
  input_data: 
    type: uri_file
outputs:
  output_data:
    type: uri_file
code: ./src
environment: azureml:AzureML-sklearn-0.24-ubuntu18.04-py37-cpu@latest
command: >-
  python prep.py 
  --input_data ${{inputs.input_data}}
  --output_data ${{outputs.output_data}}

Observe que o arquivo YAML refere-se ao prep.py script, que é armazenado na src pasta. Você pode carregar o componente com o seguinte código:

from azure.ai.ml import load_component
parent_dir = ""

loaded_component_prep = load_component(source=parent_dir + "./prep.yml")

Depois de carregar o componente, você pode usá-lo em um pipeline ou registrar o componente.

Registrar um componente

Para usar um componente local num pipeline, mantenha o script e a definição YAML juntos. Para tornar o componente acessível a outros utilizadores do espaço de trabalho, registe-o no espaço de trabalho do Azure Machine Learning.

Você pode registrar um componente com o seguinte código:

prep = ml_client.components.create_or_update(loaded_component_prep)