1. Visão geral
Neste laboratório, você vai conhecer um fluxo de trabalho completo de ML no GCP. Em um ambiente do Cloud AI Platform Notebooks, você vai ingerir dados de um conjunto de dados públicos do BigQuery, criar e treinar um modelo XGBoost e implantar o modelo na AI Platform para previsão.
Conteúdo do laboratório
Você vai aprender a:
- Ingerir e analisar um conjunto de dados do BigQuery no AI Platform Notebooks
- Criar um modelo XGBoost
- Implantar o modelo XGBoost no AI Platform e receber previsões
O custo total da execução deste laboratório no Google Cloud é de aproximadamente US$ 1.
2. 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 Cloud AI Platform Models
Acesse a seção "Modelos do AI Platform" do console do Cloud e clique em "Ativar", se ainda não tiver feito isso.
Etapa 2: 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 3: criar uma instância do AI Platform Notebooks
Acesse a seção AI Platform Notebooks do console do Cloud e clique em Nova instância. Em seguida, selecione o tipo de instância Python mais recente:
Use as opções padrão e clique em Criar. Quando a instância tiver sido criada, selecione Abrir o JupyterLab:
Etapa 4: instalar o XGBoost
Depois que a instância do JupyterLab for aberta, adicione o pacote XGBoost.
Para fazer isso, selecione "Terminal" no acesso rápido:
Em seguida, execute o comando a seguir para instalar a versão mais recente do XGBoost compatível com a AI Platform:
pip3 install xgboost==0.82
Depois que isso for concluído, abra uma instância do notebook Python 3 no iniciador. Tudo pronto para começar a usar o notebook.
Etapa 5: importar pacotes Python
Na primeira célula do notebook, adicione as importações a seguir e execute a célula. Para executar, pressione o botão de seta para a direita no menu superior ou pressione command-enter:
import pandas as pd
import xgboost as xgb
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
3. Como analisar o conjunto de dados do BigQuery
O BigQuery disponibilizou vários conjuntos de dados para você explorar. Neste laboratório, vamos usar o conjunto de dados de natalidade. Ele contém dados de quase todos os nascimentos nos EUA em um período de 40 anos, incluindo o peso ao nascer da criança e informações demográficas sobre os pais do bebê. Vamos usar um subconjunto de recursos para prever o peso de um bebê ao nascer.
Etapa 1: fazer o download dos dados do BigQuery para o notebook
Vamos usar a biblioteca de cliente Python do BigQuery para fazer o download dos dados em um DataFrame do Pandas. O conjunto de dados original tem 21 GB e contém 123 milhões de linhas. Para simplificar,vamos usar apenas 10 mil linhas do conjunto de dados.
Construa a consulta e visualize o DataFrame resultante com o código a seguir. Aqui, estamos recebendo quatro recursos do conjunto de dados original, além do peso do bebê (o que nosso modelo vai prever). O conjunto de dados é de muitos anos atrás, mas, para este modelo, vamos usar apenas dados de depois de 2000:
query="""
SELECT
weight_pounds,
is_male,
mother_age,
plurality,
gestation_weeks
FROM
publicdata.samples.natality
WHERE year > 2000
LIMIT 10000
"""
df = bigquery.Client().query(query).to_dataframe()
df.head()
Para receber um resumo dos recursos numéricos no conjunto de dados, execute:
df.describe()
Isso mostra a média, o desvio padrão, o mínimo e outras métricas das colunas numéricas. Por fim, vamos coletar alguns dados sobre a coluna booleana que indica o sexo do bebê. Podemos fazer isso com o método value_counts do Pandas:
df['is_male'].value_counts()
Parece que o conjunto de dados está quase equilibrado em 50/50 por gênero.
4. Preparar os dados para treinamento
Nesta seção, vamos dividir os dados em conjuntos de treinamento e teste para preparar o treinamento do modelo.
Etapa 1: extrair a coluna de rótulos
Primeiro, remova as linhas com valores nulos do conjunto de dados e embaralhe os dados:
df = df.dropna()
df = shuffle(df, random_state=2)
Em seguida, extraia a coluna de rótulos para uma variável separada e crie um DataFrame apenas com nossos atributos:
labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
Agora, se você visualizar o conjunto de dados executando data.head(), vai ver os quatro recursos que vamos usar para treinamento.
Etapa 2: converter recursos categóricos em números inteiros
Como o XGBoost exige que todos os dados sejam numéricos, precisamos mudar a forma como representamos os dados na coluna is_male, que atualmente são strings "True" / "False". Para fazer isso, basta mudar o tipo da coluna:
data['is_male'] = data['is_male'].astype(int)
Etapa 3: dividir os dados em conjuntos de treinamento e teste
Vamos usar o utilitário train_test_split do Scikit Learn, que importamos no início do notebook, para dividir nossos dados em conjuntos de treino e teste:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Agora estamos prontos para criar e treinar nosso modelo.
5. Um guia rápido do XGBoost
O XGBoost é uma estrutura de machine learning que usa árvores de decisão e otimização de gradiente para criar modelos preditivos. Ele funciona combinando várias árvores de decisão com base na pontuação associada a diferentes nós folha em uma árvore.
O diagrama abaixo é uma visualização simplificada de uma rede de árvores de conjunto para um modelo que avalia se alguém vai gostar ou não de um jogo de computador específico (isso é dos documentos do XGBoost):
Por que estamos usando o XGBoost para esse modelo? Embora as redes neurais tradicionais tenham mostrado um desempenho melhor em dados não estruturados, como imagens e texto, as árvores de decisão geralmente têm um desempenho muito bom em dados estruturados, como o conjunto de dados de hipoteca que vamos usar neste codelab.
6. Criar, treinar e avaliar um modelo XGBoost
Etapa 1: definir e treinar o modelo XGBoost
Criar um modelo no XGBoost é simples. Vamos usar a classe XGBRegressor para criar o modelo e só precisamos transmitir o parâmetro objective certo para nossa tarefa específica. Aqui, estamos usando um modelo de regressão porque estamos prevendo um valor numérico (peso do bebê). Se estivéssemos agrupando nossos dados para determinar se um bebê pesava mais ou menos de 2,7 kg, usaríamos um modelo de classificação.
Neste caso, vamos usar reg:squarederror como o objetivo do nosso modelo.
O código a seguir cria um modelo XGBoost:
model = xgb.XGBRegressor(
objective='reg:linear'
)
É possível treinar o modelo com uma linha de código, chamando o método fit() e transmitindo os dados e rótulos de treinamento.
model.fit(x_train, y_train)
Etapa 2: avaliar o modelo com dados de teste
Agora podemos usar o modelo treinado para gerar previsões nos dados de teste com a função predict():
y_pred = model.predict(x_test)
Vamos ver como o modelo se comportou nos primeiros 20 valores do nosso conjunto de teste. Abaixo, vamos imprimir o peso previsto e o peso real do bebê para cada exemplo de teste:
for i in range(20):
print('Predicted weight: ', y_pred[i])
print('Actual weight: ', y_test.iloc[i])
print()
Etapa 3: salvar o modelo
Para implantar o modelo, execute o seguinte código para salvá-lo em um arquivo local:
model.save_model('model.bst')
7. Implantar o modelo no AI Platform da IA do Google Cloud
Nosso modelo está funcionando localmente, mas seria bom se pudéssemos fazer previsões nele de qualquer lugar, não apenas deste notebook. Nesta etapa, vamos implantá-lo na nuvem.
Etapa 1: criar um bucket do Cloud Storage para nosso modelo
Primeiro, vamos definir algumas variáveis de ambiente que vamos usar no restante do codelab. Preencha os valores abaixo com o nome do seu projeto na nuvem do Google Cloud, o nome do bucket do Cloud Storage que você quer criar (precisa ser globalmente exclusivo) e o nome da versão da primeira versão do modelo:
# Update these to your own GCP project, model, and version names
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
VERSION_NAME = 'v1'
MODEL_NAME = 'baby_weight'
Agora estamos prontos para criar um bucket de armazenamento para armazenar o arquivo modelo XGBoost. Vamos direcionar a AI Platform do Cloud para esse arquivo durante a implantação.
Execute este comando gsutil no notebook para criar um bucket:
!gsutil mb $MODEL_BUCKET
Etapa 2: copiar o arquivo modelo para o Cloud Storage
Em seguida, vamos copiar o arquivo do modelo salvo do XGBoost para o Cloud Storage. Execute o comando gsutil a seguir:
!gsutil cp ./model.bst $MODEL_BUCKET
Acesse o navegador de armazenamento no console do Cloud para confirmar se o arquivo foi copiado:
Etapa 3: criar e implantar o modelo
O comando ai-platform gcloud a seguir vai criar um novo modelo no seu projeto. Vamos chamar esse de xgb_mortgage:
!gcloud ai-platform models create $MODEL_NAME
Agora é hora de implantar o modelo. Podemos fazer isso com este comando gcloud:
!gcloud ai-platform versions create $VERSION_NAME \
--model=$MODEL_NAME \
--framework='XGBOOST' \
--runtime-version=1.15 \
--origin=$MODEL_BUCKET \
--python-version=3.7 \
--project=$GCP_PROJECT
Enquanto isso, verifique a seção de modelos do console da AI Platform. A nova versão vai aparecer sendo implantada:
Quando a implantação for concluída, uma marca de seleção verde vai aparecer no lugar do ícone de carregamento. A implantação leva de 2 a 3 minutos.
Etapa 4: testar o modelo implantado
Para garantir que o modelo implantado esteja funcionando, teste-o usando o gcloud para fazer uma previsão. Primeiro, salve um arquivo JSON com dois exemplos do nosso conjunto de testes:
%%writefile predictions.json
[0.0, 33.0, 1.0, 27.0]
[1.0, 26.0, 1.0, 40.0]
Teste o modelo salvando a saída do seguinte comando gcloud em uma variável e imprimindo-a:
prediction = !gcloud ai-platform predict --model=$MODEL_NAME --json-instances=predictions.json --version=$VERSION_NAME
print(prediction.s)
A previsão do modelo vai aparecer na saída. O peso real do bebê nesses dois exemplos é de 1,9 e 8,1 libras, respectivamente.
8. Limpeza
Se você quiser continuar usando esse notebook, recomendamos que o desative quando não estiver em uso. Na interface de Notebooks no console do Cloud, selecione o notebook e clique em Parar:
Se quiser excluir todos os recursos criados neste laboratório, exclua a instância do notebook em vez de interrompê-la.
No menu de navegação do console do Cloud, acesse "Storage" e exclua os dois buckets criados para armazenar os recursos do modelo.