Modelos de prototipagem em notebooks do AI Platform

Este laboratório irá guiá-lo por várias ferramentas nos Notebooks do AI Platform para explorar seus dados e criar protótipos de modelos de ML.

O que você aprende

Você aprenderá como:

  • Crie e personalize uma instância do AI Platform Notebooks
  • Rastreie o código de seus notebooks com git, diretamente integrado aos notebooks do AI Platform
  • Use a ferramenta de variações hipotéticas em seu notebook

O custo total para executar este laboratório no Google Cloud é de cerca de US $ 1 . Detalhes completos sobre os preços dos notebooks do AI Platform podem ser encontrados aqui .

Você precisará de um projeto do Google Cloud Platform com faturamento ativado para executar este codelab. Para criar um projeto, siga asinstruções aqui .

Etapa 2: ativar a API Compute Engine

Navegue até o Compute Engine e selecione Ativar se ainda não estiver ativado. Você precisará disso para criar sua instância de notebook.

Etapa 3: Criar uma instância de notebook

Navegue até a seção de Notebooks do AI Platform do seu console de nuvem e clique em Nova instância . Em seguida, selecione o tipo de instância TensorFlow 2 Enterprise mais recente sem GPUs :

9f2bb4dec1ba4f4f.png

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

63be602ba45ca7c9.png

Os notebooks do AI Platform têm 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. Usaremos os padrões para região e ambiente. Para a configuração da máquina, usaremos uma máquina n1-standard-8 :

27101d232f765a17.png

Não adicionaremos GPUs e usaremos os padrões para disco de inicialização, rede e permissão. Selecione Criar para criar sua instância. Isso levará alguns minutos para ser concluído.

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

3598f414887ea9a8.png

Ao abrir a instância, crie um novo diretório chamado codelab. Este é o diretório no qual trabalharemos neste laboratório:

c16a821546acd92.png

Clique em seu diretório codelab recém-criado clicando duas vezes nele e selecione Python 3 notebook no inicializador:

4390b1614ae8eae4.png

Renomeie o bloco de notas para demo.ipynb ou qualquer nome que você gostaria de dar a ele.

Etapa 4: importar pacotes Python

Crie uma nova célula no notebook e importe as bibliotecas que usaremos 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

O BigQuery, o armazenamento de big data do Google Cloud, disponibilizou muitos conjuntos de dados publicamente para sua exploração. Os notebooks da AI Platform são compatíveis com integração direta com o BigQuery sem exigir autenticação.

Para este laboratório, usaremos 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 da criança ao nascer e informações demográficas dos pais do bebê. Usaremos um subconjunto de recursos para prever o peso do bebê ao nascer.

Etapa 1: faça download dos dados do BigQuery em nosso notebook

Usaremos a biblioteca cliente Python para BigQuery para baixar os dados em um Pandas DataFrame. O conjunto de dados original tem 21 GB e contém 123 milhões de linhas. Para manter as coisas simples, usaremos apenas 10.000 linhas do conjunto de dados.

Construa a consulta e visualize o DataFrame resultante com o código a seguir. Aqui estamos obtendo 4 recursos do conjunto de dados original, junto com o peso do bebê (o que nosso modelo irá prever). O conjunto de dados remonta a muitos anos, mas para este modelo usaremos apenas dados posteriores a 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 obter um resumo dos recursos numéricos em nosso 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. Finalmente, vamos obter alguns dados em nossa coluna booleana indicando o sexo do bebê. Podemos fazer isso com o método Pandas value_counts :

df['is_male'].value_counts()

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

Etapa 2: preparar o conjunto de dados para treinamento

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

Primeiro, vamos eliminar 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 do rótulo em uma variável separada e crie um DataFrame apenas com nossos recursos. Como is_male é um booleano, vamos convertê-lo em um número inteiro para que todas as entradas do nosso 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 nosso conjunto de dados executando data.head() , deverá ver os quatro recursos que usaremos para o treinamento.

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 seu notebook. Isso dá suporte à confirmação de código diretamente na IU do notebook ou por meio do Terminal disponível no JupyterLab. Nesta seção, inicializaremos um repositório git em nosso notebook e faremos nosso primeiro commit por meio da IU.

Etapa 1: inicializar um repositório git

No diretório do codelab, selecione Git e, em seguida, Init na barra de menu superior do JupyterLab:

d9f1729358f18e58.png

Quando for perguntado se você deseja tornar este diretório um repositório Git, selecione Sim . Em seguida, selecione o ícone Git na barra lateral esquerda para ver o status de seus arquivos e commits:

1648d6828f11a6db.png

Etapa 2: Faça seu primeiro commit

