5 เคล็ดลับสำหรับการฝึกอบรม multi-GPU ด้วย Keras

• January 21, 2018
• Vasilis Vryniotiso
• . 1 ความคิดเห็น

Deep Learning (คำศัพท์ยอดนิยมในช่วงปลายปี 2010 ควบคู่ไปกับ blockchain/bitcoin และ Data Science/Machine Learning) ทำให้เราสามารถทำสิ่งที่เจ๋งๆ ได้ในช่วงไม่กี่ปีที่ผ่านมา นอกเหนือจากความก้าวหน้าในอัลกอริธึม (ซึ่งเป็นที่ยอมรับตามแนวคิดที่รู้จักกันมาตั้งแต่ทศวรรษ 1990 หรือที่เรียกว่า “ยุคการขุดข้อมูล”) สาเหตุหลักของความสำเร็จนั้นมาจากความพร้อมใช้งานของชุดข้อมูลขนาดใหญ่ฟรี การแนะนำไลบรารีโอเพนซอร์ซ และ การใช้ GPU ในบล็อกโพสต์นี้ ฉันจะเน้นที่สองข้อสุดท้ายและฉันจะแบ่งปันเคล็ดลับบางอย่างที่ฉันได้เรียนรู้จากความยากลำบาก

ทำไมต้อง TensorFlow & Keras?

TensorFlow เป็นห้องสมุด Deep Learning ยอดนิยมที่พัฒนาโดย Google ซึ่งช่วยให้คุณสร้างเครือข่ายที่ซับซ้อนได้อย่างรวดเร็ว มันมาพร้อมกับคุณสมบัติที่น่าสนใจมากมาย เช่น การแยกส่วนอัตโนมัติ (ซึ่งช่วยให้คุณไม่ต้องประเมิน/เข้ารหัสการไล่ระดับสีของฟังก์ชันต้นทุน) และการรองรับ GPU (ซึ่งช่วยให้คุณได้รับการปรับปรุงความเร็ว 200x ได้อย่างง่ายดายโดยใช้ฮาร์ดแวร์ที่เหมาะสม) นอกจากนี้ยังมีอินเทอร์เฟซ Python ซึ่งหมายความว่าคุณสามารถสร้างต้นแบบได้อย่างรวดเร็วโดยไม่ต้องเขียนโค้ด C หรือ CUDA เป็นที่ยอมรับว่ามีเฟรมเวิร์กอื่นๆ มากมายที่คุณสามารถใช้แทน TensorFlow เช่น Torch, MXNet, Theano, Caffe, Deeplearning4j, CNTK เป็นต้น แต่ทั้งหมดนี้ขึ้นอยู่กับกรณีการใช้งานและความชอบส่วนตัวของคุณ

แต่ทำไม Keras? สำหรับฉันการใช้ TF โดยตรงก็เหมือนการทำ Machine Learning กับ Numpy ใช่ เป็นไปได้และคุณต้องทำในบางครั้ง (โดยเฉพาะถ้าคุณเขียนเลเยอร์/ฟังก์ชันการสูญเสียที่กำหนดเอง) แต่คุณต้องการเขียนโค้ดที่อธิบายเครือข่ายที่ซับซ้อนเป็นชุดของการดำเนินการเวกเตอร์จริงๆ หรือไม่ (ใช่ ฉันรู้) มีวิธีระดับสูงใน TF แต่ไม่เจ๋งเท่า Keras)? แล้วถ้าคุณต้องการย้ายไปห้องสมุดอื่นล่ะ ถ้าอย่างนั้นคุณอาจจะต้องเขียนโค้ดใหม่ ซึ่งมันแย่มาก Ta ta taaa Keras ช่วยชีวิต! Keras อนุญาตให้คุณอธิบายเครือข่ายของคุณโดยใช้แนวคิดระดับสูงและเขียนโค้ดที่เป็นแบ็กเอนด์ไม่เชื่อเรื่องพระเจ้า ซึ่งหมายความว่าคุณสามารถเรียกใช้เครือข่ายผ่านไลบรารีการเรียนรู้เชิงลึกต่างๆ บางสิ่งที่ฉันชอบเกี่ยวกับ Keras คือมันเขียนได้ดี มีสถาปัตยกรรมเชิงวัตถุ มีส่วนร่วมได้ง่าย และมีชุมชนที่เป็นมิตร ถ้าชอบก็ขอบคุณนะ ฟรองซัว ชอลเลต์ เพื่อพัฒนาและโอเพ่นซอร์ส

เคล็ดลับและ Gotchas สำหรับการฝึกอบรม Multi-GPU

