Обучайте гигантские модели с почти линейным масштабированием, используя параллелизм сегментированных данных в Amazon SageMaker.

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

Вот почему мы недавно запустили sжесткий параллелизм данных on Создатель мудреца Амазонки, новая методика распределенного обучения с экономией памяти в Библиотека параллельных моделей SageMaker (SMP). Параллелизм разделенных данных специально разработан для моделей экстремального масштаба и использует собственные ресурсы Amazon. МиКС технология под капотом, научные усилия по минимизации масштабов связи за счет снижения дорогостоящих накладных расходов на связь, основанных на сборе параметров и синхронизации градиентов. С моделью GPT-30 с параметром 2B и длиной последовательности 2048 эта новая функция достигла 141 TFLOP, что на 39.7% больше по сравнению с DeepSpeed ​​ZeRO-3. Для модели 10B GPT-2 с длиной последовательности 512 эта новая функция также достигла 564 выборок в секунду, что на 13.9% больше, чем у PyTorch Fully Sharded Data Parallel (FSDP). Помните, что при обучении гигантской модели каждый процент ускорения означает сэкономленные доллары и повышение производительности вашей команды.

В этом сообщении блога мы сначала подробно рассмотрим ключевые отличия параллелизма сегментированных данных и когда его использовать. Затем вы узнаете, как легко обучить модель GPT-30 с параметрами 2 Б в SageMaker с помощью этой новой функции. Наконец, мы сравним производительность с другими вариантами с открытым исходным кодом, в частности, превосходя DeepSpeed ​​ZeRO на 39.7% на 256 графических процессорах.

Как работает параллелизм сегментированных данных и когда его использовать

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

В существующих фреймворках, подпадающих под эту парадигму, в частности, DeepSpeed ​​ZeRO-3 и FSDP PyTorch, вышестоящих из FairScale, состояния модели разделяются на части. Найти Графические процессоры — стратегия, которая снижает потребление памяти на каждом графическом процессоре за счет больших накладных расходов на связь, которые увеличиваются с размером кластера и, следовательно, приводят к значительному снижению масштабируемости при масштабировании. Напротив, параллелизм сегментированных данных в библиотеке SMP разделяет состояния модели в с учетом масштаба путем разделения каждой реплики состояний модели только в пределах подмножество графических процессоров.

Давайте посмотрим поближе на разбиение модели с учетом масштаба в MiCS, основной технологии, лежащей в основе параллелизма сегментированных данных. Интуиция, стоящая за этой схемой, заключается в том, что разделение состояний обучения по всей группе параллельных данных может не потребоваться для обучения модели с десятками миллиардов параметров. Например, 8 графических процессоров V100 (по 32 ГБ каждый) достаточно для хранения реплики состояний модели модели с параметрами 10B, которой требуется около 200 ГБ памяти при обучении оптимизатором Adam с использованием смешанной точности. Ограничивая полную реплику состояний модели в наименьшее подмножество графических процессоров, мы можем эффективно уменьшить масштаб коммуникационных издержек по сравнению с DeepSpeed ​​и PyTorch FSDP. Параллельное разделение данных также использует другие методы MiCS, такие как иерархическая коммуникация и градиентная синхронизация с двумя переходами. Для получения дополнительной информации, проверьте Почти линейное масштабирование обучения гигантской модели на AWS or MiCS: почти линейное масштабирование для обучения гигантской модели в общедоступном облаке.

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

Использование параллелизма сегментированных данных для обучения GPT-2 на Amazon SageMaker

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

1. Начать

Параллелизм разделенных данных доступен в PyTorch v1.12.0+ и работает как с FP16, так и с BF16. Самый простой способ использовать библиотеку SMP — использовать предварительно созданный контейнер глубокого обучения AWS для PyTorch. Однако, если вы хотите использовать свой собственный контейнер Docker, вы можете обратиться к Создайте свой собственный контейнер Docker с помощью параллельной библиотеки распределенных моделей SageMaker. Для начала следуйте Изменить сценарий обучения PyTorch чтобы адаптировать API-интерфейсы SMP к вашему учебному сценарию. В этом разделе мы приводим только несколько основных шагов с фрагментами кода из готового сценария обучения. train_gpt_simple.py. Вы можете следить за комментариями в сценарии и API документ чтобы узнать больше о том, где используются SMP API.

