Criar e executar pipelines de aprendizado de máquina usando componentes com a CLI do Azure Machine Learning

APLICA-SE A: Azure CLI ml extension v2 (atual)

Neste artigo, você aprenderá a criar e executar pipelines de aprendizado de máquina usando a CLI e os componentes do Azure. Você pode criar pipelines sem usar componentes, mas os componentes fornecem flexibilidade e permitem a reutilização. Os pipelines do Azure Machine Learning podem ser definidos em YAML e executados a partir da CLI, criados em Python ou compostos no Azure Machine Learning studio Designer por meio de uma interface do usuário de arrastar e soltar. Este artigo se concentra na CLI.

Pré-requisitos

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

• Um espaço de trabalho do Azure Machine Learning.

• A extensão da CLI do Azure para Machine Learning, instalada e configurada.

• Um clone do repositório de exemplos. Você pode usar estes comandos para clonar o repositório:

  git clone https://github.com/Azure/azureml-examples --depth 1
  cd azureml-examples/cli/jobs/pipelines-with-components/basics
  

Pré-leitura sugerida

• O que são os pipelines do Azure Machine Learning?
• O que é um componente do Azure Machine Learning?

Crie o seu primeiro pipeline com componentes

Primeiro, você criará um pipeline com componentes usando um exemplo. Isso oferece uma impressão inicial da aparência de um pipeline e de um componente no Aprendizado de Máquina do Azure.

No diretório cli/jobs/pipelines-with-components/basics do repositório azureml-examples, vá para o subdiretório 3b_pipeline_with_data. Há três tipos de arquivos neste diretório. Esses são os arquivos que você precisa criar ao criar seu próprio pipeline.

• pipeline.yml. Este arquivo YAML define o pipeline de aprendizado de máquina. Ele descreve como dividir uma tarefa completa de aprendizado de máquina em um fluxo de trabalho de várias etapas. Por exemplo, considere a tarefa simples de aprendizado de máquina de usar dados históricos para treinar um modelo de previsão de vendas. Talvez você queira criar um fluxo de trabalho sequencial que contenha processamento de dados, treinamento de modelo e etapas de avaliação de modelo. Cada etapa é um componente que tem uma interface bem definida e pode ser desenvolvida, testada e otimizada de forma independente. O pipeline YAML também define como as etapas filhas se conectam a outras etapas na pipeline. Por exemplo, a etapa de treinamento do modelo gera um arquivo de modelo e o arquivo de modelo é passado para uma etapa de avaliação do modelo.

• component.yml. Esses arquivos YAML definem os componentes. Contêm as seguintes informações:

  • Metadados: Nome, nome para exibição, versão, descrição, tipo e assim por diante. Os metadados ajudam a descrever e gerenciar o componente.
  • Interface: Entradas e saídas. Por exemplo, um componente de treinamento de modelo usa dados de treinamento e número de épocas como entrada e gera um arquivo de modelo treinado como saída. Depois que a interface é definida, diferentes equipes podem desenvolver e testar o componente de forma independente.
  • Comando, código e ambiente: O comando, o código e o ambiente para executar o componente. O comando é o comando shell para executar o componente. O código geralmente se refere a um diretório de código-fonte. O ambiente pode ser um ambiente do Azure Machine Learning (curado ou criado pelo cliente), uma imagem do Docker ou um ambiente de conda.

• component_src. Estes são os diretórios de código-fonte para componentes específicos. Eles contêm o código-fonte que é executado no componente. Você pode usar sua linguagem preferida, incluindo Python, R e outros. O código deve ser executado por um comando shell. O código-fonte pode receber algumas entradas da linha de comando do shell para controlar como essa etapa é executada. Por exemplo, uma etapa de treinamento pode usar dados de treinamento, taxa de aprendizado e o número de épocas para controlar o processo de treinamento. O argumento de um comando shell é usado para passar entradas e saídas para o código.

Agora você criará um pipeline usando o 3b_pipeline_with_data exemplo. Cada ficheiro é explicado mais pormenorizadamente nas secções seguintes.

Primeiro, liste seus recursos de computação disponíveis usando o seguinte comando:

az ml compute list

Se você não o tiver, crie um cluster chamado cpu-cluster executando este comando:

az ml compute create -n cpu-cluster --type amlcompute --min-instances 0 --max-instances 10

Agora, crie um trabalho de pipeline definido no arquivo pipeline.yml executando o seguinte comando. O destino de computação é referenciado no arquivo pipeline.yml como azureml:cpu-cluster. Se o destino de computação usar um nome diferente, lembre-se de atualizá-lo no arquivo pipeline.yml.

