Рекомендации по ускоренному обучению TensorFlow 1.x на Amazon SageMaker

Сегодня многие клиенты используют TensorFlow для обучения моделей глубокого обучения их рейтингу кликов в рекламе и рекомендациям по персонализации в электронной коммерции. Поскольку поведение их клиентов меняется, они могут накапливать большие объемы новых данных каждый день. Итерация модели — одна из повседневных задач специалистов по данным, но они сталкиваются с проблемой слишком долгого обучения на больших наборах данных.

Создатель мудреца Амазонки — это полностью управляемая платформа машинного обучения (ML), которая может помочь специалистам по данным сосредоточиться на моделях, а не на инфраструктуре, со встроенной поддержкой собственных алгоритмов и сред, таких как TensorFlow и PyTorch. SageMaker предлагает гибкие варианты распределенного обучения, которые адаптируются к вашим конкретным рабочим процессам. Поскольку многим специалистам по данным может не хватать опыта в процессе ускоренного обучения, в этом посте мы покажем вам факторы, которые имеют значение для быстрого обучения модели глубокого обучения, и передовые методы ускоренного обучения для TensorFlow 1.x в SageMaker. У нас также есть пример кода ДипФМ распространял обучение по SageMaker на Репо GitHub.

Существует множество факторов, которые следует учитывать для максимального использования ЦП/ГП при запуске скрипта TensorFlow в SageMaker, таких как инфраструктура, тип ускорителя, метод распределенного обучения, метод загрузки данных, обучение смешанной точности и многое другое.

Мы обсуждаем лучшие практики в следующих областях:

• Ускорьте обучение на одном экземпляре
• Ускорьте обучение на нескольких экземплярах
• Конвейеры данных
• Автоматическая тренировка смешанной точности

Ускорьте обучение на одном экземпляре

При запуске скрипта TensorFlow на одном экземпляре вы можете выбрать серию, оптимизированную для компьютера, например Эластичное вычислительное облако Amazon (Amazon EC2) серии C5 или серии ускоренных вычислений с несколькими графическими процессорами в одном экземпляре, например p3.8xlarge, p3.16xlarge, p3dn.24xlarge и p4d.24xlarge.

В этом разделе мы обсудим стратегии для нескольких ЦП в одном экземпляре и распределенное обучение с несколькими графическими процессорами в одном экземпляре.

Несколько ЦП на одном экземпляре

В этом разделе мы обсудим ручную настройку параллелизма операторов на процессорных устройствах, метод башни, TensorFlow MirroredStrategy и Horovod.

Ручная настройка параллелизма операторов на процессорных устройствах

TensorFlow автоматически выбирает подходящее количество потоков для распараллеливания расчета операций в процессе обучения. Тем не менее, вы можете установить intra_op пул потоков и inter_op настройки параллелизма, предоставляемые TensorFlow, и использовать переменные среды MKL-DNN для установки привязки для потока ОС. См. следующий код:

# Set parallelism of intra_op and inter_op
num_cpus = int(os.environ['SM_NUM_CPUS'])
config = tf.ConfigProto(allow_soft_placement=True, device_count={'CPU': num_cpus}, intra_op_parallelism_threads=num_cpus, inter_op_parallelism_threads=num_cpus)
run_config = tf.estimator.RunConfig().replace(session_config = config)

# Use Intel MKL-DNN Setting to accelerate training speed
os.environ["KMP_AFFINITY"]= "verbose,disabled"
os.environ['OMP_NUM_THREADS'] = str(num_cpus)
os.environ['KMP_SETTINGS'] = '1'

Переменная окружения KMP_AFFINITY MKL-DNN настроен на granularity=fine,compact,1,0 по умолчанию. После установки максимального количества виртуальных ЦП текущего экземпляра для внутреннего и внутреннего TensorFlow верхний предел использования ЦП почти совпадает с количеством физических ядер обучающего экземпляра.

Если вы установите os.environ["KMP_AFFINITY"]= "verbose,disabled", поток ОС не привязан к аппаратному гиперпотоку, а использование ЦП может превышать количество физических ядер.

Что касается настроек внутреннего параллелизма TensorFlow, внутреннего параллелизма TensorFlow и количества потоков MKL-DNN, различные комбинации этих трех параметров приводят к разным скоростям обучения. Поэтому вам нужно протестировать каждый случай, чтобы найти наилучшую комбинацию. Обычной ситуацией является установка трех параметров (intra_op_parallelism_threads и inter_op_parallelism_threads для ТензорФлоу, os.environ['OMP_NUM_THREADS'] для MKL-DNN) до половины количества виртуальных ЦП (физических ядер) или общего количества виртуальных ЦП.