Сначала импортируйте и инициализируйте библиотеку, вызвав smdistributed.modelparallel.torch.init() в начале обучающего скрипта:

import smdistributed.modelparallel.torch as smp

smp.init(smp_config)

Во-вторых, оберните модель, которая будет разделена, с помощью smdistributed.modelparallel.torch.DistributedModel и использовать возвращенный DistributedModel объект движется вперед:

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_config(model_config)
model = smp.DistributedModel(model, trace_device="gpu", backward_passes_per_step=args.gradient_accumulation)

Оберните оптимизатор с smdistributed.modelparallel.torch.DistributedOptimizer для сохранения и загрузки состояний оптимизатора.

from torch import optim

optimizer = optim.Adam(
    param_groups, betas=(args.beta1, args.beta2), lr=args.lr, weight_decay=args.weight_decay
)

optimizer = smp.DistributedOptimizer(
        optimizer, 
        static_loss_scale=None, 
        dynamic_loss_scale=True,
        dynamic_loss_args={"scale_window": 1000, "min_scale": 1, "delayed_shift": 2},
        )

Поместите прямую и обратную логику в ступенчатую функцию и украсьте ее smdistributed.modelparallel.torch.step.  Любое вычисление, определенное внутри smp.step-decorated функция выполняется распределенным образом.

@smp.step
def train_step(model, optimizer, input_ids, attention_mask, args):
    loss = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)["loss"]
    model.backward(loss)

    return loss

@smp.step
def test_step(model, input_ids, attention_mask):
    loss = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)["loss"]
    
    return loss

2. Подготовьте набор данных

Мы используем открытый веб-текст набор данных, который мы используем в этом примере. Блокнот использует скрипт data_prep_512.py для загрузки и предварительной обработки набора данных. Вы также можете тренироваться с другими наборами данных, изменив data_pipeline.py. При работе с большим набором данных и моделью вы можете ускорить задание по обучению, используя данные, хранящиеся в Amazon FSx для блеска, которая обеспечивает высокопроизводительную файловую систему, изначально интегрированную с Простой сервис хранения Amazon (С3). Пожалуйста, ознакомьтесь с инструкциями от Настройте канал ввода данных для использования Amazon FSx для Lustre руководство по настройке файловой системы FSx Lustre в качестве канала ввода данных.

3. Запустите обучающие задания

Этот шаг предполагает, что вы уже изменил ваш сценарий обучения и подготовил набор данных, как упоминалось в предыдущих разделах. К включить параллелизм разделенных данных, просто установите sharded_data_parallel_degree в Оценщик PyTorch. В этом уроке мы устанавливаем sharded_data_parallel_degree=128 и instace_count=32 для узлов p4d.24xlarge, что указывает на то, что состояния модели будут разделены на 128 графических процессоров из общего числа 256 графических процессоров. На основе этого выбранного значения SMP автоматически установит степень параллелизма данных на 2 (поскольку 256/128=2), что означает, что у нас будет две реплики для параллелизма данных. Общее правило выбора идеального значения для sharded_data_parallel_degree заключается в добавлении еще одного узла в группу совместного использования на каждые 3 байта параметров модели. В этом руководстве размер нашей модели составляет 30 байт, поэтому мы должны использовать не менее 10 узлов для сегментирования. А поскольку 16 узлов (128 графических процессоров) — это наименьшая степень двойки выше порогового значения, мы устанавливаем sharded_data_parallel_degree=128.

Для создания контрольных точек мы также предоставляем набор утилит для создания контрольных точек в sharded_data_parallel_checkpoint.py , включая утилиту для восстановления полного state_dict для расширенных вариантов использования. Наконец, мы можем запустить распределенное задание обучения, вызвав метод fit() в Estimator.

