โปรโฮสต์ > บล็อก > การบริหาร > การเรียนรู้แบบกระจายด้วย Apache MXNet และ Horovod

การเรียนรู้แบบกระจายด้วย Apache MXNet และ Horovod

การแปลบทความจัดทำขึ้นในวันเริ่มต้นหลักสูตร “ML อุตสาหกรรมบน Big Data”

การฝึกอบรมแบบกระจายบนอินสแตนซ์การประมวลผลประสิทธิภาพสูงหลายรายการสามารถลดเวลาการฝึกอบรมของเครือข่าย Deep Neural สมัยใหม่กับข้อมูลจำนวนมากจากสัปดาห์เป็นชั่วโมงหรือนาที ทำให้เทคนิคการฝึกอบรมนี้แพร่หลายในการใช้งานจริงของการเรียนรู้เชิงลึก ผู้ใช้จะต้องเข้าใจวิธีการแชร์และซิงโครไนซ์ข้อมูลระหว่างหลายอินสแตนซ์ ซึ่งจะส่งผลกระทบอย่างมากต่อประสิทธิภาพในการปรับขนาด นอกจากนี้ ผู้ใช้ควรรู้วิธีปรับใช้สคริปต์การฝึกอบรมที่ทำงานบนอินสแตนซ์เดียวไปยังหลายอินสแตนซ์

ในบทความนี้ เราจะพูดถึงวิธีที่ง่ายและรวดเร็วในการเผยแพร่การเรียนรู้โดยใช้ไลบรารีการเรียนรู้เชิงลึกแบบเปิด Apache MXNet และเฟรมเวิร์กการเรียนรู้แบบกระจาย Horovod เราจะแสดงให้เห็นอย่างชัดเจนถึงคุณประโยชน์ด้านประสิทธิภาพของกรอบงาน Horovod และสาธิตวิธีเขียนสคริปต์การฝึกอบรม MXNet เพื่อให้ทำงานในลักษณะกระจายร่วมกับ Horovod

Apache MXNet คืออะไร

Apache MX Net เป็นเฟรมเวิร์กการเรียนรู้เชิงลึกแบบโอเพ่นซอร์สที่ใช้ในการสร้าง ฝึกอบรม และปรับใช้โครงข่ายประสาทเชิงลึก MXNet สรุปความซับซ้อนที่เกี่ยวข้องกับการนำโครงข่ายประสาทเทียมไปใช้ มีประสิทธิภาพสูงและปรับขนาดได้ และเสนอ API สำหรับภาษาการเขียนโปรแกรมยอดนิยม เช่น หลาม, C + +, Clojure, ชวา, จูเลีย, R, สกาล่า และอื่น ๆ

การฝึกอบรมแบบกระจายใน MXNet พร้อมเซิร์ฟเวอร์พารามิเตอร์

โมดูลการเรียนรู้แบบกระจายมาตรฐานใน MXNet ใช้วิธีการเซิร์ฟเวอร์พารามิเตอร์ โดยจะใช้ชุดเซิร์ฟเวอร์พารามิเตอร์เพื่อรวบรวมการไล่ระดับสีจากผู้ปฏิบัติงานแต่ละคน ดำเนินการรวมกลุ่ม และส่งการไล่ระดับสีที่อัปเดตกลับไปยังผู้ปฏิบัติงานเพื่อการทำซ้ำการปรับให้เหมาะสมครั้งถัดไป การกำหนดอัตราส่วนที่ถูกต้องของเซิร์ฟเวอร์ต่อผู้ปฏิบัติงานเป็นกุญแจสำคัญในการปรับขนาดที่มีประสิทธิภาพ หากมีเซิร์ฟเวอร์พารามิเตอร์เพียงเซิร์ฟเวอร์เดียว อาจกลายเป็นปัญหาคอขวดในการคำนวณ ในทางกลับกัน หากมีการใช้งานเซิร์ฟเวอร์มากเกินไป การสื่อสารแบบกลุ่มต่อกลุ่มอาจทำให้การเชื่อมต่อเครือข่ายทั้งหมดอุดตันได้

โฮโรโวดคืออะไร

ฮอโรวอด เป็นเฟรมเวิร์กการเรียนรู้เชิงลึกแบบกระจายแบบเปิดที่พัฒนาขึ้นที่ Uber โดยใช้ประโยชน์จากเทคโนโลยีข้าม GPU และข้ามโหนดที่มีประสิทธิภาพ เช่น NVIDIA Collective Communications Library (NCCL) และ Message Passing Interface (MPI) เพื่อกระจายและรวมพารามิเตอร์โมเดลข้าม vorec ปรับการใช้แบนด์วิดท์เครือข่ายให้เหมาะสมและปรับขนาดได้ดีเมื่อทำงานกับโมเดลเครือข่ายประสาทเชิงลึก ปัจจุบันรองรับเฟรมเวิร์กการเรียนรู้ของเครื่องยอดนิยมหลายประการ กล่าวคือ MX เน็ต, เทนเซอร์โฟลว์, Keras และ PyTorch