Башенный метод

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

Если вы не устанавливаете процессорное устройство вручную, TensorFlow не использует метод башни для усреднения градиентов, поэтому в таких случаях вам не нужно масштабировать размер пакета.

1. Установите устройство ЦП вручную:

device_list = []
if manual_CPU_device_set:
		cpu_prefix=’/cpu:’
		for I in range(1, num_cpus):
			devices_list.append(cpu_prefix + str(i))

2. Используйте replicate_model_fn обернуть model_fn:

DeepFM = tf.estimator.Estimator(model_fn=tf.contrib.estimator.replicate_model_fn(model_fn, devices=device_list), model_dir=FLAGS.model_dir, params=model_params, config=config)

3. Используйте TowerOptimizer обернуть optimizer:

optimizer = tf.contrib.estimator.TowerOptimizer(optimizer)

4. Оберните свой model_fn:

with tf.variable_scope(‘deepfm_model’, reuse=tf.AUTO_REUSE)

5. Уменьшите размер пакета до (NUM_CPU — 1).

Давайте посмотрим на разницу в загрузке ЦП при включенном режиме башни. На следующем рисунке показано использование ЦП экземпляра ml.c5.18xlarge со следующей конфигурацией:

Нет Tower + данные LibSVM + конвейерный режим + MKL-DNN отключить привязку + настройка внутри/межоперационного параллелизма TensorFlow для максимального количества виртуальных ЦП экземпляра

На следующем рисунке показано использование ЦП экземпляра ml.c5.18xlarge со следующей конфигурацией:

Башня с установленным устройством ЦП + данные LibSVM + режим конвейера + отключение привязки MKL-DNN + настройка внутри/межоперационного параллелизма TensorFlow для максимального количества виртуальных ЦП экземпляра

Использование ЦП выше при использовании башенного метода и превышает количество физических ядер.

TensorFlow MirroredСтратегии

TensorFlow MirroredStrategy означает синхронное обучение на нескольких репликах на одном компьютере. Эта стратегия обычно используется для обучения на одной машине с несколькими графическими процессорами. Чтобы сравнить скорость обучения с другим методом, мы используем MirroredStrategy для нашего процессорного устройства.

При использовании TensorFlow MirroredStrategy, если вы не установите устройство ЦП, TensorFlow просто использует один ЦП в качестве единственного рабочего, что является пустой тратой ресурсов. Мы рекомендуем вручную установить процессорное устройство, потому что оно будет выполнять операцию сокращения на /CPU:0, Так что /CPU:0 устройство не используется в качестве реплики здесь. См. следующий код:

device_list = []
if manual_CPU_device_set:
		cpu_prefix=’/cpu:’
		for I in range(1, num_cpus):
			devices_list.append(cpu_prefix + str(i))
mirrored_strategy = tf.distribute.MirroredStrategy(devices=devices_list)
	else:
mirrored_strategy = tf.distribute.MirroredStrategy()

# Set strategy to config:
config = tf.estimator.RunConfig(train_distribute=mirrored_strategy,
eval_distribute=mirrored_strategy,
session_config = config)

Вам необходимо масштабировать размер пакета при использовании MirroredStrategy; например, увеличьте размер пакета до числа, кратного количеству устройств GPU.

Для подстратегии, когда вы устанавливаете устройство ЦП, если вы не устанавливаете cross_device_ops параметр в tf.distribute.MirroredStrategy(), TensorFlow использует ReductionToOneDevice подстратегия по умолчанию. Однако, если вы установите HierarchicalCopyAllReduce в качестве подстратегии TensorFlow просто выполняет работу по сокращению /CPU:0. Когда вы используете API набора данных TensorFlow и распространяете стратегию вместе, объект набора данных должен быть возвращен вместо функций и меток в функции. input_fn.

Обычно TensorFlow MirroredStrategy медленнее, чем метод башни при обучении ЦП, поэтому мы не рекомендуем использовать MirroredStrategy на одном хосте с несколькими ЦП.

Хоровод

Хоровод — это распределенная обучающая среда глубокого обучения для TensorFlow, Keras, PyTorch и Apache MXNet. Цель Horovod — сделать распределенное глубокое обучение быстрым и простым в использовании.

Есть параметр distribution в SageMaker Python SDK Estimator API, который можно использовать для определения распределенного обучения Horovod. SageMaker подготавливает инфраструктуру и запускает ваш сценарий с помощью MPI. См. следующий код:

