Criar uma cadeia de processamento

No Azure Machine Learning, um pipeline é um fluxo de trabalho de tarefas de aprendizado de máquina no qual cada tarefa é definida como um componente.

Os componentes podem ser organizados sequencialmente ou em paralelo, permitindo que você crie uma lógica de fluxo sofisticada para orquestrar operações de aprendizado de máquina. Cada componente pode ser executado em um alvo de computação específico, tornando possível combinar diferentes tipos de processamento conforme necessário para atingir um objetivo geral.

Um pipeline pode ser executado como processo ao executar o pipeline como uma tarefa de pipeline. Cada componente é executado como uma tarefa subordinada, integrada no pipeline global.

Construa um pipeline

Um pipeline do Azure Machine Learning é definido em um arquivo YAML. O arquivo YAML inclui o nome do trabalho de pipeline, entradas, saídas e configurações.

Você pode criar o arquivo YAML ou usar a @pipeline() função para criar o arquivo YAML.

Por exemplo, se você quiser criar um pipeline que primeiro prepara os dados e, em seguida, treina o modelo, você pode usar o seguinte código:

from azure.ai.ml.dsl import pipeline

@pipeline()
def pipeline_function_name(pipeline_job_input):
    prep_data = loaded_component_prep(input_data=pipeline_job_input)
    train_model = loaded_component_train(training_data=prep_data.outputs.output_data)

    return {
        "pipeline_job_transformed_data": prep_data.outputs.output_data,
        "pipeline_job_trained_model": train_model.outputs.model_output,
    }

Para passar um ativo de dados registado como entrada para o trabalho de pipeline, pode chamar a função que criou com o ativo de dados como entrada:

from azure.ai.ml import Input
from azure.ai.ml.constants import AssetTypes

pipeline_job = pipeline_function_name(
    Input(type=AssetTypes.URI_FILE, 
    path="azureml:data:1"
))

A @pipeline() função constrói um pipeline que consiste em duas etapas sequenciais, representadas pelos dois componentes carregados.

Para compreender o pipeline criado no exemplo, reveja os elementos que o compõem:

• O pipeline é construído definindo a função pipeline_function_name.
• A função de pipeline espera pipeline_job_input como a entrada geral do pipeline.
• O primeiro passo do pipeline requer um valor para input_data. O pipeline transmite o valor de pipeline_job_input.
• A primeira etapa do pipeline é definida pelo componente carregado em prep_data.
• O valor de output_data da primeira etapa do pipeline é utilizado como a entrada training_data esperada da segunda etapa do pipeline.
• A segunda etapa do pipeline é definida pelo componente carregado para train_model e dá origem a um modelo treinado designado por model_output.
• As saídas do pipeline são definidas pela devolução de variáveis da função pipeline. Existem duas saídas:
  • pipeline_job_transformed_data com o valor de prep_data.outputs.output_data
  • pipeline_job_trained_model com o valor de train_model.outputs.model_output

O resultado da execução da @pipeline() função é um arquivo YAML que você pode revisar imprimindo o pipeline_job objeto criado ao chamar a função:

print(pipeline_job)

A saída utiliza o formato YAML e inclui a configuração do pipeline e dos seus componentes. O exemplo seguinte mostra alguns dos parâmetros gerados.

display_name: pipeline_function_name
type: pipeline
inputs:
  pipeline_job_input:
    type: uri_file
    path: azureml:data:1
outputs:
  pipeline_job_transformed_data: null
  pipeline_job_trained_model: null
jobs:
  prep_data:
    type: command
    inputs:
      training_data:
        path: ${{parent.inputs.pipeline_job_input}}
    outputs:
      output_data: ${{parent.outputs.pipeline_job_transformed_data}}
  train_model:
    type: command
    inputs:
      input_data:
        path: ${{parent.outputs.pipeline_job_transformed_data}}
    outputs:
      model_output: ${{parent.outputs.pipeline_job_trained_model}}
tags: {}
properties: {}
settings: {}