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

DistributedDataParallel (DDP)

กลุ่มกระบวนการ dist.init_process_group, DistributedSampler และการทำกราดิเอนต์ให้ตรงกัน

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

DDP คืออะไร

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

กลุ่มกระบวนการ

DDP ประสานงานกระบวนการต่าง ๆ ผ่านกลุ่มกระบวนการ แต่ละกระบวนการจะได้รับลำดับที่ไม่ซ้ำกันและทราบขนาดของกลุ่มทั้งหมด กระบวนการเหล่านี้สื่อสารกันผ่านระบบเบื้องหลังการสื่อสาร โดยบน GPU ของ NVIDIA ระบบเบื้องหลังนั้นคือ nccl

init_process_group

ทุกกระบวนการเริ่มต้นด้วยการเข้าร่วมกลุ่ม dist.init_process_group พร้อม backend="nccl" จะตั้งค่าการสื่อสารระหว่าง GPU

import torch.distributed as dist
import os

dist.init_process_group(backend="nccl")
rank = dist.get_rank()
world_size = dist.get_world_size()

การกำหนดอุปกรณ์

แต่ละกระบวนการควรเป็นเจ้าของ GPU หนึ่งตัว ใช้ลำดับภายในเครื่องเพื่อกำหนดอุปกรณ์ เพื่อให้กระบวนการ 0 ใช้ cuda:0 กระบวนการ 1 ใช้ cuda:1 และต่อไปตามลำดับ

local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)

การห่อหุ้มโมเดล

ย้ายโมเดลไปยัง GPU ของโมเดลนั้น จากนั้นห่อหุ้มด้วย DDP และ device_ids=[local_rank] DDP จะลงทะเบียนฮุกเพื่อซิงโครไนซ์เกรเดียนต์ระหว่างการส่งผ่านย้อนกลับ

from torch.nn.parallel import DistributedDataParallel as DDP

model = MyModel().to(device)
model = DDP(model, device_ids=[local_rank])

DistributedSampler

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

from torch.utils.data import DataLoader
from torch.utils.data.distributed import DistributedSampler

sampler = DistributedSampler(dataset)
loader = DataLoader(dataset, batch_size=32, sampler=sampler)

การสุ่มสับใหม่ในแต่ละยุค

เรียกใช้ sampler.set_epoch(epoch) เมื่อเริ่มต้นแต่ละยุค วิธีนี้จะตั้งค่าเมล็ดของการสุ่มสับใหม่ให้สอดคล้องกันระหว่างกระบวนการ เพื่อให้ทุกลำดับสุ่มในลักษณะเดียวกันและส่วนแบ่งยังคงไม่ทับซ้อนกัน

for epoch in range(epochs):
    sampler.set_epoch(epoch)
    for x, y in loader:
        ...

การรวมเกรเดียนต์ทั้งหมด

ระหว่าง loss.backward() DDP จะทำการรวมค่าทั้งหมด: ทุกกระบวนการส่งเกรเดียนต์ของตนเองและรับผลลัพธ์ที่หาค่าเฉลี่ยแล้ว ทำให้แบบจำลองทุกชุดใช้การปรับปรุงที่เหมือนกัน การรวมค่าทั้งหมดจะทำงานซ้อนกับการส่งผ่านย้อนกลับเพื่อซ่อนต้นทุนด้านการสื่อสาร

ไม่มีคอขวดที่ GPU 0

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

การเปิดใช้งานด้วยคำสั่งทอร์ชรัน

ทอร์ชรันจะเปิดใช้กระบวนการต่อ GPU และตั้งค่าตัวแปรสภาพแวดล้อมสำหรับลำดับ --nproc_per_node=4 จะเริ่มต้น 4 กระบวนการ (หนึ่งกระบวนการต่อ GPU) บนโหนดนี้

torchrun --nproc_per_node=4 train.py

บันทึกเฉพาะที่ลำดับ 0

ทุกลำดับมีน้ำหนักเหมือนกัน ดังนั้นควรมีเพียงลำดับเดียวที่เขียนจุดตรวจสอบ เพื่อป้องกันการเขียนทับกัน ควบคุมการบันทึกด้วยการตรวจสอบลำดับ

if rank == 0:
    torch.save(model.module.state_dict(), "model.pt")
dist.barrier()

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

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

ทบทวน

คุณได้เรียนรู้ DistributedDataParallel:

dist.init_process_group(backend="nccl") เข้าร่วมกลุ่มกระบวนการ
DistributedSampler มอบส่วนย่อยของข้อมูลที่ไม่ทับซ้อนกันให้แต่ละลำดับ
DDP(model, device_ids=[rank]) ซิงโครไนซ์เกรเดียนต์ผ่านการรวมค่าทั้งหมด
เปิดใช้งานด้วย torchrun --nproc_per_node=4
บันทึกเฉพาะที่ลำดับ 0

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

บทเรียน “DistributedDataParallel (DDP)” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “DistributedDataParallel (DDP)”

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

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

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

บทเรียน “DistributedDataParallel (DDP)” ใช้เวลานานแค่ไหน

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

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

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

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

← กลับไปที่ Learn AI with Python