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 na 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 os 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 completa 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, consulte 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.
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 Cloud Console, clique no botão abaixo para ativar o Cloud Shell:
Se você nunca iniciou o Cloud Shell, vai aparecer uma tela intermediária (abaixo da dobra) com a descrição dele. Se esse for o caso, clique em Continuar e você não vai encontrar essa tela novamente. Esta é a aparência dessa tela única:
Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.
Essa máquina virtual contém 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 saída do comando vai ser parecida com esta:
Execute o comando a seguir no Cloud Shell para confirmar se 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 esses dados várias vezes neste 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 entender onde e por que esses serviços são necessários. Por enquanto, apenas execute este comando para conceder 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, precisamos de um bucket de armazenamento para armazenar os recursos de modelo salvos. O bucket precisa ser regional. Estamos usando us-central aqui, mas você pode usar qualquer outra, é só fazer a substituição durante o 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
A próxima etapa é configurar o acesso da conta de serviço do computador 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 o 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 precisa ser igual ou mais recente do que 1.8:
!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, vamos criar variáveis para cada um.
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 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 seguinte para importar as bibliotecas que vamos usar durante este 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 seu pipeline foram gravados. Aqui, estamos usando us-central1 como 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="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 para o job de treinamento do modelo personalizado. Para treinar o modelo, vamos usar o conjunto de dados Dry beans (feijões secos) do UCI Machine Learning, 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 nosso job de treinamento. No código de treinamento, teremos acesso à variável de ambiente para acessar esse conjunto de dados gerenciado.
Veja como vamos configurar nosso job de treinamento personalizado:
- Crie um modelo
DecisionTreeClassifierdo Scikit-learn para classificar os 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 Launcher 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, um diretório chamado traincontainer/ será 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
A primeira etapa na conteinerização do código é criar um Dockerfile. No Dockerfile, vamos incluir todos os comandos necessários para executar a imagem. Isso vai resultar na instalação de todas as bibliotecas que você estiver usando e na configuração do ponto de entrada do seu 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 enquanto os edita na instância do notebook, use ctrl+s.
Em seguida, abra o arquivo train.py. É aqui que vamos adicionar o 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 Scikit-learn e faz o 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 seu notebook e execute o seguinte comando 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 você fizer isso, não inclua gs:// no nome do bucket ao atualizar o script.
Agora nosso 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. Mais tarde, ao configurar o componente de treinamento do nosso pipeline, vamos apontar o Vertex Pipelines para esse contêiner.
Volte para o 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"
Em seguida, crie o contêiner executando o seguinte:
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 no seu 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 feijões. 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
Em seguida, copie o arquivo para o bucket do Cloud Storage:
!gsutil cp batch_examples.csv $BUCKET_NAME
Vamos fazer referência a esse arquivo na próxima etapa, quando definirmos o pipeline.
7. Criar um pipeline com componentes pré-criados
Agora que o código de treinamento está na nuvem, podemos fazer a chamada dele no 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 modelos 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 nosso modelo de classificação treinado do Scikit-learn
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. Vamos usar isso no nosso ID de trabalho:
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 acessar esse recurso abrindo o painel de pipelines. Seu pipeline vai ficar assim quando concluído:
Esse pipeline vai levar de 5 a 10 minutos para ser executado, mas você pode continuar para a próxima etapa antes que ele seja concluído. A seguir, você aprenderá mais sobre o que acontece em cada uma dessas etapas do pipeline.
8. Entender a execução do pipeline
Vamos analisar melhor 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 na seção "Pipelines" do console:
O conjunto de dados vai aparecer na Vertex AI, incluindo um link para a fonte de dados no BigQuery e informações sobre as diferentes colunas. Depois de fazer upload de um conjunto de dados gerenciado para a Vertex AI, ele pode ser usado para treinar um modelo 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, é possível implantar esse modelo em um endpoint para previsões on-line ou para criar um job de previsão em lote, o que será feito 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ê encontra os resultados da previsão, e clique para fazer o download de um dos arquivos prediction.results. No arquivo, você vai encontrar linhas parecidas com esta:
{"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 modelo. Neste exemplo, nosso modelo acha que se trata de um bean "HOROZ".
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 de pipeline
Para saber mais sobre as diferentes partes da Vertex, consulte a documentação.
9. Limpeza
Para que você não seja cobrado, recomendamos que exclua os recursos criados neste laboratório.
Etapa 1: interromper ou excluir a instância do 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. Se quiser excluir a instância por completo, 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":
