Повышение скорости контрольных точек и снижение затрат с помощью туманности

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

Обзор

Nebula — это быстрое, простое средство контрольных точек с поддержкой модели без дисков в контейнере Azure для PyTorch (ACPT). Nebula предлагает простое решение для контрольных точек с высокой скоростью для распределенных крупномасштабных заданий обучения моделей с помощью PyTorch. Используя новейшие распределенные вычислительные технологии, Nebula может сократить время контрольных точек с часов до секунд - потенциально экономия 95% до 99,9% времени. Крупномасштабные учебные задания могут значительно воспользоваться производительностью Nebula.

Чтобы сделать Nebula доступными для заданий обучения, импортируйте nebulaml пакет Python в скрипте. Nebula имеет полную совместимость с различными распределенными стратегиями обучения PyTorch, включая PyTorch Lightning, DeepSpeed и многое другое. API Nebula предлагает простой способ мониторинга и просмотра жизненных циклов контрольных точек. API поддерживают различные типы моделей и обеспечивают согласованность контрольных точек и надежность.

Внимание

Пакет nebulaml недоступен в общедоступном индексе пакета PyPI python. Он доступен только в курированной среде Контейнера Azure для PyTorch (ACPT) на Машинное обучение Azure. Чтобы избежать проблем, не пытайтесь установить nebulaml из PyPI или с помощью pip команды.

В этом документе вы узнаете, как использовать Nebula с ACPT на Машинное обучение Azure для быстрой контрольной точки заданий обучения модели. Кроме того, вы узнаете, как просматривать данные контрольной точки Nebula и управлять ими. Вы также узнаете, как возобновить задания обучения модели из последней доступной контрольной точки, если есть прерывание, сбой или завершение Машинное обучение Azure.

Почему оптимизация контрольных точек для обучения больших моделей имеет важное значение

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

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

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

Однако процесс сохранения контрольных точек может привести к значительным издержкам. Сохранение контрольной точки размера ТБ часто может стать узким местом в процессе обучения, при этом синхронизированный процесс контрольной точки блокирует обучение в течение нескольких часов. В среднем накладные расходы, связанные с контрольными точками, могут учитывать 12% общего времени обучения и могут увеличиваться до 43% (Maeng et al., 2021).

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

Туманность для спасения

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

С помощью Nebula вы можете:

• Повышение скорости контрольных точек до 1000 раз с помощью простого API, который работает асинхронно с процессом обучения. Небула может сократить время контрольных точек с часов до секунд - потенциальное сокращение до 95% до 99%.

  

  В этом примере показана контрольная точка и комплексное сокращение времени обучения для четырех контрольных точек с сохранением заданий обучения Hugging Face GPT2, GPT2-Large и GPT-XL. Для средних размеров контрольных точек Hugging Face GPT2-XL экономит (20,6 ГБ), Небула достигла сокращения времени на 96,9 % для одной контрольной точки.

  Увеличение скорости контрольной точки по-прежнему может увеличиваться с размером модели и номерами GPU. Например, тестирование контрольной точки обучения с сохранением 97 ГБ на 128 A100 GPU NVIDIA может сократиться с 20 минут до 1 секунды.

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

• Обеспечение полной совместимости с PyTorch. Nebula обеспечивает полную совместимость с PyTorch и обеспечивает полную интеграцию с распределенными платформами обучения, включая DeepSpeed (=0.7.3) и PyTorch Lightning (>>=1.5.0). Его также можно использовать с различными целевыми объектами вычислений Машинное обучение Azure, например Машинное обучение Azure вычислений или AKS.

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

  • Хранилище BLOB-объектов Azure
  • Azure Data Lake Storage
  • NFS

  и доступ к ним в любое время с помощью нескольких строк кода.

Необходимые компоненты

• Подписка Azure и рабочая область Машинное обучение Azure. Дополнительные сведения о создании ресурсов рабочей области см. в статье "Создание ресурсов рабочей области"
• Целевой объект вычислений Машинное обучение Azure. Дополнительные сведения о создании целевого объекта вычислений см. в статье "Управление обучением и развертыванием вычислений"
• Сценарий обучения, использующий PyTorch.
• Среда ACPT-curated (контейнер Azure для PyTorch). Сведения о получении изображения ACPT см . в курированных средах . Узнайте, как использовать курированную среду

