0x00 сводка

Horovod — это простая в использовании высокопроизводительная распределенная платформа обучения, выпущенная Uber в 2017 году и широко используемая в отрасли.

Эта серия поможет вам понять Horovod с помощью анализа исходного кода. В серии от 15 до 18 статей.Эта статья является первой статьей в серии и знакомит с соответствующими базовыми знаниями.

0x01 Распределенное параллельное обучение

Сначала мы вводим распределенное параллельное обучение.

1.1 Необходимость распределенного параллельного обучения

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

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

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

1.2 Распределенное обучение

Обучение, упомянутое в этой статье, относится к процессу использования обучающих данных для итеративной оптимизации параметров нейронной сети путем вычисления градиентного спуска и, наконец, вывода модели сети. В одной итерации обучения модели выполняются следующие операции:

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

Основная идея параллельного градиентного спуска заключается в том, что несколько процессоров используют свои собственные данные для вычисления градиентов и, наконец, добиваются параллельного вычисления градиентного спуска за счет агрегации или других методов для ускорения процесса обучения модели. Например, два процессора обрабатывают половину данных для вычисления градиента g_1, g_2 соответственно, а затем объединяют и обновляют два результата градиента, таким образом реализуя параллельный градиентный спуск.

1.3 Параллелизм обучения

1.3.1 Три механизма

Из-за алгоритма мини-пакетов ширина (∝W) и глубины (∝D) прямое распространение и обратное распространение распределены по параллельным процессорам, так что есть три основных параллельных механизма глубокого обучения:

Первый — модельный параллелизм (разделение по сетевой структуре).
- Обычно граф разбивается, когда узел не может хранить всю модель.
- Распределенное хранение параметров модели. Каждое вычисление на компьютере можно смоделировать как ориентированный ациклический граф (DAG), где вершины — это инструкции вычисления, а ребра — зависимости данных (поток данных). «Разбиение на основе графа» разбивает большой граф на части на основе нейронов в каждом слое (т. Е. Измерения C, H или W в четырехмерном тензоре), и каждая часть вычисляется на многих устройствах.
- Или можно понять так: расчет глубокого обучения это в основном матричные операции.Иногда матрица слишком велика для размещения в видеопамяти, поэтому сверхбольшую матрицу можно только разделить и разместить на разных картах для расчет.
- Расчет последней части модели должен дождаться завершения предыдущего расчета, поэтому расчет между разными узлами фактически является последовательным. Но каждая часть расчета не мешает друг другу, больше похожа на конвейерную структуру.
Второй — параллелизм данных (разбиение по входным отсчетам).
- В большем количестве сценариев масштаб нашей модели невелик, что умещается в один GPU, но объем обучающих данных будет относительно большим, в этом случае используется механизм параллелизма данных.
- В частности, разделение данных и параллельное обучение на нескольких узлах.
Третий, реже используемый механизм параллелизма — конвейерная обработка (разделение по слоям).
- В глубоком обучении конвейерная обработка может относиться к перекрывающимся вычислениям, то есть к последовательным вычислениям между одним уровнем и следующим (когда данные готовы), или к разделению DNN на основе глубины, назначению слоев конкретным процессорам.
- Конвейерную обработку можно рассматривать как форму параллелизма данных, поскольку элементы (выборки) обрабатываются параллельно через сеть, но ее также можно рассматривать как модельный параллелизм, поскольку длина конвейера определяется структурой DNN.

Подробности можно увидеть на следующем рисунке:

1.3.2 Как использовать

Параллелизм данных часто означает масштабируемую вычислительную производительность, а параллелизм моделей часто означает масштабируемое использование памяти.

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

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

сверточный слой, который занимает 90% ~ 95% объема вычислений и 5% параметров, но имеет большую выразительную силу для результатов.
полносвязный слой, который занимает от 5% до 10% вычислений, 95% параметров, но имеет относительно небольшую мощность для выражения результатов.

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

