 Veja no TensorFlow.org |  Executar no Google Colab |  Ver no GitHub |  Baixar caderno |  Corra no Kaggle |
Neste exemplo, usaremos o CloudTuner e o Google Cloud para ajustar um modelo amplo e profundo com base no modelo ajustável introduzido no aprendizado de dados estruturados com redes amplas, profundas e cruzadas . Neste exemplo, usaremos o conjunto de dados do CAIIS Dogfood Day
Importar módulos necessários
import datetime
import uuid
import numpy as np
import pandas as pd
import tensorflow as tf
import os
import sys
import subprocess
from tensorflow.keras import datasets, layers, models
from sklearn.model_selection import train_test_split
# Install the latest version of tensorflow_cloud and other required packages.
if os.environ.get("TF_KERAS_RUNNING_REMOTELY", True):
subprocess.run(
['python3', '-m', 'pip', 'install', 'tensorflow-cloud', '-q'])
subprocess.run(
['python3', '-m', 'pip', 'install', 'google-cloud-storage', '-q'])
subprocess.run(
['python3', '-m', 'pip', 'install', 'fsspec', '-q'])
subprocess.run(
['python3', '-m', 'pip', 'install', 'gcsfs', '-q'])
import tensorflow_cloud as tfc
print(tfc.__version__)
0.1.15
tf.version.VERSION
'2.6.0'
Configurações do projeto
Configurando os parâmetros do projeto. Para obter mais detalhes sobre os parâmetros específicos do Google Cloud, consulte as instruções de configuração do projeto do Google Cloud .
# Set Google Cloud Specific parameters
# TODO: Please set GCP_PROJECT_ID to your own Google Cloud project ID.
GCP_PROJECT_ID = 'YOUR_PROJECT_ID'
# TODO: Change the Service Account Name to your own Service Account
SERVICE_ACCOUNT_NAME = 'YOUR_SERVICE_ACCOUNT_NAME'
SERVICE_ACCOUNT = f'{SERVICE_ACCOUNT_NAME}@{GCP_PROJECT_ID}.iam.gserviceaccount.com'
# TODO: set GCS_BUCKET to your own Google Cloud Storage (GCS) bucket.
GCS_BUCKET = 'YOUR_GCS_BUCKET_NAME'
# DO NOT CHANGE: Currently only the 'us-central1' region is supported.
REGION = 'us-central1'
# Set Tuning Specific parameters
# OPTIONAL: You can change the job name to any string.
JOB_NAME = 'wide_and_deep'
# OPTIONAL: Set Number of concurrent tuning jobs that you would like to run.
NUM_JOBS = 5
# TODO: Set the study ID for this run. Study_ID can be any unique string.
# Reusing the same Study_ID will cause the Tuner to continue tuning the
# Same Study parameters. This can be used to continue on a terminated job,
# or load stats from a previous study.
STUDY_NUMBER = '00001'
STUDY_ID = f'{GCP_PROJECT_ID}_{JOB_NAME}_{STUDY_NUMBER}'
# Setting location were training logs and checkpoints will be stored
GCS_BASE_PATH = f'gs://{GCS_BUCKET}/{JOB_NAME}/{STUDY_ID}'
TENSORBOARD_LOGS_DIR = os.path.join(GCS_BASE_PATH,"logs")
Como autenticar o notebook para usar seu projeto do Google Cloud
Para Kaggle Notebooks, clique em "Complementos"->"Google Cloud SDK" antes de executar a célula abaixo.
# Using tfc.remote() to ensure this code only runs in notebook
if not tfc.remote():
# Authentication for Kaggle Notebooks
if "kaggle_secrets" in sys.modules:
from kaggle_secrets import UserSecretsClient
UserSecretsClient().set_gcloud_credentials(project=GCP_PROJECT_ID)
# Authentication for Colab Notebooks
if "google.colab" in sys.modules:
from google.colab import auth
auth.authenticate_user()
os.environ["GOOGLE_CLOUD_PROJECT"] = GCP_PROJECT_ID
Carregar os dados
Leia dados brutos e divida para treinar e testar conjuntos de dados. Para esta etapa, você precisará copiar o conjunto de dados para o bucket do GCS para que ele possa ser acessado durante o treinamento. Para este exemplo, estamos usando o conjunto de dados de https://www.kaggle.com/c/caiis-dogfood-day-2020
Para fazer isso, você pode executar os comandos a seguir para fazer download e copiar o conjunto de dados para o bucket do GCS ou baixar manualmente o conjunto de dados na interface do usuário do Kaggle e fazer upload do arquivo train.csv para o bucket do GCS na interface do usuário do GCS .
# Download the datasetkaggle competitions download -c caiis-dogfood-day-2020# Copy the training file to your bucketgsutil cp ./caiis-dogfood-day-2020/train.csv $GCS_BASE_PATH/caiis-dogfood-day-2020/train.csv
train_URL = f'{GCS_BASE_PATH}/caiis-dogfood-day-2020/train.csv'
data = pd.read_csv(train_URL)
train, test = train_test_split(data, test_size=0.1)
# A utility method to create a tf.data dataset from a Pandas Dataframe
def df_to_dataset(df, shuffle=True, batch_size=32):
df = df.copy()
labels = df.pop('target')
ds = tf.data.Dataset.from_tensor_slices((dict(df), labels))
if shuffle:
ds = ds.shuffle(buffer_size=len(df))
ds = ds.batch(batch_size)
return ds
sm_batch_size = 1000 # A small batch size is used for demonstration purposes
train_ds = df_to_dataset(train, batch_size=sm_batch_size)
test_ds = df_to_dataset(test, shuffle=False, batch_size=sm_batch_size)
Pré-processe os dados
Configurando camadas de pré-processamento para dados de entrada categóricos e numéricos. Para obter mais detalhes sobre camadas de pré-processamento, consulte trabalhando com camadas de pré-processamento .
from tensorflow.keras.layers.experimental import preprocessing
def create_model_inputs():
inputs ={}
for name, column in data.items():
if name in ('id','target'):
continue
dtype = column.dtype
if dtype == object:
dtype = tf.string
else:
dtype = tf.float32
inputs[name] = tf.keras.Input(shape=(1,), name=name, dtype=dtype)
return inputs
#Preprocessing the numeric inputs, and running them through a normalization layer.
def preprocess_numeric_inputs(inputs):
numeric_inputs = {name:input for name,input in inputs.items()
if input.dtype==tf.float32}
x = layers.Concatenate()(list(numeric_inputs.values()))
norm = preprocessing.Normalization()
norm.adapt(np.array(data[numeric_inputs.keys()]))
numeric_inputs = norm(x)
return numeric_inputs
# Preprocessing the categorical inputs.
def preprocess_categorical_inputs(inputs):
categorical_inputs = []
for name, input in inputs.items():
if input.dtype == tf.float32:
continue
lookup = preprocessing.StringLookup(vocabulary=np.unique(data[name]))
one_hot = preprocessing.CategoryEncoding(max_tokens=lookup.vocab_size())
x = lookup(input)
x = one_hot(x)
categorical_inputs.append(x)
return layers.concatenate(categorical_inputs)
Defina a arquitetura do modelo e os hiperparâmetros
Nesta seção, definimos nossos parâmetros de ajuste usando Keras Tuner Hyper Parameters e uma função de construção de modelo. A função de construção de modelo recebe um argumento hp do qual você pode amostrar hiperparâmetros, como hp.Int('units', min_value=32, max_value=512, step=32) (um inteiro de um determinado intervalo).
import kerastuner
# Configure the search space
HPS = kerastuner.engine.hyperparameters.HyperParameters()
HPS.Float('learning_rate', min_value=1e-4, max_value=1e-2, sampling='log')
HPS.Int('num_layers', min_value=2, max_value=5)
for i in range(5):
HPS.Float('dropout_rate_' + str(i), min_value=0.0, max_value=0.3, step=0.1)
HPS.Choice('num_units_' + str(i), [32, 64, 128, 256])
from tensorflow.keras import layers
from tensorflow.keras.optimizers import Adam
def create_wide_and_deep_model(hp):
inputs = create_model_inputs()
wide = preprocess_categorical_inputs(inputs)
wide = layers.BatchNormalization()(wide)
deep = preprocess_numeric_inputs(inputs)
for i in range(hp.get('num_layers')):
deep = layers.Dense(hp.get('num_units_' + str(i)))(deep)
deep = layers.BatchNormalization()(deep)
deep = layers.ReLU()(deep)
deep = layers.Dropout(hp.get('dropout_rate_' + str(i)))(deep)
both = layers.concatenate([wide, deep])
outputs = layers.Dense(1, activation='sigmoid')(both)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
metrics = [
tf.keras.metrics.Precision(name='precision'),
tf.keras.metrics.Recall(name='recall'),
'accuracy',
'mse'
]
model.compile(
optimizer=Adam(lr=hp.get('learning_rate')),
loss='binary_crossentropy',
metrics=metrics)
return model
Configurar um CloudTuner
Nesta seção, configuramos o sintonizador de nuvem para execução remota e local. A principal diferença entre os dois é a estratégia de distribuição.
from tensorflow_cloud import CloudTuner
distribution_strategy = None
if not tfc.remote():
# Using MirroredStrategy to use a single instance with multiple GPUs
# during remote execution while using no strategy for local.
distribution_strategy = tf.distribute.MirroredStrategy()
tuner = CloudTuner(
create_wide_and_deep_model,
project_id=GCP_PROJECT_ID,
project_name=JOB_NAME,
region=REGION,
objective='accuracy',
hyperparameters=HPS,
max_trials=100,
directory=GCS_BASE_PATH,
study_id=STUDY_ID,
overwrite=True,
distribution_strategy=distribution_strategy)
# Configure Tensorboard logs
callbacks=[
tf.keras.callbacks.TensorBoard(log_dir=TENSORBOARD_LOGS_DIR)]
# Setting to run tuning remotely, you can run tuner locally to validate it works first.
if tfc.remote():
tuner.search(train_ds, epochs=20, validation_data=test_ds, callbacks=callbacks)
# You can uncomment the code below to run the tuner.search() locally to validate
# everything works before submitting the job to Cloud. Stop the job manually
# after one epoch.
# else:
# tuner.search(train_ds, epochs=1, validation_data=test_ds, callbacks=callbacks)
Inicie o treinamento remoto
Esta etapa preparará seu código deste notebook para execução remota e iniciará NUM_JOBS execuções paralelas remotamente para treinar o modelo. Depois que os trabalhos forem enviados, você poderá ir para a próxima etapa para monitorar o progresso dos trabalhos por meio do Tensorboard.
tfc.run_cloudtuner(
distribution_strategy='auto',
docker_config=tfc.DockerConfig(
image_build_bucket=GCS_BUCKET
),
chief_config=tfc.MachineConfig(
cpu_cores=16,
memory=60,
),
job_labels={'job': JOB_NAME},
service_account=SERVICE_ACCOUNT,
num_jobs=NUM_JOBS
)
Resultados do treinamento
Reconecte sua instância do Colab
A maioria dos trabalhos de treinamento remoto são de longa duração, se você estiver usando o Colab, pode ocorrer o tempo limite antes que os resultados do treinamento estejam disponíveis. Nesse caso, execute novamente as seções a seguir para reconectar e configurar sua instância do Colab para acessar os resultados do treinamento. Execute as seguintes seções em ordem:
- Importar módulos necessários
- Configurações do projeto
- Como autenticar o notebook para usar seu projeto do Google Cloud
Carregar Tensorboard
Enquanto o treinamento está em andamento, você pode usar o Tensorboard para visualizar os resultados. Observe que os resultados serão exibidos somente após o início do treinamento. Isso pode levar alguns minutos.
%load_ext tensorboard
%tensorboard --logdir $TENSORBOARD_LOGS_DIR
Você pode acessar os ativos de treinamento da seguinte maneira. Observe que os resultados serão exibidos somente após a conclusão do trabalho de ajuste pelo menos uma vez. Isso pode levar alguns minutos.
if not tfc.remote():
tuner.results_summary(1)
best_model = tuner.get_best_models(1)[0]
best_hyperparameters = tuner.get_best_hyperparameters(1)[0]
# References to best trial assets
best_trial_id = tuner.oracle.get_best_trials(1)[0].trial_id
best_trial_dir = tuner.get_trial_dir(best_trial_id)