Использование nebula

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

• Использование среды ACPT
• Инициализация Nebula
• Вызов API для сохранения и загрузки контрольных точек

Использование среды ACPT

Контейнер Azure для PyTorch (ACPT), курированная среда для обучения модели PyTorch, включает Nebula в качестве предварительно установленного пакета Python. Дополнительные сведения о образе ACPT см. в контейнере Azure для PyTorch (ACPT), чтобы просмотреть курированную среду и включить глубокое обучение с помощью контейнера Azure для PyTorch в Машинное обучение Azure.

Инициализация Nebula

Чтобы включить Nebula с средой ACPT, необходимо только изменить скрипт обучения для импорта nebulaml пакета, а затем вызвать API Nebula в соответствующих местах. Вы можете избежать изменения пакета SDK или CLI Машинное обучение Azure. Вы также можете избежать изменения других шагов для обучения большой модели на платформе Машинное обучение Azure.

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

  import nebulaml as nm
  nm.init(persistent_storage_path=<YOUR STORAGE PATH>) # initialize Nebula

Nebula интегрирована в DeepSpeed и PyTorch Lightning. В результате инициализация становится простой и легкой. В этих примерах показано, как интегрировать Nebula в сценарии обучения.

Внимание

Сохранение контрольных точек с помощью Nebula требует некоторой памяти для хранения контрольных точек. Убедитесь, что память больше трех копий контрольных точек.

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

Если несколько процессов выполняются на одном узле, максимальный объем памяти для сохранения контрольных точек будет составлять половину ограничения, разделенного на количество процессов. Небула будет использовать другую половину для координации с несколькими процессами. Например, если вы хотите ограничить использование памяти на каждом узле до 200 МБ, можно задать переменную среды как export NEBULA_MEMORY_BUFFER_SIZE=200000000 (в байтах около 200 МБ) в команде. В этом случае Nebula будет использовать только 200 МБ памяти для хранения контрольных точек на каждом узле. Если на одном узле запущено 4 процесса, nebula будет использовать 25 МБ памяти для каждого процесса для хранения контрольных точек.

Вызов API для сохранения и загрузки контрольных точек

Nebula предоставляет API для обработки сохранения контрольных точек. Эти API можно использовать в скриптах обучения, аналогичных API PyTorch torch.save() . В этих примерах показано, как использовать Nebula в сценариях обучения.

Просмотр историй контрольных точек

Когда задание обучения завершится, перейдите в область задания Name> Outputs + logs . На левой панели разверните папку Nebula и выберитеcheckpointHistories.csv, чтобы просмотреть подробные сведения о экономии контрольных точек Nebula — длительность, пропускная способность и размер контрольных точек.

Примеры

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

Использование PyTorch natively

Чтобы включить полную совместимость Nebula с скриптами обучения на основе PyTorch, измените сценарий обучения по мере необходимости.

1. Сначала импортируйте необходимый nebulaml пакет:

     # Import the Nebula package for fast-checkpointing 
     import nebulaml as nm
   

2. Чтобы инициализировать Nebula, вызовите функцию nm.init() , main()как показано ниже:

     # Initialize Nebula with variables that helps Nebula to know where and how often to save your checkpoints
     persistent_storage_path="/tmp/test",
     nm.init(persistent_storage_path, persistent_time_interval=2)
   

3. Чтобы сохранить контрольные точки, замените исходную torch.save() инструкцию, чтобы сохранить контрольную точку с помощью Nebula. Убедитесь, что экземпляр контрольной точки начинается с "global_step", например "global_step500" или "global_step1000":

   checkpoint = nm.Checkpoint('global_step500')  
   checkpoint.save('<CKPT_NAME>', model)  
   

   Примечание.

   <'CKPT_TAG_NAME'> — уникальный идентификатор контрольной точки. Тег обычно является числом шагов, номером эпохи или любым определяемым пользователем именем. Необязательный необязательный <'NUM_OF_FILES'> параметр указывает номер состояния, который будет сохранен для этого тега.

