GSP965

Visão geral

Pipelines ajudam você a automatizar e reproduzir seu fluxo de trabalho de ML. A Vertex AI integra as ofertas de ML do Google Cloud em uma experiência de desenvolvimento intuitiva. Anteriormente, modelos treinados com o AutoML e modelos personalizados eram acessíveis por serviços separados. A Vertex AI combina os dois tipos em uma única API, junto com outros novos produtos. Além disso, ela inclui uma variedade de produtos de MLOps, como o Vertex Pipelines. Neste laboratório, você vai aprender como criar e executar pipelines de ML com o Vertex Pipelines.

Por que pipelines de ML são úteis?

Antes de começar, primeiro entenda por que você usaria um pipeline. Imagine que você está criando um fluxo de trabalho de ML que inclui processamento de dados, treinamento de modelos, ajuste de hiperparâmetros, avaliação e implantação de modelos. Cada uma dessas etapas pode ter dependências diferentes, o que pode ser difícil de administrar se você tratar o fluxo inteiro como algo monolítico. Ao começar a escalonar seu processo de ML, você pode querer compartilhar seu fluxo de trabalho de ML com outras pessoas da sua equipe para que elas possam executar e colaborar com código. Sem um processo confiável e possível de ser reproduzido, isso pode ser difícil. Com pipelines, cada etapa do seu processo de ML é um contêiner próprio, o que permite que você desenvolva as etapas independentemente e rastreie a entrada e a saída de cada etapa de maneira possível de ser reproduzida. Você também pode agendar ou acionar execuções do seu pipeline com base em outros eventos do seu ambiente do Cloud, como quando novos dados de treinamento estiverem disponíveis.

O que você aprenderá:

• usar o SDK do Kubeflow Pipelines para criar pipelines de ML escalonáveis;
• criar e executar um pipeline introdutório de três etapas que recebe uma entrada de texto;
• criar e executar um pipeline que treina, avalia e implanta um modelo de classificação do AutoML;
• usar componentes pré-criados para interagir com os serviços da Vertex AI, usando a biblioteca google_cloud_pipeline_components;
• agendar um job de pipeline com o Cloud Scheduler.

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você verá o seguinte:

   • O botão Abrir Console do Cloud
   • Tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações se forem necessárias

2. Clique em Abrir Console do Google. O laboratório ativa recursos e depois abre outra guia com a página Fazer login.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Caso seja preciso, copie o Nome de usuário no painel Detalhes do laboratório e cole esse nome na caixa de diálogo Fazer login. Clique em Avançar.

4. Copie a Senha no painel Detalhes do laboratório e a cole na caixa de diálogo Olá. Clique em Avançar.

   Importante: você precisa usar as credenciais do painel à esquerda. Não use suas credenciais do Google Cloud Ensina. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

5. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do GCP vai ser aberto nesta guia.

Observação: para ver uma lista dos produtos e serviços do Google Cloud, clique no Menu de navegação no canto superior esquerdo.

Tarefa 1. Crie uma instância de notebooks da Vertex AI

1. Clique no menu de navegação.

2. Acesse Vertex AI e depois Workbench.

3. Na página de instâncias do notebook, acesse a guia Notebooks gerenciados pelo usuário e aguarde até ai-notebook ser totalmente criado.

Observação: a criação do notebook deve levar alguns minutos.

4. Quando a instância tiver sido criada, selecione Abrir o JupyterLab:

Verifique se o notebook foi criado

Tarefa 2. Configure o Vertex Pipelines

É preciso instalar algumas bibliotecas adicionais para usar o Vertex Pipelines:

• Kubeflow Pipelines: o SDK usado para criar o pipeline. O Vertex Pipelines suporta pipelines em execução criados com o Kubeflow Pipelines ou o TFX.
• Componentes de pipeline do Google Cloud: essa biblioteca oferece componentes pré-criados que facilitam a interação com os serviços da Vertex AI nas etapas do seu pipeline.

Etapa 1: criar o notebook Python e instalar as bibliotecas

1. No menu inicial da sua instância do notebook, selecione Python 3 para criar um notebook:

2. Para acessar o menu inicial, clique no sinal de + no canto superior esquerdo da sua instância do notebook.

3. Para instalar os dois serviços necessários para este laboratório, primeiro defina a flag do usuário em uma célula do notebook:

USER_FLAG = "--user"

4. Em seguida, execute o seguinte no seu notebook:

!pip3 install {USER_FLAG} google-cloud-aiplatform==1.0.0 --upgrade !pip3 install {USER_FLAG} kfp google-cloud-pipeline-components==0.1.1 --upgrade

5. Depois de instalar esses pacotes, será necessário reiniciar o kernel:

import os if not os.getenv("IS_TESTING"): # Automatically restart kernel after installs import IPython app = IPython.Application.instance() app.kernel.do_shutdown(True)

6. Por fim, verifique se os pacotes foram instalados corretamente. A versão do SDK do KFP deve ser a 1.6 ou uma mais recente:

!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))" !python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"

Etapa 2: configurar o ID do projeto e o bucket

Neste laboratório, você vai fazer referência ao ID do projeto do Cloud e ao bucket que você criou anteriormente. Em seguida, você vai criar variáveis para cada um.

1. Se você não souber o ID do projeto, execute o seguinte para conferi-lo:

import os PROJECT_ID = "" # Confira seu ID do projeto do Google Cloud na gcloud if not os.getenv("IS_TESTING"): shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null PROJECT_ID = shell_output[0] print("Project ID: ", PROJECT_ID)

2. Depois, crie uma variável para armazenar o nome do seu bucket.

BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"

Etapa 3: importar as bibliotecas

• Para importar as bibliotecas que você vai usar durante este laboratório, adicione:

from typing import NamedTuple import kfp from kfp import dsl from kfp.v2 import compiler from kfp.v2.dsl import (Artifact, Dataset, Input, InputPath, Model, Output, OutputPath, ClassificationMetrics, Metrics, component) from kfp.v2.google.client import AIPlatformClient from google.cloud import aiplatform from google_cloud_pipeline_components import aiplatform as gcc_aip

Etapa 4: definir as constantes

• A última etapa antes de criar o pipeline é definir mais variáveis constantes. PIPELINE_ROOT é o caminho do Cloud Storage em que os artefatos criados pelo seu pipeline foram gravados. Você está usando a região , mas, se você usou uma região diferente quando criou o bucket, atualize a variável REGION no código abaixo:

PATH=%env PATH %env PATH={PATH}:/home/jupyter/.local/bin REGION="{{{ project_0.default_region | Placeholder value. }}}" PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/" PIPELINE_ROOT

Depois de executar o código acima, você verá o diretório raiz do seu pipeline. Esse é o local do Cloud Storage em que os artefatos do seu pipeline serão gravados. Ele terá o formato gs://<bucket_name>/pipeline_root/.

Tarefa 3. Crie seu primeiro pipeline

• Crie um pipeline curto usando o SDK do KFP. Esse pipeline não faz nada relacionado a ML (não se preocupe, vamos chegar lá!). Este exercício ensina você o seguinte:

  • Como criar componentes personalizados no SDK do KFP
  • Como executar e monitorar um pipeline no Vertex Pipelines

Você vai criar um pipeline que mostra uma sentença usando duas saídas: um nome de produto e uma descrição de emoji. O pipeline vai consistir de três componentes:

• product_name: este componente aceita um nome de produto como entrada e retorna essa string como a saída.
• emoji: este componente usa a descrição em texto de um emoji e a converte no emoji. Por exemplo, o código de texto de ✨ é "sparkles". Este componente usa uma biblioteca de emojis para mostrar a você como gerenciar dependências externas no seu pipeline.
• build_sentence: este último componente consome a saída dos últimos dois componentes para criar uma frase que usa o emoji. Por exemplo, a saída resultante pode ser "Vertex Pipelines is ✨".

Etapa 1: criar um componente baseado em função do Python

Usando o SDK do KFP, você pode criar componentes baseados em funções do Python. Primeiro, crie o componente product_name, que simplesmente usa uma string como entrada e retorna essa string.

• Adicione o seguinte ao seu notebook:

@component(base_image="python:3.9", output_component_file="first-component.yaml") def product_name(text: str) -> str: return text

Vamos analisar melhor essa sintaxe:

• O decorador @component compila essa função em um componente quando o pipeline é executado. Você vai usar esse decorador sempre que criar um componente personalizado.
• O parâmetro base_image especifica a imagem de contêiner que esse componente vai usar.
• O parâmetro output_component_file é opcional e especifica o arquivo yaml em que o componente compilado vai ser criado. Depois de executar a célula, você deve ver o arquivo gravado na sua instância do notebook. Se você quiser compartilhar esse componente com alguém, pode enviar o arquivo yaml gerado e pedir para a pessoa carregar com o seguinte:

product_name_component = kfp.components.load_component_from_file('./first-component.yaml')

O elemento -> str depois da definição da função especifica o tipo de saída desse componente.

Etapa 2: criar dois componentes adicionais

1. Para completar o pipeline, crie mais dois componentes. O primeiro usa uma string como entrada e a converte no emoji correspondente, se houver um. O componente retorna uma tupla com o texto de entrada transmitido e o emoji resultante:

@component(base_image="python:3.9", output_component_file="second-component.yaml", packages_to_install=["emoji"]) def emoji( text: str, ) -> NamedTuple( "Outputs", [ ("emoji_text", str), # Return parameters ("emoji", str), ], ): import emoji emoji_text = text emoji_str = emoji.emojize(':' + emoji_text + ':', language='alias') print("output one: {}; output_two: {}".format(emoji_text, emoji_str)) return (emoji_text, emoji_str)

Esse componente é um pouco mais complexo que o anterior. Confira as novidades:

• O parâmetro packages_to_install informa ao componente sobre quaisquer dependências de bibliotecas externas do contêiner. Neste caso, você está usando uma biblioteca chamada "emoji".
• Esse componente retorna uma NamedTuple chamada Outputs. Observe que cada uma das strings dessa tupla tem chaves: emoji_text e emoji. Você as usará no próximo componente para acessar a saída.

2. O último componente desse pipeline consome a saída dos dois primeiros e as combina para retornar uma string:

@component(base_image="python:3.9", output_component_file="third-component.yaml") def build_sentence( product: str, emoji: str, emojitext: str ) -> str: print("We completed the pipeline, hooray!") end_str = product + " is " if len(emoji) > 0: end_str += emoji else: end_str += emojitext return(end_str)

Você pode se perguntar como esse componente sabe que é preciso usar a saída das etapas anteriores que você definiu.

Essa é uma boa pergunta. Você vai unir tudo na próxima etapa.

Etapa 3: unir os componentes em um pipeline

As configurações do componente definidas acima criaram funções de fábrica que podem ser usadas em uma definição de pipeline para criar etapas.

1. Para configurar um pipeline, use o decorador @dsl.pipeline, dê um nome e uma descrição ao pipeline, e forneça o caminho raiz em que os artefatos do seu pipeline serão gravados. Artefatos são quaisquer arquivos de saída gerados pelo seu pipeline. Este pipeline introdutório não gera nenhum artefato, mas seu próximo pipeline vai gerar.

2. No próximo bloco de código, você vai definir uma função intro_pipeline. É nela que você especifica as entradas das suas etapas iniciais do pipeline e como as etapas se conectam umas às outras:

• product_task usa um nome de produto como entrada. Aqui, você está transmitindo "Vertex Pipelines", mas pode alterar para o que você quiser.
• emoji_task usa o código de texto de um emoji como entrada. Também é possível alterar para o que você quiser. Por exemplo, "party_face" se refere ao emoji 🥳. Observe que, como esse componente e product_task não têm etapas para gerar uma entrada, você especifica manualmente a entrada deles ao definir seu pipeline.
• A última etapa do pipeline, consumer_task, tem três parâmetros de entrada:
  • A saída de product_task. Como esta etapa só produz uma saída, você pode fazer referência a ela usando product_task.output.
  • A saída de emoji, da etapa emoji_task. Consulte o componente emoji definido acima, em que você nomeou os parâmetros de saída.
  • Do mesmo modo, a saída nomeada emoji_text do componente emoji. Caso o pipeline receba texto que não corresponde a um emoji, ele usará esse texto para criar uma sentença.

@dsl.pipeline( name="hello-world", description="An intro pipeline", pipeline_root=PIPELINE_ROOT, ) # You can change the `text` and `emoji_str` parameters here to update the pipeline output def intro_pipeline(text: str = "Vertex Pipelines", emoji_str: str = "sparkles"): product_task = product_name(text) emoji_task = emoji(emoji_str) consumer_task = build_sentence( product_task.output, emoji_task.outputs["emoji"], emoji_task.outputs["emoji_text"], )

Etapa 4: compilar e executar o pipeline

1. Com seu pipeline definido, está tudo pronto para compilá-lo. O código a seguir gera um arquivo JSON que você vai usar para executar o pipeline:

compiler.Compiler().compile( pipeline_func=intro_pipeline, package_path="intro_pipeline_job.json" )

2. Em seguida, instancie um cliente de API:

api_client = AIPlatformClient( project_id=PROJECT_ID, region=REGION, )

3. Por fim, execute o pipeline:

response = api_client.create_run_from_job_spec( job_spec_path="intro_pipeline_job.json", # pipeline_root=PIPELINE_ROOT # esse argumento não será necessário se você não especificar PIPELINE_ROOT como parte da definição do pipeline. )

Executar um pipeline gera um link para ver a execução no seu console. Ele vai ficar assim quando concluído:

4. Esse pipeline vai levar de 5 a 6 minutos para ser executado. Quando concluído, você pode clicar no componente build-sentence para conferir a saída final:

Agora que você sabe como o SDK do KFP e o Vertex Pipelines funcionam, você já pode criar um pipeline que cria e implanta um modelo de ML usando outros serviços da Vertex AI.

Verifique se o seu pipeline de emoji foi concluído

Tarefa 4. Crie um pipeline de ML completo

É hora de criar seu primeiro pipeline de ML. Nesse pipeline, você vai usar o conjunto de dados UCI Machine Learning Dry Beans, de: KOKLU, M. e OZKAN, I.A., (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques."In Computers and Electronics in Agriculture, 174, 105507. DOI.

Observação: esse pipeline vai levar mais de 2 horas para ser concluído. Então, não será preciso esperar toda a duração do pipeline para concluir o laboratório. Siga as etapas até que seu job de pipeline seja iniciado.

Esse é um conjunto de dados tabular que você vai usar no seu pipeline para treinar, avaliar e implantar um modelo de AutoML que classifica grãos em um dos sete tipos com base nas características deles.

Esse pipeline vai fazer o seguinte:

• criar um conjunto de dados na Vertex AI;
• treinar um modelo de classificação tabular com o AutoML;
• receber métricas de avaliação sobre o modelo;
• com base nas métricas de avaliação, decidir se é preciso implantar o modelo usando a lógica condicional no Vertex Pipelines;
• implantar o modelo em um endpoint usando o Vertex Prediction.

Cada uma das etapas descritas será um componente. A maioria das etapas do pipeline vai usar componentes pré-criados para serviços da Vertex AI usando a biblioteca google_cloud_pipeline_components que você importou anteriormente neste laboratório.

Nesta seção, vamos primeiro definir um componente personalizado e só depois definir as outras etapas do pipeline usando componentes pré-criados. Com componentes pré-criados, é mais fácil acessar serviços da Vertex AI como o treinamento de modelos e a implantação.

A maior parte do tempo gasto nessa etapa é para o treinamento do AutoML no pipeline, o que leva cerca de uma hora.

Etapa 1: um componente personalizado para avaliação de modelos

O componente personalizado que você vai definir será usado ao final do pipeline assim que o treinamento de modelos for concluído. Esse componente faz algumas coisas:

• recebe métricas de avaliação do modelo de classificação treinado do AutoML;
• analisa as métricas e as renderiza na IU do Vertex Pipelines;
• compara as métricas com um limite para determinar se o modelo deve ser implantado.

Antes de definir o componente, entenda os parâmetros de entrada e saída dele. Como entrada, o pipeline usa metadados do seu projeto do Cloud, o modelo treinado resultante (você vai definir esse componente mais tarde), as métricas de avaliação do modelo e thresholds_dict_str.

O elemento thresholds_dict_str será definido quando você executar seu pipeline. No caso deste modelo de classificação, ele será o valor da área sob a curva ROC em que você quer implantar o modelo. Por exemplo, se você transmitir 0,95, isso significa que você só quer que o pipeline implante o modelo se a métrica estiver acima de 95%.

O componente de avaliação retorna uma string que indica se o modelo deve ser implantado ou não.

• Adicione o seguinte em uma célula do notebook para criar o componente personalizado:

@component( base_image="gcr.io/deeplearning-platform-release/tf2-cpu.2-3:latest", output_component_file="tables_eval_component.yaml", # Opcional: use isso para carregar o componente em outro momento packages_to_install=["google-cloud-aiplatform"], ) def classif_model_eval_metrics( project: str, location: str, # "region", api_endpoint: str, # "region-aiplatform.googleapis.com", thresholds_dict_str: str, model: Input[Model], metrics: Output[Metrics], metricsc: Output[ClassificationMetrics], ) -> NamedTuple("Outputs", [("dep_decision", str)]): # Return parameter. """Essa função renderiza métricas de avaliação para um modelo de classificação tabular do AutoML. Ela recupera a avaliação do modelo de classificação gerada pelo processo de treinamento tabular do AutoML Tabular, faz uma análise e usa essa informação para renderizar a curva ROC e a matriz de confusão do modelo. Ela também usa as informações de limite de métricas fornecidas e as compara com os resultados da avaliação para determinar se o modelo é acurado o bastante para ser implantado. """ import json import logging from google.cloud import aiplatform # Fetch model eval info def get_eval_info(client, model_name): from google.protobuf.json_format import MessageToDict response = client.list_model_evaluations(parent=model_name) metrics_list = [] metrics_string_list = [] for evaluation in response: print("model_evaluation") print(" name:", evaluation.name) print(" metrics_schema_uri:", evaluation.metrics_schema_uri) metrics = MessageToDict(evaluation._pb.metrics) for metric in metrics.keys(): logging.info("metric: %s, value: %s", metric, metrics[metric]) metrics_str = json.dumps(metrics) metrics_list.append(metrics) metrics_string_list.append(metrics_str) return ( evaluation.name, metrics_list, metrics_string_list, ) # Use the given metrics threshold(s) to determine whether the model is # accurate enough to deploy. def classification_thresholds_check(metrics_dict, thresholds_dict): for k, v in thresholds_dict.items(): logging.info("k {}, v {}".format(k, v)) if k in ["auRoc", "auPrc"]: # higher is better if metrics_dict[k] < v: # if under threshold, don't deploy logging.info( "{} < {}; returning False".format(metrics_dict[k], v) ) return False logging.info("threshold checks passed.") return True def log_metrics(metrics_list, metricsc): test_confusion_matrix = metrics_list[0]["confusionMatrix"] logging.info("rows: %s", test_confusion_matrix["rows"]) # log the ROC curve fpr = [] tpr = [] thresholds = [] for item in metrics_list[0]["confidenceMetrics"]: fpr.append(item.get("falsePositiveRate", 0.0)) tpr.append(item.get("recall", 0.0)) thresholds.append(item.get("confidenceThreshold", 0.0)) print(f"fpr: {fpr}") print(f"tpr: {tpr}") print(f"thresholds: {thresholds}") metricsc.log_roc_curve(fpr, tpr, thresholds) # log the confusion matrix annotations = [] for item in test_confusion_matrix["annotationSpecs"]: annotations.append(item["displayName"]) logging.info("confusion matrix annotations: %s", annotations) metricsc.log_confusion_matrix( annotations, test_confusion_matrix["rows"], ) # log textual metrics info as well for metric in metrics_list[0].keys(): if metric != "confidenceMetrics": val_string = json.dumps(metrics_list[0][metric]) metrics.log_metric(metric, val_string) # metrics.metadata["model_type"] = "AutoML Tabular classification" logging.getLogger().setLevel(logging.INFO) aiplatform.init(project=project) # extract the model resource name from the input Model Artifact model_resource_path = model.uri.replace("aiplatform://v1/", "") logging.info("model path: %s", model_resource_path) client_options = {"api_endpoint": api_endpoint} # Initialize client that will be used to create and send requests. client = aiplatform.gapic.ModelServiceClient(client_options=client_options) eval_name, metrics_list, metrics_str_list = get_eval_info( client, model_resource_path ) logging.info("got evaluation name: %s", eval_name) logging.info("got metrics list: %s", metrics_list) log_metrics(metrics_list, metricsc) thresholds_dict = json.loads(thresholds_dict_str) deploy = classification_thresholds_check(metrics_list[0], thresholds_dict) if deploy: dep_decision = "true" else: dep_decision = "false" logging.info("deployment decision is %s", dep_decision) return (dep_decision,)

Etapa 2: adicionar componentes pré-criados do Google Cloud

Nesta etapa, você vai definir os componentes restantes do seu pipeline e ver como todos se encaixam.

1. Primeiro, defina o nome de exibição da sua execução de pipeline usando um carimbo de data/hora:

import time DISPLAY_NAME = 'automl-beans{}'.format(str(int(time.time()))) print(DISPLAY_NAME)

2. Depois, copie o seguinte em uma nova célula do notebook:

@kfp.dsl.pipeline(name="automl-tab-beans-training-v2", pipeline_root=PIPELINE_ROOT) def pipeline( bq_source: str = "bq://aju-dev-demos.beans.beans1", display_name: str = DISPLAY_NAME, project: str = PROJECT_ID, gcp_region: str = "{{{ project_0.default_region | Placeholder value. }}}", api_endpoint: str = "{{{ project_0.default_region | Placeholder value. }}}-aiplatform.googleapis.com", thresholds_dict_str: str = '{"auRoc": 0.95}', ): dataset_create_op = gcc_aip.TabularDatasetCreateOp( project=project, display_name=display_name, bq_source=bq_source ) training_op = gcc_aip.AutoMLTabularTrainingJobRunOp( project=project, display_name=display_name, optimization_prediction_type="classification", budget_milli_node_hours=1000, column_transformations=[ {"numeric": {"column_name": "Area"}}, {"numeric": {"column_name": "Perimeter"}}, {"numeric": {"column_name": "MajorAxisLength"}}, {"numeric": {"column_name": "MinorAxisLength"}}, {"numeric": {"column_name": "AspectRation"}}, {"numeric": {"column_name": "Eccentricity"}}, {"numeric": {"column_name": "ConvexArea"}}, {"numeric": {"column_name": "EquivDiameter"}}, {"numeric": {"column_name": "Extent"}}, {"numeric": {"column_name": "Solidity"}}, {"numeric": {"column_name": "roundness"}}, {"numeric": {"column_name": "Compactness"}}, {"numeric": {"column_name": "ShapeFactor1"}}, {"numeric": {"column_name": "ShapeFactor2"}}, {"numeric": {"column_name": "ShapeFactor3"}}, {"numeric": {"column_name": "ShapeFactor4"}}, {"categorical": {"column_name": "Class"}}, ], dataset=dataset_create_op.outputs["dataset"], target_column="Class", ) model_eval_task = classif_model_eval_metrics( project, gcp_region, api_endpoint, thresholds_dict_str, training_op.outputs["model"], ) with dsl.Condition( model_eval_task.outputs["dep_decision"] == "true", name="deploy_decision", ): deploy_op = gcc_aip.ModelDeployOp( # noqa: F841 model=training_op.outputs["model"], project=project, machine_type="e2-standard-4", )

O que está acontecendo nesse código:

• Primeiro, assim como no pipeline anterior, você define os parâmetros de entrada que o pipeline aceita. É preciso selecioná-los manualmente, porque eles não dependem da saída de outras etapas do pipeline.
• O restante do pipeline usa alguns componentes pré-criados para interagir com serviços da Vertex AI:
  • TabularDatasetCreateOp cria um conjunto de dados tabular na Vertex AI quando recebe uma origem de banco de dados no Cloud Storage ou no BigQuery. Neste pipeline, você está transmitindo dados usando um URL de tabela do BigQuery.
  • AutoMLTabularTrainingJobRunOp inicia um job de treinamento do AutoML em um conjunto de dados tabular. Você transmite alguns parâmetros de configuração para este componente, incluindo o tipo de modelo (nesse caso, classificação), alguns dados nas colunas, por quanto tempo você quer executar o treinamento e um ponteiro para o conjunto de dados. Observe que, para transmitir o conjunto de dados para este componente, você fornece a saída do componente anterior usando dataset_create_op.outputs["dataset"] .
  • ModelDeployOp implanta um modelo específico em um endpoint da Vertex AI. Há outras opções de configuração disponíveis, mas aqui você fornece o tipo de máquina do endpoint, o projeto e o modelo que você quer implantar. Você transmite o modelo acessando as saídas da etapa de treinamento do seu pipeline.
• Este pipeline também usa a lógica condicional, um recurso do Vertex Pipelines que permite definir uma condição, junto com diferentes ramificações baseadas no resultado dessa condição. Lembre-se de que, ao definir o pipeline, você transferiu um parâmetro thresholds_dict_str. Esse é o limite de precisão que você usa para determinar se o modelo será implantado em um endpoint. Para implementar, use a classe Condition do SDK do KFP. A condição transmitida é a saída do componente de avaliação personalizada que você definiu anteriormente no laboratório. Se essa condição for verdadeira, o pipeline continua a executar o componente deploy_op. Se a acurácia não atingir o limite predefinido, o pipeline para aqui e não implanta um modelo.

Etapa 3: compilar e executar o pipeline de ML completo

1. Com o pipeline completo definido, é hora de compilá-lo:

compiler.Compiler().compile( pipeline_func=pipeline, package_path="tab_classif_pipeline.json" )

2. Em seguida, inicie uma execução do pipeline:

response = api_client.create_run_from_job_spec( "tab_classif_pipeline.json", pipeline_root=PIPELINE_ROOT, parameter_values={"project": PROJECT_ID,"display_name": DISPLAY_NAME} )

3. Clique no link mostrado após a execução da célula acima para conferir seu pipeline no console. A execução desse pipeline vai levar pouco mais de uma hora. A maior parte do tempo é gasta na etapa de treinamento do AutoML. O pipeline concluído será como este:

4. Se você acionar o botão "Expandir artefatos" na parte de cima da tela, poderá conferir detalhes dos diferentes artefatos criados usando seu pipeline. Por exemplo, se você clicar no artefato dataset, pode ver detalhes sobre o conjunto de dados da Vertex AI que foi criado. Você pode clicar no link mostrado aqui para acessar a página do conjunto de dados:

5. Da mesma maneira, para conferir as visualizações de métricas resultantes do seu componente de avaliação personalizado, clique no artefato chamado metricsc. No lado direito do seu painel, você pode ver a matriz de confusão do modelo:

6. Para conferir o modelo e o endpoint criados nessa execução do pipeline, acesse a seção de modelos e clique no modelo chamado automl-beans. Você vai conferir esse modelo implantado em um endpoint:

7. Também é possível acessar essa página clicando no artefato endpoint no gráfico do seu pipeline.

8. Além de conferir o gráfico do pipeline no console, é possível usar o Vertex Pipelines para fazer o Rastreamento de linhagem.

9. Ou seja, o rastreamento de artefatos criados usando seu pipeline. Isso pode ajudar você a entender onde os artefatos foram criados e como eles estão sendo usados em um fluxo de trabalho de ML. Por exemplo, para conferir o rastreamento de linhagem para o conjunto de dados criado no pipeline, clique no artefato do conjunto de dados e em Ver linhagem:

Isso mostra todos os lugares em que o artefato está sendo usado:

Observação: aguarde até o job de treinamento do pipeline ser iniciado e verifique seu progresso abaixo. O job de treinamento vai demorar mais que o tempo alocado para este laboratório, mas você receberá todos os pontos ao concluir o envio do job. Verifique se o seu job de treinamento do pipeline de ML de ponta a ponta foi iniciado

Etapa 4: comparar métricas entre as execuções de pipeline (opcional)

• Se você executar o pipeline muitas vezes, talvez queira compartilhar as métricas entre execuções. É possível usar o método aiplatform.get_pipeline_df() para acessar os metadados da execução. Aqui, você vai receber metadados de todas as execuções desse pipeline e carregá-los em um DataFrame do Pandas:

pipeline_df = aiplatform.get_pipeline_df(pipeline="automl-tab-beans-training-v2") small_pipeline_df = pipeline_df.head(2) small_pipeline_df

Agora você sabe como criar, executar e receber metadados de um pipeline de ML de ponta a ponta no Vertex Pipelines.

Parabéns!

Neste laboratório, você criou e executou um pipeline de emoji. Você também aprendeu como criar, executar e receber metadados de um pipeline de ML de ponta a ponta no Vertex Pipelines.

Termine a Quest

Este laboratório autoguiado faz parte da Quest com selo de habilidade Build and Deploy Machine Learning Solutions on Vertex AI. Uma Quest é um conjunto de laboratórios relacionados que formam um programa de aprendizado. Ao concluir uma Quest, você ganha um selo como reconhecimento da sua conquista. É possível incluir um link dos selos no seu currículo on-line ou nas redes sociais para mostrar suas conquistas. Inscreva-se em uma Quest e receba crédito de conclusão imediatamente. Consulte todas as Quests disponíveis no catálogo do Google Cloud Ensina.

Comece o próximo laboratório

Continue a Quest Build and Deploy Machine Learning Solutions on Vertex AI no Laboratório com desafio: como criar e implantar soluções de machine learning com a Vertex AI.

Próximas etapas / Saiba mais

Teste o mesmo cenário no seu próprio projeto do Google Cloud usando o codelab de Relações com desenvolvedores!

• Introdução ao Vertex Pipelines, de Sara Robinson

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 30 de agosto de 2023

Laboratório testado em 30 de agosto de 2023

Copyright 2024 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.