Увеличьте скорость тренировок с тензорфлоу на 50% с этими трюками TPU
hackernoon-top-story machine-learning tensorflow-training-speed google-cloud-tpu tpu-pods tpu-custom-training-loop tpu-distributed-strategy cloud-tpu-tensorflow-guide tpu-mnist-tutorial

Увеличьте скорость тренировок с тензорфлоу на 50% с этими трюками TPU

13 августа 2025 г.

Обзор контента

  • Настраивать
  • TPU инициализация '
  • Ручное размещение устройства
  • Стратегии распространения
  • Классификация на TPU
  • Определите модель кераса
  • Загрузите набор данных
  • Обучить модель с помощью API высокого уровня кераса
  • Обучить модель, используя индивидуальную тренировочную петлю
  • Повышение производительности с несколькими шагами внутри tf.function
  • Следующие шаги

Это руководство демонстрирует, как провести базовое обучение наТензорные обработки единицы (TPU)и TPU PODS, коллекция устройств TPU, подключенные специальными высокоскоростными сетевыми интерфейсами, сtf.kerasи индивидуальные тренировочные петли.

TPU-это разработка Google, разработанные в интегрированных цепях (ASIC), используемых для ускорения рабочих нагрузок машинного обучения. Они доступны черезGoogle Colab,TPU Research Cloud, иОблачный TPUПолем

Настраивать

Перед запуском этой ноутбука Colab убедитесь, что ваш аппаратный ускоритель является TPU, проверив настройки ноутбука:Время выполнения > Изменить тип времени выполнения > Аппаратный ускоритель > TPUПолем

Импортируйте некоторые необходимые библиотеки, включая наборы данных 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: Could not find TensorRT

TPU инициализация

TPU обычноОблачный TPUработники, которые отличаются от локального процесса, запускающего программу Python пользователя. Таким образом, вам необходимо выполнить некоторую работу по инициализации, чтобы подключиться к удаленному кластеру и инициализации TPU. Обратите внимание, чтоtpuаргументtf.distribute.cluster_resolver.TPUClusterResolverэто специальный адрес только для Колаба. Если вы запускаете свой код в Google Compute Engine (GCE), вместо этого вам следует передать имя вашего облачного TPU.

Примечание:Код инициализации TPU должен быть в начале вашей программы.

resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')
tf.config.experimental_connect_to_cluster(resolver)
# This is the TPU initialization code that has to be at the beginning.
tf.tpu.experimental.initialize_tpu_system(resolver)
print("All devices: ", tf.config.list_logical_devices('TPU'))


INFO:tensorflow:Deallocate tpu buffers before initializing tpu system.
2023-06-09 12:13:34.011755: E tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.cc:266] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
INFO:tensorflow:Deallocate tpu buffers before 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:Finished initializing TPU system.
INFO:tensorflow:Finished initializing TPU system.
All devices:  [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')]

Ручное размещение устройства

После того, как TPU инициализирован, вы можете использовать ручное размещение устройства для размещения вычисления на одном устройстве TPU:

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

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

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


c device:  /job:worker/replica:0/task:0/device:TPU:0
tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32)

Стратегии распространения

Обычно вы запускаете свою модель на нескольких TPU в параллельном виде. Чтобы распределить вашу модель на нескольких TPU (а также несколько графических процессоров или нескольких машин), TensorFlow предлагаетtf.distribute.StrategyAPI. Вы можете заменить свою стратегию распространения, и модель будет работать на любом данном (TPU) устройстве. Узнайте больше вРаспределенное обучение с TensorFlowгид.

Используяtf.distribute.TPUStrategyОпция реализует синхронное распределенное обучение. TPU предоставляют свою собственную реализацию эффективных все-восстановительных и других коллективных операций по нескольким ядрам TPU, которые используются вTPUStrategyПолем

Чтобы продемонстрировать это, создайтеtf.distribute.TPUStrategyобъект:

strategy = tf.distribute.TPUStrategy(resolver)


INFO:tensorflow:Found TPU system:
INFO:tensorflow:Found TPU system:
INFO:tensorflow:*** Num TPU Cores: 8
INFO:tensorflow:*** Num TPU Cores: 8
INFO:tensorflow:*** Num TPU Workers: 1
INFO:tensorflow:*** Num TPU Workers: 1
INFO:tensorflow:*** Num TPU Cores Per Worker: 8
INFO:tensorflow:*** Num TPU Cores Per Worker: 8
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0)

Чтобы повторить вычисление, чтобы оно могло работать во всех ядрах TPU, вы можете передать его вStrategy.runAPI. Ниже приведен пример, который показывает все ядра, получающие те же входы(a, b)и выполнение умножения матрицы на каждом ядре независимо. Выходы будут значениями от всех реплик.

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

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


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

Классификация на TPU

Освещая основные концепции, рассмотрите более конкретный пример. Этот раздел демонстрирует, как использовать стратегию распространения -tf.distribute.TPUStrategy- Чтобы тренировать модель кераса на облачный TPU.