Nesta IU, você pode adicionar arquivos a um commit, ver diffs de arquivo (veremos isso mais tarde) e enviar suas alterações. Vamos começar com o commit do arquivo de notebook que acabamos de adicionar.

Marque a caixa ao lado de seu arquivo de bloco de notas demo.ipynb para demo.ipynb -lo para o commit (você pode ignorar o diretório .ipynb_checkpoints/ ). Insira uma mensagem de confirmação na caixa de texto e clique na marca de seleção para confirmar suas alterações:

fe7366522a3a268f.png

Digite seu nome e e-mail quando solicitado. Em seguida, volte para a guia Histórico para ver seu primeiro commit:

d03567c3592afb77.png

Observe que as capturas de tela podem não corresponder exatamente à sua IU, devido às atualizações desde a publicação deste laboratório.

Usaremos o conjunto de dados de natalidade do BigQuery que baixamos em nosso notebook para construir um modelo que prevê o peso do bebê. Neste laboratório, vamos nos concentrar nas ferramentas do notebook, em vez da precisão do modelo em si.

Etapa 1: divida seus dados em conjuntos de treinamento e teste

Usaremos o utilitário train_test_split Learn train_test_split para dividir nossos dados antes de construir nosso modelo:

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

Agora estamos prontos para construir nosso modelo TensorFlow!

Etapa 2: construir e treinar o modelo TensorFlow

Estaremos construindo este modelo usando a API do modelo Sequential tf.keras, que nos permite definir nosso modelo como uma pilha de camadas. Todo o código de que precisamos para construir nosso modelo está aqui:

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

Em seguida, compilaremos nosso modelo para que possamos treiná-lo. Aqui, escolheremos o otimizador do modelo, a função de perda e as métricas que gostaríamos que o modelo registrasse durante o treinamento. Como este é um modelo de regressão (prevendo um valor numérico), estamos usando o erro quadrático médio em vez da precisão como nossa métrica:

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

Você pode usar a útil função model.summary() Keras para ver a forma e o número de parâmetros treináveis ​​de seu modelo em cada camada.

Agora estamos prontos para treinar nosso modelo. Tudo o que precisamos fazer é chamar o método fit() , passando nossos dados de treinamento e rótulos. Aqui, usaremos o parâmetro opcional validation_split, que conterá uma parte de nossos dados de treinamento para validar o modelo em cada etapa. Idealmente, você quer ver a formação e perda de validação, tanto diminuindo. Mas lembre-se de que, neste exemplo, estamos mais focados no modelo e nas ferramentas de notebook 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 ver o desempenho de nosso modelo, vamos gerar algumas previsões de teste nos primeiros 10 exemplos de nosso conjunto de dados de teste.

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

E então iremos iterar sobre 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: use git diff e envie suas alterações

Agora que você fez algumas alterações no notebook, pode experimentar o recurso git diff disponível na IU git do Notebooks. O demo.ipynb notas demo.ipynb agora deve estar na seção "Alterado" na IU. Passe o mouse sobre o nome do arquivo e clique no ícone diff:

a370facb3632fb32.png

Com isso, você deve ser capaz de ver um diff de suas alterações, como o seguinte:

461c502bd3ab910e.png

Desta vez, enviaremos nossas alterações por meio da linha de comando usando o Terminal. No menu Git na barra de menu superior do JupyterLab, selecione Comando Git no Terminal . Se você tem a aba git de sua barra lateral esquerda aberta enquanto executa os comandos abaixo, poderá ver suas mudanças refletidas na IU do git.

Em sua nova instância de terminal, execute o seguinte para preparar seu arquivo de notebook para confirmação:

git add demo.ipynb

E então execute o seguinte para confirmar suas alterações (você pode usar qualquer mensagem de confirmação que desejar):

git commit -m "Build and train TF model"

Então você deverá ver seu último commit no histórico:

a4b44045e97cb7a7.png

A ferramenta What-If é uma interface visual interativa projetada para ajudá-lo a visualizar seus conjuntos de dados e entender melhor a saída de seus modelos de ML. É uma ferramenta de código aberto criada pela equipe PAIR do Google. Embora funcione com qualquer tipo de modelo, possui alguns recursos criados exclusivamente para o Cloud AI Platform.

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

Etapa 1: preparar dados para a ferramenta de variações hipotéticas

Para aproveitar ao máximo a ferramenta de y_test , enviaremos a ela exemplos de nosso conjunto de testes junto com os rótulos de verdade fundamental para esses exemplos ( y_test ). Assim, podemos comparar o que nosso modelo previu com a verdade fundamental. Execute a linha de código abaixo para criar um novo DataFrame com nossos exemplos de teste e seus rótulos:

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

