Crie uma conduta

Os pipelines do Vertex AI permitem-lhe orquestrar os seus fluxos de trabalho de aprendizagem automática (AA) sem servidor. Antes de os Vertex AI Pipelines poderem orquestrar o seu fluxo de trabalho de ML, tem de descrever o fluxo de trabalho como um pipeline. Os pipelines de ML são fluxos de trabalho de ML portáteis e escaláveis baseados em contentores e Google Cloud serviços.

Este guia descreve como começar a criar pipelines de ML.

Que SDK do Google Cloud Pipelines devo usar?

Os Vertex AI Pipelines podem executar pipelines criados com qualquer um dos seguintes SDKs:

  • SDK do Kubeflow Pipelines v2.0 ou posterior

  • TensorFlow Extended v0.30.0 ou posterior

Se usar o TensorFlow num fluxo de trabalho de ML que processa terabytes de dados estruturados ou dados de texto, recomendamos que crie o seu pipeline usando o TFX.

Para outros exemplos de utilização, recomendamos que crie o seu pipeline com o SDK Kubeflow Pipelines. Ao criar um pipeline com o SDK Kubeflow Pipelines, pode implementar o seu fluxo de trabalho criando componentes personalizados ou reutilizando componentes pré-criados, como os Google Cloud componentes de pipeline. Google Cloud Os componentes de pipelines facilitam a utilização de serviços do Vertex AI, como o AutoML, no seu pipeline.

Este guia descreve como criar pipelines com o SDK Kubeflow Pipelines.

Antes de começar

Antes de criar e executar os pipelines, use as seguintes instruções para configurar o Google Cloud projeto e o ambiente de desenvolvimento.

  1. Para preparar o seu Google Cloud projeto para executar pipelines de ML, siga as instruções no guia para configurar o seu Google Cloud projeto.

  2. Instale a versão 2 ou posterior do SDK Kubeflow Pipelines.

    pip install --upgrade "kfp>=2,<3"

  1. Para usar o cliente Python do Vertex AI nos seus pipelines, instale as bibliotecas cliente do Vertex AI v1.7 ou posterior.

  2. Para usar os serviços da Vertex AI nos seus pipelines, instale o Google Cloud SDK.

Introdução à criação de um pipeline

Para orquestrar o seu fluxo de trabalho de ML no Vertex AI Pipelines, tem de descrever primeiro o fluxo de trabalho como um pipeline. O exemplo seguinte demonstra como usar os Google Cloud componentes de pipeline com o Vertex AI para criar um conjunto de dados, preparar um modelo com o AutoML e implementar o modelo preparado para previsões.

Antes de executar o seguinte exemplo de código, tem de configurar a autenticação.

Como configurar a autenticação

