0Pricing
Learn AI with Python · บทเรียน

การฝึกหลาย GPU ด้วย DataParallel

nn.DataParallel การจัดสมดุลหน่วยความจำ GPU คอขวดแบนด์วิดท์ และกรณีที่ DDP เหมาะกว่า

การฝึกหลาย GPU ด้วย DataParallel เป็นบทเรียน Learn AI with Python ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn AI with Python และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn AI with Python มีบทเรียนทั้งหมด 4 บทเรียน

เหตุผลที่ใช้ GPU หลายตัว

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

การประมวลผลข้อมูลแบบขนาน

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

nn.DataParallel

nn.DataParallel ห่อหุ้มโมเดลได้ด้วยโค้ดเพียงบรรทัดเดียว คุณส่งรหัส GPU ที่ต้องการใช้ แล้ว PyTorch จะจัดการกระจายข้อมูลขาเข้าและรวบรวมผลลัพธ์โดยอัตโนมัติ

import torch
import torch.nn as nn

model = MyModel().cuda()
model = nn.DataParallel(model, device_ids=[0, 1])

การแบ่งชุดข้อมูลโดยอัตโนมัติ

ระหว่างการส่งผ่านไปข้างหน้า DataParallel จะแบ่งชุดข้อมูลตามมิติที่ 0 ไปยัง GPU ที่ระบุไว้ ชุดข้อมูลขนาด 64 บน GPU สองตัวจะกลายเป็นชุดข้อมูลย่อยสองชุด ชุดละ 32 ตัว GPU แต่ละตัวจะเรียกใช้โมเดลเดียวกันกับชุดข้อมูลย่อยของตนเองแบบขนานกัน

# batch of 64 with device_ids=[0, 1]
# GPU 0 processes samples 0..31
# GPU 1 processes samples 32..63

การหาค่าเฉลี่ยเกรเดียนต์

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

วงรอบการฝึกปกติ

ส่วนที่ดีที่สุดคือวงรอบการฝึกของคุณแทบไม่ต้องเปลี่ยนแปลง คุณย้ายข้อมูลไปยัง GPU หลักแล้วเรียกใช้โมเดลที่ห่อหุ้มไว้ตามปกติ โดย DataParallel จะจัดการการกระจายข้อมูลเบื้องหลัง

for x, y in loader:
    x, y = x.cuda(), y.cuda()
    optimizer.zero_grad()
    out = model(x)            # auto-split across GPUs
    loss = criterion(out, y)
    loss.backward()           # gradients averaged
    optimizer.step()

ความไม่สมดุลของ GPU 0

DataParallel มีข้อบกพร่องที่ทราบกันดี นั่นคือ GPU หลัก (โดยปกติคือGPU 0) จะรวบรวมผลลัพธ์ทั้งหมดและคำนวณฟังก์ชันสูญเสีย จึงต้องรับภาระหน่วยความจำและการคำนวณเพิ่มเติม เมื่อมี GPU หลายตัว GPU 0 จะกลายเป็นคอขวดและอาจหน่วยความจำไม่พอก่อน GPU ตัวอื่น

กระบวนการเดียว หลายเธรด

DataParallel ทำงานในกระบวนการภาษาไพธอนเพียงกระบวนการเดียวและใช้เธรดควบคุม GPU การล็อกตัวแปลภาษาส่วนกลางของภาษาไพธอน รวมถึงค่าใช้จ่ายในการกระจายและรวบรวมข้อมูล จะจำกัดประสิทธิภาพการเพิ่มขนาด โดยเฉพาะเมื่อใช้ GPU มากกว่า 2 ถึง 4 ตัว

เหตุผลที่แนะนำให้ใช้ DDP

ด้วยเหตุผลเหล่านี้ จึงแนะนำให้ใช้DistributedDataParallel (DDP)สำหรับงานที่ใช้ GPU หลายตัวอย่างจริงจัง DDP เรียกใช้หนึ่งกระบวนการต่อ GPU ซิงโครไนซ์เกรเดียนต์ด้วยการรวมค่าทั้งหมดที่มีประสิทธิภาพ และหลีกเลี่ยงคอขวดที่ GPU 0 ทำให้เพิ่มขนาดได้เกือบเป็นเชิงเส้น

กรณีที่ DataParallel ยังเหมาะสม

DataParallel ยอมรับได้สำหรับการทดลองอย่างรวดเร็วบนเครื่องเดียวที่มี GPU 2 ตัว ซึ่งความเรียบง่ายของการใช้เพียงบรรทัดเดียวมีข้อดีมากกว่าความไม่มีประสิทธิภาพ แต่สำหรับการฝึกบนหลายโหนดหรือการใช้ GPU หลายตัว ควรเลือกใช้ DDP แทน

ข้อผิดพลาดที่พบบ่อย: การบันทึก

พจนานุกรมสถานะของโมเดลที่ห่อหุ้มไว้จะมีคำนำหน้า module. หากต้องการบันทึกจุดตรวจสอบที่สะอาด ให้บันทึก model.module.state_dict() เพื่อให้โหลดเข้าสู่โมเดลที่ไม่ได้ห่อหุ้มได้อย่างถูกต้องในภายหลัง

torch.save(model.module.state_dict(), "model.pt")

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความรู้เกี่ยวกับ DataParallel ของคุณ

ทบทวน

คุณได้เรียนรู้การฝึกด้วย GPU หลายตัวโดยใช้ DataParallel:

  • nn.DataParallel(model, device_ids=[0, 1]) จำลองโมเดลและแบ่งชุดข้อมูล
  • เกรเดียนต์จะถูกหาค่าเฉลี่ยข้าม GPU ในแต่ละขั้นตอน
  • ความไม่สมดุลของ GPU 0และการออกแบบให้ใช้กระบวนการเดียวจำกัดความสามารถในการเพิ่มขนาด
  • ควรเลือกใช้DDPเมื่อมี GPU หลายตัวหรือฝึกบนหลายโหนด

คำถามที่พบบ่อย

บทเรียน “การฝึกหลาย GPU ด้วย DataParallel” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การฝึกหลาย GPU ด้วย DataParallel” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn AI with Python ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn AI with Python มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การฝึกหลาย GPU ด้วย DataParallel”

nn.DataParallel การจัดสมดุลหน่วยความจำ GPU คอขวดแบนด์วิดท์ และกรณีที่ DDP เหมาะกว่า คุณปฏิบัติ Learn AI with Python ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn AI with Python หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn AI with Python บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การฝึกหลาย GPU ด้วย DataParallel” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn AI with Python นี้ได้ไหม

ได้ บทเรียน Learn AI with Python ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การฝึกหลาย GPU ด้วย DataParallel
  2. DistributedDataParallel (DDP)
  3. การฝึกความแม่นยำผสมด้วย AMP
  4. การฝึกอย่างมีประสิทธิภาพด้วย Hugging Face Accelerate
← กลับไปที่ Learn AI with Python