1.4 Параллельное обучение данных

В этой серии мы сосредоточимся на параллельном обучении данных (одна из этих архитектур).

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

Предположим, что машина имеет $k$ графические процессоры. Учитывая модель для обучения, каждый графический процессор будет независимо поддерживать полный набор параметров модели, хотя значения параметров на графических процессорах одинаковы и синхронизированы. Например, на рисунке ниже показано $k=2$ При использовании параллельного обучения данных.

В целом процесс обучения выглядит следующим образом:

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

Каждый GPU вычисляет потери и градиенты параметров модели на основе назначенного ему подмножества мини-пакетов.

будет $k$ Локальные градиенты каждого из графических процессоров агрегируются для получения текущего мини-пакетного стохастического градиента.

Совокупные градиенты перераспределяются на каждый GPU.

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

0x02 Связь и архитектура

Пример параллельного градиентного спуска, упомянутый выше: два процессора обрабатывают общие данные для расчета градиента g_1, g_2 соответственно, затем объединяют два результата градиента и, наконец, отправляют последние параметры в каждый блок расчета распределения.Этот алгоритм обучения называетсяМетод согласованности модели(методы непротиворечивой модели). Это связано с проблемой связи, то есть с тем, как выполнять агрегацию.

2.1 Метод и архитектура

Обычно существует два метода связи: совместное использование памяти и передача сообщений.

Совместная память означает, что все процессоры используют одну и ту же память, что облегчает обмен данными, но память может быть разделена между процессорами в одном узле, и память не может быть разделена между процессорами разных узлов.

Передача сообщений — это использование сообщений (например, на основе TCP/IP или RDMA) для передачи/общения между различными узлами, которые легко расширять и обучать в больших масштабах.

Итак, мы знаем, что передача сообщений — это решение, которое поднимает проблему: как координировать связь между этими узлами.

Есть две архитектуры:

Архитектура клиент-сервер: серверный узел координирует работу других узлов, а другие узлы являются рабочими, используемыми для выполнения вычислительных задач.
Одноранговая архитектура: у каждого узла есть соседи, и соседи могут общаться друг с другом.

2.2 Асинхронный и синхронный

Асинхронный и синхронный — еще один аспект коммуникации.

При параллельном обучении каждое вычислительное устройство рассчитывает потери в прямом направлении в соответствии с пакетом, полученным им самим, а затем выполняет обратное распространение для расчета градиента. После расчета градиента он включаетПроблема с синхронизацией градиента: Каждое вычислительное устройство имеет градиенты, рассчитанные на его собственных данных, как поддерживать согласованность между разными копиями модели на разных графических процессорах. Если разные модели каким-то образом получат разные веса, обновления веса станут несогласованными, и обучение модели будет другим.

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

Стратегии синхронизации градиента для распределенного обучения можно разделить на механизмы асинхронного обновления градиента и синхронного обновления градиента.

Синхронизация означает, что все устройства обучаются с одинаковыми параметрами модели.После завершения мини-пакетного обучения всех устройств их градиенты собираются и усредняются, а затем выполняется обновление параметров модели.
- Синхронное обучение эквивалентно обучению модели путем объединения мини-пакетов на многих устройствах в один большой пакет. Facebook делает это, но они обнаружили, что линейное увеличение скорости обучения при увеличении размера пакета может дать хорошие результаты.
- Синхронное обучение выглядит хорошо, но на самом деле оно требует сбалансированной вычислительной мощности каждого устройства и сбалансированной связи в кластере.
- Потому что в конце каждого раунда быстрым узлам нужно дождаться, пока медленные узлы закончат вычисления, а затем перейти к следующему раунду итерации. Как и в случае с эффектом бочки, бутылка с горючим серьезно замедлит ход тренировки, поэтому метод синхронной тренировки относительно замедлит скорость тренировки. Эту бутылку с буксирным маслом обычно называют отставшим.
При асинхронном обучении после того, как каждое устройство завершит мини-пакетное обучение, ему не нужно ждать, пока другие узлы напрямую обновят параметры модели, так что общая скорость обучения будет намного выше.
- Очень серьезной проблемой при асинхронном обучении являются устаревшие градиенты.В начале все устройства используют одни и те же параметры для обучения, но в асинхронном случае, после того, как устройство завершит одношаговое обучение, может обнаружиться, что параметры модели действительно использовались другими устройствами.После обновления срок действия градиента истекает в это время, потому что текущие параметры модели отличаются от параметров, используемых до обучения. Асинхронное обучение, хотя и быстрое, может упасть на неоптимальную производительность обучения из-за проблем со сбоем градиента.

