Criar, treinar e implantar um modelo XGBoost na AI Platform do Cloud

Criar, treinar e implantar um modelo XGBoost na AI Platform do Cloud

Sobre este codelab

subjectÚltimo jun. 25, 2021 atualizado
account_circleEscrito por sararob@

1. Visão geral

Neste laboratório, você analisará um fluxo de trabalho de ML completo no GCP. Em um ambiente do AI Platform Notebooks do Cloud, você fará a ingestão de dados de um conjunto de dados público do BigQuery, criará e treinará um modelo XGBoost e implantará o modelo no 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 da 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", caso essa opção ainda não esteja ativada.

d0d38662851c6af3.png

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 de Notebooks no AI Platform

Acesse a seção de Notebooks do AI Platform do console do Cloud e clique em Nova instância. Em seguida, selecione o tipo de instância mais recente do Python:

a81c82876c6c16f9.png

Use as opções padrão e clique em Criar. Depois que a instância for criada, selecione Abrir JupyterLab:

Etapa 4: instalar o XGBoost

Quando sua instância do JupyterLab for aberta, adicione o pacote XGBoost.

Para fazer isso, selecione Terminal no acesso rápido:

28dcf2790ce77c96.png

Em seguida, execute o comando a seguir para instalar a versão mais recente do XGBoost compatível com o AI Platform:

pip3 install xgboost==0.82

Depois disso, abra uma instância de notebook do Python 3 no acesso rápido. Você já pode começar a usar seu notebook.

Etapa 5: importar pacotes do Python

Na primeira célula do notebook, adicione as importações abaixo e execute a célula. Para executá-lo, 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. conheça o conjunto de dados do BigQuery

O BigQuery disponibilizou muitos conjuntos de dados publicamente para análise. 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 da criança ao nascer e informações demográficas sobre os pais do bebê. Vamos usar um subconjunto de atributos para prever o peso de um bebê ao nascer.

Etapa 1: fazer o download dos dados do BigQuery para nosso notebook

Vamos usar a biblioteca de cliente Python para BigQuery para fazer o download dos dados para 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.000 linhas do conjunto de dados.

Crie a consulta e visualize o DataFrame resultante com o código a seguir. Aqui estamos recebendo quatro atributos do conjunto de dados original, junto com o peso do bebê (o que nosso modelo vai prever). O conjunto de dados remonta a muitos anos, mas para este modelo usaremos 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 ver um resumo dos atributos numéricos do conjunto de dados, execute:

df.describe()

Isso mostra a média, o desvio padrão, o mínimo e outras métricas para nossas colunas numéricas. Por fim, vamos obter alguns dados em nossa coluna booleana indicando o gênero do bebê. Podemos fazer isso com o Pandas Método value_counts:

df['is_male'].value_counts()

Parece que o conjunto de dados está quase equilibrado 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 prepará-los para o treinamento do modelo.

Etapa 1: extrair a coluna de rótulos

Primeiro, elimine 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ótulo em uma variável separada e crie um DataFrame apenas com os atributos:

labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])

Agora, ao executar data.head() para visualizar nosso conjunto de dados, você verá os quatro atributos que vamos usar no treinamento.

Etapa 2: converter atributos categóricos em números inteiros

Como o XGBoost exige que todos os dados sejam numéricos, mudaremos a forma como os dados são representados na coluna is_male, que atualmente são strings verdadeiras ou falsas. Para fazer isso, basta alterar 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 treinamento 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 o modelo.

5. Uma breve introdução à XGBoost

O XGBoost (em inglês) é um framework de machine learning que usa árvores de decisão e aumento de gradiente para criar modelos preditivos. Ela funciona unindo várias árvores de decisão com base na pontuação associada a diferentes nós de folha em uma árvore.

O diagrama abaixo é uma visualização simplificada de uma rede de árvores de ensemble para um modelo que avalia se alguém vai gostar de um jogo de computador específico (isso pode ser feito na documentação do XGBoost):

fb061cd8c8f69999.png

