Բաշխված ուսուցում Apache MXNet-ի և Horovod-ի հետ

Հոդվածի թարգմանությունը պատրաստվել է դասընթացի մեկնարկի նախօրեին «Արդյունաբերական ML մեծ տվյալների վրա»

Բաշխված թրեյնինգը մի քանի բարձր արդյունավետությամբ հաշվողական օրինակների վրա կարող է նվազեցնել ժամանակակից խորը նյարդային ցանցերի վերապատրաստման ժամանակը մեծ քանակությամբ տվյալների վրա շաբաթներից մինչև ժամեր կամ նույնիսկ րոպեներ՝ դարձնելով այս վերապատրաստման տեխնիկան տարածված խորը ուսուցման գործնական կիրառություններում: Օգտագործողները պետք է հասկանան, թե ինչպես կարելի է համօգտագործել և համաժամեցնել տվյալները մի քանի օրինակների միջև, ինչն իր հերթին մեծ ազդեցություն ունի մասշտաբավորման արդյունավետության վրա: Բացի այդ, օգտատերերը պետք է նաև իմանան, թե ինչպես տեղադրել ուսուցման սկրիպտը, որն աշխատում է մեկ օրինակով մի քանի օրինակների վրա:

Այս հոդվածում մենք կխոսենք ուսուցումը բաշխելու արագ և հեշտ եղանակի մասին՝ օգտագործելով Apache MXNet բաց խորը ուսուցման գրադարանը և Horovod-ի բաշխված ուսուցման շրջանակը: Մենք հստակ ցույց կտանք Horovod Framework-ի կատարողական առավելությունները և ցույց կտանք, թե ինչպես գրել MXNet ուսուցման սցենար, որպեսզի այն աշխատի բաշխված ձևով Horovod-ի հետ:

Ինչ է Apache MXNet-ը

Apache MX Net բաց կոդով խորը ուսուցման շրջանակ է, որն օգտագործվում է խորը նեյրոնային ցանցեր ստեղծելու, վարժեցնելու և տեղակայելու համար: MXNet-ը վերացում է նեյրոնային ցանցերի ներդրման հետ կապված բարդությունները, բարձր կատարողական է և մասշտաբային, և առաջարկում է API-ներ հայտնի ծրագրավորման լեզուների համար, ինչպիսիք են. Python, C ++, Clojure, Java, Julia, R, Scala եւ այլն:

Բաշխված ուսուցում MXNet-ում պարամետրային սերվերով

Ստանդարտ բաշխված ուսուցման մոդուլ MXNet-ում օգտագործում է պարամետրային սերվերի մոտեցում: Այն օգտագործում է պարամետրային սերվերների մի շարք՝ յուրաքանչյուր աշխատողից գրադիենտներ հավաքելու, ագրեգացիա կատարելու և թարմացված գրադիենտներ ուղարկելու համար աշխատողներին հաջորդ օպտիմալացման կրկնության համար: Սերվերների և աշխատողների ճիշտ հարաբերակցության որոշումը արդյունավետ մասշտաբավորման բանալին է: Եթե ​​կա միայն մեկ պարամետրային սերվեր, ապա այն կարող է հայտնվել հաշվարկների մեջ խոչընդոտ: Եվ հակառակը, եթե օգտագործվում են շատ սերվերներ, շատ-շատերի միջև հաղորդակցությունը կարող է խցանել բոլոր ցանցային կապերը:

Ինչ է Հորովոդը

Հորովոդ բաց բաշխված խորը ուսուցման շրջանակ է, որը մշակվել է Uber-ում: Այն օգտագործում է արդյունավետ cross-GPU և cross-node տեխնոլոգիաներ, ինչպիսիք են NVIDIA Collective Communications Library (NCCL) և Message Passing Interface (MPI)՝ մոդելի պարամետրերը vorecs-ում բաշխելու և համախմբելու համար: Այն օպտիմիզացնում է ցանցի թողունակության օգտագործումը և լավ սանդղակում է խորը նեյրոնային ցանցի մոդելների հետ աշխատելիս: Այն ներկայումս աջակցում է մի քանի հայտնի մեքենայական ուսուցման շրջանակներ, մասնավորապես MX Net, Tensorflow, Keras և PyTorch:

MXNet և Horovod ինտեգրում

MXNet-ը ինտեգրվում է Horovod-ի հետ Horovod-ում սահմանված Distributed Learning API-ների միջոցով: Horovod կապի API-ներ horovod.broadcast(), horovod.allgather() и horovod.allreduce() իրականացվում է MXNet շարժիչի ասինխրոն հետադարձ զանգերի միջոցով՝ որպես իր առաջադրանքների գրաֆիկի մաս: Այս կերպ հաղորդակցության և հաշվարկի միջև տվյալների կախվածությունը հեշտությամբ կառավարվում է MXNet շարժիչի կողմից՝ համաժամացման պատճառով կատարողականի կորուստներից խուսափելու համար: Հորովոդում սահմանված բաշխված օպտիմիզատոր օբյեկտ horovod.DistributedOptimizer ընդլայնվում է Օպտիմիզատոր MXNet-ում, որպեսզի այն կանչի համապատասխան Horovod API-ները բաշխված պարամետրերի թարմացումների համար: Իրականացման այս բոլոր մանրամասները թափանցիկ են վերջնական օգտագործողների համար:

Արագ մեկնարկ

Դուք կարող եք արագ սկսել փոքր կոնվուլցիոն նեյրոնային ցանցի վարժեցում MNIST տվյալների բազայի վրա՝ օգտագործելով MXNet-ը և Horovod-ը ձեր MacBook-ում:
Նախ տեղադրեք mxnet-ը և horovod-ը PyPI-ից.

pip install mxnet
pip install horovod

Նշում. Եթե ընթացքում սխալ եք հանդիպում pip install horovodմիգուցե պետք է փոփոխական ավելացնել MACOSX_DEPLOYMENT_TARGET=10.vvՈրտեղ vv – սա ձեր MacOS տարբերակի տարբերակն է, օրինակ, MacOSX Sierra-ի համար պետք է գրել MACOSX_DEPLOYMENT_TARGET=10.12 pip install horovod

Այնուհետև տեղադրեք OpenMPI ուստի.

Վերջում ներբեռնեք թեստային սցենարը mxnet_mnist.py ուստի և գործարկեք հետևյալ հրամանները MacBook տերմինալում աշխատանքային գրացուցակում.

mpirun -np 2 -H localhost:2 -bind-to none -map-by slot python mxnet_mnist.py

Սա կանցկացնի ուսուցում ձեր պրոցեսորի երկու միջուկների վրա: Արդյունքը կլինի հետևյալը.

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.870000

Կատարման ցուցադրություն

Երբ վերապատրաստում եք ResNet50-v1 մոդելը ImageNet տվյալների բազայի վրա 64 GPU-ի վրա՝ ութ օրինակով p3.16x մեծ EC2, որոնցից յուրաքանչյուրը պարունակում է 8 NVIDIA Tesla V100 GPU AWS ամպի վրա, մենք հասանք 45000 պատկեր/վրկ ուսուցման թողունակության (այսինքն՝ վերապատրաստված նմուշների քանակը վայրկյանում): Մարզումն ավարտվել է 44 դարաշրջանից հետո 90 րոպեում՝ 75.7% լավագույն ճշգրտությամբ։

Մենք դա համեմատեցինք MXNet-ի բաշխված ուսուցման մոտեցման հետ՝ օգտագործելով պարամետրային սերվերներ 8, 16, 32 և 64 GPU-ներում մեկ պարամետր սերվերով և սերվերից աշխատող հարաբերակցությամբ՝ համապատասխանաբար 1-ից 1 և 2-ից 1-ի: Արդյունքը կարող եք տեսնել ստորև նկար 1-ում: Ձախ կողմում գտնվող y առանցքի վրա գծերը ներկայացնում են վայրկյանում վերապատրաստվող պատկերների քանակը, գծերը արտացոլում են մասշտաբավորման արդյունավետությունը (այսինքն՝ իրական և իդեալական թողունակության հարաբերակցությունը) աջ կողմում գտնվող y առանցքի վրա: Ինչպես տեսնում եք, սերվերների քանակի ընտրությունը ազդում է մասշտաբավորման արդյունավետության վրա։ Եթե ​​կա միայն մեկ պարամետրային սերվեր, ապա մասշտաբի արդյունավետությունը իջնում ​​է մինչև 38% 64 GPU-ների վրա: Նույն մասշտաբային արդյունավետության հասնելու համար, ինչ Հորովոդի դեպքում, դուք պետք է կրկնապատկեք սերվերների թիվը աշխատողների թվի համեմատ:

Նկար 1. MXNet-ի միջոցով բաշխված ուսուցման համեմատությունը Horovod-ի և պարամետրային սերվերի հետ

Ստորև բերված Աղյուսակ 1-ում մենք համեմատում ենք մեկ օրինակի վերջնական արժեքը 64 GPU-ի վրա փորձարկումներ իրականացնելիս: MXNet-ի օգտագործումը Horovod-ի հետ ապահովում է լավագույն թողունակությունը ամենացածր գնով:

Աղյուսակ 1. Հորովոդի և պարամետրային սերվերի միջև ծախսերի համեմատություն սերվերից աշխատող 2-ից 1 հարաբերակցությամբ:

Վերարտադրման քայլեր

Հաջորդ քայլերում մենք ձեզ ցույց կտանք, թե ինչպես կարելի է վերարտադրել բաշխված մարզումների արդյունքը՝ օգտագործելով MXNet-ը և Horovod-ը: MXNet-ով բաշխված ուսուցման մասին ավելին իմանալու համար կարդացեք այս գրառումը.

Քայլ 1

Ստեղծեք միատարր օրինակների կլաստեր MXNet 1.4.0 կամ ավելի նոր տարբերակով և Horovod 0.16.0 կամ ավելի բարձր տարբերակով՝ բաշխված ուսուցումն օգտագործելու համար: Ձեզ անհրաժեշտ կլինի նաև գրադարաններ տեղադրել GPU-ի վերապատրաստման համար: Մեր օրինակների համար մենք ընտրեցինք Ubuntu 16.04 Linux, GPU Driver 396.44, CUDA 9.2, cuDNN 7.2.1 գրադարան, NCCL 2.2.13 կոմունիկատոր և OpenMPI 3.1.1: Նաև կարող եք օգտագործել Amazon Deep Learning AMI, որտեղ այս գրադարաններն արդեն նախապես տեղադրված են։

