Aumentar la velocidad de entrenamiento de TensorFlow en un 50% con estos trucos de TPU

Descripción basic del contenido

• Configuración
• Inicialización de TPU ‘
• Colocación del dispositivo guide
• Estrategias de distribución
• Clasificación en TPUS
• Definir un modelo keras
• Cargar el conjunto de datos
• Entrena el modelo con API de alto nivel Keras
• Entrena el modelo usando un bucle de entrenamiento personalizado
• Mejorar el rendimiento con múltiples pasos dentro de TF.
• Siguientes pasos

Esta guía demuestra cómo realizar capacitación básica en unidades de procesamiento de tensor (TPU) y vainas TPU, una colección de dispositivos TPU conectados por interfaces de crimson de alta velocidad dedicadas, con tf.keras y bucles de entrenamiento personalizados.

Las TPU son los circuitos integrados (ASIC) específicos de aplicaciones personalizados de Google utilizados para acelerar las cargas de trabajo de aprendizaje automático. Están disponibles a través de Google Colab, TPU Analysis Cloud y Cloud TPU.

Configuración

Antes de ejecutar este cuaderno Colab, asegúrese de que su acelerador de {hardware} sea una TPU revisando su configuración de cuaderno: Tiempo de ejecución > Cambiar el tipo de tiempo de ejecución > Acelerador de {hardware} > TPU.

Importar algunas bibliotecas necesarias, incluidos los conjuntos de datos TensorFlow:

import tensorflow as tf

import os
import tensorflow_datasets as tfds

2023-06-09 12:13:32.486552: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Couldn't discover TensorRT

Inicialización de TPU

Las TPU suelen ser trabajadores de TPU en la nube, que son diferentes del proceso native que ejecuta el programa Python del usuario. Por lo tanto, debe hacer un trabajo de inicialización para conectarse al clúster remoto e inicializar las TPU. Tenga en cuenta que el tpu argumentar tf.distribute.cluster_resolver.TPUClusterResolver es una dirección especial solo para Colab. Si está ejecutando su código en Google Compute Engine (GCE), debe pasar el nombre de su TPU en la nube.

resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')
tf.config.experimental_connect_to_cluster(resolver)
# That is the TPU initialization code that needs to be originally.
tf.tpu.experimental.initialize_tpu_system(resolver)
print("All units: ", tf.config.list_logical_devices('TPU'))

INFO:tensorflow:Deallocate tpu buffers earlier than initializing tpu system.
2023-06-09 12:13:34.011755: E tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.cc:266] failed name to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable system is detected
INFO:tensorflow:Deallocate tpu buffers earlier than initializing tpu system.
INFO:tensorflow:Initializing the TPU system: grpc://10.25.167.66:8470
INFO:tensorflow:Initializing the TPU system: grpc://10.25.167.66:8470
INFO:tensorflow:Completed initializing TPU system.
INFO:tensorflow:Completed initializing TPU system.
All units:  [LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:0', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:1', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:2', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:3', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:4', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:5', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:6', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:7', device_type='TPU')]

Colocación del dispositivo guide

Después de inicializar la TPU, puede usar la ubicación guide del dispositivo para colocar el cálculo en un solo dispositivo TPU:

