ML Space

Запустить процесс обучения

Модели можно обучать следующими способами:

Напрямую из Jupyter Server на выделенных GPU.
С помощью функции client_lib, отправляя задачи на исполнение в регион.
С помощью public API.

В этой инструкции описано, как подготовиться к обучению (шаг 1), и подробно рассмотрено два из перечисленных выше способа обучения: из Jupyter Server и при помощи функции client_lib (шаг 2).

Особенности обучения из Jupyter Server и с помощью client_lib

Шаг 1. Выполните подготовку к обучению

Создайте Jupyter Server или подключитесь к уже существующему.
Выберите среду для обучения модели: Jupyter Notebook или JupyterLab.

JupyterLab существенно обогащает возможности классического Jupyter Notebook, поскольку поддерживает работу одновременно с несколькими ноутбуками, текстовыми файлами, датасетами, терминалами и позволяет упорядочить документы в рабочей области.
Перенесите данные и скрипты для обучения из объектного хранилища S3 в локальное хранилище NFS требуемого региона.

Шаг 2. Обучите модель одним из способов

Способ 1. Обучение из Jupyter Server с GPU

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

Если для работы необходимо установить дополнительные модули Python или обновить существующие, выполните следующий код:
```
pip   install   -- user   < package_name >   ==   < version > 
```
Где:
- package_name — наименование модуля, который предполагается установить;
- version — версия устанавливаемого модуля.
Подробнее об использовании pip — в документации менеджера пакетов.

Подсказка
Если необходимы более новые версии Python и CUDA, создайте нужное окружение с помощью CLI-утилиты ML Space.

Запустите обучение модели.

Для запуска используйте образ, в котором версия tensorflow выше 2.0.0, например jupyter-cuda11.0-tf2.4.0-pt1.7.1-gpu:0.0.82-1.

Пример обучения модели из Jupyter Server c GPU приведен ниже.

from   __future__   import   absolute_import ,   division ,   print_function 

 import   tensorflow   as   tf 
 from   tensorflow.keras   import   Model ,   layers 
 import   numpy   as   np 

 tf . compat . v1 . enable_eager_execution () 

 num_classes   =   10 
 num_features   =   784 

 learning_rate   =   0.1 
 training_steps   =   2000 
 batch_size   =   256 
 display_step   =   100 

 n_hidden_1   =   128 
 n_hidden_2   =   256 

 from   tensorflow.keras.datasets   import   mnist 
 ( x_train ,   y_train ),   ( x_test ,   y_test )   =   mnist . load_data () 
 x_train ,   x_test   =   np . array ( x_train ,   np . float32 ),   np . array ( x_test ,   np . float32 ) 
 x_train ,   x_test   =   x_train . reshape ([ - 1 ,   num_features ]),   x_test . reshape ([ - 1 ,   num_features ]) 
 x_train ,   x_test   =   x_train   /   255. ,   x_test   /   255. 

 train_data   =   tf . data . Dataset . from_tensor_slices (( x_train ,   y_train )) 
 train_data   =   train_data . repeat () . shuffle ( 5000 ) . batch ( batch_size ) . prefetch ( 1 ) 

 class   NeuralNet ( Model ): 
    def   __init__ ( self ): 
       super ( NeuralNet ,   self ) . __init__ () 
       self . fc1   =   layers . Dense ( n_hidden_1 ,   activation = tf . nn . relu ) 
       self . fc2   =   layers . Dense ( n_hidden_2 ,   activation = tf . nn . relu ) 
       self . out   =   layers . Dense ( num_classes ) 

    def   call ( self ,   x ,   is_training = False ): 
       x   =   self . fc1 ( x ) 
       x   =   self . fc2 ( x ) 
       x   =   self . out ( x ) 
       if   not   is_training : 
             x   =   tf . nn . softmax ( x ) 
       return   x 

 neural_net   =   NeuralNet () 

 def   cross_entropy_loss ( x ,   y ): 
    y   =   tf . cast ( y ,   tf . int64 ) 
    loss   =   tf . nn . sparse_softmax_cross_entropy_with_logits ( labels = y ,   logits = x ) 
    return   tf . reduce_mean ( loss ) 

 def   accuracy ( y_pred ,   y_true ): 
    correct_prediction   =   tf . equal ( tf . argmax ( y_pred ,   1 ),   tf . cast ( y_true ,   tf . int64 )) 
    return   tf . reduce_mean ( tf . cast ( correct_prediction ,   tf . float32 ),   axis =- 1 ) 

 optimizer   =   tf . keras . optimizers . SGD ( learning_rate ) 

 def   run_optimization ( x ,   y ): 
    with   tf . GradientTape ()   as   g : 
       pred   =   neural_net ( x ,   is_training = True ) 
       loss   =   cross_entropy_loss ( pred ,   y ) 
    trainable_variables   =   neural_net . trainable_variables 
    gradients   =   g . gradient ( loss ,   trainable_variables ) 
    optimizer . apply_gradients ( zip ( gradients ,   trainable_variables )) 

 for   step ,   ( batch_x ,   batch_y )   in   enumerate ( train_data . take ( training_steps ),   1 ): 
    run_optimization ( batch_x ,   batch_y ) 

    if   step   %   display_step   ==   0 : 
       pred   =   neural_net ( batch_x ,   is_training = True ) 
       loss   =   cross_entropy_loss ( pred ,   batch_y ) 
       acc   =   accuracy ( pred ,   batch_y ) 
       print ( "step:  %i , loss:  %f , accuracy:  %f "   %   ( step ,   loss ,   acc )) 

 pred   =   neural_net ( x_test ,   is_training = False ) 
 print ( "Test Accuracy:  %f "   %   accuracy ( pred ,   y_test )) 