hvd_processes_per_host = 4
distribution = {'mpi': { 
'enabled': True, 
'processes_per_host': hvd_processes_per_host,
'custom_mpi_options': '-verbose --NCCL_DEBUG=INFO -x OMPI_MCA_btl_vader_single_copy_mechanism=none' 
} 
}

При выборе экземпляра GPU, такого как ml.p3.8xlarge, вам необходимо закрепить каждый GPU для каждого воркера:

config = tf.ConfigProto()
config.gpu_options.visible_device_list = str(hvd.local_rank())

Чтобы ускорить сходимость модели, масштабируйте скорость обучения по количеству работников в соответствии с официальной документацией Horovod. Однако в реальных проектах вы должны в некоторой степени масштабировать скорость обучения, но не по количеству рабочих, что приводит к плохой производительности модели. Например, если исходная скорость обучения равна 0.001, мы масштабируем скорость обучения до 0.0015, даже если количество рабочих составляет четыре или более.

Как правило, только первичный (ранг Хоровода 0) сохраняет контрольную точку и модель, а также операцию оценки. Вам не нужно масштабировать размер партии при использовании Horovod. SageMaker предлагает Режим трубы для потоковой передачи данных из Простой сервис хранения Amazon (Amazon S3) в учебные экземпляры. Когда вы включаете режим Pipe, имейте в виду, что разные рабочие процессы на одном хосте должны использовать разные каналы, чтобы избежать ошибок. Это связано с тем, что первый рабочий процесс считывает данные FIFO/канала, а другие рабочие процессы в том же экземпляре будут зависать, потому что они не могут читать данные из того же FIFO/канала, поэтому Horovod не работает должным образом. Чтобы избежать этой проблемы, установите каналы в соответствии с количеством рабочих процессов на экземпляр. По крайней мере убедитесь, что разные воркеры на одном хосте потребляют разные каналы; один и тот же канал может использоваться рабочими на другом хосте.

При использовании Horovod вы можете столкнуться со следующей ошибкой:

“One or more tensors were submitted to be reduced, gathered or broadcasted by subset of ranks and are waiting for remainder of ranks for more than 60 seconds. This may indicate that different ranks are trying to submit different tensors or that only subset of ranks is submitting tensors, which will cause deadlock.”

Возможная причина этой проблемы заключается в том, что определенный ранг (например, ранг 0) работает медленнее или выполняет больше задач, чем другие ранги, и это заставляет другие ранги ждать в течение длительного времени. Хотя ранг 0 иногда должен выполнять больше работы, чем другие ранги, следует отметить, что ранг 0 не должен делать много в течение длительного времени. Например, для оценки модели на проверочном наборе и сохранения контрольных точек во время обучения, если неизбежно, что эти операции будут занимать много времени, что может привести к ошибкам, можно разрешить всем рабочим выполнять ту же работу, что и для ранга 0 (контрольные точки сохранение, оценка и так далее).

Разделение данных — одна из самых важных вещей, которые следует учитывать при использовании распределенного обучения. Вы можете использовать TensorFlow dataset.shard() в вашем сценарии. SageMaker также предлагает функцию сегментирования набора данных в входной канал установив distribution=S3shardbykey в канале набора данных. См. следующий код:

dataset = PipeModeDataset(channel, record_format='TFRecord')

number_host = len(FLAGS.hosts)

if FLAGS.enable_data_multi_path : # If there are multi channels mapping with different S3 path
    if FLAGS.enable_s3_shard == False :
        if number_host > 1:
            index = hvd.rank() // FLAGS.worker_per_host
            dataset = dataset.shard(number_host, index)
else :
    if FLAGS.enable_s3_shard :
        dataset = dataset.shard(FLAGS.worker_per_host, hvd.local_rank())
    else :
        dataset = dataset.shard(hvd.size(), hvd.rank())

На следующем рисунке показан результат при использовании Horovod (ml.c5.18xlarge, Horovod + LibSVM + настройки по умолчанию для внутренней и внутренней операций), который можно сравнить с методом башни.

Распределенное обучение с несколькими графическими процессорами на одном экземпляре

Начинать распределенное обучение с несколькими графическими процессорами на одном экземпляре — это нормально, потому что специалистам по данным нужно управлять только одним экземпляром и использовать преимущества высокоскоростной связи между графическими процессорами. Учебные задания SageMaker поддерживают несколько типов экземпляров с несколькими графическими процессорами в одном экземпляре, например ml.p3.8xlarge, ml.p3.16xlarge, ml.p3dn.24xlarge и ml.p4d.24xlarge. Метод такой же, как несколько ЦП в одном экземпляре, но с некоторыми изменениями в сценарии.

