Share via

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

  • Artigo

APLICA-SE A:Extensão ml da CLI do Azure 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

Pré-leitura sugerida

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:

Nota

Ignore esta etapa para usar a computação sem servidor.

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:

Key Description
name O nome baseado em GUID do trabalho.
experiment_name O nome sob o qual os trabalhos serão organizados em estúdio.
services.Studio.endpoint Uma URL para monitorar e revisar o trabalho de pipeline.
status O status do trabalho. Isso provavelmente será Preparing neste momento.

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

Screenshot of a graph visualization of the 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 .

Nota

Para usar computação sem servidor, substitua default_compute: azureml:cpu-cluster por default_compute: azureml:serverless neste arquivo.

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

key descrição
tipo Necessário. O tipo de trabalho deve ser pipeline para trabalhos de pipeline.
display_name Nome de exibição do trabalho de pipeline na interface do usuário do estúdio. Editável na interface do usuário do estúdio. Não precisa ser exclusivo em todos os trabalhos no espaço de trabalho.
empregos Necessário. Dicionário do conjunto de trabalhos individuais a serem executados como etapas dentro do pipeline. Esses trabalhos são considerados empregos filhos do trabalho de pipeline pai. Nesta versão, os tipos de trabalho suportados no pipeline são command e sweep
Insumos Dicionário de entradas para o trabalho de pipeline. A chave é um nome para a entrada dentro do contexto do trabalho e o valor é o valor de entrada. Essas entradas de pipeline podem ser referenciadas pelas entradas de um trabalho de etapa individual no pipeline usando o ${{ parent.inputs.<> input_name }} expressão.
saídas Dicionário de configurações de saída do trabalho de pipeline. A chave é um nome para a saída dentro do contexto do trabalho e o valor é a configuração de saída. Essas saídas de pipeline podem ser referenciadas pelas saídas de um trabalho de etapa individual no pipeline usando ${{ parents.outputs.<> output_name }} expressão.

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.

Screenshot of the pipeline with data example.

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.

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.

key descrição
nome Necessário. Nome do componente. Deve ser exclusivo no espaço de trabalho do Azure Machine Learning. Deve começar com letra minúscula. Permita letras minúsculas, números e sublinhado(_). O comprimento máximo é de 255 caracteres.
display_name Nome de exibição do componente na interface do usuário do estúdio. Pode não ser exclusivo dentro do espaço de trabalho.
comando Necessário o comando para executar
code Caminho local para o diretório do código-fonte a ser carregado e usado para o componente.
ambiente Necessário. O ambiente que é usado para executar o componente.
Insumos Dicionário de entradas de componentes. A chave é um nome para a entrada dentro do contexto do componente e o valor é a definição de entrada do componente. As entradas podem ser referenciadas no comando usando as entradas ${{.<> input_name }} expressão.
saídas Dicionário de saídas de componentes. A chave é um nome para a saída dentro do contexto do componente e o valor é a definição de saída do componente. As saídas podem ser referenciadas no comando usando as saídas ${{.<> output_name }} expressão.
is_deterministic Se o resultado do trabalho anterior deve ser reutilizado se as entradas do componente não forem alteradas. O valor padrão é true, também conhecido como reutilização por padrão. O cenário comum quando definido como false é para forçar a recarga de dados de um armazenamento em nuvem ou URL.

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.

Screenshot of pipeline with data example showing componentA.

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,,integernumber, ou ) ou booleande um objeto que contém o esquema de entrada.

A entrada de objeto (do tipo uri_file, ,,uri_foldermlflow_model,) pode se conectar a outras etapas no trabalho de pipeline pai e, portanto,mltablecustom_model 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,,,integernumber)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 digitar, você também pode adicionar valor mínimo e máximo do valor aceito usando min e maxinteger 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.

Screenshot of the input and output of the train linear regression model component.

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:

Screenshot of Studio showing the components that were just registered.

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 para demonstrar como usar 1b_e2e_registered_components o componente registrado no pipeline YAML. Navegue até o diretório, abra o 1b_e2e_registered_componentspipeline.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.

comandos descrição
az ml component create Criar um componente
az ml component list Listar componentes em um espaço de trabalho
az ml component show Mostrar detalhes de um componente
az ml component update Atualize um componente. Apenas alguns campos (descrição, display_name) suportam atualização
az ml component archive Arquivar um contêiner de componente
az ml component restore Restaurar um componente arquivado

Próximos passos