Para configurar a autenticação, tem de criar uma chave de conta de serviço e definir uma variável de ambiente para o caminho da chave de conta de serviço.

  1. Crie uma conta de serviço:

    1. Na Google Cloud consola, aceda à página Criar conta de serviço.

      Aceda a Criar conta de serviço

    2. No campo Nome da conta de serviço, introduza um nome.
    3. Opcional: no campo Descrição da conta de serviço, introduza uma descrição.
    4. Clique em Criar.
    5. Clique no campo Selecionar uma função. Em Todas as funções, selecione Vertex AI > Utilizador do Vertex AI.

    6. Clique em Concluído para criar a conta de serviço.

      Não feche a janela do navegador. Vai usá-lo no passo seguinte.

  2. Crie uma chave de conta de serviço para autenticação:

    1. Na Google Cloud consola, clique no endereço de email da conta de serviço que criou.
    2. Clique em Chaves.
    3. Clique em Adicionar chave e, de seguida, em Criar nova chave.
    4. Clique em Criar. É transferido um ficheiro de chave JSON para o seu computador.
    5. Clique em Fechar.
  3. Conceda à nova conta de serviço acesso à conta de serviço que usa para executar pipelines.
    1. Clique em para voltar à lista de contas de serviço.

    2. Clique no nome da conta de serviço que usa para executar pipelines. É apresentada a página Detalhes da conta de serviço.

      Se seguiu as instruções no guia para configurar o seu projeto para os Vertex AI Pipelines, esta é a mesma conta de serviço que criou na secção Configure uma conta de serviço com autorizações detalhadas. Caso contrário, o Vertex AI usa a conta de serviço predefinida do Compute Engine para executar pipelines. A conta de serviço predefinida do Compute Engine tem um nome semelhante ao seguinte: PROJECT_NUMBER-compute@developer.gserviceaccount.com

    3. Clique no separador Autorizações.
    4. Clique em Conceder acesso. É apresentado o painel Adicionar responsáveis.
    5. Na caixa Novos membros, introduza o endereço de email da conta de serviço que criou num passo anterior.
    6. Na lista pendente Função, selecione Contas de serviço > Utilizador da conta de serviço.
    7. Clique em Guardar.

  4. Defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para o caminho do ficheiro JSON que contém a chave da sua conta de serviço. Esta variável aplica-se apenas à sua sessão de shell atual. Por isso, se abrir uma nova sessão, defina a variável novamente.

    Exemplo: Linux ou macOS

    Substitua [PATH] pelo caminho do ficheiro JSON que contém a chave da sua conta de serviço. 

    export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

    Por exemplo:

    export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

    Exemplo: Windows

    Substitua [PATH] pelo caminho do ficheiro JSON que contém a chave da conta de serviço e [FILE_NAME] pelo nome do ficheiro.

    Com o PowerShell:

    $env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

    Por exemplo:

    $env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\[FILE_NAME].json"

    Com a linha de comandos:

    set GOOGLE_APPLICATION_CREDENTIALS=[PATH]

Defina o seu fluxo de trabalho através do pacote DSL do Kubeflow Pipelines

O pacote kfp.dsl contém a linguagem específica do domínio (DSL) que pode usar para definir e interagir com pipelines e componentes.

Os componentes do pipeline do Kubeflow são funções de fábrica que criam passos do pipeline. Cada componente descreve as entradas, as saídas e a implementação do componente. Por exemplo, no exemplo de código abaixo, ds_op é um componente.

Os componentes são usados para criar passos do pipeline. Quando um pipeline é executado, os passos são executados à medida que os dados de que dependem ficam disponíveis. Por exemplo, um componente de preparação pode usar um ficheiro CSV como entrada e usá-lo para preparar um modelo.

import kfp
from google.cloud import aiplatform
from google_cloud_pipeline_components.v1.dataset import ImageDatasetCreateOp
from google_cloud_pipeline_components.v1.automl.training_job import AutoMLImageTrainingJobRunOp
from google_cloud_pipeline_components.v1.endpoint import EndpointCreateOp, ModelDeployOp

project_id = PROJECT_ID
pipeline_root_path = PIPELINE_ROOT

# Define the workflow of the pipeline.
@kfp.dsl.pipeline(
    name="automl-image-training-v2",
    pipeline_root=pipeline_root_path)
def pipeline(project_id: str):
    # The first step of your workflow is a dataset generator.
    # This step takes a Google Cloud Pipeline Component, providing the necessary
    # input arguments, and uses the Python variable `ds_op` to define its
    # output. Note that here the `ds_op` only stores the definition of the
    # output but not the actual returned object from the execution. The value
    # of the object is not accessible at the dsl.pipeline level, and can only be
    # retrieved by providing it as the input to a downstream component.
    ds_op = ImageDatasetCreateOp(
        project=project_id,
        display_name="flowers",
        gcs_source="gs://cloud-samples-data/vision/automl_classification/flowers/all_data_v2.csv",
        import_schema_uri=aiplatform.schema.dataset.ioformat.image.single_label_classification,
    )

    # The second step is a model training component. It takes the dataset
    # outputted from the first step, supplies it as an input argument to the
    # component (see `dataset=ds_op.outputs["dataset"]`), and will put its
    # outputs into `training_job_run_op`.
    training_job_run_op = AutoMLImageTrainingJobRunOp(
        project=project_id,
        display_name="train-iris-automl-mbsdk-1",
        prediction_type="classification",
        model_type="CLOUD",
        dataset=ds_op.outputs["dataset"],
        model_display_name="iris-classification-model-mbsdk",
        training_fraction_split=0.6,
        validation_fraction_split=0.2,
        test_fraction_split=0.2,
        budget_milli_node_hours=8000,
    )

    # The third and fourth step are for deploying the model.
    create_endpoint_op = EndpointCreateOp(
        project=project_id,
        display_name = "create-endpoint",
    )

    model_deploy_op = ModelDeployOp(
        model=training_job_run_op.outputs["model"],
        endpoint=create_endpoint_op.outputs['endpoint'],
        automatic_resources_min_replica_count=1,
        automatic_resources_max_replica_count=1,
    )