Другие примеры обучения моделей приведены на Github.

Способ 2. Обучение с помощью client_lib

Соберите кастомный образ с необходимыми библиотеками с помощью функции client_lib. Используйте описание параметров ImageBuildJob.

Ниже представлен пример, как дополнить базовый образ cr.ai.cloud.ru/aicloud-base-images/horovod-cuda10.0-tf1.15.0-pt1.3.0 нужными зависимостями. Обратите внимание на то, что путь к файлу с зависимостями указывается полностью.
```
job   =   client_lib . ImageBuildJob ( 
                      from_image = 'cr.ai.cloud.ru/aicloud-base-images/horovod-cuda10.0-tf1.15.0-pt1.3.0' ,     # Base image 
                      requirements_file = '/home/jovyan/quick-start/job_launch/requirements.txt'      # File with dependencies for custom image 
 ) 
```
Файл requirements.txt должен находиться на NFS-хранилище Christofari.V100.

Для запуска сборки кастомного образа выполните:
```
job . submit () 
 job . new_image       # id of the custom image 
```
Подсказка
Посмотреть логи сборки образа в интерактивном режиме можно с помощью команды:
job . logs ()
Создайте задачу обучения с помощью client_lib. Используйте описание параметров Job.

Ниже приведено несколько примеров создания задач с помощью Job().

Пример 1. Задача обучения модели с использованием базового образа

В этом примере обязательный параметр base_image указывает на базовый образ или кастомный образ, загруженный в Docker registry, script — на скрипт, который запустится.

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

Подсказка
Для получения значения instance_type воспользуйтесь инструкцией.
```
mnist_tf_run   =   client_lib . Job ( base_image = 'cr.ai.cloud.ru/aicloud-base-images/horovod-cuda10.0-tf1.15.0-pt1.3.0:0.0.31' , 
                               script = '/home/jovyan/quick-start/job_launch/scripts/horovod/tensorflow_mnist_estimator.py' , 
                               instance_type = 'your instance_type' , 
                               job_desc = 'your_job_description' ) 
```
Дополнительный параметр processes_per_worker задает количество процессов на один рабочий узел региона, если не подходит количество процессов, равное количеству GPU.
```
job   =   Job ( base_image = 'cr.ai.cloud.ru/aicloud-base-images/horovod-cuda10.0-tf1.15.0-pt1.3.0' , 
          script = '/home/jovyan/my-script.py' , 
          n_workers   =   1 , 
          region   =   A100 - MT , 
          instance_type   =   a100 .1 gpu ,        # 1 GPU Tesla A100 80GB, 16 CPU-cores, 243 GB RAM 
          processes_per_worker   =   1 ,      # Start one process 
          type   =   'horovod' ) 
```
Примечание
Распределенное обучение запускается с помощью скрипта обучения, использующего библиотеку Horovod. Если вы не работали с данной библиотекой, ознакомьтесь c документацией, а также с примером использования.