a = tf.fixed([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
b = tf.fixed([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])

with tf.system('/TPU:0'):
  c = tf.matmul(a, b)

print("c system: ", c.system)
print(c)

c system:  /job:employee/reproduction:0/process:0/system:TPU:0
tf.Tensor(
[[22. 28.]
 [49. 64.]], form=(2, 2), dtype=float32)

Estrategias de distribución

Por lo basic, ejecuta su modelo en múltiples TPU de una manera paralela de datos. Para distribuir su modelo en múltiples TPU (así como múltiples GPU o múltiples máquinas), TensorFlow ofrece el tf.distribute.Technique API. Puede reemplazar su estrategia de distribución y el modelo se ejecutará en cualquier dispositivo (TPU). Obtenga más información en la capacitación distribuida con TensorFlow Information.

Usando el tf.distribute.TPUStrategy La opción implementa capacitación distribuida sincrónica. Las TPU proporcionan su propia implementación de las operaciones colectivas eficientes y otras operaciones colectivas en múltiples núcleos de TPU, que se utilizan en TPUStrategy.

Para demostrar esto, cree un tf.distribute.TPUStrategy objeto:

technique = tf.distribute.TPUStrategy(resolver)

INFO:tensorflow:Discovered TPU system:
INFO:tensorflow:Discovered TPU system:
INFO:tensorflow:*** Num TPU Cores: 8
INFO:tensorflow:*** Num TPU Cores: 8
INFO:tensorflow:*** Num TPU Employees: 1
INFO:tensorflow:*** Num TPU Employees: 1
INFO:tensorflow:*** Num TPU Cores Per Employee: 8
INFO:tensorflow:*** Num TPU Cores Per Employee: 8
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:localhost/reproduction:0/process:0/system:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:localhost/reproduction:0/process:0/system:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:0, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:0, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:1, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:1, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:2, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:2, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:3, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:3, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:4, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:4, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:5, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:5, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:6, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:6, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:7, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU:7, TPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:XLA_CPU:0, XLA_CPU, 0, 0)
INFO:tensorflow:*** Out there Machine: _DeviceAttributes(/job:employee/reproduction:0/process:0/system:XLA_CPU:0, XLA_CPU, 0, 0)

Para replicar un cálculo para que pueda ejecutarse en todos los núcleos de TPU, puede pasarlo al Technique.run API. A continuación se muestra un ejemplo que muestra todos los núcleos que reciben las mismas entradas (a, b) y realizar multiplicación de matriz en cada núcleo de forma independiente. Las salidas serán los valores de todas las réplicas.

@tf.operate
def matmul_fn(x, y):
  z = tf.matmul(x, y)
  return z

z = technique.run(matmul_fn, args=(a, b))
print(z)

PerReplica:{
  0: tf.Tensor(
[[22. 28.]
 [49. 64.]], form=(2, 2), dtype=float32),
  1: tf.Tensor(
[[22. 28.]
 [49. 64.]], form=(2, 2), dtype=float32),
  2: tf.Tensor(
[[22. 28.]
 [49. 64.]], form=(2, 2), dtype=float32),
  3: tf.Tensor(
[[22. 28.]
 [49. 64.]], form=(2, 2), dtype=float32),
  4: tf.Tensor(
[[22. 28.]
 [49. 64.]], form=(2, 2), dtype=float32),
  5: tf.Tensor(
[[22. 28.]
 [49. 64.]], form=(2, 2), dtype=float32),
  6: tf.Tensor(
[[22. 28.]
 [49. 64.]], form=(2, 2), dtype=float32),
  7: tf.Tensor(
[[22. 28.]
 [49. 64.]], form=(2, 2), dtype=float32)
}

Clasificación en TPUS

Habiendo cubierto los conceptos básicos, considere un ejemplo más concreto. Esta sección demuestra cómo usar la estrategia de distribución.tf.distribute.TPUStrategy—Ponelas para entrenar un modelo Keras en una TPU en la nube.

Definir un modelo keras

Comience con una definición de un Sequential Modelo Keras para la clasificación de imágenes en el conjunto de datos MNIST. No es diferente de lo que usarías si estuvieras entrenando en CPU o GPU. Tenga en cuenta que la creación del modelo de keras debe estar dentro del Technique.scopepor lo que las variables se pueden crear en cada dispositivo TPU. Otras partes del código no son necesarias para estar dentro del Technique alcance.

def create_model():
  return tf.keras.Sequential(
      [tf.keras.layers.Conv2D(256, 3, activation='relu', input_shape=(28, 28, 1)),
       tf.keras.layers.Conv2D(256, 3, activation='relu'),
       tf.keras.layers.Flatten(),
       tf.keras.layers.Dense(256, activation='relu'),
       tf.keras.layers.Dense(128, activation='relu'),
       tf.keras.layers.Dense(10)])

Cargar el conjunto de datos

Uso eficiente del tf.knowledge.Dataset La API es crítica cuando se usa una TPU de la nube. Puede obtener más información sobre el rendimiento del conjunto de datos en la Guía de rendimiento de la tubería de entrada.

Si está utilizando nodos TPU, debe almacenar todos los archivos de datos leídos por TensorFlow Dataset En los cubos de almacenamiento en la nube de Google (GCS). Si está utilizando las máquinas virtuales de TPU, puede almacenar datos donde quiera. Para obtener más información sobre los nodos TPU y las máquinas virtuales de TPU, consulte la documentación de la arquitectura del sistema TPU.

Para la mayoría de los casos de uso, se recomienda convertir sus datos en el TFRecord formatear y usar un tf.knowledge.TFRecordDataset para leerlo. Consulte el tfrecord y el tutorial de Ejemplo para obtener detalles sobre cómo hacer esto. No es un requisito difícil y puede usar otros lectores de conjuntos de datos, como tf.knowledge.FixedLengthRecordDataset o tf.knowledge.TextLineDataset.

Puede cargar conjuntos de datos pequeños enteros en la memoria utilizando tf.knowledge.Dataset.cache.

Independientemente del formato de datos utilizado, se recomienda encarecidamente que use archivos grandes del orden de 100 MB. Esto es especialmente importante en esta configuración en crimson, ya que la sobrecarga de abrir un archivo es significativamente mayor.

Como se muestra en el código a continuación, debe usar los conjuntos de datos TensorFlow tfds.load Módulo para obtener una copia de los datos de entrenamiento y prueba de MNIST. Tenga en cuenta que try_gcs se especifica para usar una copia que esté disponible en un cubo GCS público. Si no especifica esto, la TPU no podrá acceder a los datos descargados.

def get_dataset(batch_size, is_training=True):
  break up = 'practice' if is_training else 'take a look at'
  dataset, data = tfds.load(identify='mnist', break up=break up, with_info=True,
                            as_supervised=True, try_gcs=True)

  # Normalize the enter knowledge.
  def scale(picture, label):
    picture = tf.forged(picture, tf.float32)
    picture /= 255.0
    return picture, label

  dataset = dataset.map(scale)

  # Solely shuffle and repeat the dataset in coaching. The benefit of getting an
  # infinite dataset for coaching is to keep away from the potential final partial batch
  # in every epoch, in order that you do not want to consider scaling the gradients
  # primarily based on the precise batch measurement.
  if is_training:
    dataset = dataset.shuffle(10000)
    dataset = dataset.repeat()

  dataset = dataset.batch(batch_size)

  return dataset

Entrena el modelo con API de alto nivel Keras

Puedes entrenar a tu modelo con keras Mannequin.match y Mannequin.compile Apis. No hay nada específico de TPU en este paso: escribe el código como si estuviera usando múltiples GPU y un MirroredStrategy en lugar de el TPUStrategy. Puede obtener más información en la capacitación distribuida con el tutorial de Keras.

with technique.scope():
  mannequin = create_model()
  mannequin.compile(optimizer='adam',
                loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                metrics=['sparse_categorical_accuracy'])

batch_size = 200
steps_per_epoch = 60000 // batch_size
validation_steps = 10000 // batch_size

train_dataset = get_dataset(batch_size, is_training=True)
test_dataset = get_dataset(batch_size, is_training=False)

mannequin.match(train_dataset,
          epochs=5,
          steps_per_epoch=steps_per_epoch,
          validation_data=test_dataset,
          validation_steps=validation_steps)

Epoch 1/5
300/300 [==============================] - 17s 32ms/step - loss: 0.1235 - sparse_categorical_accuracy: 0.9620 - val_loss: 0.0462 - val_sparse_categorical_accuracy: 0.9856
Epoch 2/5
300/300 [==============================] - 7s 24ms/step - loss: 0.0333 - sparse_categorical_accuracy: 0.9894 - val_loss: 0.0401 - val_sparse_categorical_accuracy: 0.9878
Epoch 3/5
300/300 [==============================] - 7s 24ms/step - loss: 0.0186 - sparse_categorical_accuracy: 0.9938 - val_loss: 0.0352 - val_sparse_categorical_accuracy: 0.9900
Epoch 4/5
300/300 [==============================] - 7s 25ms/step - loss: 0.0127 - sparse_categorical_accuracy: 0.9957 - val_loss: 0.0482 - val_sparse_categorical_accuracy: 0.9879
Epoch 5/5
300/300 [==============================] - 7s 24ms/step - loss: 0.0111 - sparse_categorical_accuracy: 0.9962 - val_loss: 0.0448 - val_sparse_categorical_accuracy: 0.9894

Para reducir la sobrecarga de Python y maximizar el rendimiento de su TPU, pase en el steps_per_execution Argumento a Keras Mannequin.compile. En este ejemplo, aumenta el rendimiento en aproximadamente un 50%:

with technique.scope():
  mannequin = create_model()
  mannequin.compile(optimizer='adam',
                # Something between 2 and `steps_per_epoch` might assist right here.
                steps_per_execution = 50,
                loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                metrics=['sparse_categorical_accuracy'])

mannequin.match(train_dataset,
          epochs=5,
          steps_per_epoch=steps_per_epoch,
          validation_data=test_dataset,
          validation_steps=validation_steps)

Epoch 1/5
300/300 [==============================] - 14s 45ms/step - loss: 0.1306 - sparse_categorical_accuracy: 0.9591 - val_loss: 0.0420 - val_sparse_categorical_accuracy: 0.9863
Epoch 2/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0333 - sparse_categorical_accuracy: 0.9900 - val_loss: 0.0502 - val_sparse_categorical_accuracy: 0.9846
Epoch 3/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0193 - sparse_categorical_accuracy: 0.9936 - val_loss: 0.0406 - val_sparse_categorical_accuracy: 0.9879
Epoch 4/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0135 - sparse_categorical_accuracy: 0.9955 - val_loss: 0.0416 - val_sparse_categorical_accuracy: 0.9882
Epoch 5/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0110 - sparse_categorical_accuracy: 0.9962 - val_loss: 0.0463 - val_sparse_categorical_accuracy: 0.9882

Entrena el modelo usando un bucle de entrenamiento personalizado

También puede crear y entrenar a su modelo utilizando tf.operate y tf.distribute API directamente. Puedes usar el Technique.experimental_distribute_datasets_from_function API para distribuir el tf.knowledge.Dataset dada una función de conjunto de datos. Tenga en cuenta que en el ejemplo debajo del tamaño de lote pasó a la Dataset es el tamaño de lote per-replica en lugar del tamaño de lote international. Para obtener más información, consulte la capacitación personalizada con tf.distribute.Technique tutorial.

Primero, cree el modelo, los conjuntos de datos y tf.operates:

# Create the mannequin, optimizer and metrics contained in the `tf.distribute.Technique`
# scope, in order that the variables could be mirrored on every system.
with technique.scope():
  mannequin = create_model()
  optimizer = tf.keras.optimizers.Adam()
  training_loss = tf.keras.metrics.Imply('training_loss', dtype=tf.float32)
  training_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
      'training_accuracy', dtype=tf.float32)

