Guía de uso

La API tfc.run le permite entrenar sus modelos a escala en GCP.

La API tfc.run se puede utilizar de cuatro formas diferentes. Esto se define según dónde ejecuta la API (script de Python frente a cuaderno de Python) y su parámetro entry_point :

• Archivo Python como entry_point .
• Archivo de cuaderno como entry_point .
• run dentro de un script de Python que contiene el modelo tf.keras .
• run dentro de un script de cuaderno que contiene el modelo tf.keras . La forma más común es utilizar run dentro de un cuaderno.

El entry_point es una (ruta a) un script de Python o un archivo de cuaderno, o None . Si es None , todo el archivo actual se envía a Google Cloud.

Usando un archivo Python como entry_point .

Si tiene su modelo tf.keras en un archivo Python ( mnist_example.py ), puede escribir el siguiente script simple ( scale_mnist.py ) para escalar su modelo en GCP.

import tensorflow_cloud as tfc
tfc.run(entry_point='mnist_example.py')

Tenga en cuenta que todos los archivos en el mismo árbol de directorios que entry_point se empaquetarán en la imagen de la ventana acoplable creada, junto con el archivo entry_point . Se recomienda crear un nuevo directorio para albergar cada proyecto en la nube que incluya los archivos necesarios y nada más, para optimizar los tiempos de creación de imágenes.

Usando un archivo de cuaderno como entry_point .

Si tiene su modelo tf.keras en un archivo de cuaderno ( mnist_example.ipynb ), puede escribir el siguiente script simple ( scale_mnist.py ) para escalar su modelo en GCP.

import tensorflow_cloud as tfc
tfc.run(entry_point='mnist_example.ipynb')

Tenga en cuenta que todos los archivos en el mismo árbol de directorios que entry_point se empaquetarán en la imagen de la ventana acoplable creada, junto con el archivo entry_point . Al igual que el entry_point del script de Python anterior, recomendamos crear un nuevo directorio para albergar cada proyecto en la nube que incluya los archivos necesarios y nada más, para optimizar los tiempos de creación de imágenes.

Usar run dentro de un script de Python que contiene el modelo tf.keras .

Puede utilizar la API run desde su archivo Python que contiene el modelo tf.keras ( mnist_scale.py ). En este caso de uso, entry_point debería ser None . La API run se puede llamar desde cualquier lugar y todo el archivo se ejecutará de forma remota. Se puede llamar a la API al final para ejecutar el script localmente con fines de depuración (posiblemente con menos épocas y otros indicadores).

import tensorflow_datasets as tfds
import tensorflow as tf
import tensorflow_cloud as tfc

tfc.run(
    entry_point=None,
    distribution_strategy='auto',
    requirements_txt='requirements.txt',
    chief_config=tfc.MachineConfig(
            cpu_cores=8,
            memory=30,
            accelerator_type=tfc.AcceleratorType.NVIDIA_TESLA_T4,
            accelerator_count=2),
    worker_count=0)

datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']

num_train_examples = info.splits['train'].num_examples
num_test_examples = info.splits['test'].num_examples

BUFFER_SIZE = 10000
BATCH_SIZE = 64

def scale(image, label):
    image = tf.cast(image, tf.float32)
    image /= 255
    return image, label

train_dataset = mnist_train.map(scale).cache()
train_dataset = train_dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(
        28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

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

Tenga en cuenta que todos los archivos en el mismo árbol de directorios que el script de Python se empaquetarán en la imagen de la ventana acoplable creada, junto con el archivo de Python. Se recomienda crear un nuevo directorio para albergar cada proyecto en la nube que incluya los archivos necesarios y nada más, para optimizar los tiempos de creación de imágenes.

Usando run dentro de un script de cuaderno que contiene el modelo tf.keras .

En este caso de uso, entry_point debe ser None y se debe especificar docker_config.image_build_bucket para garantizar que la compilación se pueda almacenar y publicar.

¿Qué sucede cuando llamas run ?

La llamada API logrará lo siguiente:

1. Preparar entidades de código como un script/notebook de Keras, la nube y la distribución .
2. Convertir esta entidad de distribución en un contenedor acoplable con las dependencias requeridas.
3. Implemente este contenedor a escala y capacítelo utilizando estrategias de distribución de TensorFlow.
4. Transmita registros y superviselos en TensorBoard alojado, administre el almacenamiento de puntos de control.

De forma predeterminada, el demonio Docker local para crear y publicar imágenes de Docker en el registro de contenedores de Google. Las imágenes se publican en gcr.io/your-gcp-project-id . Si especifica docker_config.image_build_bucket , usaremos Google Cloud build para crear y publicar imágenes de Docker.

La plataforma Google AI se utiliza para implementar imágenes de Docker en Google Cloud.

Nota: Cuando entry_point es una ruta de archivo, todos los archivos en el mismo árbol de directorios que entry_point se empaquetarán en la imagen de Docker creada junto con el archivo entry_point .