[Анализ исходного кода] Распространение PyTorch (1) ------ история и обзор

0x00 сводка

Эта статья в основном добавляет мое собственное понимание перевода официальных документов PyTorch. Я надеюсь дать вам распределенный исторический контекст и основные концепции PyTorch. Заинтересованные друзья могут внимательно изучить историю и посмотреть, как работает система машинного обучения шаг за шагом. Войти распределенный мир / совершенствовать его функциональность.

Другие статьи из этой серии:

Автоматическая дифференциация инструментов глубокого обучения (1)

Автоматическая дифференциация инструментов глубокого обучения (2)

Автоматическая дифференциация оружия глубокого обучения (3) --- Пример интерпретации

[Анализ исходного кода] Как PyTorch реализует прямое распространение (1) --- Базовый класс (1)

[Анализ исходного кода] Как PyTorch реализует прямое распространение (2) --- Базовый класс (ниже)

[Анализ исходного кода] Как PyTorch реализует прямое распространение (3) --- конкретная реализация

[Анализ исходного кода] Как Pytorch реализует обратное распространение (1) ---- вызов движка

[Анализ исходного кода] Как Pytorch реализует обратное распространение (2) ---- Статическая структура движка

[Анализ исходного кода] Как Pytorch реализует обратное распространение (3) ---- Динамическая логика движка

[Анализ исходного кода] Как PyTorch реализует обратное распространение (4) ---- конкретный алгоритм

0x01 История распространения PyTorch

получилаРаспространяется с PyTorchВдохновившись этим шедевром, давайте разберемся в актуальной истории распространения PyTorch до версии 1.9.

Примечание. Если вы хотите изучить исходный код PyTorch, рекомендуетсяGemfieldиИнтерпретация исходного кода PyTorchВ этих двух столбцах анализ исходного кода довольно глубокий!

История распространения PyTorch начинается сGitHub.com/py torch/Пак Ючон…Исходя из содержания, автор условно делит современную историю на 7 этапов.

Они есть:

Используйте torch.multiprocessing, чтобы обернуть собственный многопроцессорный модуль Python, чтобы можно было использовать несколько ядер ЦП.
Импортированный THD (распределенный pytorch), в котором есть базовая библиотека для распределенных вычислений.
Был представлен пакет torch.distributed, который позволяет обмениваться тензорами между несколькими машинами. Используйте этот пакет для обучения с большими партиями на нескольких машинах.
Была выпущена библиотека c10d, которая стала базовым бэкэндом для пакета torch.distributed и torch.nn.parallel.DistributedDataParallel, а THD объявлен устаревшим.
Распределенная среда RPC предоставляется для поддержки параллельного обучения распределенных моделей. Он позволяет запускать функции и удаленно ссылаться на удаленные объекты без копирования реальных данных, а также предоставляет API-интерфейсы автоградации и оптимизатора для прозрачного обратного распространения и обновления параметров через границы RPC.
Представляя эластичное обучение, Torchelastic предоставляет строгий расширенный набор CLI «torch.distributed.launch» с добавлением отказоустойчивости и эластичности.
Вводится конвейерный параллелизм, который называется torchgpipe.

Его историческая эволюция выглядит следующим образом:

                                           v1.0

                                           v1.1

                                           v1.2

               v0.1.8                      v1.3                  v1.7

                THD                        C10D               TorchElastic
                 +                          +                      +
                 |                          |                      |
                 |                          |                      |
                 |                          |                      |
                 |                          |                      |
                 |                          |                      |
                 |                          |                      |
+-------+--------+------------+-------------+-----------+----------+------------+---------->
        |                     |                         |                       |
        |                     |                         |                       |
        |                     |                         |                       |
        |                     |                         |                       |
        |                     |                         |                       |
        +                     +                         +                       +

  Multiprocessing       torch.distributed              RPC                   Pipeline

     v0.1.2                  v0.2                      v1.4                   v1.8

     v0.1.6                  v0.4                      v1.5                   v1.9

                                                       v1.6

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

1.1 Multiprocessing

PyTorch 0.1.2

Используйте torch.multiprocessing, чтобы обернуть собственный многопроцессорный модуль Python, чтобы можно было использовать несколько ядер ЦП.

Конкретная причина заключается в том, что в Python существуют технические проблемы с использованием потоков, в основномGlobal Interpreter Lock, поэтому следует использовать многопроцессорность.

