 Ver en TensorFlow.org |  Ejecutar en Google Colab |  Ver en GitHub |  Descargar cuaderno |  Ejecutar en Kaggle |
En este ejemplo, usaremos CloudTuner y Google Cloud para ajustar un modelo amplio y profundo basado en el modelo ajustable introducido en el aprendizaje de datos estructurados con redes anchas, profundas y cruzadas . En este ejemplo usaremos el conjunto de datos de CAIIS Dogfood Day.
Importar módulos requeridos
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'
Configuraciones de proyecto
Configuración de los parámetros del proyecto. Para obtener más detalles sobre los parámetros específicos de Google Cloud, consulte las Instrucciones de configuración del proyecto de 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")
Autenticar el cuaderno para usar su proyecto Google Cloud
Para Kaggle Notebooks, haga clic en "Complementos" -> "Google Cloud SDK" antes de ejecutar la siguiente celda.
# 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
Cargar los datos
Lea datos sin procesar y divídalos para entrenar y probar conjuntos de datos. Para este paso, deberá copiar el conjunto de datos en su depósito de GCS para poder acceder a él durante el entrenamiento. Para este ejemplo, utilizamos el conjunto de datos de https://www.kaggle.com/c/caiis-dogfood-day-2020
Para hacer esto, puede ejecutar los siguientes comandos para descargar y copiar el conjunto de datos en su depósito de GCS, o descargar manualmente el conjunto de datos en la interfaz de usuario de Kaggle y cargar el archivo train.csv en su depósito de GCS en la interfaz de usuario de 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)
Preprocesar los datos
Configuración de capas de preprocesamiento para datos de entrada categóricos y numéricos. Para obtener más detalles sobre el preprocesamiento de capas, consulte trabajar con capas de preprocesamiento .
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)
Definir la arquitectura del modelo y los hiperparámetros.
En esta sección definimos nuestros parámetros de ajuste utilizando Keras Tuner Hyper Parameters y una función de creación de modelos. La función de creación de modelos toma un argumento hp del cual se pueden tomar muestras de hiperparámetros, como hp.Int('units', min_value=32, max_value=512, step=32) (un número entero de un rango determinado).
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 un CloudTuner
En esta sección configuramos el sintonizador de nube para ejecución tanto remota como local. La principal diferencia entre los dos es la estrategia de distribución.
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)
Iniciar la formación remota
Este paso preparará su código desde este cuaderno para la ejecución remota e iniciará NUM_JOBS ejecuciones paralelas de forma remota para entrenar el modelo. Una vez enviados los trabajos, puede pasar al siguiente paso para monitorear el progreso de los trabajos a través de 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 del entrenamiento
Vuelva a conectar su instancia de Colab
La mayoría de los trabajos de capacitación remota son de larga duración; si utiliza Colab, es posible que se agote el tiempo de espera antes de que los resultados de la capacitación estén disponibles. En ese caso, vuelva a ejecutar las siguientes secciones para volver a conectarse y configurar su instancia de Colab para acceder a los resultados de la capacitación. Ejecute las siguientes secciones en orden:
- Importar módulos requeridos
- Configuraciones de proyecto
- Autenticar el cuaderno para usar su proyecto Google Cloud
Cargar tensorboard
Mientras el entrenamiento está en curso, puedes usar Tensorboard para ver los resultados. Tenga en cuenta que los resultados se mostrarán solo después de que haya comenzado su entrenamiento. Esto puede tomar unos pocos minutos.
%load_ext tensorboard
%tensorboard --logdir $TENSORBOARD_LOGS_DIR
Puede acceder a los recursos de capacitación de la siguiente manera. Tenga en cuenta que los resultados se mostrarán solo después de que su trabajo de ajuste haya completado al menos una prueba. Esto puede tomar unos pocos 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)