# Calculate per reproduction batch measurement, and distribute the `tf.knowledge.Dataset`s
# on every TPU employee.
per_replica_batch_size = batch_size // technique.num_replicas_in_sync

train_dataset = technique.experimental_distribute_datasets_from_function(
    lambda _: get_dataset(per_replica_batch_size, is_training=True))

@tf.operate
def train_step(iterator):
  """The step operate for one coaching step."""

  def step_fn(inputs):
    """The computation to run on every TPU system."""
    pictures, labels = inputs
    with tf.GradientTape() as tape:
      logits = mannequin(pictures, coaching=True)
      loss = tf.keras.losses.sparse_categorical_crossentropy(
          labels, logits, from_logits=True)
      loss = tf.nn.compute_average_loss(loss, global_batch_size=batch_size)
    grads = tape.gradient(loss, mannequin.trainable_variables)
    optimizer.apply_gradients(listing(zip(grads, mannequin.trainable_variables)))
    training_loss.update_state(loss * technique.num_replicas_in_sync)
    training_accuracy.update_state(labels, logits)

  technique.run(step_fn, args=(subsequent(iterator),))

WARNING:tensorflow:From /tmpfs/tmp/ipykernel_9094/1509474074.py:14: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will likely be eliminated in a future model.
Directions for updating:
rename to distribute_datasets_from_function
WARNING:tensorflow:From /tmpfs/tmp/ipykernel_9094/1509474074.py:14: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will likely be eliminated in a future model.
Directions for updating:
rename to distribute_datasets_from_function