Башенный метод

Башенный метод здесь почти такой же, как и при многопроцессорном обучении. Вам необходимо масштабировать размер пакета в соответствии с количеством используемых графических процессоров.

TensorFlow MirroredСтратегии

Подстратегия по умолчанию MirroredStrategy is NcclAllReduce. Вам необходимо масштабировать размер пакета в соответствии с количеством используемых графических процессоров. См. следующий код:

mirrored_strategy = tf.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(train_distribute=mirrored_strategy,
				eval_distribute=mirrored_strategy)

Ускорьте обучение на нескольких экземплярах

Масштабирование — это всегда возможность повысить скорость обучения. Все больше и больше специалистов по данным выбирают этот вариант по умолчанию в отношении распределенного обучения. В этом разделе мы обсудим стратегии распределенного обучения с несколькими хостами.

Несколько ЦП с несколькими экземплярами

Существует четыре основных метода использования нескольких ЦП с несколькими экземплярами при включении распределенного обучения:

• • Сервер параметров без ручной настройки параллелизма операторов на устройствах ЦП
  • Сервер параметров с ручной настройкой параллелизма операторов на процессорных устройствах
  • Сервер параметров с башней (настройка устройств ЦП вручную и установка allow_soft_placement=True in tf.ConfigProto)
  • Хоровод

При использовании сервера параметров в tf.estimator API, путь контрольной точки должен быть общедоступным путем, таким как Amazon S3 или локальный путь Эластичный файловый сервис Amazon (Amazon EFS) сопоставление с контейнером. Для сервера параметров в tf.keras, путь контрольной точки может быть установлен на локальный путь. Для Horovod путь к контрольной точке может быть задан как локальный путь обучающего экземпляра.

При использовании сервера параметров и tf.estimator API с путем к контрольной точке на Amazon S3, если модель достаточно большая, может возникнуть ошибка первичного зависания при сохранении контрольной точки на S3. Вы можете использовать встроенный контейнер SageMaker TensorFlow 1.15 или TensorFlow 1.15.2 или использовать Amazon EFS в качестве контрольной точки общего ресурса.

При использовании сервера параметров для нескольких хостов загрузка параметров для каждого процесса сервера параметров может быть несбалансированной (особенно при наличии относительно больших переменных таблицы внедрения), что может вызвать ошибки. Вы можете проверить размер файла каждой контрольной точки сегмента в Amazon S3, чтобы определить, сбалансированы ли параметры на сервере параметров, поскольку каждый сервер параметров соответствует сегменту файла контрольной точки. Чтобы избежать таких проблем, вы можете использовать функцию разделения, чтобы попытаться равномерно распределить параметры каждого сервера параметров:

with tf.variable_scope('deepfm_model', reuse=tf.AUTO_REUSE, partitioner = tf.fixed_size_partitioner(num_shards=len(FLAGS.hosts))):

Один GPU с несколькими экземплярами

Учебные задания SageMaker поддерживают экземпляры, имеющие только один графический процессор, например серии ml.p3.xlarge, ml.g4dn и ml.g5. В этом сценарии используются два основных метода: серверы параметров и Horovod.

Метод распределенного обучения встроенного сервера параметров SageMaker заключается в запуске процесса сервера параметров и рабочего процесса для каждого обучающего экземпляра (каждый сервер параметров отвечает только за часть параметров модели), поэтому по умолчанию используется многомашинный однопроцессорный процесс. Тренировка графического процессора. Распределенное обучение встроенного сервера параметров SageMaker представляет собой асинхронный метод обновления градиента. Чтобы уменьшить влияние асинхронных обновлений на сходимость обучения, рекомендуется уменьшить скорость обучения. Если вы хотите использовать все графические процессоры в экземпляре, вам необходимо использовать комбинацию серверов параметров и метода башни.

Для Хоровода просто установите processes_per_host=1 в параметре распределения SageMaker Python Estimator API.

Несколько графических процессоров с несколькими экземплярами

Для серверов параметров и метода башни изменения кода в основном такие же, как и для метода башни для одного экземпляра с несколькими графическими процессорами, и нет необходимости вручную настраивать устройства графического процессора.

