Asista al Simposio Mujeres en ML el 7 de diciembre Regístrese ahora

Nube TensorFlow

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Ver en TensorFlow.org Ejecutar en Google Colab Ver en GitHub Descargar libreta logotipo de KaggleCorre en Kaggle

TensorFlow Cloud es una biblioteca que facilita el entrenamiento y el ajuste de hiperparámetros de los modelos de Keras en Google Cloud.

Con la API de run de TensorFlow Cloud, puede enviar el código de su modelo directamente a su cuenta de Google Cloud y usar los recursos informáticos de Google Cloud sin necesidad de iniciar sesión e interactuar con la interfaz de usuario de Cloud (una vez que haya configurado su proyecto en la consola).

Esto significa que puede usar sus recursos informáticos de Google Cloud desde dentro directamente de un cuaderno de Python: ¡un cuaderno como este! También puede enviar modelos a Google Cloud desde una secuencia de comandos Python .py simple.

ejemplo sencillo

Este es un ejemplo introductorio simple para demostrar cómo entrenar un modelo de forma remota usando TensorFlow Cloud y Google Cloud.

Puede simplemente leerlo para tener una idea de cómo funciona esto, o puede ejecutar el cuaderno en Google Colab. Ejecutar el cuaderno requiere conectarse a una cuenta de Google Cloud e ingresar sus credenciales y la identificación del proyecto. Consulte Configuración y conexión a su cuenta de Google Cloud si aún no tiene una cuenta o no está seguro de cómo configurar un proyecto en la consola.

Importar módulos requeridos

import tensorflow as tf
tf.version.VERSION
'2.6.0'
! pip install -q tensorflow-cloud
import tensorflow_cloud as tfc
print(tfc.__version__)
import sys

Configuraciones del proyecto

Establecer los parámetros del proyecto. Si no sabe cuál debe ser su GCP_PROJECT_ID o GCS_BUCKET , consulte Configuración y conexión a su cuenta de Google Cloud .

JOB_NAME es opcional y puede establecerlo en cualquier cadena. Si está realizando varios experimentos de capacitación (por ejemplo) como parte de un proyecto más grande, es posible que desee otorgar a cada uno de ellos un JOB_NAME único.

# 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: 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'

# OPTIONAL: You can change the job name to any string.
JOB_NAME = 'mnist'

# Setting location were training logs and checkpoints will be stored
GCS_BASE_PATH = f'gs://{GCS_BUCKET}/{JOB_NAME}'
TENSORBOARD_LOGS_DIR = os.path.join(GCS_BASE_PATH,"logs")
MODEL_CHECKPOINT_DIR = os.path.join(GCS_BASE_PATH,"checkpoints")
SAVED_MODEL_DIR = os.path.join(GCS_BASE_PATH,"saved_model")

Autenticar el cuaderno para usar su proyecto de Google Cloud

Este código autentica el cuaderno y verifica tus credenciales e identidad válidas de Google Cloud. Está dentro del bloque if not tfc.remote() para garantizar que solo se ejecute en la computadora portátil y no se ejecutará cuando el código de la computadora portátil se envíe a Google Cloud.

# 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

Configuración de modelo y datos

Desde aquí estamos siguiendo el procedimiento básico para configurar un modelo Keras simple para ejecutar la clasificación en el conjunto de datos MNIST.

Cargar y dividir datos

Lea datos sin procesar y divídalos para entrenar y probar conjuntos de datos.

(x_train, y_train), (_, _) = tf.keras.datasets.mnist.load_data()

x_train = x_train.reshape((60000, 28 * 28))
x_train = x_train.astype('float32') / 255

Crea un modelo y prepárate para el entrenamiento.

Cree un modelo simple y configure algunas devoluciones de llamada para él.

from tensorflow.keras import layers