Քայլ 2

Ավելացրեք Horovod API-ի հետ աշխատելու հնարավորությունը ձեր MXNet ուսուցման սցենարին: Ստորև բերված սցենարը, որը հիմնված է MXNet Gluon API-ի վրա, կարող է օգտագործվել որպես պարզ ձևանմուշ: Թավ տողերը անհրաժեշտ են, եթե արդեն ունեք համապատասխան վերապատրաստման սցենար: Ահա մի քանի կարևոր փոփոխություններ, որոնք դուք պետք է անեք Հորովոդի հետ սովորելու համար.

• Սահմանեք համատեքստը ըստ տեղական Հորովոդի աստիճանի (տող 8) հասկանալու համար, որ ուսուցումն իրականացվում է ճիշտ գրաֆիկական միջուկի վրա:
• Նախնական պարամետրերը փոխանցեք մեկ աշխատողից բոլորին (տող 18), որպեսզի համոզվեք, որ բոլոր աշխատողները սկսում են նույն սկզբնական պարամետրերով:
• Ստեղծեք Հորովոդ DistributedOptimizer (տող 25) պարամետրերը բաշխված եղանակով թարմացնելու համար:

Ամբողջական սցենարը ստանալու համար խնդրում ենք դիմել Horovod-MXNet-ի օրինակներին ՄՆԻՍՏ и ImageNet.

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    ...

Քայլ 3

Մուտք գործեք աշխատողներից մեկի մոտ՝ MPI հրահանգի միջոցով բաշխված ուսուցում սկսելու համար: Այս օրինակում բաշխված ուսուցումն անցկացվում է չորս օրինակով՝ յուրաքանչյուրը 4 GPU-ով և կլաստերում՝ ընդհանուր 16 GPU-ով: Stochastic Gradient Descent (SGD) օպտիմիզատորը կօգտագործվի հետևյալ հիպերպարամետրերով.

• մինի խմբաքանակի չափը՝ 256
• ուսուցման մակարդակը` 0.1
• թափ՝ 0.9
• քաշի քայքայումը՝ 0.0001

Երբ մենք մեկ GPU-ից հասցնում էինք 64 GPU-ի, մենք գծային մասշտաբում էինք վերապատրաստման արագությունը՝ ըստ GPU-ների քանակի (0,1-ից 1 GPU-ի համար մինչև 6,4-ը՝ 64 GPU-ի համար), մինչդեռ մեկ GPU-ի պատկերների քանակը պահելով 256-ի վրա (մի խմբաքանակից): 256 պատկեր 1 GPU-ի համար մինչև 16 պատկեր 384 GPU-ի համար): Քաշի քայքայման և իմպուլսի պարամետրերը փոխվեցին GPU-ների քանակի աճով: Մենք օգտագործեցինք խառը ճշգրիտ ուսուցում float64 տվյալների տիպի հետ՝ առաջ անցնելու համար և float16՝ գրադիենտների համար՝ արագացնելու float32 հաշվարկները, որոնք աջակցում են NVIDIA Tesla GPU-ները:

$ 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.py

Ամփոփում

Այս հոդվածում մենք դիտարկեցինք Apache MXNet-ի և Horovod-ի միջոցով բաշխված մոդելների ուսուցման մասշտաբային մոտեցումը: Մենք ցուցադրեցինք մասշտաբավորման արդյունավետությունը և ծախսարդյունավետությունը՝ համեմատած ImageNet տվյալների բազայի պարամետրային սերվերի մոտեցման հետ, որի վրա վերապատրաստվել է ResNet50-v1 մոդելը: Մենք նաև ներառել ենք քայլեր, որոնք կարող եք օգտագործել գոյություն ունեցող սկրիպտը փոփոխելու համար՝ Հորովոդի միջոցով բազմատիպ ուսուցում իրականացնելու համար:

Եթե ​​նոր եք սկսում MXNet-ով և խորը ուսուցմամբ, անցեք տեղադրման էջ MXNeնախ կառուցել MXNet-ը: Մենք նաև խստորեն խորհուրդ ենք տալիս կարդալ հոդվածը MXNet 60 րոպեումսկսելու համար:

Եթե ​​արդեն աշխատել եք MXNet-ի հետ և ցանկանում եք փորձել բաշխված ուսուցում Հորովոդի հետ, ապա դիտեք Հորովոդի տեղադրման էջ, կառուցեք այն MXNet-ից և հետևեք օրինակին ՄՆԻՍՏ կամ ImageNet.

*Արժեքը հաշվարկված է ժամային դրույքաչափեր AWS EC2 դեպքերի համար

Իմացեք ավելին դասընթացի մասին «Արդյունաբերական ML մեծ տվյալների վրա»

Source: www.habr.com