Substitua o seguinte:

  • PROJECT_ID: O Google Cloud projeto no qual esta pipeline é executada.

  • PIPELINE_ROOT_PATH: especifique um URI do Cloud Storage ao qual a sua conta de serviço de pipelines possa aceder. Os artefactos das execuções do pipeline são armazenados na raiz do pipeline. O URI do Cloud Storage tem de começar com gs://.

    A raiz do pipeline pode ser definida como um argumento da anotação @kfp.dsl.pipeline na função do pipeline ou pode ser definida quando chama create_run_from_job_spec para criar uma execução do pipeline.

Compile o pipeline num ficheiro YAML

Depois de definir o fluxo de trabalho do seu pipeline, pode avançar para a compilação do pipeline no formato YAML. O ficheiro YAML inclui todas as informações para executar o seu pipeline no Vertex AI Pipelines.

from kfp import compiler

compiler.Compiler().compile(
    pipeline_func=pipeline,
    package_path='image_classif_pipeline.yaml'
)

Envie a execução da pipeline

Depois de o fluxo de trabalho do seu pipeline ser compilado no formato YAML, pode usar o cliente Python do Vertex AI para enviar e executar o pipeline.

import google.cloud.aiplatform as aip

# Before initializing, make sure to set the GOOGLE_APPLICATION_CREDENTIALS
# environment variable to the path of your service account.
aip.init(
    project=project_id,
    location=PROJECT_REGION,
)

# Prepare the pipeline job
job = aip.PipelineJob(
    display_name="automl-image-training-v2",
    template_path="image_classif_pipeline.yaml",
    pipeline_root=pipeline_root_path,
    parameter_values={
        'project_id': project_id
    }
)

job.submit()

Substitua o seguinte:

  • PROJECT_REGION: a região em que este pipeline é executado.

No exemplo anterior:

  1. Um pipeline do Kubeflow é definido como uma função Python. A função é anotada com o decorador @kfp.dsl.pipeline, que especifica o nome e o caminho raiz do pipeline. O caminho raiz do pipeline é a localização onde os artefactos do pipeline são armazenados.
  2. Os passos do fluxo de trabalho do pipeline são criados através dos Google Cloud componentes do pipeline. Ao usar as saídas de um componente como entrada de outro componente, define o fluxo de trabalho do pipeline como um gráfico. Por exemplo: training_job_run_op depende do resultado de ds_op.dataset
  3. Compila o pipeline com kfp.compiler.Compiler.
  4. Cria uma execução de pipeline no Vertex AI Pipelines através do cliente Python do Vertex AI. Quando executa um pipeline, pode substituir o nome do pipeline e o caminho raiz do pipeline. As execuções de pipelines podem ser agrupadas com o nome do pipeline. A substituição do nome do pipeline pode ajudar a distinguir entre execuções de pipeline de produção e experimentais.

Para saber como criar pipelines, leia a secção Criar pipelines do Kubeflow e siga os exemplos e os tutoriais.

Teste um pipeline localmente (opcional)

Depois de definir os pipelines e os componentes, pode testar o código do componente executando o código no seu ambiente de criação local. Ao executar o pipeline ou um componente localmente, pode identificar e depurar potenciais problemas antes de criar uma execução do pipeline num ambiente remoto, como os Vertex AI Pipelines. Para mais informações sobre a execução local de pipelines e componentes, consulte o artigo Execução local na documentação do KFP.

