1. Visão geral
Neste laboratório, você vai usar a Vertex AI para treinar e fornecer um modelo do TensorFlow usando código em um contêiner personalizado.
Estamos usando o TensorFlow para o código do modelo aqui, mas ele pode ser facilmente substituído por outro framework.
Conteúdo do laboratório
Você vai aprender a:
- Criar e conteinerizar o código de treinamento de modelo no Vertex Workbench
- Enviar um job de treinamento de modelo personalizado para a Vertex AI
- Implantar o modelo treinado em um endpoint e usar esse endpoint para fazer previsões
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 existentes para a Vertex AI. Se você tiver algum feedback, consulte a página de suporte.
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: Training, Prediction 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. Você vai precisar disso para criar sua instância de notebook.
Etapa 2: ativar a API Vertex AI
Navegue até a seção "Vertex AI" do Console do Cloud e clique em Ativar API Vertex AI.
Etapa 3: ativar a API Container Registry
Navegue até o Container Registry e selecione Ativar. Use isso para criar um contêiner para seu job de treinamento personalizado.
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 a versão mais recente do tipo de instância TensorFlow Enterprise (com LTS) sem GPUs:
Use as opções padrão e clique em Criar.
O modelo que vamos treinar e disponibilizar neste laboratório é baseado neste tutorial (em inglês) da documentação do TensorFlow. O tutorial usa o conjunto de dados Auto MPG do Kaggle para prever a eficiência de combustível de um veículo.
4. conteinerize o código de treinamento
Para enviar este job de treinamento para a Vertex, vamos colocar o código de treinamento em um contêiner do Docker e enviar esse contêiner para o Google Container Registry. Com essa abordagem, é possível 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:
Crie um novo diretório chamado mpg e coloque cd nele:
mkdir mpg
cd mpg
Etapa 1: criar um Dockerfile
A 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. 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. No seu terminal, crie um Dockerfile vazio:
touch Dockerfile
Abra o Dockerfile e copie o seguinte nele:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-6
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.train"]
Este Dockerfile usa a imagem do Docker do TensorFlow Enterprise 2.3 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 que estamos usando inclui TF Enterprise 2.3, Pandas, Scikit-learn e outros. Depois de fazer o download dessa imagem, este Dockerfile configura o ponto de entrada para nosso código de treinamento. Ainda não criamos esses arquivos – na próxima etapa, vamos adicionar o código para treinar e exportar nosso modelo.
Etapa 2: criar um bucket do Cloud Storage
No job de treinamento, vamos exportar o modelo do TensorFlow treinado para um bucket do Cloud Storage. Dessa forma, a Vertex vai conseguir ler os ativos do seu modelo exportado e implantá-lo. 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: A flag -l (localização) é importante, já que é necessário estar na mesma região onde você vai implantar um endpoint de modelo mais adiante no tutorial:
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
Etapa 3: adicionar o código de treinamento do modelo
No seu terminal, execute o seguinte para criar um diretório para o código de treinamento e um arquivo Python em que vamos adicionar o código:
mkdir trainer
touch trainer/train.py
Agora você deve ter o seguinte no seu diretório mpg/:
+ Dockerfile
+ trainer/
+ train.py
Em seguida, abra o arquivo train.py que você acabou de criar e copie o código abaixo (adaptado do tutorial nas documentações do TensorFlow).
No início do arquivo, atualize a variável BUCKET com o nome do bucket do Storage criado na etapa anterior:
import numpy as np
import pandas as pd
import pathlib
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
"""## The Auto MPG dataset
The dataset is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/).
### Get the data
First download the dataset.
"""
dataset_path = keras.utils.get_file("auto-mpg.data", "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data")
dataset_path
"""Import it using pandas"""
column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
'Acceleration', 'Model Year', 'Origin']
dataset = pd.read_csv(dataset_path, names=column_names,
na_values = "?", comment='\t',
sep=" ", skipinitialspace=True)
dataset.tail()
# TODO: replace `your-gcs-bucket` with the name of the Storage bucket you created earlier
BUCKET = 'gs://your-gcs-bucket'
"""### Clean the data
The dataset contains a few unknown values.
"""
dataset.isna().sum()
"""To keep this initial tutorial simple drop those rows."""
dataset = dataset.dropna()
"""The `"Origin"` column is really categorical, not numeric. So convert that to a one-hot:"""
dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})
dataset = pd.get_dummies(dataset, prefix='', prefix_sep='')
dataset.tail()
"""### Split the data into train and test
Now split the dataset into a training set and a test set.
We will use the test set in the final evaluation of our model.
"""
train_dataset = dataset.sample(frac=0.8,random_state=0)
test_dataset = dataset.drop(train_dataset.index)
"""### Inspect the data
Have a quick look at the joint distribution of a few pairs of columns from the training set.
Also look at the overall statistics:
"""
train_stats = train_dataset.describe()
train_stats.pop("MPG")
train_stats = train_stats.transpose()
train_stats
"""### Split features from labels
Separate the target value, or "label", from the features. This label is the value that you will train the model to predict.
"""
train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')
"""### Normalize the data
Look again at the `train_stats` block above and note how different the ranges of each feature are.
It is good practice to normalize features that use different scales and ranges. Although the model *might* converge without feature normalization, it makes training more difficult, and it makes the resulting model dependent on the choice of units used in the input.
Note: Although we intentionally generate these statistics from only the training dataset, these statistics will also be used to normalize the test dataset. We need to do that to project the test dataset into the same distribution that the model has been trained on.
"""
def norm(x):
return (x - train_stats['mean']) / train_stats['std']
normed_train_data = norm(train_dataset)
normed_test_data = norm(test_dataset)
"""This normalized data is what we will use to train the model.
Caution: The statistics used to normalize the inputs here (mean and standard deviation) need to be applied to any other data that is fed to the model, along with the one-hot encoding that we did earlier. That includes the test set as well as live data when the model is used in production.
## The model
### Build the model
Let's build our model. Here, we'll use a `Sequential` model with two densely connected hidden layers, and an output layer that returns a single, continuous value. The model building steps are wrapped in a function, `build_model`, since we'll create a second model, later on.
"""
def build_model():
model = keras.Sequential([
layers.Dense(64, activation='relu', input_shape=[len(train_dataset.keys())]),
layers.Dense(64, activation='relu'),
layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mse',
optimizer=optimizer,
metrics=['mae', 'mse'])
return model
model = build_model()
"""### Inspect the model
Use the `.summary` method to print a simple description of the model
"""
model.summary()
"""Now try out the model. Take a batch of `10` examples from the training data and call `model.predict` on it.
It seems to be working, and it produces a result of the expected shape and type.
### Train the model
Train the model for 1000 epochs, and record the training and validation accuracy in the `history` object.
Visualize the model's training progress using the stats stored in the `history` object.
This graph shows little improvement, or even degradation in the validation error after about 100 epochs. Let's update the `model.fit` call to automatically stop training when the validation score doesn't improve. We'll use an *EarlyStopping callback* that tests a training condition for every epoch. If a set amount of epochs elapses without showing improvement, then automatically stop the training.
You can learn more about this callback [here](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping).
"""
model = build_model()
EPOCHS = 1000
# The patience parameter is the amount of epochs to check for improvement
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
early_history = model.fit(normed_train_data, train_labels,
epochs=EPOCHS, validation_split = 0.2,
callbacks=[early_stop])
# Export model and save to GCS
model.save(BUCKET + '/mpg/model')
Etapa 4: criar e testar o contêiner localmente
No seu terminal, defina uma variável com o URI da imagem do seu contêiner no Google Container Registry:
IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"
Agora execute o comando a seguir na raiz do diretório mpg para criar o diretório:
docker build ./ -t $IMAGE_URI
Execute o contêiner na sua instância de notebook para garantir o funcionamento correto dela:
docker run $IMAGE_URI
O modelo deve encerrar o treinamento dentro de 1 a 2 minutos com uma precisão de validação de aproximadamente 72% (a precisão exata pode variar). Quando terminar de executar o contêiner localmente, envie-o para o Google Container Registry:
docker push $IMAGE_URI
Depois que nosso contêiner for enviado para o Container Registry, estamos prontos para iniciar um job de treinamento de modelo personalizado.
5. execute um job de treinamento na Vertex AI
Há duas opções de modelos de treinamento na Vertex AI:
- AutoML: treine modelos de alta qualidade com esforço mínimo e experiência em ML.
- Treinamento personalizado: execute seus aplicativos de treinamento personalizados na nuvem usando um dos contêineres pré-criados do Google Cloud ou seus próprios.
Neste laboratório, vamos usar o treinamento personalizado do nosso próprio contêiner personalizado no Google Container Registry. Para começar, acesse a seção Modelos na seção "Vertex" do console do Cloud:
Etapa 1: iniciar o job de treinamento
Clique em Criar para inserir os parâmetros do seu job de treinamento e modelo implantado:
- 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.
- Clique em Continuar.
Na próxima etapa, insira mpg (ou como quiser nomear seu modelo) em Nome do modelo. Em seguida, selecione Contêiner personalizado:
Na caixa de texto Imagem do contêiner, clique em Procurar e encontre a imagem do Docker que você acabou de enviar para o Container Registry. Deixe os outros campos em branco e clique em Continuar.
Não vamos usar o ajuste de hiperparâmetros neste tutorial. Portanto, deixe a caixa "Ativar o ajuste de hiperparâmetros" desmarcada e clique em Continuar.
Em Computação e preços, não mude a região selecionada e escolha n1-standard-4 como tipo de máquina:
Deixe os campos do acelerador em branco e selecione Continuar. Como o modelo desta demonstração treina rapidamente, estamos usando um tipo de máquina menor.
Na etapa Contêiner de previsão, selecione Contêiner pré-criado e, em seguida, TensorFlow 2.6.
Não mexa nas configurações padrão para o contêiner pré-construído. Em diretório do modelo, insira seu bucket do GCS com o subdiretório mpg. Esse é o caminho no seu script de treinamento do modelo onde você exporta o modelo treinado:
A Vertex vai procurar neste local quando implantar seu modelo. Agora está tudo pronto para o treinamento! Clique em Iniciar treinamento para começar seu job de treinamento. Na seção "Treinamento" do console, você vai encontrar algo como:
6. implante um endpoint de modelo
Ao configurar o job de treinamento, especificamos onde a Vertex AI precisa procurar os recursos de modelo exportados. Como parte do nosso pipeline de treinamento, a Vertex vai criar um recurso de modelo com base nesse caminho de ativo. O recurso de modelo em si não é um modelo implantado, mas quando você tiver um modelo, estará com tudo pronto para implantá-lo em um endpoint. Para saber mais sobre modelos e endpoints na Vertex AI, consulte a documentação.
Nesta etapa, vamos criar um endpoint para o modelo treinado. Podemos usar isso para receber previsões sobre o modelo pela API Vertex AI.
Etapa 1: implantar o endpoint
Quando o job de treinamento concluir, um modelo chamado mpg (ou com algum outro nome que você tiver escolhido) vai aparecer na seção Modelos do seu console:
Quando o seu job de treinamento foi executado, a Vertex criou um recurso do modelo para você. Para usar esse modelo, é necessário implantar um endpoint. É possível ter diversos endpoints por modelo. Clique no modelo e depois em Implantar no endpoint.
Selecione Criar novo endpoint e dê um nome a ele, como v1. Deixe a opção Padrão selecionada para "Acesso" e clique em Continuar.
Deixe a Divisão de tráfego em 100 e digite 1 em Número mínimo de nós de computação. Em Tipo de máquina, selecione n1-standard-2 (ou qualquer tipo de máquina que você quiser). Mantenha os outros valores padrão selecionados e clique em Continuar. Não vamos ativar o monitoramento para este modelo. Portanto, clique em Implantar para iniciar a implantação do endpoint.
A implantação do endpoint vai levar de 10 a 15 minutos, e você vai receber um e-mail quando ela for concluída. Quando a implantação do endpoint for concluída, o seguinte conteúdo será exibido, mostrando um endpoint implantado no seu recurso do modelo:
Etapa 2: receber previsões no modelo implantado
Vamos fazer previsões sobre nosso modelo treinado em um notebook Python, usando a API Vertex Python. Volte à sua instância de notebook e crie um notebook Python 3 na Tela de início:
No notebook, execute o seguinte em uma célula para instalar o SDK da Vertex AI:
!pip3 install google-cloud-aiplatform --upgrade --user
Depois adicione uma célula no seu notebook para importar o SDK e criar uma referência ao endpoint que você acabou de implantar:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="projects/YOUR-PROJECT-NUMBER/locations/us-central1/endpoints/YOUR-ENDPOINT-ID"
)
Você terá que substituir dois valores na string endpoint_name acima pelo endpoint e número do seu projeto. Para encontrar o número do projeto, acesse o painel do projeto e confira o valor do Número do projeto.
O seu ID do endpoint pode ser encontrado na seção de endpoints do console, como mostrado abaixo:
Por último, faça uma previsão para seu endpoint copiando e executando o código a seguir em uma célula nova:
test_mpg = [1.4838871833555929,
1.8659883497083019,
2.234620276849616,
1.0187816540094903,
-2.530890710602246,
-1.6046416850441676,
-0.4651483719733302,
-0.4952254087173721,
0.7746763768735953]
response = endpoint.predict([test_mpg])
print('API response: ', response)
print('Predicted MPG: ', response.predictions[0][0])
Este exemplo já tem valores normalizados, que é o formato esperado pelo modelo.
Quando essa célula for executada, será exibida uma previsão em torno de 7 km por litro.
Parabéns! 🎉
Você aprendeu a usar a Vertex AI para:
- Treinar um modelo fornecendo o código de treinamento em um contêiner personalizado. Neste exemplo, você usou um modelo do TensorFlow, mas é possível treinar um modelo criado com qualquer framework usando contêineres personalizados.
- Implantar um modelo do TensorFlow usando um contêiner predefinido como parte do mesmo fluxo de trabalho usado no treinamento.
- Criar um endpoint de modelo e gerar uma previsão.
Para saber mais sobre as diferentes partes da Vertex, consulte a documentação.
7. Limpeza
Se você quiser continuar usando o notebook que criou neste laboratório, é recomendado que você o desligue quando não estiver usando. Na interface do Workbench no Console do Cloud, selecione o notebook e clique em Parar.
Se quiser excluir o notebook completamente, clique no botão Excluir no canto superior direito.
Para excluir o endpoint implantado, acesse a seção Endpoints do console da Vertex AI, clique no endpoint que você criou e selecione Cancelar a implantação do modelo do endpoint:
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":