เพื่อไม่ให้เป็นการเสียเวลา เรามาข้ามไปที่เคล็ดลับสองสามข้อเกี่ยวกับวิธีการใช้ประโยชน์สูงสุดจากการฝึกอบรม GPU บน Keras และ gotchas สองสามอย่างที่คุณควรคำนึงถึง:

1. การฝึกอบรม Multi-GPU นั้นไม่อัตโนมัติ

โมเดลการฝึกอบรมบน GPU โดยใช้ Keras & Tensorflow นั้นราบรื่น หากคุณมีการ์ด NVIDIA และคุณติดตั้ง CUDA ไว้ ไลบรารีจะตรวจหาและใช้สำหรับการฝึกอบรมโดยอัตโนมัติ เจ๋ง! แต่ถ้าคุณเป็นเด็กเหลือขอนิสัยเสียและคุณมี GPU หลายตัวล่ะ น่าเสียดายที่คุณจะต้องทำงานสักหน่อยเพื่อให้ได้รับการฝึกอบรม GPU หลายตัว

มีหลายวิธีในการขนานเครือข่ายขึ้นอยู่กับสิ่งที่คุณต้องการบรรลุ แต่สองวิธีหลักคือแบบจำลองและการทำให้ขนานข้อมูล อย่างแรกสามารถช่วยคุณได้หากโมเดลของคุณซับซ้อนเกินไปที่จะใส่ใน GPU ตัวเดียว ในขณะที่ตัวหลังช่วยคุณได้เมื่อคุณต้องการเร่งการดำเนินการ โดยปกติเมื่อมีคนพูดถึงการฝึกอบรม multi-GPU พวกเขาหมายถึงสิ่งหลัง มันเคยยากกว่าที่จะทำสำเร็จ แต่โชคดีที่ Keras ได้รวมวิธีการยูทิลิตี้ที่เรียกว่า mutli_gpu_model ซึ่งทำให้การฝึก/การคาดการณ์แบบคู่ขนานง่ายขึ้น (ปัจจุบันมีให้เฉพาะกับแบ็กเอนด์ TF เท่านั้น) แนวคิดหลักคือการที่คุณส่งแบบจำลองของคุณผ่านวิธีการและจะถูกคัดลอกไปยัง GPU ต่างๆ อินพุตดั้งเดิมจะถูกแบ่งออกเป็นชิ้น ๆ ซึ่งป้อนไปยัง GPU ต่างๆ แล้วรวมเป็นเอาต์พุตเดียว วิธีนี้สามารถใช้เพื่อให้ได้รับการฝึกอบรมและการคาดการณ์แบบคู่ขนาน อย่างไรก็ตาม โปรดทราบว่าสำหรับการฝึกอบรมจะไม่ปรับขนาดเป็นเส้นตรงตามปริมาณของ GPU เนื่องจากการซิงโครไนซ์ที่จำเป็น

2. ใส่ใจกับขนาดแบทช์

เมื่อคุณทำการฝึกอบรม GPU หลายตัว ให้ใส่ใจกับขนาดแบทช์ เนื่องจากมีผลหลายอย่างต่อความเร็ว/หน่วยความจำ การลู่เข้าของโมเดลของคุณ และถ้าคุณไม่ระวัง คุณอาจสร้างความเสียหายให้กับน้ำหนักโมเดลของคุณ!

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

การบรรจบกัน: หากคุณใช้ Stochastic Gradient Decent (SGD) หรือตัวแปรบางส่วนเพื่อฝึกโมเดลของคุณ คุณควรจำไว้ว่าขนาดแบทช์อาจส่งผลต่อความสามารถของเครือข่ายของคุณในการบรรจบกันและสรุป ขนาดแบทช์โดยทั่วไปในปัญหาการมองเห็นคอมพิวเตอร์จำนวนมากอยู่ระหว่าง 32-512 ตัวอย่าง เนื่องจาก เคสการ์และคณะ กล่าวไว้ว่า "ในทางปฏิบัติมีข้อสังเกตว่าเมื่อใช้ชุดงานที่ใหญ่กว่า (มากกว่า 512) คุณภาพของแบบจำลองจะเสื่อมลง ซึ่งวัดจากความสามารถในการสรุป" โปรดทราบว่าเครื่องมือเพิ่มประสิทธิภาพที่แตกต่างกันอื่นๆ มีคุณสมบัติที่แตกต่างกัน และเทคนิคการเพิ่มประสิทธิภาพแบบกระจายเฉพาะทางสามารถช่วยแก้ปัญหาได้ หากคุณสนใจรายละเอียดทางคณิตศาสตร์ เราขอแนะนำให้คุณอ่านวิทยานิพนธ์ของ Joeri Hermans “เกี่ยวกับการเรียนรู้เชิงลึกที่ปรับขนาดได้และการไล่ระดับสีแบบขนาน"