az ml job create --file pipeline.yml

Você deverá receber um dicionário JSON com informações sobre a tarefa de pipeline, incluindo:

Vá para o services.Studio.endpoint URL para ver uma visualização do pipeline:

Compreender a definição de pipeline YAML

Agora você examinará a definição de pipeline no arquivo 3b_pipeline_with_data/pipeline.yml .

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

display_name: 3b_pipeline_with_data
description: Pipeline with 3 component jobs with data dependencies

settings:
  default_compute: azureml:cpu-cluster

outputs:
  final_pipeline_output:
    mode: rw_mount

jobs:
  component_a:
    type: command
    component: ./componentA.yml
    inputs:
      component_a_input: 
        type: uri_folder
        path: ./data

    outputs:
      component_a_output: 
        mode: rw_mount
  component_b:
    type: command
    component: ./componentB.yml
    inputs:
      component_b_input: ${{parent.jobs.component_a.outputs.component_a_output}}
    outputs:
      component_b_output: 
        mode: rw_mount
  component_c:
    type: command
    component: ./componentC.yml
    inputs:
      component_c_input: ${{parent.jobs.component_b.outputs.component_b_output}}
    outputs:
      component_c_output: ${{parent.outputs.final_pipeline_output}}
      #  mode: upload

A tabela a seguir descreve os campos mais comumente usados do esquema YAML do pipeline. Para saber mais, consulte o esquema YAML de pipeline completo.

O exemplo 3b_pipeline_with_data contém um pipeline de três etapas.

• As três etapas são definidas em jobs. Todas as três etapas são do tipo command. A definição de cada etapa está em um arquivo correspondente component*.yml . Você pode ver os arquivos YAML componente no diretório 3b_pipeline_with_data . componentA.yml é descrito na próxima seção.
• Esse pipeline tem dependência de dados, o que é comum em pipelines do mundo real. O componente A recebe a entrada de dados de uma pasta local em ./data (linhas 18-21) e passa sua saída para o componente B (linha 29). A saída do componente A pode ser referenciada como ${{parent.jobs.component_a.outputs.component_a_output}}.
• default_compute Define a computação padrão para o pipeline. Se um componente em jobs define uma computação diferente, as configurações específicas do componente são respeitadas.

Ler e gravar dados em um pipeline

Um cenário comum é ler e escrever dados num pipeline. No Aprendizado de Máquina do Azure, você usa o mesmo esquema para ler e gravar dados para todos os tipos de trabalhos (trabalhos de pipeline, trabalhos de comando e trabalhos de varredura). A seguir estão exemplos de uso de dados em pipelines para cenários comuns:

• Dados locais
• Ficheiro Web com um URL público
• Caminho e armazenamento de dados do Azure Machine Learning
• Ativo de dados do Azure Machine Learning

Compreender a definição de componente YAML

Aqui está o arquivo componentA.yml , um exemplo de YAML que define um componente:

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

name: component_a
display_name: componentA
version: 1

inputs:
  component_a_input:
    type: uri_folder

outputs:
  component_a_output:
    type: uri_folder

code: ./componentA_src

environment: 
  image: python

command: >-
  python hello.py --componentA_input ${{inputs.component_a_input}} --componentA_output ${{outputs.component_a_output}}

Esta tabela define os campos mais comumente usados do componente YAML. Para saber mais, consulte o esquema YAML do componente completo.

No exemplo em 3b_pipeline_with_data/componentA.yml, o componente A tem uma entrada de dados e uma saída de dados, que podem ser conectadas a outras etapas no pipeline pai. Todos os arquivos na code seção do componente YAML serão carregados no Azure Machine Learning quando o trabalho de pipeline for submetido. Neste exemplo, os ficheiros em ./componentA_src serão carregados. (Linha 16 em componentA.yml.) Você pode ver o código-fonte carregado na interface do usuário do estúdio: clique duas vezes na etapa componentA no gráfico e vá para a guia Código , conforme mostrado na captura de tela a seguir. Pode-se ver que é um script de 'hello-world' que faz uma impressão simples e escreve a data e a hora atuais no caminho componentA_output. O componente recebe entrada e fornece saída através da linha de comando. É tratado em hello.py via argparse.

Entrada e saída

A entrada e a saída definem a interface de um componente. A entrada e a saída podem ser valores literais (do tipo string, , numberinteger, ou boolean) ou um objeto que contém um esquema de entrada.

