A tradución do artigo preparouse na véspera do comezo do curso
O adestramento distribuído en múltiples instancias informáticas de alto rendemento pode reducir o tempo de adestramento das redes neuronais profundas modernas en grandes cantidades de datos de semanas a horas ou mesmo minutos, o que fai que esta técnica de adestramento prevaleza nas aplicacións prácticas da aprendizaxe profunda. Os usuarios deben comprender como compartir e sincronizar datos en varias instancias, o que á súa vez ten un gran impacto na eficiencia de escalado. Ademais, os usuarios tamén deben saber como implementar un script de adestramento que se executa nunha única instancia en varias instancias.
Neste artigo falaremos dun xeito rápido e sinxelo de distribuír a aprendizaxe mediante a biblioteca aberta de aprendizaxe profunda Apache MXNet e o marco de aprendizaxe distribuído de Horovod. Demostraremos claramente os beneficios de rendemento do framework de Horovod e demostraremos como escribir un script de adestramento MXNet para que funcione de forma distribuída con Horovod.
Que é Apache MXNet
é un marco de aprendizaxe profunda de código aberto que se usa para crear, adestrar e implantar redes neuronais profundas. MXNet abstrae as complexidades asociadas coa implementación de redes neuronais, ten un alto rendemento e escalabilidade e ofrece API para linguaxes de programación populares como , , , , , , e outros.
Formación distribuída en MXNet con servidor de parámetros
utiliza un enfoque de servidor de parámetros. Usa un conxunto de servidores de parámetros para recoller os gradientes de cada traballador, realizar a agregación e enviar os gradientes actualizados aos traballadores para a seguinte iteración de optimización. Determinar a proporción correcta de servidores e traballadores é a clave para un escalado efectivo. Se só hai un servidor de parámetros, pode resultar un pescozo de botella nos cálculos. Pola contra, se se usan demasiados servidores, a comunicación de moitos a moitos pode obstruír todas as conexións de rede.
Que é Horovod
é un marco de aprendizaxe profundo distribuído aberto desenvolvido en Uber. Aproveita tecnoloxías eficientes entre GPU e entre nodos, como a biblioteca de comunicacións colectivas de NVIDIA (NCCL) e a interface de paso de mensaxes (MPI) para distribuír e agregar parámetros do modelo en vorecs. Optimiza o uso do ancho de banda da rede e escala ben cando se traballa con modelos de redes neuronais profundas. Actualmente admite varios marcos populares de aprendizaxe automática, a saber , Tensorflow, Keras e PyTorch.
Integración MXNet e Horovod
MXNet intégrase con Horovod a través das API de aprendizaxe distribuída definidas en Horovod. API de comunicación de Horovod horovod.broadcast(), horovod.allgather() и horovod.allreduce() implementado mediante devolucións de chamada asíncronas do motor MXNet, como parte do seu gráfico de tarefas. Deste xeito, o motor MXNet xestiona facilmente as dependencias de datos entre a comunicación e a computación para evitar perdas de rendemento debido á sincronización. Obxecto optimizador distribuído definido en Horovod horovod.DistributedOptimizer expande Optimizador en MXNet para que chame ás correspondentes API de Horovod para as actualizacións de parámetros distribuídas. Todos estes detalles de implementación son transparentes para os usuarios finais.
Inicio rápido
Podes comezar rapidamente a adestrar unha pequena rede neuronal convolucional no conxunto de datos MNIST usando MXNet e Horovod no teu MacBook.
Primeiro, instala mxnet e horovod desde PyPI:
pip install mxnet
pip install horovodNota: se atopa un erro durante pip instalar horovodquizais necesites engadir unha variable MACOSX_DEPLOYMENT_TARGET=10.vvonde vv – esta é a versión da túa versión de MacOS, por exemplo, para MacOSX Sierra terás que escribir MACOSX_DEPLOYMENT_TARGET=10.12 pip install horovod
Despois instala OpenMPI .
Ao final, descarga o script de proba mxnet_mnist.py e executa os seguintes comandos no terminal MacBook no directorio de traballo:
mpirun -np 2 -H localhost:2 -bind-to none -map-by slot python mxnet_mnist.pyIsto executará o adestramento en dous núcleos do teu procesador. A saída será a seguinte:
INFO:root:Epoch[0] Batch [0-50] Speed: 2248.71 samples/sec accuracy=0.583640
INFO:root:Epoch[0] Batch [50-100] Speed: 2273.89 samples/sec accuracy=0.882812
INFO:root:Epoch[0] Batch [50-100] Speed: 2273.39 samples/sec accuracy=0.870000Demo de performance
Cando se adestra un modelo ResNet50-v1 nun conxunto de datos ImageNet en 64 GPU con oito instancias p3.16xgrande EC2, cada unha con 8 GPU NVIDIA Tesla V100 na nube de AWS, conseguimos un rendemento de adestramento de 45000 imaxes/seg (é dicir, o número de mostras adestradas por segundo). Adestramento completo en 44 minutos despois de 90 épocas cunha mellor precisión do 75.7%.
Comparamos isto co enfoque de adestramento distribuído de MXNet de usar servidores de parámetros en 8, 16, 32 e 64 GPU cun único servidor de parámetros e unha relación de servidor a traballador de 1 a 1 e 2 a 1, respectivamente. Podes ver o resultado na Figura 1 a continuación. No eixe Y da esquerda, as barras representan o número de imaxes para adestrar por segundo, as liñas reflicten a eficiencia de escala (é dicir, a relación entre o rendemento real e ideal) no eixe Y da dereita. Como podes ver, a elección do número de servidores afecta a eficiencia de escalado. Se só hai un servidor de parámetros, a eficiencia de escalado cae ata o 38 % en 64 GPU. Para conseguir a mesma eficiencia de escalado que con Horovod, cómpre duplicar o número de servidores en relación ao número de traballadores.
Figura 1. Comparación da aprendizaxe distribuída usando MXNet con Horovod e co servidor de parámetros
Na táboa 1 a continuación, comparamos o custo final por instancia cando se realizan experimentos en 64 GPU. Usar MXNet con Horovod proporciona o mellor rendemento ao menor custo.
Táboa 1. Comparación de custos entre Horovod e Parameter Server cunha relación servidor/traballador de 2 a 1.
Pasos para reproducir
Nos próximos pasos, mostrarémosche como reproducir o resultado do adestramento distribuído usando MXNet e Horovod. Para obter máis información sobre a aprendizaxe distribuída con MXNet, lea .
Paso 1
Crea un clúster de instancias homoxéneas con MXNet versión 1.4.0 ou superior e Horovod versión 0.16.0 ou superior para usar a aprendizaxe distribuída. Tamén terás que instalar bibliotecas para o adestramento da GPU. Para os nosos casos, escollemos Ubuntu 16.04 Linux, con GPU Driver 396.44, CUDA 9.2, biblioteca cuDNN 7.2.1, comunicador NCCL 2.2.13 e OpenMPI 3.1.1. Tamén podes usar , onde estas bibliotecas xa están preinstaladas.
Paso 2
Engade a posibilidade de traballar coa API de Horovod ao teu script de adestramento MXNet. O seguinte script baseado na API MXNet Gluon pódese usar como un modelo sinxelo. As liñas en negra son necesarias se xa tes un guión de adestramento correspondente. Aquí tes algúns cambios críticos que debes facer para aprender con Horovod:
- Establece o contexto segundo o rango de Horovod local (liña 8) para entender que o adestramento se realiza no núcleo gráfico correcto.
- Pasa os parámetros iniciais dun traballador a todos (liña 18) para garantir que todos os traballadores comezan cos mesmos parámetros iniciais.
- Crea un Horovod DistributedOptimizer (liña 25) para actualizar os parámetros de forma distribuída.
Para obter o script completo, consulte os exemplos de Horovod-MXNet и .
1 import mxnet as mx
2 import horovod.mxnet as hvd
3
4 # Horovod: initialize Horovod
5 hvd.init()
6
7 # Horovod: pin a GPU to be used to local rank
8 context = mx.gpu(hvd.local_rank())
9
10 # Build model
11 model = ...
12
13 # Initialize parameters
14 model.initialize(initializer, ctx=context)
15 params = model.collect_params()
16
17 # Horovod: broadcast parameters
18 hvd.broadcast_parameters(params, root_rank=0)
19
20 # Create optimizer
21 optimizer_params = ...
22 opt = mx.optimizer.create('sgd', **optimizer_params)
23
24 # Horovod: wrap optimizer with DistributedOptimizer
25 opt = hvd.DistributedOptimizer(opt)
26
27 # Create trainer and loss function
28 trainer = mx.gluon.Trainer(params, opt, kvstore=None)
29 loss_fn = ...
30
31 # Train model
32 for epoch in range(num_epoch):
33 ...Paso 3
Inicie sesión nun dos traballadores para comezar a impartir formación mediante a directiva MPI. Neste exemplo, o adestramento distribuído execútase en catro instancias con 4 GPU cada unha e un total de 16 GPU no clúster. O optimizador de descenso de gradiente estocástico (SGD) empregarase cos seguintes hiperparámetros:
- Tamaño do mini-lote: 256
- taxa de aprendizaxe: 0.1
- Momento: 0.9
- descenso de peso: 0.0001
A medida que pasamos dunha GPU a 64 GPU, escalamos linealmente a taxa de adestramento segundo o número de GPU (de 0,1 para 1 GPU a 6,4 para 64 GPU), mantendo o número de imaxes por GPU en 256 (a partir dun lote de GPU). 256 imaxes para 1 GPU a 16 para 384 GPU). O descenso do peso e os parámetros de impulso cambiaron a medida que aumentaba o número de GPU. Usamos un adestramento de precisión mixto co tipo de datos float64 para o paso adiante e float16 para os gradientes para acelerar os cálculos float32 compatibles coas GPU de NVIDIA Tesla.
$ mpirun -np 16
-H server1:4,server2:4,server3:4,server4:4
-bind-to none -map-by slot
-mca pml ob1 -mca btl ^openib
python mxnet_imagenet_resnet50.pyConclusión
Neste artigo, analizamos un enfoque escalable para o adestramento de modelos distribuídos mediante Apache MXNet e Horovod. Demostramos a eficiencia de escalado e a rendibilidade en comparación co enfoque do servidor de parámetros no conxunto de datos ImageNet no que se adestrou o modelo ResNet50-v1. Tamén incluímos pasos que podes usar para modificar un script existente para executar adestramento multiinstancia usando Horovod.
Se estás comezando a usar MXNet e a aprendizaxe profunda, vai á páxina de instalación primeiro para construír MXNet. Tamén recomendamos encarecidamente a lectura do artigo para comezar.
Se xa traballaches con MXNet e queres probar a aprendizaxe distribuída con Horovod, bótalle un ollo a , constrúeo desde MXNet e siga o exemplo ou .
*O custo calcúlase en función de AWS para instancias EC2
Máis información sobre o curso
Fonte: www.habr.com