ทำลายน้ำหนัก: นี่เป็นรายละเอียดทางเทคนิคที่น่ารังเกียจซึ่งอาจส่งผลเสียหายได้ เมื่อคุณทำการฝึกอบรม GPU หลายตัว สิ่งสำคัญคือต้องป้อน GPU ทั้งหมดด้วยข้อมูล อาจเกิดขึ้นได้ว่าแบตช์สุดท้ายของยุคของคุณมีข้อมูลน้อยกว่าที่กำหนดไว้ (เนื่องจากขนาดของชุดข้อมูลของคุณไม่สามารถแบ่งตามขนาดของแบตช์ของคุณได้อย่างแน่นอน) ซึ่งอาจทำให้ GPU บางตัวไม่ได้รับข้อมูลใดๆ ในระหว่างขั้นตอนสุดท้าย น่าเสียดายที่ Keras Layers บางตัวที่สะดุดตาที่สุดคือ Batch Normalization Layer ไม่สามารถรับมือกับค่าที่นำไปสู่ค่า nan ที่ปรากฏในน้ำหนัก (ค่าเฉลี่ยและความแปรปรวนในเลเยอร์ BN) ในการทำให้สิ่งต่าง ๆ เลวร้ายยิ่งขึ้น เราจะไม่สังเกตเห็นปัญหาระหว่างการฝึก (ในขณะที่ขั้นตอนการเรียนรู้คือ 1) เนื่องจากเลเยอร์เฉพาะใช้ค่าเฉลี่ย/ความแปรปรวนของชุดงานในการประมาณค่า อย่างไรก็ตาม ในระหว่างการคาดการณ์ (ตั้งค่าเฟสการเรียนรู้เป็น 0) ค่าเฉลี่ย/ความแปรปรวนกำลังถูกใช้ ซึ่งในกรณีของเราสามารถกลายเป็นน่านซึ่งนำไปสู่ผลลัพธ์ที่ไม่ดี ดังนั้นโปรดทำสิ่งที่ชอบให้ตัวเองและตรวจสอบให้แน่ใจเสมอว่าขนาดแบทช์ของคุณได้รับการแก้ไขเมื่อคุณทำการฝึกอบรม GPU หลายตัว วิธีง่ายๆ สองวิธีในการบรรลุเป้าหมายนี้คือการปฏิเสธชุดงานที่ไม่ตรงกับขนาดที่กำหนดไว้ล่วงหน้า หรือทำซ้ำระเบียนภายในชุดงานจนกว่าคุณจะถึงขนาดที่กำหนดไว้ล่วงหน้า สุดท้ายแต่ไม่ท้ายสุด พึงระลึกไว้เสมอว่าในการตั้งค่า multi-GPU ขนาดแบทช์ควรเป็นจำนวนเท่าของ GPU ที่มีอยู่ในระบบของคุณ

3. ข้อมูล GPU ความอดอยาก หรือที่รู้จักว่าซีพียูไม่สามารถตาม GPU ได้

โดยทั่วไปแล้ว ส่วนที่แพงที่สุดขณะฝึก/ทำนายเครือข่าย Deep คือการประมาณค่าที่เกิดขึ้นกับ GPU ข้อมูลจะได้รับการประมวลผลล่วงหน้าใน CPU บนพื้นหลัง และจะถูกป้อนไปยัง GPU เป็นระยะ อย่างไรก็ตาม เราไม่ควรประมาทความเร็วของ GPU; อาจเกิดขึ้นได้หากเครือข่ายของคุณตื้นเกินไปหรือขั้นตอนก่อนการประมวลผลซับซ้อนเกินไปที่ CPU ของคุณไม่สามารถตาม GPU ของคุณหรือกล่าวอีกนัยหนึ่งคือพวกเขาไม่ได้ป้อนข้อมูลอย่างรวดเร็วเพียงพอ ซึ่งอาจนำไปสู่การใช้ GPU ต่ำ ซึ่งแปลเป็นเงิน/ทรัพยากรที่สูญเปล่า

