განაწილებული სწავლა Apache MXNet-ით და Horovod-ით

სტატიის თარგმანი მომზადდა კურსის დაწყების წინა დღეს "ინდუსტრიული ML დიდ მონაცემებზე"

განაწილებულმა ტრენინგმა მრავალჯერადი მაღალი ხარისხის გამოთვლით ინსტანციებზე შეიძლება შეამციროს თანამედროვე ღრმა ნერვული ქსელების ვარჯიშის დრო დიდი რაოდენობით მონაცემებზე კვირებიდან საათამდე ან თუნდაც წუთამდე, რაც გახდის ამ ტრენინგის გავრცელებულს ღრმა სწავლის პრაქტიკულ გამოყენებაში. მომხმარებლებმა უნდა გააცნობიერონ, თუ როგორ გააზიარონ და სინქრონიზაცია გაუკეთონ მონაცემთა მრავალ ინსტანციას, რაც თავის მხრივ დიდ გავლენას ახდენს სკალირების ეფექტურობაზე. გარდა ამისა, მომხმარებლებმა ასევე უნდა იცოდნენ, როგორ განათავსონ სასწავლო სკრიპტი, რომელიც მუშაობს ერთ ეგზემპლარზე მრავალ ინსტანციაზე.

ამ სტატიაში ვისაუბრებთ სწავლის გავრცელების სწრაფ და მარტივ გზაზე ღია ღრმა სწავლების ბიბლიოთეკის Apache MXNet-ისა და Horovod-ის განაწილებული სასწავლო ჩარჩოს გამოყენებით. ჩვენ ნათლად წარმოვაჩენთ Horovod-ის ფრეიმვორკის შესრულების უპირატესობებს და ვაჩვენებთ, თუ როგორ უნდა დავწეროთ MXNet სასწავლო სკრიპტი ისე, რომ ის მუშაობს განაწილებულად Horovod-თან.

რა არის Apache MXNet

Apache MX Net არის ღია კოდის ღრმა სწავლების ჩარჩო, რომელიც გამოიყენება ღრმა ნერვული ქსელების შესაქმნელად, ტრენინგსა და განსათავსებლად. MXNet აბსტრაქტებს ნერვულ ქსელების დანერგვასთან დაკავშირებულ სირთულეებს, არის მაღალი ხარისხის და მასშტაბირებადი და გთავაზობთ API-ებს პოპულარული პროგრამირების ენებისთვის, როგორიცაა Python, C + +, კლასიკო, Java, Julia, R, მასშტაბის და სხვები.

განაწილებული ტრენინგი MXNet-ში პარამეტრული სერვერით

სტანდარტული განაწილებული სასწავლო მოდული MXNet-ში იყენებს პარამეტრი სერვერის მიდგომას. ის იყენებს პარამეტრული სერვერების ერთობლიობას თითოეული მუშაკისგან გრადიენტების შესაგროვებლად, აგრეგაციის შესასრულებლად და განახლებული გრადიენტების გაგზავნისთვის მუშებს შემდეგი ოპტიმიზაციის გამეორებისთვის. სერვერებისა და მუშაკების სწორი თანაფარდობის დადგენა ეფექტური სკალირების გასაღებია. თუ არსებობს მხოლოდ ერთი პარამეტრის სერვერი, ეს შეიძლება აღმოჩნდეს გამოთვლების შეფერხება. პირიქით, თუ ძალიან ბევრი სერვერი გამოიყენება, ბევრი-მრავალ კომუნიკაციას შეუძლია დაბლოკოს ყველა ქსელური კავშირი.

რა არის ჰოროვოდი

ჰოროვოდი არის ღია განაწილებული ღრმა სწავლების ჩარჩო, რომელიც შემუშავებულია Uber-ში. ის იყენებს ეფექტურ cross-GPU და cross-node ტექნოლოგიებს, როგორიცაა NVIDIA Collective Communications Library (NCCL) და Message Passing Interface (MPI), რათა გაანაწილოს და დააგროვოს მოდელის პარამეტრები ვორეკებში. ის ოპტიმიზებს ქსელის გამტარუნარიანობის გამოყენებას და კარგად მასშტაბებს ღრმა ნერვული ქსელის მოდელებთან მუშაობისას. ის ამჟამად მხარს უჭერს რამდენიმე პოპულარულ მანქანათმცოდნეობის ჩარჩოს, კერძოდ MX Net, Tensorflow, Keras და PyTorch.

MXNet და Horovod ინტეგრაცია

MXNet ინტეგრირდება Horovod-თან Horovod-ში განსაზღვრული განაწილებული სასწავლო API-ების მეშვეობით. Horovod საკომუნიკაციო API horovod.broadcast(), horovod.allgather() и horovod.allreduce() განხორციელებულია MXNet ძრავის ასინქრონული გამოძახების გამოყენებით, როგორც მისი ამოცანების გრაფიკის ნაწილი. ამ გზით, მონაცემთა დამოკიდებულებები კომუნიკაციასა და გამოთვლას შორის ადვილად უმკლავდება MXNet ძრავას, რათა თავიდან აიცილოს შესრულების დანაკარგები სინქრონიზაციის გამო. Horovod-ში განსაზღვრული განაწილებული ოპტიმიზატორი ობიექტი 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 პიპის ინსტალაცია 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-ზე. სკალირების იგივე ეფექტურობის მისაღწევად, როგორც Horovod-თან, თქვენ უნდა გააორმაგოთ სერვერების რაოდენობა მუშაკების რაოდენობასთან შედარებით.

სურათი 1. MXNet-ის გამოყენებით განაწილებული სწავლების შედარება Horovod-თან და პარამეტრულ სერვერთან

ქვემოთ ცხრილში 1, ჩვენ შევადარებთ საბოლოო ღირებულებას 64 GPU-ზე ექსპერიმენტების გაშვებისას. Horovod-თან MXNet-ის გამოყენება უზრუნველყოფს საუკეთესო გამტარუნარიანობას ყველაზე დაბალ ფასად.

ცხრილი 1. ღირებულების შედარება Horovod-სა და პარამეტრულ სერვერს შორის სერვერის თანამშრომელთან თანაფარდობით 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-ის მაგალითები MNIST и 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 გრადიენტებისთვის NVIDIA Tesla GPU-ების მიერ მხარდაჭერილი float32 გამოთვლების დასაჩქარებლად.

$ 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 მოდელი. ჩვენ ასევე დავამატეთ საფეხურები, რომლებიც შეგიძლიათ გამოიყენოთ არსებული სკრიპტის შესაცვლელად მრავალ ინსტანციის ტრენინგის გასატარებლად Horovod-ის გამოყენებით.

თუ ახლახან იწყებთ MXNet-ს და ღრმა სწავლას, გადადით ინსტალაციის გვერდზე MXNeპირველი MXNet-ის შესაქმნელად. ჩვენ ასევე მკაცრად გირჩევთ სტატიის წაკითხვას MXNet 60 წუთშიდასაწყებად.

თუ თქვენ უკვე მუშაობდით MXNet-თან და გსურთ სცადოთ განაწილებული სწავლება Horovod-თან, მაშინ გადახედეთ ჰოროვოდის ინსტალაციის გვერდი, შექმენით იგი MXNet-დან და მიჰყევით მაგალითს MNIST ან IMAGEnet.

*ღირებულება გამოითვლება საფუძველზე საათობრივი ტარიფები AWS EC2 ინსტანციებისთვის

შეიტყვეთ მეტი კურსის შესახებ "ინდუსტრიული ML დიდ მონაცემებზე"

წყარო: www.habr.com