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 oferecem a maior quantidade de flexibilidade e 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 com uma interface do usuário de arrastar e soltar. Este documento centra-se na CLI.

Pré-requisitos

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

• Uma área de trabalho do Azure Machine Learning. Crie recursos de espaço de trabalho.

• Instale e configure a extensão da CLI do Azure para Machine Learning.

• Clone o repositório de exemplos:

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

Pré-leitura sugerida

• O que é o pipeline do Azure Machine Learning
• O que é o componente Azure Machine Learning

Crie seu primeiro pipeline com componente

Vamos criar seu primeiro pipeline com componentes usando um exemplo. Esta seção tem como objetivo dar uma impressão inicial da aparência de um pipeline e componente no Aprendizado de Máquina do Azure com um exemplo concreto.

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

• pipeline.yml: Este arquivo YAML define o pipeline de aprendizado de máquina. Este arquivo YAML descreve como dividir uma tarefa completa de aprendizado de máquina em um fluxo de trabalho de várias etapas. Por exemplo, considerando uma tarefa simples de aprendizado de máquina usando dados históricos para treinar um modelo de previsão de vendas, convém criar um fluxo de trabalho sequencial com processamento de dados, treinamento de modelo e etapas de avaliação de modelo. Cada etapa é um componente que tem interface bem definida e pode ser desenvolvida, testada e otimizada de forma independente. O pipeline YAML também define como as etapas filho se conectam a outras etapas no pipeline, por exemplo, a etapa de treinamento do modelo gera um arquivo de modelo e o arquivo de modelo passará para uma etapa de avaliação do modelo.

• component.yml: Este arquivo YAML define o componente. Ele empacota as seguintes informações:

  • Metadados: nome, nome de exibição, versão, descrição, tipo, etc. 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. Uma vez definida a interface, diferentes equipas podem desenvolver e testar o componente de forma independente.
  • Command, code & environment: o comando, o código e o ambiente para executar o componente. Command é o comando shell para executar o componente. 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 docker ou um ambiente conda.

• component_src: Este é o diretório de código-fonte de um componente específico. Ele contém o código-fonte que é executado no componente. Você pode usar sua linguagem preferida (Python, R...). 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 será executada. Por exemplo, uma etapa de treinamento pode levar dados de treinamento, taxa de aprendizagem, 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 vamos criar um pipeline usando o 3b_pipeline_with_data exemplo. Explicamos o significado detalhado de cada arquivo nas seções a seguir.

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

az ml compute list

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

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 com 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ê deve receber um dicionário JSON com informações sobre o trabalho de pipeline, incluindo:

Abra a services.Studio.endpoint URL para ver uma visualização em gráfico do pipeline.

Compreender a definição de pipeline YAML

Vamos dar uma olhada na 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 descreve os campos usados mais comuns do esquema YAML do pipeline. Para saber mais, consulte o esquema YAML de pipeline completo.

No exemplo 3b_pipeline_with_data, criamos um pipeline de três etapas.

• As três etapas são definidas em jobs. Todos os três tipos de etapa são trabalho de comando. A definição de cada etapa está no arquivo correspondente component.yml . Você pode ver os arquivos YAML componente em 3b_pipeline_with_data diretório. Explicaremos o componentA.yml na próxima seção.
• Esse pipeline tem dependência de dados, o que é comum na maioria dos pipelines do mundo real. Component_a recebe a entrada de dados da pasta local em ./data(linha 17-20) e passa sua saída para o componente B (linha 29). A saída do Component_a pode ser referenciada como ${{parent.jobs.component_a.outputs.component_a_output}}.
• O compute define a computação padrão para esse pipeline. Se um componente em jobs define um cálculo diferente para esse componente, o sistema respeita a configuração específica do componente.

Ler e gravar dados no pipeline

Um cenário comum é ler e gravar dados em seu pipeline. No Azure Machine Learning, usamos o mesmo esquema para ler e gravar dados para todos os tipos de trabalhos (trabalho de pipeline, trabalho de comando e trabalho de varredura). A seguir estão exemplos de trabalho de pipeline de uso de dados para cenários comuns.

