1. Visão geral
Neste laboratório, você vai aprender a executar um job de treinamento de modelo personalizado usando o SDK do Kubeflow Pipelines no Vertex Pipelines.
Conteúdo do laboratório
Você vai aprender a:
- usar o SDK do Kubeflow Pipelines para criar pipelines de ML escalonáveis;
- Criar e conteinerizar um job de treinamento de modelo personalizado do Scikit-learn que usa conjuntos de dados gerenciados da Vertex AI e será executado no Vertex AI Training em um pipeline
- Executar um job de previsão em lote no Vertex Pipelines
- Usar componentes pré-criados para interagir com serviços da Vertex AI, usando a biblioteca
google_cloud_pipeline_components
O custo total da execução deste laboratório no Google Cloud é de aproximadamente US$5.
2. Introdução à Vertex AI
Este laboratório usa a Vertex AI, nossa plataforma de ML gerenciada de ponta a ponta no Google Cloud. A Vertex AI integra as ofertas de ML do Google no Google Cloud em uma experiência de desenvolvimento intuitiva. Além de oferecer treinamento de modelos e serviços de implantação, a Vertex AI também inclui uma variedade de produtos de MLOps, como o Vertex Pipelines (o assunto desse laboratório), Monitoramento de modelos, Feature Store e outros. Confira todos as ofertas de produtos da Vertex AI no diagrama abaixo.
Se você tiver algum feedback, acesse a página de suporte.
Por que pipelines de ML são úteis?
Antes de começar, primeiro entenda em quais situações 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 iniciar uma execução de pipeline quando novos dados de treinamento estiverem disponíveis.
Texto longo, leia o resumo: os pipelines ajudam a simplificar e reproduzir seus fluxos de trabalho de ML.
3. configure o ambiente do Cloud
Para executar este codelab, você vai precisar de um projeto do Google Cloud Platform com o faturamento ativado. Para criar um projeto, siga estas instruções.
Etapa 1: iniciar o Cloud Shell
Neste laboratório, você vai trabalhar em uma sessão do Cloud Shell, que é um interpretador de comandos hospedado por uma máquina virtual em execução na nuvem do Google. A sessão também pode ser executada localmente no seu computador, mas se você usar o Cloud Shell, todas as pessoas vão ter acesso a uma experiência reproduzível em um ambiente consistente. Após concluir o laboratório, é uma boa ideia testar a sessão no seu computador.
Ativar o Cloud Shell
No canto superior direito do console do Cloud, clique no botão abaixo para Ativar o Cloud Shell:
Se você nunca iniciou o Cloud Shell antes, uma tela intermediária (abaixo da dobra) será exibida com a descrição dele. Se esse for o caso, clique em Continuar (e você não verá mais esse aviso). Esta é a aparência dessa tela única:
Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.
Essa máquina virtual tem todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Praticamente todo o seu trabalho neste codelab pode ser feito em um navegador ou no seu Chromebook.
Depois de se conectar ao Cloud Shell, você já estará autenticado e o projeto já estará configurado com seu ID do projeto.
Execute o seguinte comando no Cloud Shell para confirmar se a conta está autenticada:
gcloud auth list
A resposta ao comando deve ser parecida com esta:
Execute o seguinte comando no Cloud Shell para confirmar que o comando gcloud sabe sobre seu projeto:
gcloud config list project
Resposta ao comando
[core] project = <PROJECT_ID>
Se o projeto não estiver configurado, configure-o usando este comando:
gcloud config set project <PROJECT_ID>
Resposta ao comando
Updated property [core/project].
O Cloud Shell tem algumas variáveis de ambiente, incluindo GOOGLE_CLOUD_PROJECT, que contém o nome do nosso projeto atual do Cloud. Vamos usar isso em várias partes deste laboratório. É possível ver essa variável ao executar:
echo $GOOGLE_CLOUD_PROJECT
Etapa 2: ativar as APIs
Nas próximas etapas, você vai saber onde e por que esses serviços são necessários. Por enquanto, execute este comando para dar ao seu projeto acesso aos serviços do Compute Engine, Container Registry e Vertex AI:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
Uma mensagem semelhante a esta vai aparecer:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
Etapa 3: criar um bucket do Cloud Storage
Para executar um job de treinamento na Vertex AI, vamos precisar de um bucket de armazenamento para armazenar nossos recursos de modelo salvos. O bucket precisa ser regional. Estamos usando a us-central aqui, mas você pode usar outra região, basta fazer a substituição ao longo do laboratório. Se você já tem um bucket, pule esta etapa.
Execute os comandos a seguir no terminal do Cloud Shell para criar um bucket:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
Depois, vamos conceder à conta de serviço do Compute acesso a esse bucket. Isso garante que o Vertex Pipelines tenha as permissões necessárias para gravar arquivos no bucket. Execute o comando a seguir para adicionar essa permissão:
gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}-compute@developer.gserviceaccount.com"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin
Etapa 4: criar uma instância do Vertex AI Workbench
Na seção Vertex AI do Console do Cloud, clique em "Workbench":
Em Notebooks gerenciados pelo usuário, clique em Novo notebook:
Em seguida, selecione o tipo de instância TensorFlow Enterprise 2.3 (com LTS) sem GPUs:
Use as opções padrão e clique em Criar.
Etapa 5: abrir seu notebook
Depois que a instância for criada, selecione Abrir JupyterLab:
4. Configuração do Vertex Pipelines
É preciso instalar algumas bibliotecas adicionais para usar o Vertex Pipelines:
- Kubeflow Pipelines: o SDK que vamos usar 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
Primeiro, no menu inicial da sua instância do Notebook, que pode ser acessado clicando no ícone + no canto superior esquerdo do notebook, crie um notebook selecionando Python 3:
Para acessar o menu inicial, clique no sinal de + no canto superior esquerdo da sua instância do notebook.
Para instalar os serviços que vamos usar neste laboratório, primeiro configure a sinalização do usuário em uma célula do notebook:
USER_FLAG = "--user"
Em seguida, execute o seguinte no seu notebook:
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0 --upgrade
!pip3 install {USER_FLAG} kfp==1.8.9 google-cloud-pipeline-components==0.2.0
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)
Por fim, verifique se os pacotes foram instalados corretamente. A versão do SDK do KFP deve ser a 1.8 ou 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. A seguir, vamos criar variáveis para cada um deles.
Se não souber o ID do projeto, você pode consegui-lo executando o seguinte:
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from 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)
Caso contrário, defina-o aqui:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
Depois, crie uma variável para armazenar o nome do seu bucket. Se você criou neste laboratório, as próximas etapas vão funcionar. Caso contrário, configure manualmente o que é mostrado a seguir:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
Etapa 3: importar as bibliotecas
Adicione o código abaixo para importar as bibliotecas que vamos usar neste codelab:
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
Etapa 4: definir as constantes
Por último, precisamos definir algumas variáveis constantes antes de criar o pipeline. PIPELINE_ROOT é o caminho do Cloud Storage em que os artefatos criados pelo pipeline serão gravados. Estamos usando us-central1 como a região aqui, 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="us-central1"
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 estará no formato gs://YOUR-BUCKET-NAME/pipeline_root/
5. Como configurar um job de treinamento de modelo personalizado
Antes de configurar o pipeline, precisamos escrever o código do job de treinamento de modelo personalizado. Para treinar o modelo, vamos usar o conjunto de dados de grãos secos de machine learning da UCI, 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
Nossa primeira etapa do pipeline vai criar um conjunto de dados gerenciado na Vertex AI usando uma tabela do BigQuery com uma versão desses dados de grãos. O conjunto de dados será transmitido como entrada para o job de treinamento. No código de treinamento, vamos ter acesso à variável de ambiente para acessar esse conjunto de dados gerenciado.
Veja como vamos configurar nosso job de treinamento personalizado:
- Criar um modelo
DecisionTreeClassifierdo Scikit-learn para classificar tipos de grão nos dados - Empacotar o código de treinamento em um contêiner do Docker e enviar para o Container Registry
Depois disso, será possível iniciar um job do Vertex AI Training diretamente pelo pipeline. Vamos começar!
Etapa 1: definir o código de treinamento em um contêiner do Docker
Na instância de Notebooks, abra o acesso rápido e selecione Terminal:
Em seguida, execute o seguinte para configurar um diretório em que você vai adicionar o código conteinerizado:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
Depois de executar esses comandos, você verá um diretório com o nome traincontainer/ criado à esquerda. Talvez seja necessário clicar no ícone de atualização para vê-lo. Você verá o seguinte no diretório traincontainer/:
+ Dockerfile
+ trainer/
+ train.py
Nossa primeira etapa na conteinerização do código é criar um Dockerfile. No nosso Dockerfile, incluiremos todos os comandos necessários para executar a nossa imagem. Ele vai instalar todas as bibliotecas que estamos usando e configurar o ponto de entrada do nosso código de treinamento. Abra o Dockerfile que você acabou de criar e adicione o seguinte:
FROM gcr.io/deeplearning-platform-release/sklearn-cpu.0-23
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
RUN pip install sklearn google-cloud-bigquery joblib pandas google-cloud-storage
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
Para salvar arquivos durante a edição na instância do notebook, use ctrl+s.
Em seguida, abra o arquivo train.py. É aqui que vamos adicionar nosso código de treinamento. Copie o seguinte para train.py. Isso recupera os dados do nosso conjunto de dados gerenciado, os coloca em um DataFrame do Pandas, treina um modelo do Scikit-learn e faz upload do modelo treinado para o Cloud Storage:
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from google.cloud import bigquery
from google.cloud import storage
from joblib import dump
import os
import pandas as pd
bqclient = bigquery.Client()
storage_client = storage.Client()
def download_table(bq_table_uri: str):
prefix = "bq://"
if bq_table_uri.startswith(prefix):
bq_table_uri = bq_table_uri[len(prefix):]
table = bigquery.TableReference.from_string(bq_table_uri)
rows = bqclient.list_rows(
table,
)
return rows.to_dataframe(create_bqstorage_client=False)
# These environment variables are from Vertex AI managed datasets
training_data_uri = os.environ["AIP_TRAINING_DATA_URI"]
test_data_uri = os.environ["AIP_TEST_DATA_URI"]
# Download data into Pandas DataFrames, split into train / test
df = download_table(training_data_uri)
test_df = download_table(test_data_uri)
labels = df.pop("Class").tolist()
data = df.values.tolist()
test_labels = test_df.pop("Class").tolist()
test_data = test_df.values.tolist()
# Define and train the Scikit model
skmodel = DecisionTreeClassifier()
skmodel.fit(data, labels)
score = skmodel.score(test_data, test_labels)
print('accuracy is:',score)
# Save the model to a local file
dump(skmodel, "model.joblib")
# Upload the saved model file to GCS
bucket = storage_client.get_bucket("YOUR_GCS_BUCKET")
model_directory = os.environ["AIP_MODEL_DIR"]
storage_path = os.path.join(model_directory, "model.joblib")
blob = storage.blob.Blob.from_string(storage_path, client=storage_client)
blob.upload_from_filename("model.joblib")
Em seguida, volte ao notebook e execute o comando a seguir para substituir YOUR_GCS_BUCKET do script acima pelo nome do bucket do Cloud Storage:
BUCKET = BUCKET_NAME[5:] # Trim the 'gs://' before adding to train script
!sed -i -r 's@YOUR_GCS_BUCKET@'"$BUCKET"'@' traincontainer/trainer/train.py
Você também pode fazer isso manualmente, se preferir. Se fizer isso, não inclua gs:// no nome do bucket ao atualizar o script.
Agora o código de treinamento está em um contêiner do Docker, e estamos prontos para executar o treinamento na nuvem.
Etapa 2: enviar o contêiner para o Container Registry
Depois de concluir o código de treinamento, podemos enviá-lo para o Google Container Registry. Depois, quando configurarmos o componente de treinamento do pipeline, vamos apontar o Vertex Pipelines para esse contêiner.
Volte ao terminal e, na raiz do diretório traincontainer/, defina uma variável com o URI da imagem do contêiner no Container Registry.
PROJECT_ID=$(gcloud config get-value project)
IMAGE_URI="gcr.io/$PROJECT_ID/scikit:v1"
Crie o contêiner executando o seguinte comando:
docker build ./ -t $IMAGE_URI
Por fim, envie o contêiner para o Container Registry:
docker push $IMAGE_URI
Acesse a seção Container Registry do console do Cloud para verificar se o contêiner está lá. Algo parecido com isto será exibido:
6. Como configurar um job de previsão em lote
A última etapa do pipeline vai executar um job de previsão em lote. Para que isso funcione, precisamos fornecer um arquivo CSV no Cloud Storage com os exemplos sobre os quais queremos fazer previsões. Vamos criar esse arquivo CSV em nosso notebook e copiá-lo para o Cloud Storage usando a ferramenta de linha de comando gsutil.
Como copiar exemplos de previsão em lote para o Cloud Storage
O arquivo a seguir contém três exemplos de cada classe no conjunto de dados de grãos. O exemplo abaixo não inclui a coluna Class, já que é ela que o modelo vai prever. Execute o comando a seguir para criar esse arquivo CSV localmente no notebook:
%%writefile batch_examples.csv
Area,Perimeter,MajorAxisLength,MinorAxisLength,AspectRation,Eccentricity,ConvexArea,EquivDiameter,Extent,Solidity,roundness,Compactness,ShapeFactor1,ShapeFactor2,ShapeFactor3,ShapeFactor4
23288,558.113,207.567738,143.085693,1.450653336,0.7244336162,23545,172.1952453,0.8045881703,0.9890847314,0.9395021523,0.8295857874,0.008913077034,0.002604069884,0.6882125787,0.9983578734
23689,575.638,205.9678003,146.7475015,1.403552348,0.7016945718,24018,173.6714472,0.7652721693,0.9863019402,0.8983750474,0.8431970773,0.00869465998,0.002711119968,0.7109813112,0.9978994889
23727,559.503,189.7993849,159.3717704,1.190922235,0.5430731512,24021,173.8106863,0.8037601626,0.9877607094,0.952462433,0.9157600082,0.007999299741,0.003470231343,0.8386163926,0.9987269085
31158,641.105,212.0669751,187.1929601,1.132879009,0.4699241567,31474,199.1773023,0.7813134733,0.989959967,0.9526231013,0.9392188582,0.0068061806,0.003267009878,0.8821320637,0.9993488983
32514,649.012,221.4454899,187.1344232,1.183349841,0.5346736437,32843,203.4652564,0.7849831,0.9899826447,0.9700068737,0.9188051492,0.00681077351,0.002994124691,0.8442029022,0.9989873701
33078,659.456,235.5600775,178.9312328,1.316483846,0.6503915309,33333,205.2223615,0.7877214708,0.9923499235,0.9558229607,0.8712102818,0.007121351881,0.002530662194,0.7590073551,0.9992209221
33680,683.09,256.203255,167.9334938,1.525623324,0.7552213942,34019,207.081404,0.80680321,0.9900349805,0.9070392732,0.8082699962,0.007606985006,0.002002710402,0.6533003868,0.9966903078
33954,716.75,277.3684803,156.3563259,1.773951126,0.825970469,34420,207.9220419,0.7994819873,0.9864613597,0.8305492781,0.7496238998,0.008168948587,0.001591181142,0.5619359911,0.996846984
36322,719.437,272.0582306,170.8914975,1.591993952,0.7780978465,36717,215.0502424,0.7718560075,0.9892420405,0.8818487005,0.7904566678,0.007490177594,0.001803782407,0.6248217437,0.9947124371
36675,742.917,285.8908964,166.8819538,1.713132487,0.8119506999,37613,216.0927123,0.7788277766,0.9750618137,0.8350248381,0.7558572692,0.0077952528,0.001569528272,0.5713202115,0.9787472145
37454,772.679,297.6274753,162.1493177,1.835514817,0.8385619338,38113,218.3756257,0.8016695205,0.9827093118,0.7883332637,0.7337213257,0.007946480356,0.001420623993,0.5383469838,0.9881438654
37789,766.378,313.5680678,154.3409867,2.031657789,0.8704771226,38251,219.3500608,0.7805870567,0.9879218844,0.8085170916,0.6995293312,0.008297866252,0.001225659709,0.4893412853,0.9941740339
47883,873.536,327.9986493,186.5201272,1.758516115,0.822571799,48753,246.9140116,0.7584464543,0.9821549443,0.7885506623,0.7527897207,0.006850002074,0.00135695419,0.5666923636,0.9965376533
49777,861.277,300.7570338,211.6168613,1.42123379,0.7105823885,50590,251.7499649,0.8019106536,0.9839296304,0.843243269,0.8370542883,0.00604208839,0.001829706116,0.7006598815,0.9958014989
49882,891.505,357.1890036,179.8346914,1.986207449,0.8640114945,51042,252.0153467,0.7260210171,0.9772736178,0.7886896753,0.7055518063,0.007160679276,0.001094585314,0.4978033513,0.9887407248
53249,919.923,325.3866286,208.9174205,1.557489212,0.7666552108,54195,260.3818974,0.6966846347,0.9825445152,0.7907120655,0.8002231025,0.00611066177,0.001545654241,0.6403570138,0.9973491406
61129,964.969,369.3481688,210.9473449,1.750902193,0.8208567513,61796,278.9836198,0.7501135067,0.9892064211,0.8249553283,0.7553404711,0.006042110436,0.001213219664,0.5705392272,0.9989583843
61918,960.372,353.1381442,224.0962377,1.575832543,0.7728529173,62627,280.7782864,0.7539207091,0.9886790043,0.8436218213,0.7950947556,0.005703319619,0.00140599258,0.6321756704,0.9962029945
141953,1402.05,524.2311633,346.3974998,1.513380332,0.7505863011,143704,425.1354762,0.7147107987,0.9878152313,0.9074598849,0.8109694843,0.003692991084,0.0009853172185,0.6576715044,0.9953071199
145285,1440.991,524.9567463,353.0769977,1.486805285,0.7400216694,146709,430.0960442,0.7860466375,0.9902937107,0.8792413513,0.8192980608,0.003613289371,0.001004269363,0.6712493125,0.9980170255
146153,1476.383,526.1933264,356.528288,1.475881001,0.7354662103,149267,431.3789276,0.7319360978,0.9791380546,0.8425962592,0.8198107159,0.003600290972,0.001003163512,0.6720896099,0.991924286
Depois copie o arquivo para o bucket do Cloud Storage:
!gsutil cp batch_examples.csv $BUCKET_NAME
Faremos referência a esse arquivo na próxima etapa quando definirmos nosso pipeline.
7. Como criar um pipeline com componentes pré-criados
Agora que o código de treinamento está na nuvem, estamos prontos para chamá-lo pelo pipeline. O pipeline que vamos definir vai usar três componentes pré-criados da biblioteca google_cloud_pipeline_components que instalamos anteriormente. Esses componentes predefinidos simplificam o código que precisamos escrever para configurar nosso pipeline e nos permitem usar serviços da Vertex AI, como treinamento de modelo e previsão em lote.
Veja o que nosso pipeline de três etapas fará:
- Criar um conjunto de dados gerenciado na Vertex AI
- Executar um job de treinamento na Vertx AI usando o contêiner personalizado que configuramos
- Executar um job de previsão em lote no modelo de classificação Scikit-learn treinado
Etapa 1: definir o pipeline
Como estamos usando componentes pré-criados, podemos configurar todo o pipeline na definição dele. Adicione o seguinte a uma célula do notebook:
@pipeline(name="automl-beans-custom",
pipeline_root=PIPELINE_ROOT)
def pipeline(
bq_source: str = "bq://sara-vertex-demos.beans_demo.large_dataset",
bucket: str = BUCKET_NAME,
project: str = PROJECT_ID,
gcp_region: str = REGION,
bq_dest: str = "",
container_uri: str = "",
batch_destination: str = ""
):
dataset_create_op = gcc_aip.TabularDatasetCreateOp(
display_name="tabular-beans-dataset",
bq_source=bq_source,
project=project,
location=gcp_region
)
training_op = gcc_aip.CustomContainerTrainingJobRunOp(
display_name="pipeline-beans-custom-train",
container_uri=container_uri,
project=project,
location=gcp_region,
dataset=dataset_create_op.outputs["dataset"],
staging_bucket=bucket,
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
bigquery_destination=bq_dest,
model_serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest",
model_display_name="scikit-beans-model-pipeline",
machine_type="n1-standard-4",
)
batch_predict_op = gcc_aip.ModelBatchPredictOp(
project=project,
location=gcp_region,
job_display_name="beans-batch-predict",
model=training_op.outputs["model"],
gcs_source_uris=["{0}/batch_examples.csv".format(BUCKET_NAME)],
instances_format="csv",
gcs_destination_output_uri_prefix=batch_destination,
machine_type="n1-standard-4"
)
Etapa 2: compilar e executar o pipeline
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=pipeline, package_path="custom_train_pipeline.json"
)
Em seguida, crie uma variável TIMESTAMP. Usaremos isto em nosso ID da tarefa:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Em seguida, defina o job do pipeline, passando alguns parâmetros específicos do projeto:
pipeline_job = aiplatform.PipelineJob(
display_name="custom-train-pipeline",
template_path="custom_train_pipeline.json",
job_id="custom-train-pipeline-{0}".format(TIMESTAMP),
parameter_values={
"project": PROJECT_ID,
"bucket": BUCKET_NAME,
"bq_dest": "bq://{0}".format(PROJECT_ID),
"container_uri": "gcr.io/{0}/scikit:v1".format(PROJECT_ID),
"batch_destination": "{0}/batchpredresults".format(BUCKET_NAME)
},
enable_caching=True,
)
Por fim, execute o job para criar uma nova execução de pipeline:
pipeline_job.submit()
Depois de executar essa célula, você verá registros com um link para visualizar a execução do pipeline no console:
Acesse esse link. Também é possível acessá-lo abrindo o Painel de pipelines. Quando concluído, o pipeline ficará assim:
O pipeline vai levar de 5 a 10 minutos para ser executado, mas é possível avançar para a próxima etapa antes de concluir. A seguir, você aprenderá mais sobre o que acontece em cada uma dessas etapas do pipeline.
8. Entender a execução do pipeline
Vamos nos aprofundar em cada uma das três etapas do pipeline.
Etapa 1 do pipeline: criar um conjunto de dados gerenciado
A primeira etapa do pipeline cria um conjunto de dados gerenciado na Vertex AI. Se você clicar no link do conjunto de dados a seguir na seção "Pipelines" do console:
O conjunto de dados será mostrado na Vertex AI, incluindo um link para a fonte de dados no BigQuery, além de informações sobre as diferentes colunas do conjunto de dados. Depois de fazer upload de um conjunto de dados gerenciado para a Vertex AI, ele pode ser usado para treinar um modelo de AutoML ou personalizado.
Para jobs de modelos personalizados que usam conjuntos de dados gerenciados, a Vertex AI transmite variáveis de ambiente especiais para os jobs de treinamento e lida com a divisão dos dados em conjuntos de treinamento e teste. Vamos usar isso na próxima etapa do pipeline.
Etapa 2 do pipeline: treinar um modelo no Vertex AI Training
Enquanto o job de treinamento personalizado estiver em execução, clique para ver os registros diretamente no console do Vertex Pipelines:
Também é possível conferir detalhes sobre o job de treinamento personalizado no painel de treinamento da Vertex AI. Quando o job de treinamento for concluído, um recurso modelo será criado na Vertex AI. Em seguida, podemos implantar esse modelo em um endpoint para previsões on-line ou criar um job de previsão em lote, o que vamos fazer na próxima etapa do pipeline.
Etapa 3 do pipeline: executar um job de previsão em lote no modelo
Por fim, o pipeline vai receber previsões sobre os exemplos que transmitimos por um arquivo CSV. Quando o job de previsão em lote é concluído, a Vertex AI grava um arquivo CSV no local especificado no Cloud Storage. Quando a execução dessa etapa do pipeline começar, acesse a seção "Previsões em lote" do console da Vertex AI para conferir o job criado.
Clique no job quando ele for concluído para conferir o URL do Cloud Storage das previsões em lote:
Clique nesse link para acessar o diretório do Cloud Storage, onde você pode encontrar os resultados da previsão, e depois clique para fazer o download de um dos arquivos prediction.results. No arquivo, você vai encontrar linhas parecidas com estas:
{"instance": [33954.0, 716.75, 277.3684803, 156.3563259, 1.773951126, 0.825970469, 34420.0, 207.9220419, 0.7994819873, 0.9864613597, 0.8305492781, 0.7496238998, 0.008168948587, 0.001591181142, 0.5619359911, 0.996846984], "prediction": "HOROZ"}
Isso inclui os valores de atributo de uma instância específica e a classe prevista pelo nosso modelo. Para este exemplo, nosso modelo acha que este foi um "HOROZ" vagem.
Com isso, você concluiu o laboratório.
Parabéns! 🎉
Você aprendeu a usar a Vertex AI para:
- Usar o SDK do Kubeflow Pipelines para criar pipelines completos com componentes personalizados
- Executar pipelines no Vertex Pipelines e iniciar execuções do pipeline com o SDK
- Acessar e analisar o gráfico do Vertex Pipelines no console
- Usar componentes de pipeline pré-criados para adicionar serviços da Vertex AI ao pipeline
- Programar jobs recorrentes com pipelines
Para saber mais sobre as diferentes partes da Vertex, consulte a documentação.
9. Limpeza
Para não receber cobranças, recomendamos que você exclua os recursos criados neste laboratório.
Etapa 1: interromper ou excluir a instância de Notebooks
Se você quiser continuar usando o notebook que criou neste laboratório, é recomendado que você o desligue quando não estiver usando. A partir da interface de Notebooks no seu Console do Cloud, selecione o notebook e depois clique em Parar. Para excluir a instância completamente, selecione Excluir:
Etapa 2: excluir o bucket do Cloud Storage
Para excluir o bucket do Storage, use o menu de navegação do console do Cloud, acesse o Storage, selecione o bucket e clique em "Excluir":