В частности, как показано на рисунке ниже:

Эти два метода обновления имеют свои преимущества и недостатки:

Асинхронные обновления могут быстрее выполнить весь расчет градиента.
Синхронные обновления обеспечивают более быструю конвергенцию.

Какой метод выбрать, зависит от фактического сценария приложения.

0x03 Определенная архитектура

Далее давайте рассмотрим несколько конкретных реализаций архитектуры и сначала дадим общее описание:

название	коммуникация	Архитектура	параллелизм
MapReduce	обмен сообщениями	client-server	пакетная синхронизация
Parameter Server	обмен сообщениями	client-server	асинхронный
Decentralized	обмен сообщениями	P2P	синхронный или асинхронный

3.1 MapReduce

MapReduce — это клиент-серверная архитектура. Возьмите Spark в качестве примера, чтобы увидеть, как распараллелить:

Драйвер Spark — это сервер, а исполнитель Spark — это рабочий узел.Каждый процесс градиентного спуска включает в себя трансляцию, карту и операцию уменьшения.
Сервер определяет операции карты (то есть конкретное обучение), а также может транслировать информацию на рабочие узлы.
Рабочие выполняют операции с картами для обучения, во время которых данные распределяются между рабочими для вычислений.
После окончания расчета worker отправляет результат расчета обратно драйверу для обработки, что называется сокращением.
Во время процесса сокращения, после того как серверный узел агрегирует результаты вычислений, отправленные рабочими процессами, он передает агрегированные результаты каждому рабочему узлу для следующей итерации.

3.2 Сервер параметров (PS)

Сервер параметров также представляет собой клиент-серверную архитектуру. Отличие от MapReduce заключается в том, что сервер параметров может быть асинхронным, а MapReduce может выполнять операции сокращения только после завершения всех карт.

В архитектуре сервера параметров вычислительные устройства делятся на серверы параметров (PS) и рабочие.

Сервер параметров (сервер). Это централизованный компонент, в основном отвечающий за хранение параметров модели, средних градиентов и обновлений обмена. Серверы параметров можно настроить в соответствии с различными пропорциями серверов параметров и рабочих потоков, и каждый сервер параметров имеет разные данные конфигурации.
Рабочие узлы. Каждый рабочий узел будет отвечать за обновление расчета параметров модели, соответствующих осколкам данных в его домене (например, операции с интенсивными вычислениями, такие как прямое и обратное распространение), и в то же время они будут передавать рассчитанные градиенты параметру server. , все градиенты агрегируются сервером параметров и затем передаются обратно на все узлы.

Конкретные шаги заключаются в следующем:

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

Логика следующая:

     +----------------------------------------------+
     |  Parameter Server                            |
     |                                              |
     |                                              |
     |   Compute : New P = P + Sum(Delta P ...)     |
     |                                              |
     |                                              |
     |   Parameter 1, Parameter 2, Parameter 3 ...  |
     |                                              |
     |                                              |
     +--+----+----------+--+----------------+--+----+
        ^    |          ^  |                ^  |
        |    |          |  |                |  |
Delta P |    |   Delta P|  |         Delta P|  |
  +-----+    |          |  |                |  +------+
  |    +-----+          |  |                |         |
  |    | New P          |  | New P          +------+  |
  |    |                |  |                       |  |  New P
  |    v                |  |                       |  |
  |                     |  v                       |  v