Por que estamos usando XGBoost no modelo? Embora as redes neurais tradicionais tenham demonstrado um desempenho melhor em dados não estruturados, como imagens e texto, as árvores de decisão costumam ter um desempenho extremamente bom em dados estruturados, como o conjunto de dados de hipoteca que usaremos neste codelab.

6. Criar, treinar e avaliar um modelo XGBoost

Etapa 1: definir e treinar o modelo XGBoost

Criar um modelo no XGBoost é simples. Usaremos a classe XGBRegressor para criar o modelo. Para isso, basta transmitir o parâmetro objective correto para a tarefa específica. Estamos usando um modelo de regressão porque estamos prevendo um valor numérico (o peso do bebê). Se, em vez disso, estivéssemos agrupando nossos dados por classes para determinar se um bebê pesava mais ou menos de 2 quilos, usaríamos um modelo de classificação.

Nesse caso, usaremos reg:squarederror como o objetivo do modelo.

O código a seguir vai criar 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 nosso modelo treinado para gerar previsões nos dados de teste com a função predict():

y_pred = model.predict(x_test)

Vamos conferir o desempenho do modelo nos primeiros 20 valores do conjunto de teste. Abaixo, imprimiremos o peso previsto do bebê junto com 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 na AI Platform do Cloud

Nosso modelo está funcionando localmente, mas seria bom se pudéssemos fazer previsões sobre ele de qualquer lugar (não apenas deste notebook). Nesta etapa, vamos implantá-lo na nuvem.

Etapa 1: criar um bucket do Cloud Storage para o modelo

Primeiro, defina algumas variáveis de ambiente que serão usadas no restante do codelab. Preencha os valores abaixo com o nome do seu projeto 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 seu 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 de modelo XGBoost. Vamos indicar o AI Platform do Cloud nesse arquivo durante a implantação.

Execute este comando gsutil no seu notebook para criar um bucket:

!gsutil mb $MODEL_BUCKET

Etapa 2: copiar o arquivo de modelo para o Cloud Storage

Em seguida, você vai copiar o arquivo de modelo salvo do XGBoost no Cloud Storage. Execute o seguinte comando gsutil:

!gsutil cp ./model.bst $MODEL_BUCKET

Acesse o navegador do Storage no console do Cloud para confirmar se o arquivo foi copiado:

31e2567fa0117214.png

Etapa 3: criar e implantar o modelo

O seguinte comando gcloud ai-platform vai criar um novo modelo no seu projeto. Ele será chamado 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 ele estiver em execução, verifique a seção de modelos do console do AI Platform. Sua nova versão será implantada nesse local:

a431661f9c3e6cb2.png

Quando a implantação for concluída, uma marca de seleção verde vai aparecer no local do ícone de carregamento. A implantação deve levar de 2 a 3 minutos.

Etapa 4: testar o modelo implantado

Para verificar se o modelo implantado está funcionando, faça um teste com a gcloud para fazer uma previsão. Primeiro, salve um arquivo JSON com dois exemplos do nosso conjunto de teste:

%%writefile predictions.json
[0.0, 33.0, 1.0, 27.0]
[1.0, 26.0, 1.0, 40.0]

Para testar o modelo, salve a saída do comando gcloud a seguir em uma variável e imprima-a:

prediction = !gcloud ai-platform predict --model=$MODEL_NAME --json-instances=predictions.json --version=$VERSION_NAME
print(prediction.s)

A previsão do modelo será exibida na saída. O peso real do bebê para esses dois exemplos é de 1,9 libra e 8,1 libras, respectivamente.

8. Limpeza

Se você quiser continuar usando este notebook, é recomendado que você o desative quando não estiver em uso. A partir da IU de Notebooks no Console do Cloud, selecione o notebook e depois clique em Parar:

879147427150b6c7.png

Se quiser excluir todos os recursos criados neste laboratório, basta excluir a instância do notebook em vez de interrompê-la.

Usando o menu de navegação do console do Cloud, acesse "Storage" e exclua os dois buckets que você criou para armazenar os recursos do modelo.