smp_estimator = PyTorch(
    entry_point="train_gpt_simple.py",
    instance_type="ml.p4d.24xlarge",
    source_dir=os.getcwd(),
    volume_size=500,
    instance_count=32,
    distribution={
        "mpi": {
            "enabled": True,
            "processes_per_host": processes_per_host,
            "custom_mpi_options": mpioptions,
        },
        "smdistributed": {
            "modelparallel": {
                "enabled": True,
                "parameters": {
                    "ddp": True,
                    "skip_tracing": True,
                    "delayed_parameter_initialization": True,
                    "offload_activations": True,
                    "activation_loading_horizon": 4,
                    # To enable sharded data parallelism.
                    # Here we shard model states across 128 GPUs. 
                    "sharded_data_parallel_degree": 128, 
                    "fp16": False,
                    "bf16": True,
                    # This is to disable pipeline parallelism.
                    "partitions": 1,
                },
            }
        },
    },
    framework_version="1.12",
    py_version="py38",
    hyperparameters=hyperparameters,
    checkpoint_s3_uri=checkpoint_s3_uri if not use_fsx else None,
    checkpoint_local_path=hyperparameters["checkpoint-dir"] if use_fsx else None,
    ...
)

smp_estimator.fit(inputs=data_channels)

4. Следите за учебными заданиями

Вы можете получить доступ к журналам обучения и отслеживать использование графического процессора и памяти на Amazon CloudWatch. Обязательно посмотрите логи «algo-1» потому что это основной узел, в выходном потоке которого есть журналы заданий обучения со всех экземпляров.

Сравнительная производительность

Мы протестировали параллелизм сегментированных данных в библиотеке SMP на 16 и 32 узлах p4d.24xlarge для длины последовательности 512 и 2048 соответственно. Модель GPT30 с параметром 2B настроена на использование скрытой ширины 7168, 48 слоев и 64 головок. Вы можете принять точно такую ​​же конфигурацию, где длина последовательности равна 2048, установив model_config = "gpt2-30b" в учебной тетради. С этой настройкой SMP достиг 73.52 выборки в секунду, что на 39.7% больше по сравнению с DeepSpeed ​​ZeRO-3. Если размер вашего токена составляет 500 миллиардов, это ускорение означает почти 367 часов экономии на узлах p4d.24xlarge, что эквивалентно экономии более 12,000 XNUMX долларов США за обучение! В следующей таблице приведены результаты наших тестов.

1/ Для каждой конфигурации модели мы протестировали различные функции, этапы и конфигурации в DeepSpeed ​​ZeRO и выбрали ту, которая обеспечивает наилучшую пропускную способность, в качестве базовой линии DeepSpeed. Бенчмарк был запущен на Эластичное вычислительное облако Amazon (Амазон ЕС2). 2/ Эти результаты основаны на улучшенных коммуникационных коллективах, оптимизированных для AWS, которые будут доступны в ближайшее время. 3/ Время обучения рассчитывается исходя из скорости в зависимости от количества обработанных токенов.

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

Заключение

В этом посте мы представили новый метод распределенного обучения — параллелизм сегментированных данных — и то, как он ускоряет обучение гигантских моделей с почти линейным масштабированием в Amazon SageMaker. Мы также рассмотрели, как обучить модель GPT-2 с помощью новой техники, следуя этому полный пример. Вы можете следить за Примеры Amazon SageMaker в репозитории GitHub чтобы отслеживать все примеры параллельных моделей SageMaker или посетить нашу следующую распределенные обучающие семинары. Чтобы узнать больше о параллелизме сегментированных данных, см. документации.

Об авторах

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

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

Рахул Хуилгол является старшим инженером-программистом в AWS. Он работает над распределенными системами глубокого обучения, стремясь упростить и повысить эффективность обучения больших моделей глубокого обучения в облаке. В свободное время он увлекается фотографией, ездой на велосипеде и садоводством.

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

Эрин Хо является менеджером по продукту AWS Deep Learning. Она работает над продуктами, упрощающими клиентам обучение моделей глубокого обучения на AWS. Для развлечения вне работы она любит пешие прогулки и катание на лыжах.