With Python, one cannot use threads because of a few technical issues. Python has what is called Global Interpreter Lock, which does not allow threads to concurrently execute python code.

Hence, the most pythonic way to use multiple CPU cores is multiprocessing

We made PyTorch to seamlessly integrate with python multiprocessing. This involved solving some complex technical problems to make this an air-tight solution, and more can be read in this in-depth technical discussion.

PyTorch 0.1.6

Многопроцессорность поддерживает CUDA.

Uptil now, Tensor sharing using multiprocessing only worked for CPU Tensors. We've now enabled Tensor sharing for CUDA tensors when using python-3. You can read more notes here: Пишите на torch.org/docs/notes/…

1.2 Базовая библиотека THD

PyTorch 0.1.8

Импортированный THD (распределенный pytorch), в котором есть базовая библиотека для распределенных вычислений.

Merged an initial version of THD (distributed pytorch)

1.3 библиотека torch.distributed

PyTorch 0.2

We introduce the torch.distributed package that allows you to exchange Tensors among multiple machines. Using this package, you can scale your network training over multiple machines and larger mini-batches. For example, you are given the primitives to implement Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour.

The distributed package follows an MPI-style programming model. This means that there are functions provided to you such as send, recv, all_reduce that will exchange Tensors among nodes (machines).

For each of the machines to first identify each other and assign unique numbers to each other (ranks), we provide simple initialization methods:

shared file system (requires that all processes can access a single file system)

IP multicast (requires that all processes are in the same network)

environment variable (requires you to manually assign ranks and know an address of a node reachable from all processes)

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

ДолженdistributedПакеты следуют модели программирования в стиле MPI, т.е.distributedПакет предоставляет такие методы, как send, recv, all_reduce для обмена тензорами между разными узлами (машинами).

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

Общая файловая система (все процессы на всех машинах могут получить доступ к этой файловой системе)
Многоадресная IP-адресация (требуется, чтобы все процессы находились в одной сети)
Переменные среды (требует, чтобы пользователь вручную указал ранг и предоставил адрес узла, доступный для всех процессов)

Размер мира — это количество процессов, которые будут участвовать в обучении. Каждому процессу будет присвоен ранг, представляющий собой число от 0 до world_size - 1, уникальное для данного задания. Он будет использоваться как идентификатор процесса и будет использоваться вместо адреса, например, чтобы указать, на какой ранг (процесс) должен быть отправлен тензор.

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

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

PyTorch 0.4

Эта версия имеет несколько зависимостей.

Добавлен DistributedDataParallelCPU, который похож на DistributedDataParallel, но в основном поддерживает обучение на CPU (DistributedDataParallel нацелен на GPU). Этот класс поддерживаетmpi, gloo and tcpЭти серверные части (серверная часть tcp позже устарела).

Add DistributedDataParallelCPU. This is similar to DistributedDataParallel, but with specific support for models running on the CPU (contrary to DistributedDataParallel, which targets GPU), and supports mpi, gloo and tcp backends #5919.

Добавлены новые скрипты инструментов. Этот скрипт можно использовать на одной машине или на нескольких машинах.DistributedDataParallel.

Helper utility for launching Distributed Training jobs

We have added an utility function to help launch jobs on a distributed setup. In order to launch a script that leverages DistributedDataParallel on either single-node multiple-nodes, we can make use of torch.distributed launch as follows
python -m torch.distributed.launch my_script.py --arg1 --arg2 --arg3

Добавлен новый распределенный бэкэнд на основе NCCL 2.0, который значительно повышает скорость, а также может предоставить новый API для коллективного общения на базе нескольких GPU.

A new distributed backend based on NCCL 2.0

PyTorch now has a new distributed backend, which leverages NCCL 2.0 for maximum speed. It also provides new APIs for collective operations on multiple GPUs. You can enable the new backend via
torch.distributed.init_process_group("nccl")

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

Coalesce many small broadcasts to improve performance #4978

Add mixed-precision support for distributed training #4891

Release NCCL distributed backend. Previously it was marked as experimental. #4921

Enable Infiniband support for Gloo data channel with automatic IB device detection #4795

1.4 библиотека c10d

PyTorch 1.0

torch.distributed new "C10D" library

The torch.distributed package and torch.nn.parallel.DistributedDataParallel module are backed by the new "C10D" library. The main highlights of the new library are:

C10D is performance driven and operates entirely asynchronously for all backends: Gloo, NCCL, and MPI.

Significant Distributed Data Parallel performance improvements especially for slower network like ethernet-based hosts

Adds async support for all distributed collective operations in the torch.distributed package.

Adds send and recv support in the Gloo backend

В этом выпуске была выпущена библиотека c10d, которая стала базовой для пакетов torch.distributed и torch.nn.parallel.DistributedDataParallel.Основные особенности этой библиотеки:

Поскольку C10D работает полностью асинхронно, производительность всех серверных частей (Gloo, NCCL и MPI) значительно повышается.
Для медленных сетей, таких как Ethernet, параллелизм распределенных данных является огромным преимуществом.
Добавлена асинхронная поддержка для всех операций распределенной коллекции в пакете torch.distributed.
Добавлена поддержка отправки и получения в бэкэнд Gloo.

Есть еще несколько изменений.

Бэкэнд TCP удален, бэкенды Gloo и MPI рекомендуются для коллективной связи ЦП, а NCCL рекомендуется для коллективной коммуникации ГП.
Старый (на основе THD) пакет torch.distributed устарел.
Старый (на основе THD) пакет torch.nn.parallel.DistributedDataParallel устарел.

torch.distributed: the TCP backend is removed, we recommend to use Gloo and MPI backends for CPU collectives and NCCL backend for GPU collectives.

the old (THD-backed) torch.distributed package is deprecated but still available at torch.distributed.deprecated.

The old (THD-backed) torch.nn.parallel.DistributedDataParallel is deprecated but still available at torch.nn.parallel.deprecated.DistributedDataParallel.

PyTorch 1.1

nn.parallel.DistributedDataParallel может поддерживать модели с несколькими графическими процессорами, поэтому параллелизм моделей и параллелизм данных могут взаимодействовать между серверами.

DistributedDataParallel new functionality and tutorials

nn.parallel.DistributedDataParallel: can now wrap multi-GPU modules, which enables use cases such as model parallel (tutorial) on one server and data parallel (tutorial) across servers.

c10d ProcessGroup::getGroupRankудаленный.

PyTorch 1.2

В этой версии были сделаны следующие улучшения:

Распределенный пакет может поддерживать модули ЦП, разреженные тензоры, накопление локального градиента.

Distributed Package

DistributedDataParallel: support CPU modules. (20236)

DistributedDataParallel: support sparse tensors. (19146)

DistributedDataParallel: support local gradient accumulation. (21736)

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

PyTorch 1.3

Добавлена поддержка torch.distributed для macOS, но можно использовать только бэкэнд Gloo.Пользователям нужно изменить только одну строку кода, чтобы повторно использовать код с других платформ. Также были внесены некоторые другие улучшения.

This release adds macOS support for torch.distributed with the Gloo backend. You can more easily switch from development (e.g. on macOS) to deployment (e.g. on Linux) without having to change a single line of code. The prebuilt binaries for macOS (stable and nightly) include support out of the box.

torch.distributed.all_reduce_coalesced Support allreduce of a list of same-device tensors (24949, 25470, 24876)

torch.distributed.all_reduce Add bitwise reduction ops (BAND, BOR, BXOR) (26824)

1.5 Платформа RPC

PyTorch 1.4.0

В этом выпуске начинаются эксперименты с обучением распределенной модели.

Поскольку такие модели, как RoBERTa, продолжают масштабироваться до миллиардов параметров, параллельное обучение моделей становится все более важным, поскольку оно помогает исследователям выйти за рамки возможного. Версия 1.4.0 предоставляет распределенную структуру RPC для поддержки параллельного обучения распределенных моделей. Он позволяет запускать функции и удаленно ссылаться на удаленные объекты без копирования соответствующих реальных данных, а также предоставляет API-интерфейсы автоградации и оптимизатора для прозрачного обратного распространения и обновления параметров через границы RPC.

Distributed Model Parallel Training [Experimental]

With the scale of models, such as RoBERTa, continuing to increase into the billions of parameters, model parallel training has become ever more important to help researchers push the limits. This release provides a distributed RPC framework to support distributed model parallel training. It allows for running functions remotely and referencing remote objects without copying the real data around, and provides autograd and optimizer APIs to transparently run backwards and update parameters across RPC boundaries.