Luego, ejecute el bucle de entrenamiento:

steps_per_eval = 10000 // batch_size

train_iterator = iter(train_dataset)
for epoch in vary(5):
  print('Epoch: {}/5'.format(epoch))

  for step in vary(steps_per_epoch):
    train_step(train_iterator)
  print('Present step: {}, coaching loss: {}, accuracy: {}%'.format(
      optimizer.iterations.numpy(),
      spherical(float(training_loss.consequence()), 4),
      spherical(float(training_accuracy.consequence()) * 100, 2)))
  training_loss.reset_states()
  training_accuracy.reset_states()

Epoch: 0/5
Present step: 300, coaching loss: 0.1465, accuracy: 95.4%
Epoch: 1/5
Present step: 600, coaching loss: 0.035, accuracy: 98.94%
Epoch: 2/5
Present step: 900, coaching loss: 0.0197, accuracy: 99.39%
Epoch: 3/5
Present step: 1200, coaching loss: 0.0126, accuracy: 99.59%
Epoch: 4/5
Present step: 1500, coaching loss: 0.0109, accuracy: 99.64%

Mejorar el rendimiento con múltiples pasos adentro tf.operate

Puede mejorar el rendimiento ejecutando múltiples pasos dentro de un tf.operate. Esto se logra envolviendo el Technique.run Llame con un tf.vary adentro tf.operatey el autógrafo lo convertirá a un tf.while_loop en el trabajador de la TPU. Puedes aprender más sobre tf.operates en el mejor rendimiento con tf.operate guía.