Определите модель кераса

Начните с определенияSequentialМодель кераса для классификации изображений в наборе данных MNIST. Это ничем не отличается от того, что вы бы использовали, если бы тренировались на процессорах или графических процессорах. Обратите внимание, что создание модели кераса должно быть внутриStrategy.scope, поэтому переменные могут быть созданы на каждом устройстве TPU. Другие части кода не нужны, чтобы находиться внутриStrategyобъем.

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)])

Загрузите набор данных

Эффективное использованиеtf.data.DatasetAPI имеет решающее значение при использовании облачного TPU. Вы можете узнать больше о производительности набора данных вРуководство по производительности входного трубопроводаПолем

Если вы используетеУзлы TPU, вам нужно сохранить все файлы данных, прочитанные TensorFlowDatasetвКовхи Google Cloud Storage (GCS)Полем Если вы используетеTPU VMS, вы можете хранить данные, где бы вы ни нравились. Для получения дополнительной информации о узлах TPU и виртуальных машинах TPU см.Архитектура системы TPUдокументация.

Для большинства вариантов использования рекомендуется преобразовать ваши данные вTFRecordформат и используйтеtf.data.TFRecordDatasetЧтобы прочитать это. ПроверитьTFRECORD и TF.EXAMERДля получения подробной информации о том, как это сделать. Это не жесткое требование, и вы можете использовать другие читатели данных, например, какtf.data.FixedLengthRecordDatasetилиtf.data.TextLineDatasetПолем

Вы можете загрузить все небольшие наборы данных в память, используяtf.data.Dataset.cacheПолем

Независимо от используемого формата данных, настоятельно рекомендуется использовать большие файлы в порядке 100 МБ. Это особенно важно в этой сетевой настройке, так как накладные расходы открытия файла значительно выше.

Как показано в коде ниже, вы должны использовать наборы данных TensorFlowtfds.loadМодуль, чтобы получить копию данных обучения MNIST и тестирования. Обратите внимание, чтоtry_gcsуказан для использования копии, которая доступна в публичном ведре GCS. Если вы не указаете это, TPU не сможет получить доступ к загруженным данным.

def get_dataset(batch_size, is_training=True):
  split = 'train' if is_training else 'test'
  dataset, info = tfds.load(name='mnist', split=split, with_info=True,
                            as_supervised=True, try_gcs=True)

  # Normalize the input data.
  def scale(image, label):
    image = tf.cast(image, tf.float32)
    image /= 255.0
    return image, label

  dataset = dataset.map(scale)

  # Only shuffle and repeat the dataset in training. The advantage of having an
  # infinite dataset for training is to avoid the potential last partial batch
  # in each epoch, so that you don't need to think about scaling the gradients
  # based on the actual batch size.
  if is_training:
    dataset = dataset.shuffle(10000)
    dataset = dataset.repeat()

  dataset = dataset.batch(batch_size)

  return dataset

Обучить модель с помощью API высокого уровня кераса

Вы можете тренировать свою модель с керасомModel.fitиModel.compileАпис На этом шаге нет ничего особенного-вы пишете код, как если бы вы использовали несколько графических процессоров иMirroredStrategyвместоTPUStrategyПолем Вы можете узнать больше вРаспределенное обучение с керасомУчебник.

with strategy.scope():
  model = create_model()
  model.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)