torch.distributed.rpcэто недавно представленный пакет. Его основные строительные блоки могут удаленно запускать функции при обучении модели и выводе, что полезно для таких сценариев, как параллелизм распределенной модели или реализация фреймворков сервера параметров. В частности, он состоит из четырех столпов: RPC, удаленных ссылок, распределенного автограда и распределенного оптимизатора. видетьдокументируководствоподробнее.

RPC [Experimental]

torch.distributed.rpc is a newly introduced package. It contains basic building blocks to run functions remotely in model training and inference, which will be useful for scenarios like distributed model parallel or implementing parameter server frameworks. More specifically, it contains four pillars: RPC, Remote Reference, Distributed Autograd, and Distributed Optimizer. Please refer to the documentation and the tutorial for more details.

PyTorch 1.5

официально выпущенtorch.distributed.rpc.

Пакет «torch.distributed.rpc» предназначен для поддержки различных парадигм распределенного обучения, которые не подходят для «DistributedDataParallel». Примеры включают обучение сервера параметров, параллелизм распределенной модели и параллелизм распределенного конвейера.torch.distributed.rpcФункционал пакета можно разделить на четыре основные группы API.

RPCAPI позволяет запускать функцию с заданными аргументами в указанном целевом рабочем процессе и получать возвращаемое значение или создавать распределенную ссылку на возвращаемое значение.
RRef(удаленная ссылка) — это ссылка на объект на другом воркере. Рабочие процессы, имеющие RRefs, могут явно запрашивать копии объектов, а также могут делиться облегченными RRefs с другими рабочими процессами, не беспокоясь о подсчете ссылок. Это особенно полезно, когда нескольким рабочим процессам необходимо неоднократно обращаться к разным версиям одного и того же удаленного объекта.
использоватьРаспределенная автозагрузка, приложение может автоматически вычислять градиенты, даже если модель была разделена между несколькими рабочими процессами с помощью RPC. PyTorch сшивает графы локальной автоградации на границах RPC во время прямого распространения и позволяет участникам инициировать локальную автоградацию через границы во время обратного распространения.
Распределенный оптимизаторИспользуйте градиенты, вычисленные распределенным автоградом, для обновления параметров модели. Его конструктор принимает локальный оптимизатор (например,SGD,Adagradи т.д.) и список параметров RRefs, чьиstepФункция автоматически использует локальный оптимизатор для всех владельцев (воркеров) RRef для обновления параметров.

Distributed RPC framework APIs [Now Stable]

The torch.distributed.rpc package aims at supporting a wide range of distributed training paradigms that do not fit into DistributedDataParallel. Examples include parameter server training, distributed model parallelism, and distributed pipeline parallelism. Features in the torch.distributed.rpc package can be categorized into four main sets of APIs.

The RPC API allows running a function on a specified destination worker with given arguments and fetches the return value or creates a distributed reference to the return value.

The RRef (Remote REFerence) serves as a reference to an object on another worker. A worker holding an RRef can explicitly request copies of the object, and it can also share the light-weight RRef with other workers without worrying about reference counting. This is especially useful when multiple workers need to repeatedly access different versions of the same remote object.

With Distributed Autograd, applications can automatically compute gradients even if a model is split on multiple workers using RPC. This is achieved by stitching together local autograd graphs at RPC boundaries in the forward pass and reaching out to participants to transparently launch local autograd in the backward pass.

The Distributed Optimizer uses gradients computed by Distributed Autograd to update model parameters. Its constructor takes a local optimizer (e.g., SGD, Adagrad, etc.) and a list of parameter RRefs, and its step() function automatically uses the local optimizer to update parameters on all distinct RRef owner workers.

PyTorch 1.6

В этой версии было внесено множество улучшений в DDP и RPC, а также добавлены новые функции.

Numerous improvements and new features for both distributed data parallel (DDP) training and the remote procedural call (RPC) packages.

Бэкэнд TensorPipe для RPC

PyTorch 1.6 представляет новый бэкэнд для модуля RPC, который использует библиотеку TensorPipe. Библиотека TensorPipe — это примитив одноранговой связи с поддержкой тензора для машинного обучения, предназначенный для дополнения текущих примитивов (Gloo, MPI и т. д.) для распределенного обучения в PyTorch, которые коллективно передаются и разбиваются на части. Парный и асинхронный характер TensorPipe делает его полезным для построения новых сетевых парадигм помимо параллелизма данных: подходы клиент-сервер (например, встроенные серверы параметров, разделение актеров и учащихся в RL в стиле Impala и т. д.) Параллельное обучение конвейера (например, GPipe) , сплетни SGD и т.д.