+-+-----------+   +-----+--+---+             +-----+--+---+
| Worker      |   | Worker     |             | Worker     |
|             |   |            |             |            |
|             |   |            |   ......    |            |
|       Model |   |     Model  |             |     Model  |
+------+------+   +------+-----+             +----+-------+
       ^                 ^                        ^
       |                 |                        |
       |                 |                        |
  +----+----+       +----+-----+               +--+-----+
  | Data 1  |       |  Data 2  |               | Data 3 |
  +---------+       +----------+               +--------+

Телефон такой:

Серверы параметров можно использовать как для параллелизма данных, так и для обучения параллелизму моделей. Например, модель можно разделить на несколько частей, хранить на разных узлах PS Server и предоставлять удобные сервисы доступа, что и является сутью сервера параметров.

3.3 Decentralized Network

Децентрализованная сеть — это децентрализованная сеть, и ее характеристики следующие:

Децентрализованная сеть не имеет центрального узла и относится к архитектуре Peer-to-Peer.
Используйте передачу сообщений для связи, а узлы общаются только с соседями.
Параллелизм может быть асинхронным или синхронным.
Конвергенция децентрализованной сети зависит от сетевого подключения:
- Чем теснее связь, тем быстрее сходимость, а когда связь сильная, модель может сходиться быстро;
- Если это не сильная связь, она может не сойтись;

0x04 All Reduce

Поскольку эта серия — Хоровод, мы сначала поговорим о недостатках серверов параметров, а затем поговорим о преимуществах серверов параметров в следующих сериях.

4.1 Недостатки сервера параметров

Хотя серверы параметров могут повысить производительность, все же есть несколько проблем:

Определяем правильное соотношение воркеров к серверам параметров: если используется сервер параметров, он может стать узким местом сети или вычислений. Если используется несколько серверов параметров, режим связи становится «Все со всеми», что может привести к перегрузке сети.
Сложность обработчика: Существует множество концепций серверов параметров, которые обычно требуют сложного обучения и большого количества рефакторингов кода, что сокращает время фактического моделирования.
стоимость оборудования: Введение сервера параметров также увеличивает аппаратную стоимость системы.

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

Следует отметить, что: AllReduce может быть как децентрализованным, так и master-slave.

4.2 Классификация параллельного взаимодействия задач

Коммуникацию параллельных задач в целом можно разделить на двухточечную связь и коллективную коммуникацию.

Режим P2P имеет только одного отправителя и одного получателя, что относительно просто реализовать.Например, технология NV GPU Direct P2P обеспечивает передачу данных с несколькими картами на одной машине между картами с одной машиной.
Коллективная связь включает несколько отправителей и несколько получателей.Общие примитивы связи включают широковещательную рассылку, сбор, все-собрать, разбросать, уменьшить, все-свести, уменьшить-рассеять, все-ко-всем и т. д.

4.3 MPI_AllReduce

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

Каждый Worker можно рассматривать как процесс в концепции MPI, например, можно сформировать группу из 4 Workers, а группа состоит из 4 процессов. Мы делаем один MPI_AllReduce для градиентов в этих четырех процессах.
Согласно семантике MPI_AllReduce все процессы, участвующие в вычислении, имеют результаты, поэтому градиент распределяется. Пока мы можем гарантировать, что параметры каждого рабочего процесса непротиворечивы во время инициализации, параметры останутся неизменными в последующих итерационных вычислениях, потому что информация о градиенте непротиворечива.
AllReduce похож на MapReduce, но последний использует многоэтапный метод выполнения задачи для общей обработки задач, в то время как AllReduce позволяет программе занимать компьютер, когда это необходимо, и выполняется до конца во всех итерациях, чтобы предотвратить накладные расходы на перераспределение ресурсов. , который больше подходит для обработки задач машинного обучения.

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