Для Horovod в параметре распределения задайте для процессов_per_host количество графических процессоров каждого обучающего экземпляра. Если вы используете режим Pipe, количество рабочих процессов на экземпляр должно соответствовать количеству каналов.

Конвейеры данных

В дополнение к инфраструктуре, которую мы обсудили, есть еще одна важная вещь, которую следует учитывать: конвейер данных. Конвейер данных относится к тому, как вы загружаете данные и преобразовываете данные, прежде чем они будут переданы в нейронные сети. ЦП используется для подготовки данных, тогда как ГП используется для расчета данных из ЦП. Поскольку GPU является дорогим ресурсом, большее время простоя GPU неэффективно; хороший конвейер данных в вашей учебной работе может улучшить загрузку графического процессора и процессора.

Когда вы пытаетесь оптимизировать конвейер ввода данных TensorFlow, рассмотрите порядок API, используемый в Наборы данных TensorFlow, размер обучающих данных (много маленьких файлов или несколько больших файлов), размер пакета и так далее.

Давайте посмотрим на взаимодействие между GPU и CPU во время обучения. На следующих рисунках сравниваются взаимодействия с конвейером и без него.

Улучшенный конвейер может сократить время простоя графического процессора. Примите во внимание следующие советы:

• Используйте простую логику функций при извлечении признаков и меток
• Предварительная выборка сэмплов в память
• Сокращение ненужных дисковых операций ввода-вывода и сетевых операций ввода-вывода
• Кэшировать обработанные объекты и метки в памяти
• Уменьшите количество раз репликации между CPU и GPU
• Попросите разных работников работать с разными частями обучающего набора данных.
• Сократите время вызова API набора данных TensorFlow.

TensorFlow предоставляет API преобразования, связанный с форматами наборов данных, и порядок API преобразования в TensorFlow сильно влияет на скорость обучения. Необходимо проверить лучший порядок вызова API набора данных TensorFlow. Ниже приведены некоторые основные принципы:

• Используйте векторную карту. Это означает, что сначала вызовите пакетный API набора данных TensorFlow, а затем API карты набора данных. Пользовательская функция синтаксического анализа, предоставляемая в функции карты, например decode_tfrecord в примере кода анализирует мини-пакет данных. Напротив, сначала карта, а затем пакет — это скалярная карта, и пользовательская функция синтаксического анализатора обрабатывает только один образец.
• Используйте API кэширования набора данных TensorFlow для кэширования функций и меток. Поместите API кэширования набора данных TensorFlow перед API повторения набора данных TensorFlow, иначе использование ОЗУ будет линейно увеличиваться от эпохи к эпохе. Если размер набора данных равен объему ОЗУ, не используйте API кэширования набора данных TensorFlow. Если вам нужно использовать API кэширования набора данных TensorFlow и API перемешивания, рассмотрите возможность использования следующего порядка: создайте объект набора данных TensorFlow -> API кэширования -> API перемешивания -> API пакетной обработки -> API карты -> API повторения -> API предварительной выборки.
• Использовать tfrecord формат набора данных больше, чем формат LibSVM.
• Режим файла или режим конвейера зависит от формата набора данных и количества файлов. tfrecorddataset API может установить num_parallel_reads читать несколько файлов параллельно и устанавливать buffer_size для оптимизации чтения данных, тогда как pipemodedataset API не имеет таких настроек. Конвейерный режим больше подходит для ситуаций, когда один файл большой, а общее количество файлов невелико. Мы рекомендуем использовать задание обработки SageMaker для выполнения предварительной обработки, такой как объединение нескольких файлов в файл большего размера в соответствии с метками, использование метода выборки, чтобы сделать набор данных более сбалансированным, и перемешивание сбалансированного набора данных.

См. следующий пример кода:

def decode_tfrecord(batch_examples):
        # The feature definition here should BE consistent with LibSVM TO TFRecord process.
        features = tf.parse_example(batch_examples,
                                           features={
                                               "label": tf.FixedLenFeature([], tf.float32),
                                               "ids": tf.FixedLenFeature(dtype=tf.int64, shape=[FLAGS.field_size]),
                                               "values": tf.FixedLenFeature(dtype=tf.float32, shape=[FLAGS.field_size]) 
                                           })
        
        batch_label = features["label"]
        batch_ids = features["ids"]
        batch_values = features["values"]
        
        return {"feat_ids": batch_ids, "feat_vals": batch_values}, batch_label


    def decode_libsvm(line):
        columns = tf.string_split([line], ' ')
        labels = tf.string_to_number(columns.values[0], out_type=tf.float32)
        splits = tf.string_split(columns.values[1:], ':')
        id_vals = tf.reshape(splits.values,splits.dense_shape)
        feat_ids, feat_vals = tf.split(id_vals,num_or_size_splits=2,axis=1)
        feat_ids = tf.string_to_number(feat_ids, out_type=tf.int32)
        feat_vals = tf.string_to_number(feat_vals, out_type=tf.float32)
        return {"feat_ids": feat_ids, "feat_vals": feat_vals}, labels

