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

การฝึกความแม่นยำผสมด้วย AMP

torch.cuda.amp.autocast(), GradScaler, FP16 เทียบกับ BF16 การประหยัดหน่วยความจำ และการเพิ่มความเร็ว

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

ความแม่นยำผสมคืออะไร

การฝึกด้วยความแม่นยำผสมจะดำเนินการส่วนใหญ่ด้วยเลขทศนิยม 16 บิต (FP16) แทน 32 บิต (FP32) FP16 ใช้หน่วยความจำเพียงครึ่งเดียวและทำงานได้เร็วขึ้นบนแกนเทนเซอร์ของ GPU สมัยใหม่ ขณะที่การดำเนินการที่ไวต่อความคลาดเคลื่อนบางส่วนยังคงใช้ FP32 เพื่อความเสถียร

ประโยชน์

ความแม่นยำผสมมอบประโยชน์ดังนี้:

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

ปัญหาอันเดอร์โฟลว์ของ FP16

FP16 มีช่วงค่าที่แคบ ค่าของเกรเดียนต์ที่เล็กอาจเกิดอันเดอร์โฟลว์จนกลายเป็นศูนย์และหยุดการเรียนรู้โดยไม่แสดงข้อผิดพลาด นี่คือความท้าทายหลักที่ความแม่นยำผสมต้องแก้ไข และเป็นเหตุผลที่เราไม่สามารถแปลงทุกอย่างเป็น FP16 ได้โดยตรง

torch.cuda.amp

PyTorch Automatic Mixed Precision (AMP)จัดการรายละเอียดเหล่านี้ด้วยเครื่องมือสองอย่าง: autocast เลือกความแม่นยำสำหรับแต่ละการดำเนินการ และ GradScaler ป้องกันอันเดอร์โฟลว์ของเกรเดียนต์

import torch
from torch.cuda.amp import autocast, GradScaler

บริบทการเลือกความแม่นยำอัตโนมัติ

ห่อหุ้มการส่งผ่านไปข้างหน้าด้วย autocast() ภายในบริบทนี้ PyTorch จะเรียกใช้การดำเนินการแต่ละอย่างด้วยความแม่นยำที่ปลอดภัยที่สุดโดยอัตโนมัติ เช่น การคูณเมทริกซ์ใช้ FP16 ส่วนการลดค่าอย่างซอฟต์แมกซ์และฟังก์ชันสูญเสียใช้ FP32

with autocast():
    output = model(x)
    loss = criterion(output, y)

แนะนำ GradScaler

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

scaler = GradScaler()

การปรับสเกลฟังก์ชันสูญเสีย

scaler.scale(loss).backward() จะเพิ่มสเกลของฟังก์ชันสูญเสียแล้วเรียกใช้การส่งผ่านย้อนกลับ เกรเดียนต์ที่ได้จะถูกปรับสเกลด้วยเช่นกัน เพื่อป้องกันไม่ให้ค่าขนาดเล็กหายไป

scaler.scale(loss).backward()

scaler.step

scaler.step(optimizer) จะยกเลิกการปรับสเกลเกรเดียนต์กลับไปเป็นขนาดจริงก่อน จากนั้นจึงเรียกใช้ optimizer.step() แต่จะทำเช่นนั้นก็ต่อเมื่อไม่พบค่าอินฟินิตีหรือ NaNs หากเกรเดียนต์ล้นช่วง ขั้นตอนดังกล่าวจะถูกข้าม

scaler.step(optimizer)

scaler.update

scaler.update() จะปรับตัวคูณสเกลสำหรับรอบถัดไป โดยเพิ่มสเกลเมื่อขั้นตอนต่าง ๆ สำเร็จ และลดสเกลหลังเกิดค่าล้นช่วง การปรับสเกลแบบปรับตามสถานการณ์นี้ช่วยให้การฝึกมีเสถียรภาพโดยอัตโนมัติ

scaler.update()

วงรอบ AMP ฉบับเต็ม

เมื่อนำส่วนประกอบต่าง ๆ มารวมกัน จะได้ขั้นตอนการฝึกด้วยความแม่นยำผสมที่สมบูรณ์

scaler = GradScaler()
for x, y in loader:
    x, y = x.cuda(), y.cuda()
    optimizer.zero_grad()
    with autocast():
        out = model(x)
        loss = criterion(out, y)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

เคล็ดลับเชิงปฏิบัติ

โปรดคำนึงถึงสิ่งต่อไปนี้:

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

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

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

ทบทวน

คุณได้เรียนรู้การฝึกด้วยความแม่นยำผสมโดยใช้ AMP:

autocast() เลือก FP16 หรือ FP32 สำหรับแต่ละการดำเนินการในการส่งผ่านไปข้างหน้า
GradScaler ปรับสเกลฟังก์ชันสูญเสียเพื่อหลีกเลี่ยงอันเดอร์โฟลว์ของเกรเดียนต์
วงจรคือ scaler.scale(loss).backward(), scaler.step(optimizer), scaler.update()
ผลลัพธ์คือประหยัดหน่วยความจำประมาณ 2 เท่าและฝึกได้เร็วขึ้น

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

บทเรียน “การฝึกความแม่นยำผสมด้วย AMP” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การฝึกความแม่นยำผสมด้วย AMP”

torch.cuda.amp.autocast(), GradScaler, FP16 เทียบกับ BF16 การประหยัดหน่วยความจำ และการเพิ่มความเร็ว คุณปฏิบัติ Learn AI with Python ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

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

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

บทเรียน “การฝึกความแม่นยำผสมด้วย AMP” ใช้เวลานานแค่ไหน

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

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

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

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

การฝึกหลาย GPU ด้วย DataParallel
DistributedDataParallel (DDP)
การฝึกความแม่นยำผสมด้วย AMP
การฝึกอย่างมีประสิทธิภาพด้วย Hugging Face Accelerate

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