Neste laboratório, conectaremos a ferramenta de variações hipotéticas ao modelo que acabamos de treinar em nosso notebook. Para fazer isso, precisamos escrever uma função que a ferramenta usará para executar esses pontos de dados de teste em nosso modelo:

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

Etapa 2: instanciar a ferramenta de variações hipotéticas

Vamos instanciar a ferramenta de variações hipotéticas passando para ela 500 exemplos do conjunto de dados de teste concatenado + rótulos de verdade fundamental que acabamos de criar. Criamos uma instância de WitConfigBuilder para configurar a ferramenta, passando nossos dados, a função de predição personalizada que definimos acima, junto com 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)

Você deverá ver algo assim quando a ferramenta de variações hipotéticas for carregada:

fcdc1cb7ed8e364e.png

No eixo x, você pode ver seus pontos de dados de teste espalhados pelo valor de peso previsto do modelo, weight_pounds .

Etapa 3: explore o comportamento do modelo com a ferramenta de variações hipotéticas

Existem muitas coisas interessantes que você pode fazer com a ferramenta de variações hipotéticas. Exploraremos apenas alguns deles aqui. Primeiro, vamos dar uma olhada no editor de pontos de dados. Você pode selecionar qualquer ponto de dados para ver seus recursos e alterar os valores dos recursos. Comece clicando em qualquer ponto de dados:

2ba944f16240ff4b.png

À esquerda, você verá os valores do recurso para o ponto de dados que você selecionou. Você também pode comparar o rótulo da verdade fundamental desse ponto de dados com o valor predito pelo modelo. Na barra lateral esquerda, você também pode alterar os valores dos recursos e executar novamente a previsão do modelo para ver o efeito que essa mudança teve em seu modelo. Por exemplo, podemos alterar gestation_weeks para 30 para este ponto de dados clicando duas vezes nele para executar novamente a previsão:

aaa6a937c66758cf.png

Usando os menus suspensos na seção de gráfico da ferramenta de variações hipotéticas, você pode criar todos os 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 por seu erro de inferência (mais escuro significa uma diferença maior entre o peso previsto e o real). Aqui, parece que à medida que o peso diminui, o erro do modelo aumenta ligeiramente:

cd2ce527a9044e7b.png

Em seguida, marque o botão Parcelas de dependência parcial à esquerda. Isso mostra como cada recurso influencia a previsão do modelo. Por exemplo, conforme o tempo de gestação aumenta, o peso previsto do bebê em nosso modelo também aumenta:

1fec2a64fb03f432.png

Para obter mais ideias de exploração com a ferramenta de variações hipotéticas, verifique os links no início desta seção.

Por fim, aprenderemos como conectar o repositório git em nossa instância de notebook a um repositório em nossa conta GitHub. Se quiser seguir essa etapa, você precisará de uma conta GitHub .

Etapa 1: crie um novo repo no GitHub

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

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

git remote add origin git@github.com:username/your-repo.git

Etapa 2: autentique-se no GitHub em sua instância de notebooks

Em seguida, você precisará se autenticar no GitHub de dentro da instância do seu notebook. Este processo varia dependendo se você tem autenticação de dois fatores habilitada 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, em seguida, adicione a nova chave ao GitHub .

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

Para ter certeza de que configurou as coisas corretamente, execute git remote -v em seu terminal. Você deve ver seu novo repositório listado como remoto. Depois de ver a URL de seu repositório GitHub e autenticar no GitHub a partir de seu notebook, você estará pronto para enviar diretamente para o GitHub a partir de sua instância de notebook.

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

eec001587bb9cfb1.png

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

Na guia Histórico da IU do git do Notebooks, você pode ver se seus commits locais estão sincronizados com o GitHub. Neste exemplo, origin/master corresponde ao nosso repositório no GitHub:

2c3d1eb7cf95c24e.png

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

Você fez muito neste laboratório 👏👏👏

Para recapitular, você aprendeu como:

  • Crie e personalize uma instância do AI Platform Notebook
  • Inicialize um repositório git local nessa instância, adicione commits por meio da IU do git ou da linha de comando, visualize git diffs na IU git do Notebook
  • Crie e treine um modelo simples do TensorFlow 2
  • Use a ferramenta What-If em sua instância do Notebook
  • Conecte seu repositório git do Notebook a um repositório externo no GitHub

Se desejar continuar usando este notebook, é recomendável desligá-lo quando não estiver em uso. Na IU do Notebooks em seu Cloud Console, selecione o notebook e, em seguida, selecione Parar :

ba727f9a0aefbc30.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 em seu Console de nuvem, navegue até Armazenamento e exclua os dois intervalos que você criou para armazenar seus ativos de modelo.