if FLAGS.pipe_mode == 0:
        dataset = tf.data.TFRecordDataset(filenames)
    else :
        # Enter Pipe mode
        dataset = PipeModeDataset(channel, record_format='TFRecord')
        
    if FLAGS.enable_s3_shard == False:
        host_rank = FLAGS.hosts.index(FLAGS.current_host)
        number_host = len(FLAGS.hosts)
        dataset = dataset.shard(number_host, host_rank)
    
    dataset = dataset.batch(batch_size, drop_remainder=True) # Batch size to use
    dataset = dataset.map(decode_tfrecord,
                          num_parallel_calls=tf.data.experimental.AUTOTUNE) 

    if num_epochs > 1:
        dataset = dataset.repeat(num_epochs)
    dataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)

Для обучения на экземплярах ЦП установка параллелизма intra op, inter op, а переменная среды MKL-DNN — хорошая отправная точка.

Автоматическая тренировка смешанной точности

Последнее, что мы обсудим, — это автоматическое обучение смешанной точности, которое может ускорить скорость и повысить производительность модели. На момент написания этой статьи графические процессоры Nvidia V100 (экземпляр P3) и A100 (экземпляр P4dn) поддерживают ядро ​​​​Tensor. Вы можете включить обучение смешанной точности в TensorFlow при использовании этих типов экземпляров. Начиная с версии 1.14 TensorFlow поддерживает автоматическое обучение смешанной точности. Вы можете использовать следующий оператор, чтобы обернуть исходный оптимизатор:

tf.train.experimental.enable_mixed_precision_graph_rewrite(optimizer)

Если модель небольшая и использование графического процессора низкое, автоматическое обучение смешанной точности не дает никаких преимуществ. Если модель большая, автоматическое обучение смешанной точности может ускорить обучение.

Заключение

Приступая к обучению модели глубокого обучения в SageMaker, примите во внимание следующие советы, чтобы повысить скорость обучения:

• Сначала попробуйте метод с несколькими ЦП и одним экземпляром или метод с одним GPU и одним экземпляром. Если загрузка CPU/GPU очень высокая (например, более 90%), перейдите к следующему шагу.
• Попробуйте использовать больше процессоров на одном хосте или больше графических процессоров на одном хосте. Если загрузка близка к максимальному использованию ЦП или ГП, перейдите к следующему шагу.
• Попробуйте несколько процессоров или несколько графических процессоров с несколькими хостами.
• Вам необходимо изменить коды при использовании серверов параметров или Horovod. Модификация кода отличается от API на основе сеанса TensorFlow. tf.estimator API и tf.keras API. Сервер параметров или хоровод могут показывать разную скорость обучения в разных учебных кейсах и задачах, поэтому попробуйте оба метода, если у вас есть время и бюджет, чтобы определить лучший.

Имейте в виду следующие советы:

• Перед масштабированием проверяйте загрузку, оптимизируйте конвейер данных и перекрывайте ЦП и ГП на временной шкале.
• Сначала масштабируйте, а затем масштабируйте.
• Если вы не можете увеличить использование графического процессора после всех методов, попробуйте ЦП. Во многих случаях (особенно для модели рейтинга рейтинга кликов) общее время обучения экземпляра ЦП короче и более рентабельно, чем обучение экземпляра графического процессора.

У нас также есть пример кода в Репо GitHub, где мы показываем два примера распределенного обучения DeepFM на SageMaker. Один из них — сервер параметров TensorFlow на экземплярах CPU, другой — Horovod на экземплярах GPU.

Об авторах

Юхуэй Лян является старшим архитектором решений для машинного обучения. Он сосредоточен на продвижении и применении машинного обучения и активно участвует в проектах машинного обучения многих клиентов. У него богатый опыт в распределенном обучении глубокому обучению, рекомендательных системах и вычислительной рекламе.

Шишуай Ван является старшим архитектором решений для машинного обучения. Он работает с клиентами AWS, помогая им широко внедрять машинное обучение. Он любит смотреть фильмы и путешествовать по миру.