0x05 ring-allreduce

Baidu предложил использовать новый алгоритм для усреднения градиентов, отмены Reducer и предоставления этим градиентам связи между всеми узлами, это называется ring-allreduce, и они также реализовали этот алгоритм с помощью TensorFlow (GitHub.com/Baidu-Горячие цвета…).

5.1 Особенности

Особенности Ring-Allreduce:

Алгоритм Ring Allreduce использует четко определенную последовательность шагов попарной передачи сообщений для синхронизации состояния (в данном случае тензоров) в наборе процессов.
Кольцо в названии Ring-Allreduce означает, что топология между устройствами представляет собой логическое кольцо, каждое устройство должно иметь левого соседа и правого соседа, и устройство будет отправлять данные только своему правому соседу, а от своего левого соседа принимает данные.
Allreduce в названии Ring-Allreduce означает, что центрального узла нет, а каждый узел в архитектуре является сводным вычислительным узлом для градиентов.
В этом алгоритме каждый узел взаимодействует только с двумя соседними узлами и не нуждается в сервере параметров. Таким образом, все узлы участвуют в вычислениях и хранении и позволяют избежать узких мест в централизованной связи.
По сравнению с архитектурой PS архитектура Ring-Allreduce оптимизирована с точки зрения пропускной способности, поскольку пропускная способность каждого узла в кластере используется полностью.
- В алгоритме ring-allreduce каждый узел N обменивается данными 2 * (N-1) раз с двумя другими узлами. Во время этого процесса связи узел отправляет и получает блоки из буфера данных. В первых N - 1 итерациях полученное значение добавляется к значению в буфере узла. Во второй итерации N - 1 полученное значение заменяет значение, хранящееся в буфере узла. Статья Baidu доказывает, что этот алгоритм оптимизирует полосу пропускания, а это означает, что если буфер достаточно велик, он будет максимально использовать доступную сеть.
В процессе обучения глубокому обучению для расчета градиента используется алгоритм BP, который характеризуется тем, что сначала вычисляется градиент последнего слоя, а градиент первого слоя медленнее, чем градиент последнего слоя. Архитектура allreduce может в полной мере использовать эту возможность, при этом осуществляется градиентный перенос последующих слоев, что еще больше сокращает время обучения.
Алгоритм синхронизации в кольцевой архитектуре последовательно передает параметры в коммуникационное кольцо и часто требует выполнения нескольких шагов для выполнения синхронизации параметров. Это приведет к большим затратам на связь во время крупномасштабного обучения и не подходит для тензоров небольшого размера. Для тензоров небольшого размера можно использовать пакетные операции для уменьшения коммуникационных издержек.

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

5.2 Стратегия

Стратегия AllReduce на основе кольца включает два этапа: Scatter-Reduce и AllGather.

Первый — это scatter-reduce, где scatter-reduce будет постепенно обмениваться градиентами друг друга и плавиться, и, наконец, каждый GPU будет содержать часть полного объединенного градиента, который является блоком конечного результата.

Допустим, в кольце N воркеров, у каждого воркера есть массив одинаковой длины, и нужно просуммировать массивы воркеров. На этапе Scatter-Reduce каждый рабочий процесс разделит массив на N блоков данных, а затем выполнит N обменов данными между рабочими процессами. При k-м обмене данными i-й воркер отправит свои (i - k) % N блоков данных следующему воркеру. Получив блок данных предыдущего рабочего процесса, рабочий процесс суммирует его с соответствующим ему блоком данных.
Тогда все в сборе. Графические процессоры будут постепенно обмениваться неполными объединенными градиентами друг с другом, и в конечном итоге все графические процессоры получат полные окончательные объединенные градиенты.

