1. Visão geral
Neste laboratório, você vai usar a Vertex AI para executar um job de treinamento personalizado.
Este laboratório é parte da série de vídeos Protótipo para produção. Você vai criar um modelo de classificação de imagens usando o conjunto de dados de flores. Para saber mais, confira o vídeo complementar:
.
Conteúdo do laboratório
Você vai aprender a:
- criar um notebook gerenciado do Workbench da Vertex AI;
- configurar e iniciar um job de treinamento personalizado usando a interface da Vertex AI;
- configurar e iniciar um job de treinamento personalizado usando o SDK da Vertex AI para Python.
O custo total da execução deste laboratório no Google Cloud é de aproximadamente US$ 1.
2. Introdução à Vertex AI
Este laboratório usa a mais nova oferta de produtos de IA disponível no Google Cloud. 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 nova oferta combina ambos em uma única API, com outros novos produtos. Você também pode migrar projetos para a Vertex AI.
A Vertex AI inclui vários produtos diferentes para dar suporte a fluxos de trabalho integrais de ML. Os produtos destacados abaixo são o foco deste laboratório: treinamentos e Workbench.
3. Configurar o ambiente
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: ativar a API Compute Engine
Acesse o Compute Engine e selecione Ativar, caso essa opção ainda não esteja ativada.
Etapa 2: ativar a API Artifact Registry
Navegue até o Artifact Registry e selecione Ativar, se essa opção ainda não estiver ativada. Use isso para criar um contêiner para seu job de treinamento personalizado.
Etapa 3: ativar a API Vertex AI
Navegue até a seção "Vertex AI" do Console do Cloud e clique em Ativar API Vertex AI.
Etapa 4: criar uma instância do Vertex AI Workbench
Na seção Vertex AI do Console do Cloud, clique em "Workbench":
Ative a API Notebooks, se ela ainda não tiver sido ativada.
Após a ativação, clique em NOTEBOOK GERENCIADO:
Em seguida, selecione NOVO NOTEBOOK.
Dê um nome ao notebook. Em Permissão selecione Conta de serviço.
Selecione Configurações avançadas.
Em Segurança, selecione "Ativar terminal", se essa opção ainda não estiver ativada.
Você pode manter as outras configurações avançadas como estão.
Em seguida, clique em Criar. O provisionamento da instância vai levar alguns minutos.
Quando a instância tiver sido criada, selecione ABRIR O JUPYTERLAB.
4. Faça a conteinerização do código do aplicativo de treinamento
Você vai enviar este job de treinamento para a Vertex AI adicionado o código do aplicativo de treinamento a um contêiner do Docker e enviando esse contêiner por push para o Google Artifact Registry. Nessa abordagem, você pode treinar um modelo criado com qualquer framework.
Para começar, no menu de acesso rápido, abra uma janela de terminal na instância do notebook:
Etapa 1: criar um bucket do Cloud Storage
Neste job de treinamento, você vai exportar o modelo do TensorFlow treinado para o bucket do Cloud Storage e também armazenar os dados de treinamento nele.
No Terminal, execute o comando a seguir e defina uma variável env para o projeto. Lembre-se de substituir your-cloud-project pelo ID do projeto.
PROJECT_ID='your-cloud-project'
Depois execute o comando a seguir no terminal para criar um novo bucket no projeto:
BUCKET="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET
Etapa 2: copiar dados para o bucket do Cloud Storage
Precisamos inserir nosso conjunto de dados de flores no Cloud Storage. Na demonstração, primeiro você vai fazer o download do conjunto de dados para uma instância do Workbench e depois copiar para um bucket.
Faça o download e descompacte os dados.
wget https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz
tar xvzf flower_photos.tgz
Depois copie os dados para o bucket que você acabou de criar. Adicionamos -r porque queremos copiar o diretório inteiro e -m para executar uma cópia de multiprocessamento com maior rapidez.
gsutil -m cp -r flower_photos $BUCKET
Etapa 3: escrever código de treinamento
Crie um novo diretório chamado flowers e coloque cd nele:
mkdir flowers
cd flowers
Execute o comando a seguir para criar um diretório destinado ao código de treinamento e a um arquivo Python em que você vai adicionar o código.
mkdir trainer
touch trainer/task.py
Agora você deve ter o seguinte no diretório flowers/:
+ trainer/
+ task.py
Para saber como estruturar o código do aplicativo de treinamento, consulte os documentos.
Depois abra o arquivo task.py que você acabou de criar e copie o código abaixo.
Substitua {your-gcs-bucket} pelo nome do bucket do Cloud Storage recém-criado.
Na ferramenta Cloud Storage FUSE, os jobs de treinamento no Vertex AI Training podem acessar os dados no Cloud Storage como arquivos no sistemas de arquivos local. Quando você inicia um job de treinamento personalizado, ele identifica um diretório /gcs com todos os buckets do Cloud Storage como subdiretórios. É por isso que os caminhos no código de treinamento começam com /gcs.
import tensorflow as tf
import numpy as np
import os
## Replace {your-gcs-bucket} !!
BUCKET_ROOT='/gcs/{your-gcs-bucket}'
# Define variables
NUM_CLASSES = 5
EPOCHS=10
BATCH_SIZE = 32
IMG_HEIGHT = 180
IMG_WIDTH = 180
DATA_DIR = f'{BUCKET_ROOT}/flower_photos'
def create_datasets(data_dir, batch_size):
'''Creates train and validation datasets.'''
train_dataset = tf.keras.utils.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="training",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=batch_size)
validation_dataset = tf.keras.utils.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="validation",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=batch_size)
train_dataset = train_dataset.cache().shuffle(1000).prefetch(buffer_size=tf.data.AUTOTUNE)
validation_dataset = validation_dataset.cache().prefetch(buffer_size=tf.data.AUTOTUNE)
return train_dataset, validation_dataset
def create_model():
'''Creates model.'''
model = tf.keras.Sequential([
tf.keras.layers.Resizing(IMG_HEIGHT, IMG_WIDTH),
tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
])
return model
# CREATE DATASETS
train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)
# CREATE/COMPILE MODEL
model = create_model()
model.compile(optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy'])
# TRAIN MODEL
history = model.fit(
train_dataset,
validation_data=validation_dataset,
epochs=EPOCHS
)
# SAVE MODEL
model.save(f'{BUCKET_ROOT}/model_output')
Etapa 4: criar um Dockerfile
Para conteinerizar seu código, você precisa criar um Dockerfile. No Dockerfile, você vai incluir todos os comandos necessários para executar a imagem. Ele vai instalar todas as bibliotecas necessárias e configurar o ponto de entrada do código de treinamento.
No seu terminal, crie um Dockerfile vazio na raiz do diretório de flores.
touch Dockerfile
Agora você deve ter o seguinte no diretório flowers/:
+ Dockerfile
+ trainer/
+ task.py
Abra o Dockerfile e copie o seguinte nele:
FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-8
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]
Vamos analisar os comandos neste arquivo.
O comando FROM especifica a imagem de base (mãe) para a que você vai criar. Como imagem de base, você vai usar a imagem Docker da GPU do TensorFlow Enterprise 2.8 no Deep Learning Containers. O Deep Learning Containers no Google Cloud vem com muitas estruturas comuns de ML e ciência de dados pré-instaladas.
O comando WORKDIR especifica o diretório na imagem em que as instruções subsequentes são executadas.
O comando COPY copia o código de treinamento para a imagem Docker. Neste exemplo, só temos um arquivo Python no diretório de treinamento, mas você pode adicionar outros arquivos para um exemplo mais realista. Como o data.py, que pré-processa os dados, ou o model.py, que tem o código modelo etc. Para códigos de treinamento mais complexos, consulte os documentos sobre Python nos projetos de Python de empacotamento.
Se você quiser adicionar mais bibliotecas, use o comando RUN para fazer instalação com pip (por exemplo: RUN pip install -r requirements.txt). Mas não precisamos de mais nada para nosso exemplo aqui.
Por fim, o comando ENTRYPOINT configura o ponto de entrada para invocar o treinador. Ele vai ser executado quando começarmos o job de treinamento. No nosso caso, ele está executando o arquivo task.py.
Saiba como gravar Dockerfiles para o Vertex AI Training aqui.
Etapa 4: criar o contêiner
No terminal do notebook do Workbench, execute o seguinte comando e defina uma variável env para o projeto, substituindo your-cloud-project pelo ID dele:
PROJECT_ID='your-cloud-project'
Crie um repositório no Artifact Registry.
REPO_NAME='flower-app'
gcloud artifacts repositories create $REPO_NAME --repository-format=docker \
--location=us-central1 --description="Docker repository"
Defina uma variável com o URI da imagem do seu contêiner no Google Artifact Registry.
IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image:latest
Configure o Docker.
gcloud auth configure-docker \
us-central1-docker.pkg.dev
Agora execute o comando a seguir na raiz do diretório flower para criar o diretório:
docker build ./ -t $IMAGE_URI
Por fim, envie por push para o Artifact Registry:
docker push $IMAGE_URI
Com o contêiner enviado por push para o Artifact Registry, agora está tudo pronto para você iniciar o job de treinamento.
5. Executar um job de treinamento personalizado na Vertex AI
Este laboratório usa treinamento personalizado com um contêiner personalizado no Google Artifact Registry, mas também é possível executar um job de treinamento com os contêineres pré-criados.
Para começar, navegue até a seção Treinamento na seção da Vertex do console do Cloud:
Etapa 1: configurar job de treinamento
Clique em Criar e insira os parâmetros para seu job de treinamento.
- Em Conjunto de dados, selecione Sem conjunto de dados gerenciado.
- Selecione Treinamento personalizado (avançado) como seu método de treinamento e clique em Continuar.
- Selecione Treinar novo modelo e insira
flowers-model(ou o nome que você quiser dar ao modelo) em Nome do modelo. - Clique em Continuar
Na etapa "Configurações do contêiner", selecione Container personalizado:
Na primeira caixa (Imagem de contêiner), insira sua variável IMAGE_URI da seção anterior. Ela precisa ser: us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image:latest, com seu próprio ID do projeto. Deixe os demais campos em branco e clique em Continuar.
Pule a etapa "Hiperparâmetros" clicando de novo em Continuar.
Etapa 2: configurar cluster de computação
Configure o pool de workers 0 como flores:
Você vai pular a etapa 6 por enquanto e configurar o contêiner de previsão no próximo laboratório desta série.
Clique em INICIAR TREINAMENTO para começar seu job de treinamento. Na seção "Treinamento" do console, na guia PIPELINES DE TREINAMENTO, você vai encontrar o job recém-iniciado.
Parabéns! 🎉
Você aprendeu a usar a Vertex AI para:
- Iniciar um job de treinamento para um código de treinamento fornecido em um contêiner personalizado. Neste exemplo você usou um modelo do TensorFlow, mas é possível treinar um modelo criado com qualquer estrutura usando contêineres personalizados ou integrados.
Para saber mais sobre as diferentes partes da Vertex, consulte a documentação.
6. [Opcional] Usar o SDK da Vertex AI para Python.
A seção anterior mostrou como iniciar o job de treinamento pela interface. Nesta seção, você vai encontrar uma forma alternativa de enviar o job de treinamento usando o SDK da Vertex AI para Python.
Retorne à sua instância do notebook e crie um notebook do TensorFlow 2 na tela de início:
Importe o SDK da Vertex AI.
from google.cloud import aiplatform
Depois crie CustomContainerTrainingJob. Você vai precisar substituir {PROJECT_ID} em container_uri pelo nome do projeto e {BUCKET} em staging_bucket pelo bucket criado antes.
my_job = aiplatform.CustomContainerTrainingJob(display_name='flower-sdk-job',
container_uri='us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image:latest',
staging_bucket='gs://{BUCKET}')
Depois execute o job.
my_job.run(replica_count=1,
machine_type='n1-standard-8',
accelerator_type='NVIDIA_TESLA_V100',
accelerator_count=1)
Na demonstração, este job foi configurado para execução em uma máquina maior do que a da seção anterior. Além disso, estamos executando ele com uma GPU. Se você não especificar machine-type, accelerator_type ou accelerator_count, o job vai ser executado por padrão em n1-standard-4.
Na seção "Treinamento" do console, seu job de treinamento vai aparecer na guia JOBS PERSONALIZADOS.
7. Limpeza
Como os notebooks gerenciados do Vertex AI Workbench têm um recurso de encerramento inativo, não precisamos nos preocupar em parar a instância. Para encerrar a instância manualmente, clique no botão "Parar" na seção "Vertex AI Workbench" do console. Se quiser excluir o notebook completamente, clique no botão "Excluir".
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":