• dados locais
• ficheiro Web com 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

Agora vamos olhar para o componentA.yml como um exemplo para entender a definição de componente YAML.

$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}}

O esquema usado mais comum do componente YAML é descrito na tabela. Para saber mais, consulte o esquema YAML do componente completo.

Para o exemplo em 3b_pipeline_with_data/componentA.yml, componentA 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 no componente YAML serão carregados no Azure Machine Learning ao enviar o trabalho de pipeline. Neste exemplo, os ficheiros em ./componentA_src serão carregados (linha 16 na componentA.yml). Você pode ver o código-fonte carregado na interface do usuário do Studio: selecione duas vezes a etapa ComponentA e navegue até a guia Snapshot, conforme mostrado na captura de tela a seguir. Podemos ver que é um script hello-world apenas fazendo uma impressão simples, e escrever datetime atual para o componentA_output caminho. O componente recebe entrada e saída por meio do argumento de linha de comando e é manipulado no hello.py usando 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 de um valor literal (do tipo string,number,integer, ou boolean) ou de um objeto que contém o esquema de entrada.

A entrada de objeto (do tipo uri_file, uri_folder,,mltablemlflow_model,)custom_model pode se conectar a outras etapas no trabalho de pipeline pai e, portanto, passar dados/modelo para outras etapas. No gráfico de pipeline, a entrada do tipo de objeto é renderizada 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 o valor padrão de entradas literais em default campo. Para number e integer digitar, você também pode adicionar valor mínimo e máximo do valor aceito usando min e max campos. Se o valor de entrada exceder min e max, o pipeline falhará na validação. A validação acontece antes de enviar um trabalho de pipeline para economizar seu tempo. A validação funciona para CLI, Python SDK e designer UI. 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 no enum campo.

Se você quiser adicionar uma entrada a um componente, lembre-se de editar três locais:

• inputs campo no componente YAML
• command no componente YAML.
• Código-fonte do componente para manipular a entrada da linha de comando. Ele está marcado na caixa verde na captura de tela anterior.

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

Environment

O ambiente define o ambiente para executar o componente. Pode ser um ambiente do Azure Machine Learning (curado ou registrado personalizado), imagem docker ou ambiente conda. Veja os exemplos que se seguem.

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

Componente de registo para reutilização e partilha

Embora alguns componentes sejam específicos de um pipeline específico, o benefício real dos componentes vem da reutilização e do compartilhamento. Registre um componente em seu espaço de trabalho de Aprendizado de Máquina para disponibilizá-lo para reutilização. Os componentes registrados suportam o 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 continuarão a funcionar.

No repositório azureml-examples, navegue até 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é a conclusão, você poderá ver os componentes no Studio, em Ativo -> Componentes:

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

Na guia Detalhes , você verá informações básicas do componente, como nome, criado por, versão, etc. Você vê campos editáveis para Tags e Descrição. As tags podem ser usadas para adicionar palavras-chave pesquisadas rapidamente. O campo de descrição suporta a formatação Markdown e deve ser usado para descrever a funcionalidade e o uso básico do componente.

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

Usar componentes registrados em um arquivo YAML de trabalho de pipeline

Vamos usar 1b_e2e_registered_components para demonstrar como usar o componente registrado no pipeline YAML. Navegue até o 1b_e2e_registered_components diretório, 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 é da forma azureml:<COMPONENT_NAME>:<COMPONENT_VERSION>. A train-job definição, por exemplo, especifica que a versão mais recente do componente my_train registado deve ser utilizada:

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 do componente e gerenciar o componente usando a CLI (v2). Use az ml component -h para obter instruções detalhadas sobre o comando do componente. A tabela a seguir lista todos os comandos disponíveis. Veja mais exemplos na referência da CLI do Azure.

Próximos passos

• Experimente o exemplo de componente CLI v2