model.fit(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
<keras.callbacks.History at 0x7f79107c8d30>

Чтобы уменьшить накладные расходы на Python и максимизировать производительность вашего TPU, пройти вsteps_per_executionАргумент керасуModel.compileПолем В этом примере он увеличивает пропускную способность примерно на 50%:

with strategy.scope():
  model = create_model()
  model.compile(optimizer='adam',
                # Anything between 2 and `steps_per_epoch` could help here.
                steps_per_execution = 50,
                loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                metrics=['sparse_categorical_accuracy'])

model.fit(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
<keras.callbacks.History at 0x7f7898488e20>

Обучить модель, используя индивидуальную тренировочную петлю

Вы также можете создавать и обучить свою модель, используяtf.functionиtf.distributeAPI напрямую. Вы можете использоватьStrategy.experimental_distribute_datasets_from_functionAPI для распространенияtf.data.DatasetУчитывая функцию набора данных. Обратите внимание, что в примере ниже размера партии, переданного вDatasetэто размер партии на первое место вместо глобального размера партии. Чтобы узнать больше, проверьтеПользовательская тренировка сtf.distribute.StrategyУчебник.

Во -первых, создайте модель, наборы данных иtf.functionS:

# Create the model, optimizer and metrics inside the `tf.distribute.Strategy`
# scope, so that the variables can be mirrored on each device.
with strategy.scope():
  model = create_model()
  optimizer = tf.keras.optimizers.Adam()
  training_loss = tf.keras.metrics.Mean('training_loss', dtype=tf.float32)
  training_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
      'training_accuracy', dtype=tf.float32)

# Calculate per replica batch size, and distribute the `tf.data.Dataset`s
# on each TPU worker.
per_replica_batch_size = batch_size // strategy.num_replicas_in_sync

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

@tf.function
def train_step(iterator):
  """The step function for one training step."""

  def step_fn(inputs):
    """The computation to run on each TPU device."""
    images, labels = inputs
    with tf.GradientTape() as tape:
      logits = model(images, training=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, model.trainable_variables)
    optimizer.apply_gradients(list(zip(grads, model.trainable_variables)))
    training_loss.update_state(loss * strategy.num_replicas_in_sync)
    training_accuracy.update_state(labels, logits)

  strategy.run(step_fn, args=(next(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 be removed in a future version.
Instructions 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 be removed in a future version.
Instructions for updating:
rename to distribute_datasets_from_function

Затем запустите тренировочную петлю:

steps_per_eval = 10000 // batch_size

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

  for step in range(steps_per_epoch):
    train_step(train_iterator)
  print('Current step: {}, training loss: {}, accuracy: {}%'.format(
      optimizer.iterations.numpy(),
      round(float(training_loss.result()), 4),
      round(float(training_accuracy.result()) * 100, 2)))
  training_loss.reset_states()
  training_accuracy.reset_states()


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

Повышение производительности с несколькими шагами внутриtf.function

Вы можете улучшить производительность, выполнив несколько шагов вtf.functionПолем Это достигается путем завершенияStrategy.runпозвонить сtf.rangeвнутриtf.functionи автограф преобразует его вtf.while_loopна работнике TPU. Вы можете узнать больше оtf.functionS вЛучшая производительность сtf.functionгид.

Несмотря на улучшенную производительность, с этим методом есть компромиссы по сравнению с одним шагом вtf.functionПолем Запуск нескольких шагов вtf.functionменее гибкий - вы не можете запускать вещи с нетерпением или произвольный код Python в рамках шагов.

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

  def step_fn(inputs):
    """The computation to run on each TPU device."""
    images, labels = inputs
    with tf.GradientTape() as tape:
      logits = model(images, training=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, model.trainable_variables)
    optimizer.apply_gradients(list(zip(grads, model.trainable_variables)))
    training_loss.update_state(loss * strategy.num_replicas_in_sync)
    training_accuracy.update_state(labels, logits)

  for _ in tf.range(steps):
    strategy.run(step_fn, args=(next(iterator),))

# Convert `steps_per_epoch` to `tf.Tensor` so the `tf.function` won't get
# retraced if the value changes.
train_multiple_steps(train_iterator, tf.convert_to_tensor(steps_per_epoch))

print('Current step: {}, training loss: {}, accuracy: {}%'.format(
      optimizer.iterations.numpy(),
      round(float(training_loss.result()), 4),
      round(float(training_accuracy.result()) * 100, 2)))


Current step: 1800, training loss: 0.009, accuracy: 99.72%

Следующие шаги

Чтобы узнать больше о облачных TPU и о том, как их использовать:

  • Google Cloud TPU: Домашняя страница Google Cloud TPU.
  • Документация Google Cloud TPU: Документация Google Cloud TPU, которая включает в себя:
    • Введение в облачный TPU: Обзор работы с Cloud TPU.
    • Cloud TPU QuickStarts: QuickStart Investions для работы с облачными виртуальными машинами TPU с использованием TensorFlow и других основных структур машинного обучения.
  • Google Cloud TPU Colab Notebooks: Сквозные примеры обучения.
  • Google Cloud TPU Руководство по производительности: Повысить производительность облака TPU дальше, настраивая параметры конфигурации Cloud TPU для вашего приложения
  • Распределенное обучение с TensorFlow: Как использовать стратегии распространения, включаяtf.distribute.TPUStrategy- С примерами, показывающими лучшие практики.
  • TPU Entgeddings: TensorFlow включает в себя специализированную поддержку обучения встраиваний на TPU черезtf.tpu.experimental.embeddingПолем Кроме того,Tensorflow рекомендуетимеетtfrs.layers.embedding.TPUEmbeddingПолем Внедрения обеспечивают эффективные и плотные представления, захватывая сложные сходства и взаимосвязь между признаками. Встроенная поддержка Tensorflow, специфичная для TPU, позволяет обучать встроения, которые больше, чем память одного устройства TPU, и использовать разреженные и рваные входы на TPU.
  • TPU Research Cloud (TRC): TRC позволяет исследователям подать заявку на доступ к кластеру из более чем 1000 облачных устройств TPU.

Первоначально опубликовано наTensorflowВеб -сайт, эта статья появляется здесь под новым заголовком и имеет лицензию в CC на 4.0. Образцы кода, разделенные по лицензии Apache 2.0.

Оригинал

Recent Post

Categories

PREVIOUS ARTICLE
NEXT ARTICLE