После выполнения Scatter-Reduce в массиве каждого воркера есть определенный блок данных, который является окончательным результатом суммирования, и теперь окончательный результат суммирования каждого блока данных нужно отправить каждому воркеру. Как и Scatter-Reduce, он также требует N циклов. В k-м цикле i-й рабочий процесс отправит свой (i+1-k)%N-й блок данных следующему рабочему процессу. Получив блок данных предыдущего рабочего процесса, рабочий процесс быстро перезапишет соответствующий ему блок данных полученными данными. После N циклов каждый рабочий получает окончательный результат суммирования каждого блока данных массива.

Следующие части взяты изAndrew.GI, затем sky.com/blog/Ma Chi Nei…

5.2.1 Структура

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

5.2.2 Scatter-Reduce

scatter-reduce: постепенно меняйте местами градиенты и сплавы друг друга, и, наконец, каждый графический процессор будет содержать часть полного объединенного градиента.

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

5.2.2.1 Разделение на фрагменты

Сначала графический процессор делит массив на N меньших фрагментов (где N — количество графических процессоров в кольце).

Затем GPU выполнит N-1 итераций уменьшения рассеяния.

На каждой итерации GPU будет отправлять один из своих блоков своему правому соседу, получать блок от своего левого соседа и накапливать его в этом блоке. Фрагменты данных, которые каждый GPU отправляет и получает, различны для каждой итерации. N-й GPU начинает с отправки блока n и получения блока n – 1, а затем делает шаг назад, при этом каждая итерация отправляет блоки, полученные на предыдущей итерации.

5.2.2.2 Первая итерация

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

GPU	Отправить	Получать
0	блок 0	блок 4
1	блок 1	блок 0
2	блок 2	блок 1
3	блок 3	блок 2
4	блок 4	блок 3

Передача данных в первой итерации scatter-reduce выглядит следующим образом:

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

5.2.2.3 Все итерации

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

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

первая итерация

вторая итерация

третья итерация

Четвертая итерация

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

5.2.3 Allgather

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

Ring allgather выполняет ту же обработку, что и scatter-reduce (N-1 итераций отправки и получения), но вместо того, чтобы на этот раз накапливать значения, полученные GPU, они просто перезаписывают блоки. N-й GPU начинает отправлять n+1-й блок и получает n-й блок, а затем в последующих итерациях всегда отправляет только что полученный блок.

5.2.3.1 Первая итерация

Например, при первой итерации нашей установки с 5 графическими процессорами графический процессор будет отправлять и получать следующие блоки:

графический процессор	Отправить	Получать
0	блок 1	блок 0
1	блок 2	блок 1
2	блок 3	блок 2
3	блок 4	блок 3
4	блок 0	блок 4

Передача данных в первой итерации allgather происходит следующим образом.

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

5.2.3.2 Все итерации

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

Передача данных Allgather (итерация 1)

Передача данных Allgather (итерация 2) выглядит следующим образом:

Передача данных Allgather (итерация 3)

Передача данных Allgather (итерация 4)

Окончательное состояние после всех переносов.

5.2.4 Схема архитектуры Хоровода

Принцип работы также может бытьСообщение от Horovodприди и посмотри.

Image for post

5.2.5 Идеи Baidu

Или мы можем напрямую увидеть идею из исходного кода Baidu, и сейчас я выделю ее для всех.

Конкретные коды см.GitHub.com/Baidu-Горячие цвета…

tensorflow/contrib/mpi_collectives/ring.h