Пример 2. Задача обучения модели с использованием базового образа и дополнительных библиотек
```
mnist_tf_run   =   client_lib . Job ( base_image = job . new_image ,       # Built custom image 
                               script = '/home/jovyan/quick-start/job_launch/scripts/horovod/tensorflow_mnist_estimator.py' , 
                               instance_type = 'your instance_type' , 
                               n_workers = 2 ) 
```
Подсказка
Внутри кода задачи обучения также можно сохранять метрики модели с помощью MLflow. Подробнее в примере на GitHub.

Пример 3. Задача кросс-компиляции с использованием образов ML Space

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

 binary_run   =   client_lib . Job ( 
 base_image = "cr.ai.cloud.ru/aicloud-base-images/horovod-cuda10.1-tf2.2.0-pt1.5.0" , 
 script = '/home/jovyan/NSC/mpi_omp_test' , 
 n_workers   =   2 , 
 instance_type   =   v100 .16 gpu , 
 type   =   'binary' 
 ) 

 binary_run . submit () 

 binary_run . logs () 

 binary_run . kill () 
```
Можно собрать бинарный файл mm из примера с GitHub. Для этого используется код:
```
git   clone   https : // github . com / hpc / MPI - Examples . git 
 cd   ~/ MPI - Examples / matrix - multipy 
 make   linux 
 ./ test . sh 
```
Отправьте задачу обучения на исполнение в регион, вызвав команду submit():
```
mnist_tf_run . submit () 
```
Вы увидите сообщение о том, что задача создана:
```
Job   'lm-mpi-job-7a7aa4e0-8a8c-46a3-96fa-7116cc392336'   created 
```

Шаг 3. Проверьте логи задачи

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

Примечание

Логи отображаются для задач в статусе «Running» и «Completed».

Чтобы скачать логи задачи из интерфейса:

На вкладке Задачи и окружения → Задачи нажмите рядом с нужной задачей.
Выберите Скачать логи.

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

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

Отслеживать статус задачи обучения

Отслеживать статус задачи обучения можно:

Во вкладке Задачи и окружения.

Примечание
Для аллокаций отображается очередь выполнения задач.
С помощью status(), используя client_lib.

Остановить задачу обучения

При необходимости задачу обучения можно остановить в любой момент методом kill().

Внимание

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

mnist_tf_run . kill () 

Или так:

client_lib . kill ( 'lm-mpi-job-7a7aa4e0-8a8c-46a3-96fa-7116cc392336' )        # For region V100 

client_lib . kill ( < job   name > ,   region   =   'A100' )      # For region A100 

Подсказка

Остановить задачу также можно из интерфейса, нажав Остановить на вкладке Задачи и окружения → Задачи.

Перезапустить задачу

Для перезапуска задачи вручную:

Перейдите в Environments → Задачи и окружения.
В строке с нужной задачей нажмите (Перезапустить).

Другой способ — перейти в нужную задачу и нажать (Перезапустить).
При необходимости предварительно скопируйте или скачайте параметры запуска задачи и нажмите Перезапустить.

Примечание
Если перезапускается уже запущенная задача, то сначала она будет остановлена. Затем создастся новая задача с такими же параметрами, как у родительской.
Перезапуск может занять до 20 минут.

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

Обучение моделей на большом количестве GPU

Количество рабочих узлов определяется параметром n_workers. Максимальное количество GPU на одном рабочем узле — 16 (для Christofari.V100) и 8 (для Christofari.A100).

Если пользователь указал, что для обучения ему необходим один рабочий узел региона на 16 GPU, под задачу аллоцируется один DGX. Чем больше GPU требуется пользователю для обучения модели, тем выше вероятность того, что вычислительных ресурсов может не хватить. На практике эта ситуация возникает, если задано количество GPU от 64 до 128. В результате планировщик (scheduler) ставит задачу в очередь исполнения, и она может достаточно долго находиться в статусе «Pending».

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

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

Объем оперативной памяти может уменьшиться также из-за того, что исходные данные превысили ее лимит, который выделен на обучение. Например, датасет разбит на множество csv-файлов, метаинформация о которых содержится в одном файле верхнего уровня. Память заканчивается, когда вы пытаетесь «склеить» данные в один файл. Или еще одна ситуация, когда датасет включает несколько миллионов изображений, а пути к этим изображениям передаются как списки (list).

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

См.также

Была ли статья полезной ?

Предыдущая статья

Установить библиотеки из Git-репозитория

Следующая статья

Обучить модель с использованием PyTorch Elastic Learning