การรวม MXNet และ Horovod

MXNet ทำงานร่วมกับ Horovod ผ่าน Distributed Learning API ที่กำหนดใน Horovod API การสื่อสาร Horovod horovod.ออกอากาศ(), horovod.allgather() и horovod.allreduce() ใช้งานโดยใช้การเรียกกลับแบบอะซิงโครนัสของเอ็นจิ้น MXNet ซึ่งเป็นส่วนหนึ่งของกราฟงาน ด้วยวิธีนี้ MXNet engine จะจัดการการพึ่งพาข้อมูลระหว่างการสื่อสารและการคำนวณได้อย่างง่ายดาย เพื่อหลีกเลี่ยงการสูญเสียประสิทธิภาพเนื่องจากการซิงโครไนซ์ ออบเจ็กต์เครื่องมือเพิ่มประสิทธิภาพแบบกระจายที่กำหนดไว้ใน Horovod horovod.DistributedOptimizer ขยาย เพิ่มประสิทธิภาพ ใน MXNet เพื่อให้สามารถเรียก Horovod API ที่สอดคล้องกันสำหรับการอัปเดตพารามิเตอร์แบบกระจาย รายละเอียดการใช้งานทั้งหมดนี้โปร่งใสสำหรับผู้ใช้ปลายทาง

เริ่มต้นอย่างรวดเร็ว

คุณสามารถเริ่มต้นการฝึกโครงข่ายประสาทเทียมขนาดเล็กบนชุดข้อมูล MNIST ได้อย่างรวดเร็วโดยใช้ MXNet และ Horovod บน MacBook ของคุณ
ขั้นแรก ติดตั้ง mxnet และ horovod จาก PyPI:

pip install mxnet
pip install horovod

หมายเหตุ: หากคุณพบข้อผิดพลาดในระหว่าง pip ติดตั้ง horovodบางทีคุณอาจต้องเพิ่มตัวแปร MACOSX_DEPLOYMENT_TARGET=10.vvที่ไหน vv – นี่คือเวอร์ชันของเวอร์ชัน MacOS ของคุณ ตัวอย่างเช่น สำหรับ MacOSX Sierra คุณจะต้องเขียน MACOSX_DEPLOYMENT_TARGET=10.12 pip การติดตั้งขั้นต่ำ

จากนั้นติดตั้ง 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 บน GPU 64 ตัวพร้อมอินสแตนซ์แปดตัว p3.16xlarge EC2 ซึ่งแต่ละตัวมี NVIDIA Tesla V8 GPU 100 ตัวบน AWS Cloud ทำให้เราได้รับทรูพุตการฝึกที่ 45000 อิมเมจ/วินาที (นั่นคือ จำนวนตัวอย่างที่ได้รับการฝึกต่อวินาที) การฝึกอบรมเสร็จสิ้นใน 44 นาทีหลังจาก 90 ยุคด้วยความแม่นยำสูงสุด 75.7%

เราเปรียบเทียบสิ่งนี้กับแนวทางการฝึกอบรมแบบกระจายของ MXNet ในการใช้เซิร์ฟเวอร์พารามิเตอร์บน GPU 8, 16, 32 และ 64 GPU ด้วยเซิร์ฟเวอร์พารามิเตอร์เดียวและอัตราส่วนเซิร์ฟเวอร์ต่อผู้ปฏิบัติงานที่ 1 ต่อ 1 และ 2 ต่อ 1 ตามลำดับ คุณสามารถดูผลลัพธ์ได้ในรูปที่ 1 ด้านล่าง บนแกน y ทางด้านซ้าย แถบต่างๆ แสดงถึงจำนวนภาพที่จะฝึกต่อวินาที เส้นต่างๆ สะท้อนถึงประสิทธิภาพในการปรับขนาด (นั่นคือ อัตราส่วนของปริมาณงานจริงต่อปริมาณงานในอุดมคติ) บนแกน y ทางด้านขวา อย่างที่คุณเห็น การเลือกจำนวนเซิร์ฟเวอร์ส่งผลต่อประสิทธิภาพในการปรับขนาด หากมีเซิร์ฟเวอร์พารามิเตอร์เพียงเซิร์ฟเวอร์เดียว ประสิทธิภาพการปรับขนาดจะลดลงเหลือ 38% บน 64 GPU เพื่อให้บรรลุประสิทธิภาพในการปรับขนาดเช่นเดียวกับ Horovod คุณต้องเพิ่มจำนวนเซิร์ฟเวอร์เป็นสองเท่าเมื่อเทียบกับจำนวนคนทำงาน

การเรียนรู้แบบกระจายด้วย Apache MXNet และ Horovod
รูปที่ 1 การเปรียบเทียบการเรียนรู้แบบกระจายโดยใช้ MXNet กับ Horovod และเซิร์ฟเวอร์พารามิเตอร์