/* Perform a ring allreduce on the data. Allocate the necessary output tensor and
 * store it in the output parameter.
 *
 * Assumes that all MPI processes are doing an allreduce of the same tensor,
 * with the same dimensions.
 *
 * A ring allreduce is a bandwidth-optimal way to do an allreduce. To do the allreduce,
 * the nodes involved are arranged in a ring:
 *
 *                   .--0--.
 *                  /       \
 *                 3         1
 *                  \       /
 *                   *--2--*
 *
 *  Each node always sends to the next clockwise node in the ring, and receives
 *  from the previous one.
 *
 *  The allreduce is done in two parts: a scatter-reduce and an allgather. In
 *  the scatter reduce, a reduction is done, so that each node ends up with a
 *  chunk of the final output tensor which has contributions from all other
 *  nodes.  In the allgather, those chunks are distributed among all the nodes,
 *  so that all nodes have the entire output tensor.
 *
 *  Both of these operations are done by dividing the input tensor into N
 *  evenly sized chunks (where N is the number of nodes in the ring).
 *
 *  The scatter-reduce is done in N-1 steps. In the ith step, node j will send
 *  the (j - i)th chunk and receive the (j - i - 1)th chunk, adding it in to
 *  its existing data for that chunk. For example, in the first iteration with
 *  the ring depicted above, you will have the following transfers:
 *
 *      Segment 0:  Node 0 --> Node 1
 *      Segment 1:  Node 1 --> Node 2
 *      Segment 2:  Node 2 --> Node 3
 *      Segment 3:  Node 3 --> Node 0
 *
 *  In the second iteration, you'll have the following transfers:
 *
 *      Segment 0:  Node 1 --> Node 2
 *      Segment 1:  Node 2 --> Node 3
 *      Segment 2:  Node 3 --> Node 0
 *      Segment 3:  Node 0 --> Node 1
 *
 *  After this iteration, Node 2 has 3 of the four contributions to Segment 0.
 *  The last iteration has the following transfers:
 *
 *      Segment 0:  Node 2 --> Node 3
 *      Segment 1:  Node 3 --> Node 0
 *      Segment 2:  Node 0 --> Node 1
 *      Segment 3:  Node 1 --> Node 2
 *
 *  After this iteration, Node 3 has the fully accumulated Segment 0; Node 0
 *  has the fully accumulated Segment 1; and so on. The scatter-reduce is complete.
 *
 *  Next, the allgather distributes these fully accumululated chunks across all nodes.
 *  Communication proceeds in the same ring, once again in N-1 steps. At the ith step,
 *  node j will send chunk (j - i + 1) and receive chunk (j - i). For example, at the
 *  first iteration, the following transfers will occur:
 *
 *      Segment 0:  Node 3 --> Node 0
 *      Segment 1:  Node 0 --> Node 1
 *      Segment 2:  Node 1 --> Node 2
 *      Segment 3:  Node 2 --> Node 3
 *
 * After the first iteration, Node 0 will have a fully accumulated Segment 0
 * (from Node 3) and Segment 1. In the next iteration, Node 0 will send its
 * just-received Segment 0 onward to Node 1, and receive Segment 3 from Node 3.
 * After this has continued for N - 1 iterations, all nodes will have a the fully
 * accumulated tensor.
 *
 * Each node will do (N-1) sends for the scatter-reduce and (N-1) sends for the allgather.
 * Each send will contain K / N bytes, if there are K bytes in the original tensor on every node.
 * Thus, each node sends and receives 2K(N - 1)/N bytes of data, and the performance of the allreduce
 * (assuming no latency in connections) is constrained by the slowest interconnect between the nodes.
 *
 */

5.3 Различия

В случае с моделями среднего размера больше подходит all-reduce. Серверы параметров следует использовать при большом масштабе.

Сервер параметров подходит для обучения многомерной разреженной модели, он использует преимущества разреженной размерности, и каждый раз, когда выполняется извлечение или извлечение, обновляются только действительные значения. Но модель глубокого обучения представляет собой типичную плотную сцену, а встраивание превращает разреженное в плотное. Так что этот вид тяги или толчка не подходит. А all-reduce, более оптимизированный для сетевого взаимодействия, подходит для глубокого обучения среднего масштаба.

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

До сих пор были введены фоновые знания.В следующей статье мы представим использование Horovod.

0xEE Личная информация

★★★★★★Думая о жизни и технологиях★★★★★★

Публичный аккаунт WeChat:мысли Росси

Если вы хотите получать своевременные новости о статьях, написанных отдельными лицами, или хотите видеть технические материалы, рекомендованные отдельными лицами, обратите внимание.