ข่าวไทย
ล่าสุด
อดีตรัฐมนตรี รจิธา เสนารัตเน เตือนศรีลังกากำลังเข้าสู่ภาวะล้มละลายอีกครั้งอดีตประธานาธิบดีให้ทุนสร้างบ้านให้ครอบครัวผู้ยากไร้ในเมืองธรรมบุตเตกามาเครื่องรักษามะเร็งมูลค่าหลายพันล้านรูปีไม่ได้ใช้งาน เนื่องจากผู้ป่วยต้องเผชิญกับความล่าช้ามากขึ้นสุริยาลุ้นสร้างสถิติภาพยนตร์สามเรื่องทำรายได้เรื่องละ 2 พันล้านรูปีอินเดียในปีเดียวมีรายงานว่ากำแพงกันดินพังถล่มที่โครงการไฟฟ้าพลังน้ำ Tarbela ในปากีสถานรัฐมนตรีกล่าวว่าสถานีโทรทัศน์ระหว่างประเทศให้การสนับสนุนการท่องเที่ยวศรีลังกาตร.จับกุมผู้ต้องสงสัยมีส่วนช่วยฆ่าโนฉิยากามะชาวจีน 4 คนถูกคุมขังระหว่างสอบสวนข้อกล่าวหาเก็บสัตว์ป่าในป่าสิงหราชา
AI และเทคโนโลยี

FSDP2 การโปรไฟล์ GPU และการประมวลผลบนมือถือ

ภาพประกอบเสาไฟฟ้าแรงสูง ไม่ใช่ศูนย์ข้อมูลหรือระบบ GPU
ภาพประกอบเสาไฟฟ้าแรงสูง ไม่ใช่ศูนย์ข้อมูลหรือระบบ GPU

วิศวกรรม AI ระดับโปรดักชันเชื่อมโยงการประมวลผลแบบกระจายหลาย GPU การโปรไฟล์ระดับฮาร์ดแวร์ และรันไทม์มือถือ/เอดจ์ข้ามแพลตฟอร์มเข้าด้วยกัน ด้านล่างนี้คือการเจาะลึกทั้งสามด้าน

1. การฝึกแบบกระจายหลาย GPU ด้วย PyTorch FSDP2

FSDP2 (fully_shard) สมัยใหม่ของ PyTorch แบ่ง (shard) พารามิเตอร์ของโมเดล เกรเดียนต์ และสถานะของออปติไมเซอร์ไปยัง GPU ต่าง ๆ ในระดับต่อพารามิเตอร์โดยใช้ DTensor ช่วยขจัดการทำซ้ำหน่วยความจำ พร้อมทั้งซ้อนการสื่อสารกับการคำนวณ

ด้านล่างคือสคริปต์ฝึกแบบหลาย GPU แบบสมบูรณ์ เรียกใช้บน 4 GPU ด้วย torchrun --nproc_per_node=4 train_fsdp.py

import os
import torch
import torch.nn as nn
import torch.distributed as dist
from torch.distributed._composable.fsdp import fully_shard, MixedPrecisionPolicy

class TransformerBlock(nn.Module):
    def __init__(self, dim=2048, n_heads=16):
        super().__init__()
        self.norm1 = nn.RMSNorm(dim)
        self.attn = nn.MultiheadAttention(dim, n_heads, batch_first=True)
        self.norm2 = nn.RMSNorm(dim)
        self.ffn = nn.Sequential(
            nn.Linear(dim, dim * 4, bias=False),
            nn.SiLU(),
            nn.Linear(dim * 4, dim, bias=False),
        )

    def forward(self, x):
        h = self.norm1(x)
        attn_out, _ = self.attn(h, h, h, need_weights=False)
        x = x + attn_out
        return x + self.ffn(self.norm2(x))

class MiniLLM(nn.Module):
    def __init__(self, vocab_size=32000, dim=2048, n_layers=12):
        super().__init__()
        self.embed = nn.Embedding(vocab_size, dim)
        self.layers = nn.ModuleList([TransformerBlock(dim) for _ in range(n_layers)])
        self.head = nn.Linear(dim, vocab_size, bias=False)

    def forward(self, idx):
        x = self.embed(idx)
        for layer in self.layers:
            x = layer(x)
        return self.head(x)