4. Загрузите последнюю допустимую контрольную точку, как показано здесь:

   latest_ckpt = nm.get_latest_checkpoint()
   p0 = latest_ckpt.load(<'CKPT_NAME'>)
   

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

   Другие API могут обрабатывать управление контрольными точками

   • список всех контрольных точек
   • получение последних контрольных точек

   # Managing checkpoints
   ## List all checkpoints
   ckpts = nm.list_checkpoints()
   ## Get Latest checkpoint path
   latest_ckpt_path = nm.get_latest_checkpoint_path("checkpoint", persisted_storage_path)
   

Использование DeepSpeed

Скрипт обучения на основе DeepSpeed (>=0.7.3) может использовать Nebula, если включить Nebula в ds_config.json файле конфигурации, как показано ниже.

"nebula": {
      "enabled": true,
      "persistent_storage_path": "<YOUR STORAGE PATH>",
      "persistent_time_interval": 100,
      "num_of_version_in_retention": 2,
      "enable_nebula_load": true
  }

Эта функция фрагментов JSON работает как nebulaml.init() функция.

Инициализация с ds_config.json конфигурацией файла включает Nebula, которая включает сохранение контрольных точек в свою очередь. Исходный метод сохранения DeepSpeed с API model_engine.save_checkpoint()контрольной точки модели автоматически использует Nebula. Этот метод сохранения позволяет избежать необходимости изменения кода.

Использование PyTorch Lightning

PyTorch Lightning (Nebula поддерживает контрольные точки = >1.5.0) автоматически при использовании тренера. Так как часто можно сохранять контрольные точки с настраиваемыми поведениями для точного управления, PyTorch Lightning предоставляет два способа сохранения контрольных точек: условные сохранения с ModelCheckpoint()помощью, а также ручное сохранение с trainer.save_checkpoint()помощью. Эти методы применяются к скриптам обучения PyTorch (>=0.15.0).

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

# import Nebula package
import nebulaml as nm

# define NebulaCallback
config_params = dict()
config_params["persistent_storage_path"] = "<YOUR STORAGE PATH>"
config_params["persistent_time_interval"] = 10

nebula_checkpoint_callback = nm.NebulaCallback(
   ****, # Original ModelCheckpoint params
   config_params=config_params, # customize the config of init nebula
)

Затем добавьте nm.NebulaCheckpointIO() в качестве Trainerподключаемого модуля и измените trainer.save_checkpoint() параметры хранилища, как показано ниже.

trainer = Trainer(plugins=[nm.NebulaCheckpointIO()],   # add NebulaCheckpointIO as a plugin
                  callbacks=[nebula_checkpoint_callback]) # use NebulaCallback as a plugin

Если вы используете trainer.save_checkpoint() для сохранения контрольных точек вручную, вы можете использовать подключаемый NebulaCheckpointIO модуль в вашем модуле Trainerи изменить параметры хранилища следующим trainer.save_checkpoint() образом:

# import Nebula package
import nebulaml as nm

# initialize Nebula
nm.init(persistent_storage_path=<YOUR STORAGE PATH>) 

trainer = Trainer(plugins=[nm.NebulaCheckpointIO()])  # add NebulaCheckpointIO as a plugin

# Saving checkpoints
storage_options = {}
storage_options['is_best'] = True
storage_options['persist_path'] = "/tmp/tier3/checkpoint"

trainer.save_checkpoint("example.ckpt",
  storage_options=storage_options, # customize the config of Nebula saving checkpoint
)

Загрузка контрольной точки

Мы загружаем контрольные точки в соответствии с PyTorch и PyTorch Lightning. Единственное изменение указывает путь к хранилищу.

Чтобы загрузить последнюю контрольную точку, MyLightningModule.load_from_checkpoint() по-прежнему работает, как показано ниже.

  persistent_path = "/tmp/tier3/checkpoint"
  latest_ckpt_path = nebulaml.get_latest_checkpoint_path("checkpoint", persist_path)
  model = MyLightningModule.load_from_checkpoint(latest_ckpt_path)

Если вы использовались nebula_checkpoint_callback в вашем Trainer()исходном скрипте без изменений, как показано ниже, по-прежнему работает:

  trainer = Trainer(
      default_root_dir=tmpdir, 
      max_steps=100,
      plugins=[NebulaCheckpointIO()],
      callbacks=[nebula_checkpoint_callback],
  )
  trainer.fit(model, ckpt_path="/path/example.ckpt")

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

• Отслеживание экспериментов и моделей машинного обучения с помощью MLflow
• Ведение журнала и просмотр метрик