TensorPipe backend for RPC

PyTorch 1.6 introduces a new backend for the RPC module which leverages the TensorPipe library, a tensor-aware point-to-point communication primitive targeted at machine learning, intended to complement the current primitives for distributed training in PyTorch (Gloo, MPI, ...) which are collective and blocking. The pairwise and asynchronous nature of TensorPipe lends itself to new networking paradigms that go beyond data parallel: client-server approaches (e.g., parameter server for embeddings, actor-learner separation in Impala-style RL, ...) and model and pipeline parallel training (think GPipe), gossip SGD, etc.

[Beta] DDP+RPC

Распределенный PyTorch поддерживает две мощные парадигмы: DDP для полностью синхронного параллельного обучения данных и инфраструктуру RPC для обеспечения параллелизма распределенной модели.

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

[Beta] DDP+RPC

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

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

[Beta] RPC - Asynchronous User Functions

Асинхронные пользовательские функции RPC поддерживают выход и возобновление на стороне сервера при выполнении пользовательских функций. До этой функции поток RPC ожидал возврата пользовательской функции, пока вызываемый объект обрабатывал запрос. Если пользовательская функция содержит ввод-вывод (например, вложенный RPC) или сигнализацию (например, ожидание разблокировки другого запроса), соответствующий поток RPC будет простаивать в ожидании этих событий. Поэтому некоторые приложения должны использовать большое количество потоков и отправлять дополнительные запросы RPC, что может привести к снижению производительности. Чтобы пользовательские функции срабатывали в таких случаях, приложению необходимо: 1) использовать@rpc.functions.async_executionДекоратор оборачивает функцию: 2) заставляет функцию возвращать torch.futures.Future и устанавливает логику восстановления в качестве обратного вызова на объект Future.

[Beta] RPC - Asynchronous User Functions

RPC Asynchronous User Functions supports the ability to yield and resume on the server side when executing a user-defined function. Prior to this feature, when an callee processes a request, one RPC thread waits until the user function returns. If the user function contains IO (e.g., nested RPC) or signaling (e.g., waiting for another request to unblock), the corresponding RPC thread would sit idle waiting for these events. As a result, some applications have to use a very large number of threads and send additional RPC requests, which can potentially lead to performance degradation. To make a user function yield on such events, applications need to: 1) Decorate the function with the @rpc.functions.async_execution decorator; and 2) Let the function return a torch.futures.Future and install the resume logic as callbacks on the Future object.

[Beta] Fork/Join Parallelism

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

Параллельное выполнение программ TorchScript поддерживается с помощью двух примитивов: "torch.jit.fork" и "torch.jit.wait".

[Beta] Fork/Join Parallelism

This release adds support for a language-level construct as well as runtime support for coarse-grained parallelism in TorchScript code. This support is useful for situations such as running models in an ensemble in parallel, or running bidirectional components of recurrent nets in parallel, and allows the ability to unlock the computational power of parallel architectures (e.g. many-core CPUs) for task level parallelism.

Parallel execution of TorchScript programs is enabled through two primitives: torch.jit.fork and torch.jit.wait.

1.6 Тренировка эластичности

PyTorch 1.7

В этой версии были внесены некоторые улучшения в DDP и RPC, а также добавлены новые функции.

[Stable] TorchElastic now bundled into PyTorch docker image