A entrada de objeto (do tipo uri_file, uri_folder, mltable, mlflow_modelou custom_model) pode se conectar a outras etapas no trabalho de pipeline pai para passar dados/modelos para outras etapas. No gráfico de pipeline, o tipo de objeto de entrada é renderizado como um ponto de conexão.

Entradas de valor literal (string, number, integer, boolean) são os parâmetros que você pode passar para o componente em tempo de execução. Você pode adicionar um valor padrão de entradas literais no default campo. Para number e integer tipos, você também pode adicionar valores mínimos e máximos usando os min campos e max . Se o valor de entrada for menor que o mínimo ou mais que o máximo, o pipeline falhará na validação. A validação ocorre antes de submeter um trabalho de pipeline, o que pode poupar tempo. A validação funciona para a CLI, o Python SDK e a interface do usuário do Designer. A captura de tela a seguir mostra um exemplo de validação na interface do usuário do Designer. Da mesma forma, você pode definir valores permitidos em enum campos.

Se quiser adicionar uma entrada a um componente, você precisa fazer edições em três locais:

• O inputs campo no componente YAML.
• O command campo no componente YAML.
• No código-fonte do componente para processar a entrada da linha de comando.

Esses locais são marcados com caixas verdes na captura de tela anterior.

Para saber mais sobre entradas e saídas, consulte Gerenciar entradas e saídas para componentes e pipelines.

Ambientes

O ambiente é o ambiente no qual o componente é executado. Pode ser um ambiente do Azure Machine Learning (curado ou registado personalizadamente), uma imagem Docker ou um ambiente Conda. Veja os seguintes exemplos:

• Ativo de ambiente de Aprendizado de Máquina do Azure registrado. O ambiente é referenciado no componente com a sintaxe azureml:<environment-name>:<environment-version>.
• Imagem Docker pública.
• Arquivo Conda. O arquivo conda precisa ser usado junto com uma imagem base.

Registrar um componente para reutilização e compartilhamento

Embora alguns componentes sejam específicos de um pipeline específico, o benefício real dos componentes vem da reutilização e do compartilhamento. Você pode registrar um componente em seu espaço de trabalho de Aprendizado de Máquina para disponibilizá-lo para reutilização. Os componentes registrados oferecem suporte ao controle de versão automático para que você possa atualizar o componente, mas garantir que os pipelines que exigem uma versão mais antiga continuem a funcionar.

No repositório azureml-examples, vá para o cli/jobs/pipelines-with-components/basics/1b_e2e_registered_components diretório.

Para registrar um componente, use o az ml component create comando:

az ml component create --file train.yml
az ml component create --file score.yml
az ml component create --file eval.yml

Depois que esses comandos forem executados até à conclusão, poderá ver os componentes no Studio, em AtivosComponentes:

Selecione um componente. Você verá informações detalhadas para cada versão do componente.

A guia Detalhes mostra informações básicas, como o nome do componente, quem o criou e a versão. Há campos editáveis para Tags e Descrição. Você pode usar tags para adicionar palavras-chave de pesquisa. O campo de descrição suporta a formatação Markdown. Você deve usá-lo para descrever a funcionalidade do componente e o uso básico.

Na guia Trabalhos , você vê o histórico de todos os trabalhos que usam o componente.

Usar componentes registrados em um arquivo YAML de trabalho de pipeline

Agora você usará 1b_e2e_registered_components como exemplo de como usar o componente registrado no pipeline YAML. Vá para o 1b_e2e_registered_components diretório e abra o pipeline.yml arquivo. As chaves e valores nos inputs campos e outputs são semelhantes aos já discutidos. A única diferença significativa é o valor do component campo nas jobs.<job_name>.component entradas. O component valor está no formato azureml:<component_name>:<component_version>. A train-job definição, por exemplo, especifica que a versão mais recente do componente my_train registrado deve ser usada:

type: command
component: azureml:my_train@latest
inputs:
  training_data: 
    type: uri_folder 
    path: ./data      
  max_epocs: ${{parent.inputs.pipeline_job_training_max_epocs}}
  learning_rate: ${{parent.inputs.pipeline_job_training_learning_rate}}
  learning_rate_schedule: ${{parent.inputs.pipeline_job_learning_rate_schedule}}
outputs:
  model_output: ${{parent.outputs.pipeline_job_trained_model}}
services:
  my_vscode:

Gerenciar componentes

Você pode verificar os detalhes dos componentes e gerenciar os componentes usando a CLI v2. Use az ml component -h para obter instruções detalhadas sobre comandos de componentes. A tabela a seguir lista todos os comandos disponíveis. Veja mais exemplos na referência da CLI do Azure.

Próximo passo

• Experimente o exemplo de componente CLI v2