A pesar del rendimiento mejorado, hay compensaciones con este método en comparación con ejecutar un solo paso dentro de un tf.operate. Ejecutar múltiples pasos en un tf.operate es menos versatile: no se puede ejecutar las cosas con entusiasmo o el código de pitón arbitrario dentro de los pasos.

@tf.operate
def train_multiple_steps(iterator, steps):
  """The step operate for one coaching step."""

  def step_fn(inputs):
    """The computation to run on every TPU system."""
    pictures, labels = inputs
    with tf.GradientTape() as tape:
      logits = mannequin(pictures, coaching=True)
      loss = tf.keras.losses.sparse_categorical_crossentropy(
          labels, logits, from_logits=True)
      loss = tf.nn.compute_average_loss(loss, global_batch_size=batch_size)
    grads = tape.gradient(loss, mannequin.trainable_variables)
    optimizer.apply_gradients(listing(zip(grads, mannequin.trainable_variables)))
    training_loss.update_state(loss * technique.num_replicas_in_sync)
    training_accuracy.update_state(labels, logits)

  for _ in tf.vary(steps):
    technique.run(step_fn, args=(subsequent(iterator),))

# Convert `steps_per_epoch` to `tf.Tensor` so the `tf.operate` will not get
# retraced if the worth modifications.
train_multiple_steps(train_iterator, tf.convert_to_tensor(steps_per_epoch))

print('Present step: {}, coaching loss: {}, accuracy: {}%'.format(
      optimizer.iterations.numpy(),
      spherical(float(training_loss.consequence()), 4),
      spherical(float(training_accuracy.consequence()) * 100, 2)))

Present step: 1800, coaching loss: 0.009, accuracy: 99.72%

Siguientes pasos

Para obtener más información sobre las TPU de la nube y cómo usarlas:

• Google Cloud TPU: la página de inicio de Google Cloud TPU.
• Documentación de Google Cloud TPU: documentación de Google Cloud TPU, que incluye:
• Google Cloud TPU Colab Notebooks: ejemplos de capacitación de extremo a extremo.
• Guía de rendimiento de Google Cloud TPU: Mejore el rendimiento de la TPU en la nube aún más ajustando los parámetros de configuración de TPU en la nube para su aplicación
• Capacitación distribuida con TensorFlow: cómo usar estrategias de distribución, incluida tf.distribute.TPUStrategy—Con ejemplos que muestran las mejores prácticas.
• Incrustos de TPU: TensorFlow incluye soporte especializado para la capacitación de incrustaciones en TPUS a través de tf.tpu.experimental.embedding. Además, TensorFlow Recomenders ha tfrs.layers.embedding.TPUEmbedding. Los incrustaciones proporcionan representaciones eficientes y densas, capturando similitudes y relaciones complejas entre las características. El soporte de incrustación específico de TPU de Tensorflow le permite entrenar incrustaciones que son más grandes que la memoria de un solo dispositivo TPU, y usar entradas dispersas y ascendentes en las TPU.
• TPU Analysis Cloud (TRC): TRC permite a los investigadores solicitar acceso a un clúster de más de 1,000 dispositivos TPU en la nube.