def main():
    # 1. Initialize NCCL process group
    dist.init_process_group(backend="nccl")
    local_rank = int(os.environ["LOCAL_RANK"])
    torch.cuda.set_device(local_rank)
    device = torch.device("cuda", local_rank)

    # 2. Build model on meta device or standard CUDA, then shard layer-by-layer
    model = MiniLLM().to(device)
    mp_policy = MixedPrecisionPolicy(
        param_dtype=torch.bfloat16,
        reduce_dtype=torch.float32,
    )

    # Shard each TransformerBlock independently to prefetch weights on the fly
    for layer in model.layers:
        fully_shard(layer, mp_policy=mp_policy)
    fully_shard(model, mp_policy=mp_policy)

    optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)

    # 3. Distributed Training Step (All-Gather -> Compute -> Reduce-Scatter)
    for step in range(5):
        tokens = torch.randint(0, 32000, (8, 1024), device=device)
        targets = torch.randint(0, 32000, (8, 1024), device=device)

        optimizer.zero_grad()
        logits = model(tokens)
        loss = nn.functional.cross_entropy(logits.view(-1, 32000), targets.view(-1))
        loss.backward()
        optimizer.step()

        if local_rank == 0:
            mem_gb = torch.cuda.max_memory_allocated(device) / 1e9
            print(f"Step {step} | Loss: {loss.item():.4f} | Peak VRAM/GPU: {mem_gb:.2f} GB")

    dist.destroy_process_group()

if __name__ == "__main__":
    main()
  • สิ่งที่เกิดขึ้นเบื้องหลัง: ก่อนการ forward pass ของแต่ละเลเยอร์ FSDP จะสั่ง NCCL All-Gather แบบ asynchronous ผ่าน NVLink เพื่อสร้างน้ำหนัก bfloat16 เต็มชุดเฉพาะบล็อกนั้นขึ้นมาใหม่ ทำการคำนวณ แล้วทิ้งน้ำหนักที่ไม่ได้แบ่งทันที ระหว่าง loss.backward() เกรเดียนต์จะถูกเฉลี่ยและแบ่งกลับไปยัง GPU ต่าง ๆ ผ่าน Reduce-Scatter

2. การโปรไฟล์โมเดล PyTorch: PyTorch Profiler & NVIDIA Nsight Compute (ncu)

การเพิ่มประสิทธิภาพโค้ด GPU จำเป็นต้องรู้ว่าเคอร์เนลนั้นเป็น Memory-Bandwidth Bound (หยุดรอการอ่าน/เขียน HBM) หรือ Compute Bound (ใช้ Tensor Core FLOPS เต็มกำลัง)

ขั้นตอน A: เทรซระดับมาโครด้วย torch.profiler

ใช้ PyTorch Profiler เพื่อตรวจหาช่องว่างการ launch ของ CPU ตัวโหลดข้อมูลที่ช้า และ CUDA kernels ที่ใช้เวลามากที่สุด

import torch
from torch.profiler import profile, ProfilerActivity

model = torch.nn.Linear(4096, 4096, device="cuda", dtype=torch.float16)
x = torch.randn(1024, 4096, device="cuda", dtype=torch.float16)

with profile(
    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
    record_shapes=True,
    profile_memory=True,
) as prof:
    for _ in range(5):
        out = model(x)
        out.sum().backward()
    torch.cuda.synchronize()

print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
prof.export_chrome_trace("trace.json")  # Open in ui.perfetto.dev

ขั้นตอน B: การวิเคราะห์ Roofline ระดับจุลภาคด้วย NVIDIA Nsight Compute (ncu)

เมื่อ torch.profiler ระบุเคอร์เนลที่ช้าแล้ว ให้รัน ncu จากเทอร์มินัลเพื่อตรวจสอบตัวนับประสิทธิภาพฮาร์ดแวร์บน Streaming Multiprocessors (SMs) โดยตรง:

ncu --set full --target-processes all -o kernel_report python my_script.py

เมื่อตรวจสอบ Speed of Light (SOL) และ Roofline Chart ใน kernel_report.ncu-rep ให้ดูตัวเลขสองค่า:

ตัวชี้วัดฮาร์ดแวร์เคอร์เนลแบบ Memory-Bound (เช่น LayerNorm, Softmax, Decode)เคอร์เนลแบบ Compute-Bound (เช่น Large Batch GEMM, Prefill)
อัตราประมวลผล Compute (SM)ต่ำ (< 25%) - Tensor Cores ว่างอยู่สูง (> 75%) - Tensor Cores ทำงานใกล้ FLOPS สูงสุด
อัตราประมวลผล Memory (HBM)สูง (> 75%) - บัส HBM อิ่มตัวเต็มที่ต่ำถึงปานกลาง (< 50%) - ข้อมูลนำแคช SRAM บนชิปกลับมาใช้ซ้ำ
วิธีแก้หลักการรวมเคอร์เนล (Triton/torch.compile) การควอนไทซ์ (FP8/INT4) หรือเพิ่มขนาดแบตช์ลดความแม่นยำ (FP8/NVFP4) การจัดแนวไทล์ Tensor Core (พหุคูณของ 64/128) หรือใช้ GPU ที่ใหญ่ขึ้น

3. การประมวลผล GPU บนเอดจ์และมือถือ: Apple Metal & Vulkan Compute

การนำโครงข่ายประสาทไปใช้บนสมาร์ทโฟน แล็ปท็อป และอุปกรณ์ฝังตัวต้องทำงานโดยไม่มีไดรเวอร์ NVIDIA หรืองบพลังงานขนาดใหญ่ โดยอาศัย Apple Metal และ Vulkan Compute กับ Unified Memory Architectures (UMA) แทน

  • Unified Memory Architecture (การประมวลผลแบบ Zero-Copy)
  • ต่างจาก NVIDIA GPU แบบแยกที่ต้องคัดลอกเทนเซอร์ผ่าน PCIe จาก RAM ของ CPU ไปยัง VRAM, Apple Silicon (M-series / A-series) และ SoC มือถือ (Qualcomm Snapdragon, ARM Mali) ใช้พูลหน่วยความจำ LPDDR5/LPDDR5X ทางกายภาพเดียวร่วมกันระหว่าง CPU, GPU และ NPU
  • เฟรมเวิร์กอย่าง Apple MLX, llama.cpp และ ExecuTorch แมปน้ำหนักโมเดลเข้าสู่พื้นที่ที่อยู่ร่วมโดยตรง (MTLResourceStorageModeShared) ช่วยขจัดเวลาแฝงในการถ่ายโอนจากโฮสต์ไปยังอุปกรณ์อย่างสมบูรณ์
  • Apple Metal & Metal Performance Shaders (MPS)
  • บน macOS และ iOS, Metal แทนที่ CUDA นักพัฒนาเขียน compute shaders ด้วย Metal Shading Language (MSL) ซึ่งพัฒนามาจาก C++14 โดยกระจาย threadgroups ไปยังคอร์ GPU ของ Apple และคำสั่ง Simdgroup Matrix (เทียบเท่า Tensor Cores ของ NVIDIA ในฝั่ง Apple)
  • ใน PyTorch การตั้งค่า device="mps" จะส่งการดำเนินการเทนเซอร์ผ่านคอมไพเลอร์ MPSGraph ของ Apple ซึ่งรวมการดำเนินการแบบไดนามิกและจัดตารางงานไปยังยูนิตประมวลผลของ GPU
  • Vulkan Compute & SPIR-V ข้ามแพลตฟอร์ม
  • ทั่วทั้ง Android, Windows, Linux และ GPU ของ AMD/Intel/Qualcomm, Vulkan Compute ทำหน้าที่เป็นแบ็กเอนด์ GPU สากลที่เป็นกลางต่อผู้ผลิต
  • คอมพิวต์เคอร์เนล (เขียนด้วย GLSL, HLSL หรือคอมไพล์จาก MLIR/IREE) จะถูกคอมไพล์เป็น SPIR-V bytecode ด้วยส่วนขยาย Cooperative Matrix (VK_KHR_cooperative_matrix) เคอร์เนล Vulkan สามารถเข้าถึงยูนิตคูณเมทริกซ์ของฮาร์ดแวร์บน GPU Qualcomm Adreno, ARM Mali, AMD RDNA และ Intel Arc โดยตรงด้วยไบนารีแบบพกพาเพียงหนึ่งเดียว

ข่าวเพิ่มเติม: AI และเทคโนโลยี