Torchelastic предоставляет расширенный набор интерфейсов командной строки «torch.distributed.launch» с повышенной отказоустойчивостью и отказоустойчивостью. Если пользователя не интересует отказоустойчивость, он может получить точную функциональность/поведение, установив «max_restarts=0» и добавив удобство автоматического назначения портов «RANK» и «MASTER_ADDR» (вместо «torch.distributed.launch " указывается вручную).

Объединив «torchelastic» с PyTorch в один и тот же образ докера, пользователи могут сразу начать экспериментировать с torchelastic, не устанавливая «torchelastic» отдельно. В дополнение к удобству добавление поддержки эластичных параметров в существующие распределенные операторы PyTorch Kubeflow также является хорошим вариантом.

[Stable] TorchElastic now bundled into PyTorch docker image

Torchelastic offers a strict superset of the current torch.distributed.launch CLI with the added features for fault-tolerance and elasticity. If the user is not be interested in fault-tolerance, they can get the exact functionality/behavior parity by setting max_restarts=0 with the added convenience of auto-assigned RANK and MASTER_ADDR|PORT (versus manually specified in torch.distributed.launch).

By bundling torchelastic in the same docker image as PyTorch, users can start experimenting with torchelastic right-away without having to separately install torchelasticПомимо удобства, эта работа полезна при добавлении поддержки эластичных параметров в существующие операторы распределенного PyTorch Kubeflow.

[Beta] Support for uneven dataset inputs in DDP

В PyTorch 1.7 представлен новый менеджер контекста, который можно использовать вместе с моделями, обученными с помощью «torch.nn.parallel.DistributedDataParallel», для поддержки обучения с наборами данных разного размера в разных процессах. Эта функция обеспечивает большую гибкость при использовании DDP и избавляет пользователя от необходимости вручную обеспечивать одинаковый размер наборов данных в разных процессах. Используя этот контекстный менеджер, DDP будет автоматически обрабатывать неравные размеры наборов данных, что может предотвратить ошибки или зависания в конце обучения.

[Beta] Support for uneven dataset inputs in DDP

PyTorch 1.7 introduces a new context manager to be used in conjunction with models trained using torch.nn.parallel.DistributedDataParallel to enable training with uneven dataset size across different processes. This feature enables greater flexibility when using DDP and prevents the user from having to manually ensure dataset sizes are the same across different process. With this context manager, DDP will handle uneven dataset sizes automatically, which can prevent errors or hangs at the end of training.

Другие функции включают в себя:

[Beta] NCCL Reliability - Async Error/Timeout Handling
[Beta] TorchScript remote and rpc_sync
[Beta] Distributed optimizer with TorchScript support
[Beta] Enhancements to RPC-based Profiling
[Prototype] Windows support for Distributed Training

1.7 Обучение конвейеру

PyTorch 1.8

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

где конвейерный параллелизмfairscale.nn.PipeПредставлено, это на самом деле torchgpipe.

Significant updates and improvements to distributed training including: Improved NCCL reliability; Pipeline parallelism support; RPC profiling; and support for communication hooks adding gradient compression.

Upstream fairscale.nn.Pipe into PyTorch as torch.distributed.pipeline (#44090)

PyTorch 1.9

в основном

Некоторые исправления ошибок для Distributed / TorchElastic.
Основные улучшения в RPC для поддержки крупномасштабного распределенного обучения GPU.
Распределенное обучение, использование графического процессора и эффективность SM поддерживаются в PyTorch Profiler.

Изучив историю, давайте взглянем на обзор дистрибутива.

0x02 Распределенный обзор

Следующие в основном основаны наpy torch.org/tutorials/ нет…Основано на официальных документах плюс ваше собственное понимание.

2.1 Введение

2.1.1 пакет torch.distributed

в PyTorchtorch.distributedПакеты предоставляют коммуникационные примитивы для многопроцессорного параллелизма, позволяя этим процессам обмениваться данными между несколькими вычислительными узлами, работающими на одном или нескольких компьютерах.torch.distributedПараллелизм пакета такой же, как и у многопроцессорности (torch.multiprocessing) упаковка другая,torch.distributedПакет поддерживает несколько компьютеров, подключенных к сети, и пользователь должен явно запускать отдельную копию основного обучающего сценария для каждого процесса.

В случае автономной и синхронной модели torch.distributed илиtorch.nn.parallel.DistributedDataParallel()Оболочка может по-прежнему иметь преимущества перед другими методами параллельного доступа к данным (такими как torch.nn.DataParallel):

Каждый процесс поддерживает свой собственный оптимизатор и выполняет полный шаг оптимизации на каждой итерации. Хотя это может показаться избыточным, поскольку градиенты уже сгруппированы вместе и усреднены по процессам, они одинаковы для каждого процесса, а это означает, что не требуется шага широковещательной рассылки параметров, что снижает потребность в затратах времени на передачу тензоров между узлами.
Каждый процесс содержит независимый интерпретатор Python, что устраняет дополнительные накладные расходы на интерпретатор и «перегрузку GIL», связанные с накладными расходами одного процесса Python, управляющего несколькими потоками выполнения, несколькими копиями модели или несколькими графическими процессорами. Это особенно важно для моделей, которые сильно зависят от среды выполнения Python, часто с рекурсивными слоями или множеством небольших компонентов.

Начиная с PyTorch v1.6.0, функциональностьtorch.distributedМожно разделить на три основных компонента:

Параллельное обучение с распределенными данными(DDP) — широко распространенная парадигма обучения с несколькими данными, состоящая из одной программы. При использовании DDP модель реплицируется в каждом процессе, и каждой реплике модели передается отдельный набор выборок входных данных. DDP отвечает за градиентную связь, чтобы синхронизировать реплики модели и перекрывать вычисления градиента для ускорения обучения.
Распределенное обучение на основе RPC(RPC) предназначен для поддержки общих конструкций обучения, которые не могут обеспечить параллельное обучение данных, таких как параллелизм распределенного конвейера, парадигмы сервера параметров и комбинации DDP и других парадигм обучения. Это помогает управлять жизненным циклом удаленных объектов и расширяет механизм автоградации за пределы компьютера.
коллективное общение(c10d) Библиотека поддерживает отправку тензоров между процессами внутри группы. Он предоставляет API-интерфейсы для коллективной связи (такие как all_reduce и all_gather) и API-интерфейсы для одноранговой связи (такие как send и isend). DDP и RPC (бэкенд группы процессов) построены на c10d в v1.6.0, где первый использует коллективную связь, а второй использует связь P2P. Обычно разработчикам не нужно напрямую использовать этот необработанный коммуникационный API, потому что вышеупомянутые функции DDP и RPC могут обслуживать множество сценариев распределенного обучения. Однако в некоторых случаях этот API все еще полезен. Примером является усреднение распределенных параметров, когда приложение хочет вычислить среднее значение всех параметров модели после обратного прохода, а не использовать DDP для передачи градиентов. Это отделяет связь от вычислений и позволяет более точно контролировать то, что передается, но, с другой стороны, также отказывается от оптимизации производительности, которую обеспечивает DDP. существуетНаписание распределенных приложений с помощью PyTorchПоказывает пример использования коммуникационного API c10d.
- способ общения: Базовая коммуникация torch.distributed в основном использует библиотеку Collective Communication (c10d) для поддержки отправки тензоров между процессами в группе и в основном поддерживает два типа коммуникационных API:
  - collective communication APIs: Distributed Data-Parallel Training (DDP)
  - P2P communication APIs: RPC-Based Distributed Training (RPC)
Эти два коммуникационных API соответствуют двум распределенным методам обучения в PyTorch: распределенному параллельному обучению данных (DDP) и распределенному обучению на основе RPC (RPC).

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

2.1.2 Ссылка на знания

Многопроцессорный модуль PyTorch инкапсулирует собственный многопроцессорный модуль Python, который на 100 % совместим с API, а также регистрирует пользовательские редукторы, которые могут использовать механизм IPC (общая память), чтобы позволить различным процессам читать и записывать одни и те же данные. Но то, как это работает, имеет много недостатков в CUDA, например, необходимость указывать, каков жизненный цикл различных процессов, что часто приводит к неожиданному поведению многопроцессорной обработки в CUDA.

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

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

Используйте обучение на одном устройстве, если данные и модель могут поместиться на одном графическом процессоре, а скорость обучения не имеет значения.
Если у вас есть несколько GPU на сервере и вы хотите ускорить обучение с минимальными изменениями кода, вы можете использовать DataParallel с несколькими GPU для одной машины.
Если вы хотите еще больше ускорить обучение и готовы написать больше кода для его настройки, вы можете использовать DistributedDataParallel с несколькими графическими процессорами для одной машины.
Если ваше приложение должно масштабироваться за пределы машин, используйтесценарий запуска.
Используйте, если ожидаются ошибки (например, OOM) или если ресурсы можно динамически объединять и оставлять во время обучения.torchelasticНачать распределенное обучение.

2.3 `torch.nn.DataParallel`

DataParallelПакет может обеспечить параллелизм с одной машиной и несколькими графическими процессорами с минимальным объемом кода. Для этого требуется изменить всего одну строку в коде приложения. руководствоOptional: Data ParallelismПоказан пример. Следует отметить, что хотяDataParallelОчень прост в использовании, но обычно не обеспечивает наилучшей производительности. Это потому чтоDataParallelреализация повторяет модель в каждом прямом проходе, а его однопроцессный многопоточный параллелизм страдает от гонок GIL. Для повышения производительности рассмотрите возможность использованияDistributedDataParallel.

2.4 `torch.nn.parallel.DistributedDataParallel`

иDataParallelпо сравнению с,DistributedDataParallelДля установки требуется еще один шаг, то есть вызовinit_process_group. DDP использует многопроцессный параллелизм, поэтому между копиями модели нет гонки GIL. Кроме того, модель передает данные при построении DDP, а не при каждом прямом проходе, что также помогает ускорить обучение. DDP поставляется с несколькими методами оптимизации производительности. Для более подробного объяснения см.Бумага ДДП(ВЛДБ'20).

Материалы ДДП следующие:

Примечания к DDPПриведен вводный пример и несколько кратких описаний его дизайна и реализации. Если вы впервые используете DDP, начните с этого документа.
Getting Started with Distributed Data ParallelОбъясняются некоторые распространенные проблемы с обучением DDP, в том числе несбалансированные рабочие нагрузки, контрольные точки и модели с несколькими устройствами. Обратите внимание, что DDP можно легко использовать с автономнымЛучшие практики параллелизма моделейописано в учебникеавтономныйВ сочетании с параллелизмом модели нескольких устройств.
существуетЗапустите и настройте параллельное приложение с распределенными даннымиДокументация, показывающая, как запустить скрипт с помощью DDP.
ДолженShard Optimizer States With ZeroRedundancyOptimizerРецепт продемонстрирован.ZeroRedundancyOptimizerКак помочь сократить оптимизированный объем памяти для параллельного обучения с распределенными данными.

2.5 TorchElastic

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

Иногда такие ошибки, как OOM, неизбежны при использовании DDP, но сам DDP не может восстановиться после этих ошибок, в основномtry-exceptБлоки тоже не работают. Это связано с тем, что DDP требует, чтобы все процессы выполнялись в тесной синхронизации, а все процессы запускались в разных процессах.AllReduceКоммуникации должны совпадать.

Если процесс в группе выдает исключение OOM, это, скорее всего, приведет к рассинхронизации (непревзойденномуAllReduceоперации), что приводит к сбою или зависанию. Если вы ожидаете сбоев во время обучения или ресурсы могут динамически уходить и присоединяться, используйтеtorchelasticЗапустите параллельное обучение с распределенными данными.

2.6 Общее распределенное обучение

Многие парадигмы обучения не подходят для параллелизма данных, например парадигма сервера параметров, параллелизм распределенного конвейера, приложения обучения с подкреплением с несколькими наблюдателями или агентами и т. д.torch.distributed.rpcЦель состоит в том, чтобы поддерживать общие сценарии распределенного обучения.

torch.distributed.rpcПакет состоит из четырех столпов:

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

Учебник RPC выглядит следующим образом (Некоторые статьи будут отобраны для анализа позже):

существуетНачало работы с распределенной инфраструктурой RPCВ учебнике сначала используется простой пример обучения с подкреплением (RL), чтобы проиллюстрировать RPC и RRef. Затем он применяет базовую распределенную модель параллельно с примером RNN, чтобы показать, как использовать распределенный автоград и распределенный оптимизатор.
существуетРеализовать сервер параметров с помощью распределенной инфраструктуры RPC.заимствование учебникасвиньядикая! тренироватьсяСуть его для асинхронного сервера параметров (PS) обучающих приложений.
Использовать RPCизРаспределенный конвейерный параллелизмВ этом руководстве будет распараллелен пример конвейера с одной машиной (вВведено в рекомендации для параллелизма моделей с одной машиной.) в распределенную среду и показывает, как это реализовать с помощью RPC.
Используйте асинхронное выполнение для реализации пакетной обработки RPC.Учебник, показывающий, как использовать@ rpc.functions.async_executionDecorator для реализации пакетной обработки RPC, которая может помочь ускорить вывод и обучение. Он использует аналогичные примеры RL и PS, которые использовались в учебниках 1 и 2 выше.
Сочетание распределенных инфраструктур RPC с распределенным параллелизмом данныхВ этом руководстве показано, как объединить DDP с RPC, чтобы можно было обучить модель, используя комбинацию параллелизма распределенных данных и параллелизма распределенных моделей.

0x03 Сводка

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