Como fazer o protótipo de modelos no AI Platform Notebooks

1. Visão geral

Neste laboratório, você conhecerá várias ferramentas do AI Platform Notebooks para explorar dados e prototipar modelos de ML.

Conteúdo do laboratório

Você vai aprender a:

• Criar e personalizar uma instância do AI Platform Notebooks
• Rastreie o código dos seus notebooks com o Git, diretamente integrado aos Notebooks do AI Platform
• Usar a Ferramenta What-If no seu notebook

O custo total da execução deste laboratório no Google Cloud é de aproximadamente US$ 1. Para ver todos os detalhes sobre os preços do AI Platform Notebooks, acesse este link.

2. Criar uma instância do AI Platform Notebooks

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 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 notebook

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 TensorFlow 2 Enterprise sem GPUs:

Dê um nome à instância ou use o padrão. Em seguida, exploraremos as opções de personalização. Clique no botão Personalizar:

O AI Platform Notebooks tem muitas opções de personalização diferentes, incluindo: a região em que sua instância está implantada, o tipo de imagem, o tamanho da máquina, o número de GPUs e muito mais. Vamos usar os padrões de região e ambiente. Para a configuração da máquina, usaremos uma máquina n1-standard-8:

Não vamos adicionar nenhuma GPU, e vamos usar os padrões para disco de inicialização, rede e permissão. Selecione Criar para criar a instância. Esse processo leva alguns minutos.

Depois que a instância for criada, você verá uma marca de seleção verde ao lado dela na interface de Notebooks. Selecione Abrir JupyterLab para abrir a instância e iniciar a prototipagem:

Ao abrir a instância, crie um novo diretório chamado codelab. Este é o diretório que vamos usar ao longo deste laboratório:

Clique duas vezes no diretório codelab que você acabou de criar e selecione o notebook Python 3 na tela de início:

Renomeie o notebook como demo.ipynb ou qualquer outro nome.

Etapa 4: importar pacotes do Python

Crie uma célula no notebook e importe as bibliotecas que vamos usar neste codelab:

import pandas as pd
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

import numpy as np
import json

from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder

3. Conectar os dados do BigQuery ao seu notebook

O BigQuery, o armazenamento de Big Data do Google Cloud, disponibilizou muitos conjuntos de dados publicamente para análise. Os notebooks do AI Platform oferecem suporte à integração direta com o BigQuery sem exigir autenticação.

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 método value_counts do Pandas:

df['is_male'].value_counts()

Parece que o conjunto de dados está quase equilibrado 50/50 por gênero.

Para conjuntos de dados maiores, use o conector do BigQuery em vez da integração do Pandas.

Etapa 2: preparar o conjunto de dados para treinamento

Agora que fizemos o download do conjunto de dados para o notebook como um DataFrame do Pandas, podemos fazer um pré-processamento e dividi-lo em conjuntos de treinamento e teste.

Primeiro, vamos soltar as linhas com valores nulos do conjunto de dados e embaralhar 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. Como is_male é um booleano, vamos convertê-lo em um número inteiro para que todas as entradas do modelo sejam numéricas:

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

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

4. Inicializar o git

O AI Platform Notebooks tem integração direta com o git, para que você possa fazer o controle de versão diretamente no ambiente do notebook. Isso dá suporte à confirmação do código diretamente na interface do notebook ou pelo terminal disponível no JupyterLab. Nesta seção, vamos inicializar um repositório git no notebook e fazer a primeira confirmação pela IU.

Etapa 1: inicializar um repositório git

No diretório do codelab, selecione Git e depois Init na barra de menus superior do JupyterLab:

Quando ele perguntar se você quer transformar esse diretório em um repositório Git, selecione Yes. Em seguida, selecione o ícone do Git na barra lateral esquerda para ver o status dos arquivos e commits:

Etapa 2: fazer a primeira confirmação

Nessa interface, é possível adicionar arquivos a um commit, conferir as diferenças de arquivos (falaremos sobre isso mais tarde) e confirmar as mudanças. Para começar, vamos confirmar o arquivo do notebook que acabamos de adicionar.

Marque a caixa ao lado do arquivo de notebook demo.ipynb para prepará-lo para a confirmação. Ignore o diretório .ipynb_checkpoints/. Digite uma mensagem de confirmação na caixa de texto e clique na marca de seleção para confirmar as alterações:

Digite seu nome e e-mail quando solicitado. Em seguida, volte para a guia Histórico para ver sua primeira confirmação:

As capturas de tela podem não corresponder exatamente à sua interface devido a atualizações que ocorreram desde a publicação do laboratório.

5. Criar e treinar um modelo do TensorFlow

Usaremos o conjunto de dados de natalidade do BigQuery baixado para nosso notebook para criar um modelo que prevê o peso de bebês. Neste laboratório, vamos nos concentrar nas ferramentas de notebook e não na acurácia do modelo em si.

Etapa 1: dividir os dados em conjuntos de treinamento e teste

Vamos usar o utilitário Scikit Learn train_test_split para dividir os dados antes de criar o modelo:

x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)

Agora estamos prontos para criar o modelo do TensorFlow.