model = tf.keras.Sequential([
  tf.keras.layers.Dense(512, activation='relu', input_shape=(28 * 28,)),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(loss='sparse_categorical_crossentropy',
              optimizer=tf.keras.optimizers.Adam(),
              metrics=['accuracy'])

Entrenamiento de validación rápida

Entrenaremos el modelo para una (1) época solo para asegurarnos de que todo esté configurado correctamente, y envolveremos ese comando de entrenamiento if not tfc.remote , para que solo suceda aquí en el entorno de tiempo de ejecución en el que están leyendo esto, no cuando se envía a Google Cloud.

if not tfc.remote():
    # Run the training for 1 epoch and a small subset of the data to validate setup
    model.fit(x=x_train[:100], y=y_train[:100], validation_split=0.2, epochs=1)

Prepárate para la formación a distancia

El siguiente código solo se ejecutará cuando el código del cuaderno se envíe a Google Cloud, no dentro del tiempo de ejecución en el que estás leyendo esto.

Primero, configuramos devoluciones de llamadas que:

  • Crear registros para TensorBoard .
  • Cree puntos de control y guárdelos en el directorio de puntos de control especificado anteriormente.
  • Detenga el entrenamiento del modelo si la pérdida no mejora lo suficiente.

Luego llamamos a model.fit y model.save , que (cuando este código se ejecuta en Google Cloud) ejecutan el entrenamiento completo (100 épocas) y luego guardan el modelo entrenado en el GCS Bucket y el directorio definido anteriormente.

if tfc.remote():
    # Configure Tensorboard logs
    callbacks=[
        tf.keras.callbacks.TensorBoard(log_dir=TENSORBOARD_LOGS_DIR),
        tf.keras.callbacks.ModelCheckpoint(
            MODEL_CHECKPOINT_DIR,
            save_best_only=True),
        tf.keras.callbacks.EarlyStopping(
            monitor='loss',
            min_delta =0.001,
            patience=3)]

    model.fit(x=x_train, y=y_train, epochs=100,
              validation_split=0.2, callbacks=callbacks)

    model.save(SAVED_MODEL_DIR)

Iniciar el entrenamiento a distancia

TensorFlow Cloud toma todo el código de su entorno de ejecución local (este cuaderno), lo envuelve y lo envía a Google Cloud para su ejecución. (Es por eso que los envoltorios if y if not tfc.remote son importantes).

Este paso preparará su código de este cuaderno para la ejecución remota y luego comenzará un trabajo de capacitación remota en Google Cloud Platform para entrenar el modelo.

Primero agregamos el paquete de Python tensorflow-cloud a un archivo requirements.txt , que se enviará junto con el código en este cuaderno. Puede agregar otros paquetes aquí según sea necesario.

Luego se especifica una GPU y una imagen de CPU. Solo necesitas especificar uno u otro; la GPU se utiliza en el código siguiente.

Finalmente, el corazón de la nube de TensorFlow: la llamada a tfc.run . Cuando esto se ejecute dentro de este cuaderno, todo el código de este cuaderno y el resto de los archivos en este directorio se empaquetarán y se enviarán a Google Cloud para su ejecución. Los parámetros en el método de run especifican los detalles de las imágenes de CPU GPU. Solo necesitas especificar uno u otro; la GPU se utiliza en el código siguiente.

Finalmente, el corazón de la nube de TensorFlow: la llamada a tfc.run . Cuando esto se ejecute dentro de este cuaderno, todo el código de este cuaderno y el resto de los archivos en este directorio se empaquetarán y se enviarán a Google Cloud para su ejecución. Los parámetros del método de run especifican los detalles de las imágenes de GPU y CPU. Solo necesitas especificar uno u otro; la GPU se utiliza en el código siguiente.

Finalmente, el corazón de la nube de TensorFlow: la llamada a tfc.run . Cuando esto se ejecute dentro de este cuaderno, todo el código de este cuaderno y el resto de los archivos en este directorio se empaquetarán y se enviarán a Google Cloud para su ejecución. Los parámetros del método de run especifican los detalles del entorno de ejecución y la estrategia de distribución (si corresponde) que se utilizará.

Una vez que se envía el trabajo, puede ir al siguiente paso para monitorear el progreso de los trabajos a través de Tensorboard.

# If you are using a custom image you can install modules via requirements
# txt file.
with open('requirements.txt','w') as f:
    f.write('tensorflow-cloud\n')

# Optional: Some recommended base images. If you provide none the system
# will choose one for you.
TF_GPU_IMAGE= "tensorflow/tensorflow:latest-gpu"
TF_CPU_IMAGE= "tensorflow/tensorflow:latest"

# Submit a single node training job using GPU.
tfc.run(
    distribution_strategy='auto',
    requirements_txt='requirements.txt',
    docker_config=tfc.DockerConfig(
        parent_image=TF_GPU_IMAGE,
        image_build_bucket=GCS_BUCKET
        ),
    chief_config=tfc.COMMON_MACHINE_CONFIGS['K80_1X'],
    job_labels={'job': JOB_NAME}
)

Resultados de entrenamiento

Vuelva a conectar su instancia de Colab

La mayoría de los trabajos de capacitación remota son de larga duración. Si está utilizando 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 conectar y configurar su instancia de Colab para acceder a los resultados de la capacitación.

  1. Importar módulos requeridos
  2. Configuraciones del proyecto
  3. Autenticar el cuaderno para usar su proyecto de Google Cloud

NO vuelva a ejecutar el resto del código.

Tensor de carga

Mientras la capacitación está en progreso, puede 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

Cargue su modelo entrenado

Una vez que se completa el entrenamiento, puede recuperar su modelo del GCS Bucket que especificó anteriormente.

trained_model = tf.keras.models.load_model(SAVED_MODEL_DIR)
trained_model.summary()