โดยทั่วไป Keras จะทำการประเมินแบตช์แบบขนาน อย่างไรก็ตาม เนื่องจาก GIL ของ Python (Global Interpreter Lock) ของ Python คุณจึงไม่สามารถบรรลุมัลติเธรดจริงใน Python ได้ มีวิธีแก้ไขปัญหาสองวิธี: ใช้หลายกระบวนการ (โปรดทราบว่ามี gotchas จำนวนมากในส่วนนี้ที่ฉันจะไม่กล่าวถึงที่นี่) หรือทำให้ขั้นตอนก่อนการประมวลผลของคุณเรียบง่าย ในอดีต ฉันได้ส่ง Pull-Request ไปที่ Keras เพื่อบรรเทาความเครียดที่ไม่จำเป็นบางส่วนที่เราวางไว้บน CPU ระหว่างการประมวลผลภาพล่วงหน้า ดังนั้นผู้ใช้ส่วนใหญ่ไม่ควรได้รับผลกระทบหากพวกเขาใช้ตัวสร้างมาตรฐาน หากคุณมีตัวสร้างแบบกำหนดเอง ให้พยายามผลักดันตรรกะให้มากที่สุดไปยังไลบรารี C เช่น Numpy เพราะวิธีการบางอย่างเหล่านี้จริงๆ ปล่อย GIL ซึ่งหมายความว่าคุณสามารถเพิ่มระดับของการขนาน วิธีที่ดีในการตรวจจับว่าคุณกำลังเผชิญกับความอดอยากของข้อมูล GPU หรือไม่คือการตรวจสอบการใช้ GPU อย่างไรก็ตาม ขอเตือนว่านี่ไม่ใช่เหตุผลเดียวสำหรับการสังเกตว่า (การซิงโครไนซ์ที่เกิดขึ้นระหว่างการฝึกข้าม GPU หลายตัวยังโทษว่ามีการใช้ประโยชน์น้อยอีกด้วย ). โดยปกติ GPU จะตรวจจับความอดอยากของข้อมูลได้ด้วยการสังเกตการระเบิดของ GPU ตามด้วยการหยุดยาวๆ โดยไม่มีการใช้งาน ในอดีต ฉันได้เปิดแหล่งที่มาของส่วนขยายสำหรับ Dstat ที่สามารถช่วยคุณวัดการใช้ GPU ของคุณได้ ดังนั้นให้ดูที่ โพสต์บล็อกเดิม.

4. การบันทึกโมเดลคู่ขนานของคุณ

สมมติว่าคุณใช้เมธอด mutli_gpu_model เพื่อทำให้โมเดลของคุณขนานกัน การฝึกเสร็จสิ้น และตอนนี้คุณต้องการคงน้ำหนักไว้ ข่าวร้ายคือคุณไม่สามารถเรียก save() ได้ ปัจจุบัน Keras มีข้อ จำกัด ที่ไม่อนุญาตให้คุณ บันทึกโมเดลคู่ขนาน. มี 2 ​​วิธีในการแก้ปัญหานี้: เรียก save() ตามการอ้างอิงของรุ่นดั้งเดิม (น้ำหนักจะได้รับการอัปเดตโดยอัตโนมัติ) หรือคุณจำเป็นต้องทำให้โมเดลเป็นอนุกรมโดยการตัดเวอร์ชันแบบขนานและล้างการเชื่อมต่อที่ไม่จำเป็นทั้งหมด ตัวเลือกแรกนั้นง่ายกว่ามาก แต่ในอนาคตฉันวางแผนที่จะโอเพ่นซอร์สด้วยเมธอด serialize() ที่ดำเนินการอย่างหลัง

5. การนับ GPU ที่มีอยู่มีผลข้างเคียงที่น่ารังเกียจ

น่าเสียดายในขณะนี้ มีผลข้างเคียงที่น่ารังเกียจในเมธอด tensorflow.python.client.device_lib.list_local_devices() ซึ่งทำให้มีการสร้างเซสชัน TensorFlow ใหม่และการเริ่มต้น GPU ที่มีอยู่ทั้งหมดบนระบบ ซึ่งอาจนำไปสู่ผลลัพธ์ที่ไม่คาดคิด เช่น การดู GPU มากกว่าที่กำหนด หรือการเริ่มต้นเซสชันใหม่ก่อนกำหนด (คุณสามารถอ่านรายละเอียดทั้งหมดเกี่ยวกับสิ่งนี้ได้ ดึงคำขอ). เพื่อหลีกเลี่ยงความประหลาดใจที่คล้ายกัน ขอแนะนำให้ใช้วิธี K.get_session().list_devices() ของ Keras แทน ซึ่งจะคืนค่า GPU ที่ลงทะเบียนในปัจจุบันทั้งหมดให้คุณในเซสชัน สุดท้ายแต่ไม่ท้ายสุด โปรดจำไว้ว่าการเรียกเมธอด list_devices() นั้นมีราคาแพง ดังนั้นหากคุณสนใจแค่จำนวน GPU ที่พร้อมใช้งาน ให้เรียกใช้เมธอดหนึ่งครั้งและเก็บหมายเลขนั้นไว้ในตัวแปรในเครื่อง

แค่นั้นแหละ! หวังว่ารายการนี้จะเป็นประโยชน์ หากคุณพบ gotchas/เคล็ดลับอื่นๆ สำหรับการฝึกอบรม GPU บน Keras โปรดแชร์ความคิดเห็นด้านล่าง 🙂