Etapa 2: criar e treinar o modelo do TensorFlow

Vamos criar esse modelo usando a API de modelo Sequential do tf.keras, que permite definir o modelo como uma pilha de camadas. Todo o código necessário para criar nosso modelo está aqui:

model = Sequential([
    Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
    Dense(32, activation='relu'),
    Dense(1)]
)

Depois, vamos compilar o modelo para treiná-lo. Aqui, vamos escolher o otimizador, a função de perda e as métricas do modelo que queremos que o modelo registre durante o treinamento. Como este é um modelo de regressão (que prevê um valor numérico), usaremos como métrica o erro quadrático médio em vez da precisão:

model.compile(optimizer=tf.keras.optimizers.RMSprop(),
              loss=tf.keras.losses.MeanSquaredError(),
              metrics=['mae', 'mse'])

É possível usar a função model.summary() do Keras para conferir a forma e o número de parâmetros treináveis do modelo em cada camada.

Agora estamos prontos para treinar o modelo. Basta chamar o método fit(), transmitindo os dados e rótulos de treinamento. Aqui, vamos usar o parâmetro opcional validate_split, que vai conter uma parte dos dados de treinamento para validar o modelo em cada etapa. O ideal é que as perdas de treinamento e validação sejam reduzidas. Mas lembre-se de que neste exemplo nosso foco são as ferramentas de modelo e notebook e não na qualidade do modelo:

model.fit(x_train, y_train, epochs=10, validation_split=0.1)

Etapa 3: gerar previsões em exemplos de teste

Para conferir o desempenho do nosso modelo, vamos gerar algumas previsões de teste nos primeiros 10 exemplos do conjunto de dados de teste.

num_examples = 10
predictions = model.predict(x_test[:num_examples])

Em seguida, vamos iterar as previsões do nosso modelo, comparando-as com o valor real:

for i in range(num_examples):
    print('Predicted val: ', predictions[i][0])
    print('Actual val: ',y_test.iloc[i])
    print()

Etapa 4: usar o git diff e confirmar as mudanças

Agora que você fez algumas alterações no notebook, é possível testar o recurso de diferenças do git disponível na interface do Git do Notebooks. O notebook demo.ipynb vai estar na seção "Alterados" na interface. Passe o cursor sobre o nome do arquivo e clique no ícone de diferença:

Com isso, você poderá ver uma diferença das suas mudanças, como esta:

Desta vez, confirmaremos nossas alterações pela linha de comando usando o Terminal. No menu Git da barra de menus superior do JupyterLab, selecione Comando do Git no terminal. Se a guia do Git da barra lateral esquerda estiver aberta enquanto você executar os comandos abaixo, as mudanças serão refletidas na interface do git.

Na nova instância de terminal, execute o seguinte para preparar o arquivo do notebook para confirmação:

git add demo.ipynb

Em seguida, execute o seguinte para confirmar as alterações (use a mensagem de confirmação que quiser):

git commit -m "Build and train TF model"

Você verá o commit mais recente no histórico:

6. Use a Ferramenta What-If diretamente do seu notebook

A Ferramenta What-If é uma interface visual interativa projetada para mostrar conjuntos de dados e entender melhor os resultados dos modelos de ML. É uma ferramenta de código aberto criada pela equipe PAIR no Google. Ele funciona com qualquer tipo de modelo, mas tem alguns recursos criados exclusivamente para o AI Platform do Cloud.

Quer saber mais sobre a Ferramenta What-If? Acesse o site e a página de demonstrações deles, saiba mais sobre a equipe da PAIR e confira esta minissérie do YouTube.

A Ferramenta What-If vem pré-instalada nas instâncias do AI Platform Notebooks do Cloud com o TensorFlow. Aqui, vamos usá-lo para ver o desempenho geral do modelo e inspecionar o comportamento dele em pontos de dados do conjunto de teste.

Etapa 1: preparar dados para a Ferramenta What-If

Para aproveitar ao máximo a Ferramenta What-If, vamos enviar exemplos do nosso conjunto de teste com os rótulos de informações empíricas desses exemplos (y_test). Assim, podemos comparar o que nosso modelo previu com as informações empíricas. Execute a linha de código abaixo para criar um novo DataFrame com nossos exemplos de teste e os rótulos deles:

wit_data = pd.concat([x_test, y_test], axis=1)

Neste laboratório, vamos conectar a Ferramenta What-If ao modelo que acabamos de treinar no notebook. Para fazer isso, precisamos criar uma função que a ferramenta usará para executar esses pontos de dados de teste no nosso modelo:

def custom_predict(examples_to_infer):
    preds = model.predict(examples_to_infer)
    return preds

Etapa 2: instanciar a Ferramenta What-If

Vamos instanciar a Ferramenta What-If transmitindo 500 exemplos do conjunto de dados de teste concatenado + rótulos de informações empíricas que acabamos de criar. Criamos uma instância de WitConfigBuilder para configurar a ferramenta, transmitindo nossos dados, a função de previsão personalizada definida acima, nosso destino (o que estamos prevendo) e o tipo de modelo:

config_builder = (WitConfigBuilder(wit_data[:500].values.tolist(), data.columns.tolist() + ['weight_pounds'])
  .set_custom_predict_fn(custom_predict)
  .set_target_feature('weight_pounds')
  .set_model_type('regression'))
WitWidget(config_builder, height=800)

Quando a Ferramenta What-If carregar, você verá algo parecido com isto:

No eixo X, é possível ver os pontos de dados de teste distribuídos pelo valor do peso previsto do modelo, weight_pounds.

Também é possível conectar a Ferramenta What-If diretamente aos modelos implantados na AI Platform do Cloud usando o método set_ai_platform_model. Confira um exemplo nesta demonstração.

Etapa 3: analisar o comportamento do modelo com a Ferramenta What-If

Há muitas coisas interessantes que você pode fazer com a Ferramenta What-If. Vamos explorar apenas alguns deles aqui. Primeiro, vamos dar uma olhada no editor de pontos de dados. Você pode selecionar qualquer ponto de dados para ver os atributos e mudar os valores dos atributos. Comece clicando em qualquer ponto de dados:

À esquerda, você verá os valores de atributo do ponto de dados selecionado. Também é possível comparar o rótulo de informações empíricas desse ponto de dados com o valor previsto pelo modelo. Na barra lateral esquerda, também é possível alterar os valores dos atributos e executar novamente a previsão do modelo para ver o efeito dessa alteração no modelo. Por exemplo, para esse ponto de dados, podemos alterar gestation_weeks para 30 clicando duas vezes nele em uma previsão executada novamente:

Usando os menus suspensos na seção de gráfico da Ferramenta What-If, você pode criar todos os tipos de visualizações personalizadas. Por exemplo, este é um gráfico com a peso previsto no eixo X, a idade da mãe no eixo Y e pontos coloridos por seu erro de inferência (mais escuro significa uma diferença maior entre o peso previsto e real). Aqui parece que, à medida que o peso diminui, o erro do modelo aumenta um pouco:

Em seguida, verifique o botão Gráficos de dependência parcial à esquerda. Isso mostra como cada atributo influencia a previsão do modelo. Por exemplo, conforme o tempo de gestação aumenta, o peso previsto do bebê do modelo também aumenta:

Para mais ideias de exploração com a Ferramenta What-If, confira os links no início desta seção.

7. Opcional: conectar seu repositório Git local ao GitHub

Por fim, vamos aprender a conectar o repositório do Git na instância do notebook a um repositório na conta do GitHub. Para seguir esta etapa, você precisará de uma conta do GitHub.

Etapa 1: criar um novo repositório no GitHub

Na sua conta do GitHub, crie um novo repositório. Dê um nome e uma descrição a ele, decida se quer que ele seja público e selecione Criar repositório (não é preciso inicializar com um README). Na próxima página, você vai seguir as instruções para enviar um repositório pela linha de comando.

Abra uma janela de terminal e adicione seu novo repositório como controle remoto. Substitua username no URL do repositório abaixo pelo seu nome de usuário do GitHub e your-repo pelo nome do repositório que você acabou de criar:

git remote add origin [e-mail]:username/your-repo.git

Etapa 2: autenticar no GitHub na instância dos notebooks

Em seguida, você precisará se autenticar no GitHub a partir da sua instância do notebook. Esse processo varia dependendo da ativação da autenticação de dois fatores no GitHub.

Se você não souber por onde começar, siga as etapas na documentação do GitHub para criar uma chave SSH e adicionar a nova chave ao GitHub.

Etapa 3: verificar se você vinculou corretamente seu repositório do GitHub

Para garantir que tudo foi configurado corretamente, execute git remote -v no terminal. O novo repositório vai aparecer listado como remoto. Quando você vir o URL do repositório do GitHub e fizer a autenticação no GitHub pelo notebook, poderá enviar diretamente da instância do notebook para o GitHub.

Para sincronizar o repositório git do notebook local com o repositório do GitHub recém-criado, clique no botão de upload na nuvem na parte superior da barra lateral do Git:

Atualize seu repositório do GitHub para ver o código do notebook com os commits anteriores. Se outras pessoas tiverem acesso ao seu repositório GitHub e você quiser obter as alterações mais recentes em seu notebook, clique no ícone de download na nuvem para sincronizar essas alterações.

Na guia "Histórico" da interface do Git do Notebooks, é possível ver se os commits locais estão sincronizados com o GitHub. Neste exemplo, origin/master corresponde ao nosso repositório no GitHub:

Sempre que você fizer novos commits, basta clicar no botão de upload da nuvem novamente para enviar essas alterações ao seu repositório do GitHub.

8. Parabéns!

Você fez muita coisa neste laboratório 👏👏👏

Para recapitular, você aprendeu a:

• Criar uma instância personalizada do AI Platform Notebook
• Inicialize um repositório git local nessa instância, adicione commits usando a interface ou a linha de comando do git, confira as diferenças do git na interface do git do Notebook
• Criar e treinar um modelo simples do TensorFlow 2
• Use a Ferramenta What-If na sua instância do Notebook
• Conecte seu repositório Git do notebook a um repositório externo no GitHub

9. 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:

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.