1. Visão geral
Neste laboratório, você vai conhecer várias ferramentas nos notebooks da AI Platform para explorar seus dados e fazer protótipos de modelos de ML.
Conteúdo do laboratório
Você vai aprender a:
- Criar e personalizar uma instância do AI Platform Notebooks
- Rastrear o código dos 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. Confira todos os detalhes sobre os preços do AI Platform Notebooks aqui.
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 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 "Notebooks do AI Platform" do console do Google Cloud e clique em Nova instância. Em seguida, selecione o tipo de instância TensorFlow 2 Enterprise mais recente sem GPUs:
Dê um nome à instância ou use o padrão. Em seguida, vamos analisar as opções de personalização. Clique no botão Personalizar:
O AI Platform Notebooks tem muitas opções de personalização, incluindo a região em que a instância é implantada, o tipo de imagem, o tamanho da máquina, o número de GPUs e muito mais. Vamos usar os padrões para região e ambiente. Para a configuração da máquina, vamos usar uma máquina n1-standard-8:
Não vamos adicionar GPUs e vamos usar os padrões para disco de inicialização, rede e permissão. Selecione Criar para gerar a instância. Esse processo leva alguns minutos.
Depois que a instância for criada, você vai ver uma marca de seleção verde ao lado dela na interface do Notebooks. Selecione Abrir o JupyterLab para abrir a instância e começar a criar protótipos:
Ao abrir a instância, crie um novo diretório chamado "codelab". Este é o diretório em que vamos trabalhar durante este laboratório:
Clique duas vezes no diretório codelab recém-criado e selecione o notebook Python 3 no inicializador:
Renomeie o bloco de notas para demo.ipynb ou qualquer outro nome.
Etapa 4: importar pacotes Python
Crie uma nova 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 dados do BigQuery ao seu notebook
O BigQuery, o data warehouse do Google Cloud, disponibilizou muitos conjuntos de dados publicamente para você analisar. Os AI Platform Notebooks 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 sobre 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 dos recursos para prever o peso de um bebê ao nascer.
Etapa 1: fazer o download de dados do BigQuery no seu notebook
Vamos usar a biblioteca de cliente Python para 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.000 linhas do conjunto de dados.
Crie a consulta e confira uma prévia do DataFrame resultante com o código abaixo. 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 conferir um resumo dos atributos 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 para nossas colunas numéricas. Por fim, vamos conferir alguns dados na coluna booleana que indicam 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.
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 algum pré-processamento e dividi-lo em conjuntos de treinamento e teste.
Primeiro, vamos excluir 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ótulos para uma variável separada e crie um DataFrame com apenas 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, se você visualizar o conjunto de dados executando data.head(), vai encontrar os quatro recursos que vamos usar para o treinamento.
4. Inicializar o Git
O AI Platform Notebooks tem uma integração direta com o git, para que você possa fazer o controle de versão diretamente no ambiente do notebook. Isso permite confirmar o código diretamente na interface do notebook ou pelo terminal disponível no JupyterLab. Nesta seção, vamos inicializar um repositório do Git no notebook e fazer a primeira confirmação pela interface.
Etapa 1: inicializar um repositório Git
No diretório do codelab, selecione Git e Init na barra de menus superior do JupyterLab:
Quando ele perguntar se você quer fazer desse diretório um repositório Git, selecione Sim. Em seguida, selecione o ícone do Git na barra lateral esquerda para conferir o status dos arquivos e confirmações:
Etapa 2: fazer o primeiro commit
Nela, você pode adicionar arquivos a uma confirmação, conferir as diferenças entre arquivos (falaremos sobre isso mais tarde) e confirmar suas alterações. Vamos começar com o arquivo de bloco de notas que acabamos de adicionar.
Marque a caixa ao lado do arquivo de bloco de notas demo.ipynb para colocá-lo em fase de preparação para a confirmação (ignore o diretório .ipynb_checkpoints/). Insira uma mensagem de confirmação na caixa de texto e clique na marca de seleção para confirmar as alterações:
Insira seu nome e e-mail quando solicitado. Em seguida, volte à guia History para conferir sua primeira confirmação:
As capturas de tela podem não corresponder exatamente à sua interface devido a atualizações desde a publicação deste laboratório.
5. Criar e treinar um modelo do TensorFlow
Vamos usar o conjunto de dados de natalidade do BigQuery que salvamos no notebook para criar um modelo que prevê o peso do bebê. Neste laboratório, vamos nos concentrar nas ferramentas do notebook, e não na precisão do modelo.
Etapa 1: dividir os dados em conjuntos de treinamento e teste
Vamos usar o utilitário train_test_split do Scikit Learn para dividir nossos 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 nosso 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 nosso modelo como uma pilha de camadas. Confira aqui todo o código necessário para criar nosso modelo:
model = Sequential([
Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
Dense(32, activation='relu'),
Dense(1)]
)
Em seguida, vamos compilar o modelo para que ele possa ser treinado. Aqui, vamos escolher o otimizador, a função de perda e as métricas que queremos que o modelo registre durante o treinamento. Como este é um modelo de regressão (que prevê um valor numérico), usamos o erro médio quadrático em vez da precisão como métrica:
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss=tf.keras.losses.MeanSquaredError(),
metrics=['mae', 'mse'])
Você pode usar a função model.summary() útil do Keras para conferir a forma e o número de parâmetros treináveis do modelo em cada camada.
Agora está tudo pronto para treinar o modelo. Tudo o que precisamos fazer é chamar o método fit(), transmitindo nossos dados de treinamento e rótulos. Aqui, vamos usar o parâmetro opcional validation_split, que vai conter uma parte dos dados de treinamento para validar o modelo em cada etapa. O ideal é que a perda de treinamento e de validação diminua. Mas lembre-se de que, neste exemplo, estamos mais focados nas ferramentas de modelo e de notas do que 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 saber como o modelo está se saindo, 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 sobre as previsões do 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 mudanças no notebook, teste o recurso de comparação de arquivos disponível na interface do Git para notebooks. O notebook demo.ipynb agora está na seção "Alterado" da interface. Passe o cursor sobre o nome do arquivo e clique no ícone de comparação:
Com isso, você poderá conferir uma comparação das suas mudanças, como esta:
Desta vez, vamos confirmar as mudanças na linha de comando usando o Terminal. No menu Git da barra de menus superior do JupyterLab, selecione Git Command in Terminal. Se você tiver a guia git da barra lateral esquerda aberta enquanto executa os comandos abaixo, vai poder conferir as mudanças refletidas na interface do git.
Na nova instância do terminal, execute o seguinte comando para preparar o arquivo do notebook para confirmação:
git add demo.ipynb
Em seguida, execute o comando a seguir para confirmar as mudanças. Você pode usar a mensagem de confirmação que quiser:
git commit -m "Build and train TF model"
Em seguida, você vai encontrar a confirmação mais recente no histórico:
6. Usar a Ferramenta What-If diretamente no seu notebook
A Ferramenta What-If é uma interface visual interativa projetada para ajudar você a visualizar seus conjuntos de dados e entender melhor a saída dos modelos de ML. É uma ferramenta de código aberto criada pela equipe do PAIR no Google. Embora funcione com qualquer tipo de modelo, ele tem alguns recursos criados exclusivamente para o Cloud AI Platform.
A ferramenta "E se" vem pré-instalada nas instâncias do Cloud AI Platform Notebooks com o TensorFlow. Aqui, vamos usá-lo para conferir o desempenho geral do modelo e inspecionar o comportamento dele nos pontos de dados do conjunto de teste.
Etapa 1: preparar dados para a ferramenta "O que aconteceria se"
Para aproveitar ao máximo a ferramenta "E se", vamos enviar exemplos do nosso conjunto de testes com os rótulos de informações empíricas desses exemplos (y_test). Assim, podemos comparar o que o 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 escrever uma função que a ferramenta vai usar para executar esses pontos de dados de teste no modelo:
def custom_predict(examples_to_infer):
preds = model.predict(examples_to_infer)
return preds
Etapa 2: instanciar a ferramenta "E se"
Vamos instanciar a ferramenta "E se" transmitindo 500 exemplos do conjunto de dados de teste concatenado e 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, o 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)
Você vai conferir algo parecido com isso quando a ferramenta de simulação for carregada:
No eixo x, você pode conferir os pontos de dados de teste distribuídos pelo valor de peso previsto do modelo, weight_pounds.
Etapa 3: analisar o comportamento do modelo com a Ferramenta What-If
Você pode fazer muitas coisas legais com a Ferramenta What-If. Vamos analisar apenas alguns deles aqui. Primeiro, vamos analisar o editor de pontos de dados. Você pode selecionar qualquer ponto de dados para conferir os recursos e mudar os valores deles. Comece clicando em qualquer ponto de dados:
À esquerda, você vai encontrar os valores do elemento para o ponto de dados selecionado. Também é possível comparar o rótulo de informações empíricas do 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 conferir o efeito dessa mudança. Por exemplo, podemos mudar a variável gestation_weeks para 30 para este ponto de dados clicando duas vezes nele e executando a previsão novamente:
Use os menus suspensos na seção de gráfico da ferramenta "E se" para criar vários tipos de visualizações personalizadas. Por exemplo, aqui está um gráfico com o peso previsto dos modelos no eixo x, a idade da mãe no eixo y e pontos coloridos pelo erro de inferência (mais escuro significa uma diferença maior entre o peso previsto e o real). Parece que, à medida que o peso diminui, o erro do modelo aumenta um pouco:
Em seguida, marque o botão Parciais de dependência à esquerda. Isso mostra como cada atributo influencia a previsão do modelo. Por exemplo, à medida que o tempo de gestação aumenta, o peso previsto do bebê também aumenta:
Para mais ideias de exploração com a ferramenta What-If, consulte os links no início desta seção.
7. Opcional: conectar seu repositório local do Git 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. Se você quiser fazer essa etapa, 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, decida se ele será público e selecione Criar repositório. Não é necessário inicializar com um README. Na próxima página, você vai seguir as instruções para enviar um repositório existente pela linha de comando.
Abra uma janela do Terminal e adicione o novo repositório como 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 git@github.com:username/your-repo.git
Etapa 2: autenticar no GitHub na sua instância de notebooks
Em seguida, você vai precisar fazer a autenticação no GitHub na sua instância de notebook. Esse processo varia de acordo com a ativação ou nã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 o repositório do GitHub
Para garantir que você configurou tudo corretamente, execute git remote -v no terminal. O novo repositório vai aparecer como remoto. Quando você encontrar o URL do repositório do GitHub e tiver feito a autenticação no GitHub pelo notebook, poderá fazer o push diretamente para o GitHub na instância do notebook.
Para sincronizar o repositório local do Git com o repositório do GitHub recém-criado, clique no botão de upload na nuvem na parte de cima da barra lateral do Git:
Atualize o repositório do GitHub e o código do notebook com os commits anteriores vai aparecer. Se outras pessoas tiverem acesso ao repositório do GitHub e você quiser fazer o download das alterações mais recentes no seu notebook, clique no ícone de download da nuvem para sincronizar essas mudanças.
Na guia "History" da interface do Git dos notebooks, você pode conferir se as confirmações locais estão sincronizadas com o GitHub. Neste exemplo, origin/master corresponde ao nosso repositório no GitHub:
Sempre que você fizer novas confirmações, clique no botão de upload na nuvem novamente para enviar as mudanças para o repositório do GitHub.
8. Parabéns!
Você fez muito neste laboratório 👏👏👏
Para recapitular, você aprendeu a:
- Criar e personalizar uma instância do AI Platform Notebook
- Inicializar um repositório Git local nessa instância, adicionar confirmações pela interface ou linha de comando do Git, conferir as diferenças do Git na interface do Git do Notebook
- Criar e treinar um modelo simples do TensorFlow 2
- Usar a Ferramenta What-If na sua instância do Notebook
- Conectar o repositório do notebook do Git a um repositório externo no GitHub
9. Limpeza
Se você quiser continuar usando esse notebook, é recomendável que você o desligue quando não estiver usando. Na interface de Notebooks no console do Cloud, selecione o notebook e clique em Parar:
Se você quiser excluir todos os recursos criados neste laboratório, exclua a instância do notebook em vez de interromper.
Usando o menu de navegação no console do Cloud, acesse o Storage e exclua os dois buckets que você criou para armazenar os recursos do modelo.