D'Iwwersetzung vum Artikel gouf um Virowend vum Start vum Cours virbereet
Verdeelt Training op Multiple High-Performance Computing Instanzen kënnen d'Trainingszäit vu modernen déifneuralen Netzwierker op grouss Quantitéiten un Daten vu Wochen op Stonnen oder souguer Minutten reduzéieren, sou datt dës Trainingstechnik an prakteschen Uwendunge vum Deep Learning verbreet ass. D'Benotzer musse verstoen wéi d'Donnéeën iwwer verschidde Instanzen deelen an synchroniséieren, wat am Tour e groussen Impakt op d'Skaléierungseffizienz huet. Zousätzlech sollten d'Benotzer och wësse wéi een en Trainingsskript ofsetzt deen op enger eenzeger Instanz op verschidde Instanzen leeft.
An dësem Artikel schwätze mir iwwer e séieren an einfache Wee fir Léieren ze verdeelen mat der oppener Deep Learning Bibliothéik Apache MXNet an dem Horovod verdeelt Léierkader. Mir wäerte kloer d'Performance Virdeeler vum Horovod Kader weisen a weisen wéi een en MXNet Trainingsskript schreift sou datt et op eng verdeelt Manéier mat Horovod funktionnéiert.
Wat ass Apache MXNet
ass en Open-Source Deep Learning Kader dee benotzt gëtt fir déif neural Netzwierker ze kreéieren, ze trainéieren an z'installéieren. MXNet abstrakt d'Komplexitéite verbonne mat der Ëmsetzung vun neurale Netzwierker, ass héich performant a skalierbar, a bitt APIs fir populär Programméierungssprooche wéi z. , , , , , , an anerer.
Verdeelt Training am MXNet mat Parameterserver
benotzt engem Parameter Server Approche. Et benotzt eng Rei vu Parameterservere fir Gradienten vun all Aarbechter ze sammelen, Aggregatioun auszeféieren an aktualiséiert Gradienten zréck un d'Aarbechter fir déi nächst Optimisatiounsiteratioun ze schécken. D'Bestëmmung vum korrekte Verhältnis vu Serveren zu Aarbechter ass de Schlëssel fir effektiv Skaléieren. Wann et nëmmen ee Parameterserver gëtt, kann et e Flaschenhals an de Berechnunge ginn. Ëmgekéiert, wann ze vill Servere benotzt ginn, kann vill-zu-vill Kommunikatioun all Netzwierkverbindunge verstoppen.
Wat ass Horovod
ass en oppene verdeelt Deep Learning Kader entwéckelt bei Uber. Et benotzt efficace Cross-GPU an Kräiz-Node Technologien wéi NVIDIA Collective Communications Library (NCCL) a Message Passing Interface (MPI) fir Modellparameter iwwer vorecs ze verdeelen an ze aggregéieren. Et optiméiert d'Benotzung vun der Netzwierkbandbreedung a skaléiert gutt wann Dir mat deep neuralen Netzwierkmodeller schafft. Et ënnerstëtzt de Moment verschidde populär Maschinn Léieren Kaderen, nämlech , Tensorflow, Keras a PyTorch.
MXNet an Horovod Integratioun
MXNet integréiert mat Horovod duerch d'Distributed Learning APIs definéiert an Horovod. Horovod Kommunikatioun APIen horovod.broadcast(), horovod.allgather() и horovod.allreduce() implementéiert mat asynchronen Callbacks vum MXNet Motor, als Deel vu senger Taskgrafik. Op dës Manéier ginn Datenabhängegkeeten tëscht Kommunikatioun a Berechnung einfach vum MXNet-Motor gehandhabt fir Leeschtungsverloscht wéinst Synchroniséierung ze vermeiden. Verdeelt Optimizer Objet definéiert an Horovod horovod.DistributedOptimizer erweidert Optimizer an MXNet sou datt et déi entspriechend Horovod APIs fir verdeelt Parameterupdates nennt. All dës Ëmsetzungsdetailer sinn transparent fir Endbenotzer.
Schnell Start
Dir kënnt séier ufänken e klengt convolutional neuralt Netzwierk op der MNIST Dataset mat MXNet an Horovod op Ärem MacBook ze trainéieren.
Als éischt installéiere mxnet an horovod vu PyPI:
pip install mxnet
pip install horovodNotiz: Wann Dir e Feeler begéint während pip installéieren horovodvläicht musst Dir eng Variabel derbäisetzen MACOSX_DEPLOYMENT_TARGET=10.vvwou vv - dëst ass d'Versioun vun Ärer MacOS Versioun, zum Beispill, fir MacOSX Sierra musst Dir schreiwen MACOSX_DEPLOYMENT_TARGET=10.12 Pip installéieren Horovod
Installéiert dann OpenMPI .
Um Enn luet den Testskript erof mxnet_mnist.py a lafen déi folgend Kommandoen am MacBook Terminal am Aarbechtsverzeechnes:
mpirun -np 2 -H localhost:2 -bind-to none -map-by slot python mxnet_mnist.pyDëst wäert Training op zwee Käre vun Ärem Prozessor lafen. D'Ausgab wäert déi folgend sinn:
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.870000Leeschtung Demo
Wann Dir e ResNet50-v1 Modell trainéiert op engem ImageNet Dataset op 64 GPUs mat aacht Instanzen p3.16x grouss EC2, jidderee mat 8 NVIDIA Tesla V100 GPUs op AWS Cloud, hu mir en Trainingsduerchgang vu 45000 Biller / Sek erreecht (dh d'Zuel vun trainéierte Proben pro Sekonn). Training ofgeschloss an 44 Minutten no 90 Epochen mat enger bescht Genauegkeet vu 75.7%.
Mir verglach dëst mat MXNet verdeelt Training Approche fir Parameterserveren op 8, 16, 32 an 64 GPUs mat engem eenzege Parameterserver an engem Server an Aarbechtsverhältnis vun 1 bis 1 respektiv 2 bis 1 ze benotzen. Dir kënnt d'Resultat an der Figur 1 hei ënnen gesinn. Op der Y-Achs op der lénker Säit representéieren d'Barren d'Zuel vun de Biller fir pro Sekonn ze trainéieren, d'Linnen reflektéieren d'Skaléierungseffizienz (dat ass d'Verhältnis vum aktuellen an idealen Duerchsatz) op der Y-Achs op der rietser. Wéi Dir kënnt gesinn, beaflosst d'Wiel vun der Zuel vun de Serveren d'Skaléierungseffizienz. Wann et nëmmen ee Parameterserver gëtt, fällt d'Skaléierungseffizienz op 38% op 64 GPUs. Fir déi selwecht Skaléierungseffizienz wéi mat Horovod z'erreechen, musst Dir d'Zuel vun de Serveren relativ zu der Unzuel vun den Aarbechter verdoppelen.
Figur 1. Verglach vun verdeelt Léieren benotzt MXNet mat Horovod a mat Parameter Server
An der Tabell 1 hei drënner vergläichen mir d'Finale Käschten pro Instanz wann Dir Experimenter op 64 GPUs leeft. Benotzt MXNet mat Horovod bitt de beschten Duerchsatz zu de niddregsten Käschten.
Dësch 1. Käschte Verglach tëscht Horovod a Parameter Server mat engem Server zu Aarbechter Verhältnis vun 2 zu 1.
Schrëtt fir ze reproduzéieren
An den nächste Schrëtt wäerte mir Iech weisen wéi Dir d'Resultat vun der verdeelerer Training mat MXNet an Horovod reproduzéiert. Fir méi iwwer verdeelt Léieren mat MXNet ze léieren, liest .
Schrëtt 1
Erstellt e Cluster vun homogenen Instanzen mat MXNet Versioun 1.4.0 oder méi héich an Horovod Versioun 0.16.0 oder méi héich fir verdeelt Training ze benotzen. Dir musst och d'Bibliothéike fir GPU-Training installéieren. Fir eis Instanzen hu mir gewielt Ubuntu 16.04 Linux, mat GPU Driver 396.44, CUDA 9.2, cuDNN Bibliothéik 7.2.1, NCCL Kommunikator 2.2.13 an OpenMPI 3.1.1. Dir kënnt och benotzen , wou dës Bibliothéike scho virinstalléiert sinn.
Schrëtt 2
Füügt d'Fäegkeet fir mat der Horovod API an Ärem MXNet Trainingsskript ze schaffen. De Skript hei ënnen baséiert op der MXNet Gluon API kann als einfach Schabloun benotzt ginn. D'Linnen a Fett sinn néideg wann Dir schonn en entspriechend Trainingsskript hutt. Hei sinn e puer kritesch Ännerungen déi Dir maache musst fir mat Horovod ze léieren:
- Setzt de Kontext no der lokaler Horovod Rank (Linn 8) fir ze verstoen datt d'Ausbildung op de richtege Grafikkär ausgefouert gëtt.
- Passe initial Parameteren vun engem Aarbechter un all (Linn 18) fir sécherzestellen datt all Aarbechter mat de selwechte initialen Parameteren ufänken.
- Schafen eng Horovod DistributedOptimizer (Linn 25) fir d'Parameteren op eng verdeelt Manéier ze aktualiséieren.
Fir de komplette Skript ze kréien, kuckt op d'Horovod-MXNet Beispiller и .
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 ...Schrëtt 3
Mellt Iech bei engem vun den Aarbechter un fir verdeelt Training mat der MPI-Direktiv ze starten. An dësem Beispill leeft verdeelt Training op véier Instanzen mat 4 GPUs all, an am Ganzen 16 GPUs am Cluster. De Stochastic Gradient Descent (SGD) Optimizer gëtt mat de folgenden Hyperparameter benotzt:
- Mini-Batch Gréisst: 256
- Léierrate: 0.1
- Momentum: 0.9
- Gewiicht Zerfall: 0.0001
Wéi mir vun enger GPU op 64 GPUs skaléiert hunn, hu mir den Trainingsquote linear skaléiert no der Unzuel vun de GPUs (vu 0,1 fir 1 GPU op 6,4 fir 64 GPUs), wärend d'Zuel vun de Biller pro GPU op 256 behalen (vun enger Partie vun 256 Biller fir 1 GPU op 16 fir 384 GPUs). D'Gewiicht Zerfall an Dynamik Parameteren geännert wéi d'Zuel vun GPUs erop. Mir hunn gemëschte Präzisiounstraining mam Float64 Datentyp fir de Forward Pass a Float16 fir Gradienten benotzt fir d'float32 Berechnungen ze beschleunegen ënnerstëtzt vun NVIDIA Tesla GPUs.
$ 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.pyKonklusioun
An dësem Artikel hu mir eng skalierbar Approche fir verdeelt Modelltraining mat Apache MXNet an Horovod gekuckt. Mir hunn d'Skaléierungseffizienz a Käschteneffizienz bewisen am Verglach mat der Parameterserver Approche op der ImageNet Dataset, op där de ResNet50-v1 Modell trainéiert gouf. Mir hunn och Schrëtt abegraff déi Dir benotze kënnt fir en existente Skript z'änneren fir Multi-Instance Training mat Horovod ze lafen.
Wann Dir just mat MXNet an Deep Learning ufänkt, gitt op d'Installatiounssäit fir d'éischt MXNet ze bauen. Mir recommandéieren och staark den Artikel ze liesen unzefänken.
Wann Dir scho mat MXNet geschafft hutt a wëllt verdeelt Léieren mat Horovod probéieren, da kuckt op , baut et aus MXNet a befollegt d'Beispill oder .
* Käschten sinn berechent baséiert op AWS fir EC2 Instanzen
Léiert méi iwwer de Cours
Source: will.com