ในตารางที่ 1 ด้านล่าง เราเปรียบเทียบราคาสุดท้ายต่ออินสแตนซ์เมื่อทำการทดสอบกับ GPU 64 ตัว การใช้ MXNet กับ Horovod จะให้ปริมาณงานที่ดีที่สุดในต้นทุนที่ต่ำที่สุด

การเรียนรู้แบบกระจายด้วย Apache MXNet และ Horovod
ตารางที่ 1. การเปรียบเทียบต้นทุนระหว่าง Horovod และเซิร์ฟเวอร์พารามิเตอร์ด้วยอัตราส่วนเซิร์ฟเวอร์ต่อผู้ปฏิบัติงาน 2 ต่อ 1

ขั้นตอนการสืบพันธุ์

ในขั้นตอนถัดไป เราจะแสดงวิธีสร้างผลลัพธ์ของการฝึกแบบกระจายโดยใช้ MXNet และ Horovod หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการเรียนรู้แบบกระจายด้วย MXNet โปรดอ่าน โพสต์นี้.

ขั้นตอนที่ 1

สร้างคลัสเตอร์ของอินสแตนซ์ที่เป็นเนื้อเดียวกันด้วย MXNet เวอร์ชัน 1.4.0 ขึ้นไป และ Horovod เวอร์ชัน 0.16.0 ขึ้นไปเพื่อใช้การเรียนรู้แบบกระจาย คุณจะต้องติดตั้งไลบรารีสำหรับการฝึกอบรม GPU ด้วย ในกรณีของเรา เราเลือก Ubuntu 16.04 Linux พร้อมด้วยไดรเวอร์ GPU 396.44, CUDA 9.2, ไลบรารี cuDNN 7.2.1, เครื่องมือสื่อสาร NCCL 2.2.13 และ OpenMPI 3.1.1 คุณยังสามารถใช้ Amazon การเรียนรู้เชิงลึก AMIโดยที่ไลบรารีเหล่านี้ได้รับการติดตั้งไว้ล่วงหน้าแล้ว

ขั้นตอนที่ 2

เพิ่มความสามารถในการทำงานกับ Horovod API ให้กับสคริปต์การฝึก MXNet ของคุณ สคริปต์ด้านล่างที่ใช้ MXNet Gluon API สามารถใช้เป็นเทมเพลตอย่างง่ายได้ จำเป็นต้องมีบรรทัดที่เป็นตัวหนาหากคุณมีสคริปต์การฝึกอบรมที่เกี่ยวข้องอยู่แล้ว ต่อไปนี้คือการเปลี่ยนแปลงที่สำคัญบางประการที่คุณต้องทำเพื่อเรียนรู้กับ Horovod:

  • ตั้งค่าบริบทตามอันดับ Horovod ในพื้นที่ (บรรทัดที่ 8) เพื่อทำความเข้าใจว่าการฝึกอบรมดำเนินการบนคอร์กราฟิกที่ถูกต้อง
  • ส่งผ่านพารามิเตอร์เริ่มต้นจากผู้ปฏิบัติงานคนหนึ่งไปยังทุกคน (บรรทัดที่ 18) เพื่อให้แน่ใจว่าผู้ปฏิบัติงานทั้งหมดเริ่มต้นด้วยพารามิเตอร์เริ่มต้นเดียวกัน
  • สร้างโฮโรโวด เครื่องมือเพิ่มประสิทธิภาพแบบกระจาย (บรรทัดที่ 25) เพื่ออัพเดตพารามิเตอร์ในลักษณะแบบกระจาย

หากต้องการรับสคริปต์ฉบับเต็ม โปรดดูตัวอย่าง Horovod-MXNet สวพ.FMXNUMX и อิมเมจเน็ต.

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 และมี GPU ทั้งหมด 16 ตัวในคลัสเตอร์ เครื่องมือเพิ่มประสิทธิภาพ 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 นอกจากนี้เรายังรวมขั้นตอนที่คุณสามารถใช้เพื่อแก้ไขสคริปต์ที่มีอยู่เพื่อเรียกใช้การฝึกอบรมแบบหลายอินสแตนซ์โดยใช้ Horovod

หากคุณเพิ่งเริ่มต้นใช้งาน MXNet และการเรียนรู้เชิงลึก ให้ไปที่หน้าการติดตั้ง เอ็มเอ็กซ์นีเพื่อสร้าง MXNet ก่อน เราขอแนะนำให้อ่านบทความอย่างยิ่ง MXNet ใน 60 นาทีที่จะเริ่มต้น.

หากคุณเคยร่วมงานกับ MXNet แล้ว และต้องการลองกระจายการเรียนรู้กับ Horovod ลองดูที่ หน้าการติดตั้ง Horovodให้สร้างจาก MXNet แล้วทำตามตัวอย่าง สวพ.FMXNUMX หรือ อิมเมจเน็ต.

*ต้นทุนคำนวณตาม อัตรารายชั่วโมง AWS สำหรับอินสแตนซ์ EC2

เรียนรู้เพิ่มเติมเกี่ยวกับหลักสูตร “ML อุตสาหกรรมบน Big Data”

ที่มา: will.com

เพิ่มความคิดเห็น