Esta página mostra como definir e executar um pipeline composto por duas tarefas.

Configure o seu ambiente local

  1. Opcional: instale o Docker.

  2. Use o seguinte exemplo de código para definir um pipeline simples:

    from kfp import dsl

# Define a component to add two numbers.
@dsl.component
def add(a: int, b: int) -> int:
    return a + b

# Define a simple pipeline using the component.
@dsl.pipeline
def addition_pipeline(x: int, y: int, z: int) -> int:
    task1 = add(a=x, b=y)
    task2 = add(a=task1.output, b=z)
    return task2.output

Invocar uma execução local

Inicialize uma sessão local através da função local.init(). Quando usa o local.init(), o SDK KFP executa localmente os seus pipelines e componentes quando os chama.

Quando usa local.init(), tem de especificar um tipo de executante. O tipo de executor indica como o KFP deve executar cada tarefa.

Use o exemplo seguinte para especificar o DockerRunnertipo de executor para executar cada tarefa num contentor. Para mais informações sobre os executores locais suportados pela KFP, consulte o artigo Executores locais na documentação da KFP.

from kfp import local

local.init(runner=local.DockerRunner())

pipeline_task = addition_pipeline(x=1, y=2, z=3)

Use o seguinte código para ver o resultado da tarefa do pipeline após a execução local:

print(f'Result: {pipeline_task.output}')

Criar pipelines do Kubeflow

Use o processo seguinte para criar um pipeline.

  1. Conceba o seu pipeline como uma série de componentes. Para promover a reutilização, cada componente deve ter uma única responsabilidade. Sempre que possível, crie o seu pipeline para reutilizar componentes comprovados, como os Google Cloud componentes do pipeline.

    Saiba mais sobre a conceção de pipelines.

  2. Crie todos os componentes personalizados necessários para implementar o seu fluxo de trabalho de ML com o SDK Kubeflow Pipelines. Os componentes são conjuntos autónomos de código que executam um passo no seu fluxo de trabalho de ML. Use as seguintes opções para criar os componentes do pipeline.

  3. Crie o seu pipeline como uma função Python.

    Saiba mais sobre como definir o seu pipeline como uma função Python.

  4. Use o compilador do SDK do Kubeflow Pipelines para compilar o seu pipeline.

    from kfp import compiler

compiler.Compiler().compile(
    pipeline_func=PIPELINE_FUNCTION,
    package_path=PIPELINE_PACKAGE_PATH)

    Substitua o seguinte:

    • PIPELINE_FUNCTION: o nome da função do seu pipeline.
    • PIPELINE_PACKAGE_PATH: o caminho para onde armazenar o pipeline compilado.

  5. Execute o pipeline através da Google Cloud consola ou do Python.

Aceder a recursos Google Cloud num pipeline

Se não especificar uma conta de serviço quando executa um pipeline, o Vertex AI Pipelines usa a conta de serviço predefinida do Compute Engine para executar o pipeline. Os Vertex AI Pipelines também usam a conta de serviço de uma execução do pipeline para autorizar o pipeline a aceder a recursos.Google Cloud A conta de serviço predefinida do Compute Engine tem a função Editor do projeto por predefinição. Isto pode conceder aos seus pipelines acesso excessivo a recursos no seu projeto. Google Cloud Google Cloud

Recomendamos que crie uma conta de serviço para executar os seus pipelines e, em seguida, conceda a esta conta autorizações detalhadas aos Google Cloud recursos necessários para executar o seu pipeline.

Saiba como usar a gestão de identidade e acesso para criar uma conta de serviço e gerir o acesso concedido a uma conta de serviço.

Mantenha os seus pipelines atualizados

Os clientes do SDK e as imagens de contentores que usa para criar e executar pipelines são atualizados periodicamente para novas versões para corrigir vulnerabilidades de segurança e adicionar novas funcionalidades. Para manter os seus pipelines atualizados com a versão mais recente, recomendamos que faça o seguinte:

O que se segue?