తెలుగు వార్తలు
తాజా
శ్రీలంక మళ్లీ దివాళా దిశగా వెళుతోందని మాజీ మంత్రి రజిత సేనారత్న హెచ్చరికతంబుట్టేగామలో అవసరంలో ఉన్న కుటుంబానికి ఇంటి నిర్మాణానికి మాజీ అధ్యక్షురాలి నిధులురోగులకు మరిన్ని జాప్యాలు: బిలియన్ రూపాయల క్యాన్సర్ చికిత్స యంత్రాలు వినియోగం లేకుండా నిలిచిపోయాయిసూర్యకు ఒకే ఏడాదిలో ఒక్కొక్కటి 2 బిలియన్ భారతీయ రూపాయలు వసూలు చేసే మూడు చిత్రాల అవకాశంపాకిస్థాన్‌లోని టార్బెలా జలవిద్యుత్ ప్రాజెక్టు వద్ద రిటైనింగ్ వాల్ కూలినట్లు సమాచారంశ్రీలంక టూరిజానికి అంతర్జాతీయ ప్రసార సంస్థలు మద్దతునిస్తాయని మంత్రి చెప్పారునొచ్చియాగమ హత్యకు సహకరించాడన్న ఆరోపణలపై ఓ వ్యక్తిని పోలీసులు అరెస్ట్ చేశారుసింహరాజలో వన్యప్రాణుల సేకరణ ఆరోపణలపై నలుగురు చైనా పౌరులు రిమాండ్‌కు గురయ్యారు
AI & టెక్నాలజీ

FSDP2, GPU ప్రొఫైలింగ్, మొబైల్ గణన

దృశ్య వివరణ కోసం అధిక వోల్టేజ్ విద్యుత్ స్తంభాలు; డేటా సెంటర్ లేదా GPU వ్యవస్థ కాదు.
దృశ్య వివరణ కోసం అధిక వోల్టేజ్ విద్యుత్ స్తంభాలు; డేటా సెంటర్ లేదా GPU వ్యవస్థ కాదు.

ఉత్పత్తి స్థాయి AI ఇంజినీరింగ్ పంపిణీ చేసిన బహుళ-GPU అమలు, హార్డ్‌వేర్ స్థాయి ప్రొఫైలింగ్, వివిధ ప్లాట్‌ఫారమ్‌లపై పనిచేసే మొబైల్/ఎడ్జ్ రన్‌టైమ్‌లను కలుపుతుంది. ఈ మూడు రంగాలనూ కింద వివరంగా పరిశీలిస్తాం.

1. PyTorch FSDP2తో బహుళ-GPU పంపిణీ శిక్షణ

PyTorch యొక్క ఆధునిక FSDP2 (fully_shard), DTensor ఉపయోగించి మోడల్ పారామీటర్లు, గ్రేడియెంట్లు, ఆప్టిమైజర్ స్థితులను ఒక్కో పారామీటర్ స్థాయిలో GPUల మధ్య విభజిస్తుంది. దీనివల్ల మెమరీ నకళ్లు తొలగిపోతాయి, అలాగే కమ్యూనికేషన్ గణనతో సమాంతరంగా జరుగుతుంది.

పూర్తి బహుళ-GPU శిక్షణ స్క్రిప్ట్ కింద ఉంది. torchrun --nproc_per_node=4 train_fsdp.py ఉపయోగించి దీన్ని 4 GPUలపై ప్రారంభించండి.

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()
  • అంతర్గతంగా జరిగేది: ప్రతి లేయర్ ఫార్వర్డ్ పాస్‌కు ముందు, ఆ బ్లాక్‌కు మాత్రమే పూర్తి bfloat16 వెయిట్‌లను పునర్నిర్మించడానికి FSDP, NVLink మీద అసమకాలిక NCCL All-Gatherను జారీ చేస్తుంది, గణనను నడిపి, విభజించని వెయిట్‌లను వెంటనే విస్మరిస్తుంది. loss.backward() సమయంలో గ్రేడియెంట్ల సగటు లెక్కించి, Reduce-Scatter ద్వారా వాటిని తిరిగి GPUల మధ్య విభజిస్తుంది.

2. PyTorch మోడల్ ప్రొఫైలింగ్: PyTorch Profiler & NVIDIA Nsight Compute (ncu)

GPU కోడ్‌ను ఆప్టిమైజ్ చేయాలంటే కర్నల్ మెమరీ బ్యాండ్‌విడ్త్ పరిమితికి లోబడి ఉందా (HBM రీడ్‌లు/రైట్‌ల కోసం వేచి ఆగిపోవడం), లేక గణన పరిమితికి లోబడి ఉందా (Tensor Core FLOPSను పూర్తిగా వినియోగించడం) తెలుసుకోవాలి.

దశ A: torch.profilerతో స్థూల స్థాయి ట్రేస్

CPU లాంచ్‌ల మధ్య ఖాళీలు, నెమ్మదైన డేటా లోడర్లు, అత్యధిక సమయం తీసుకునే CUDA కర్నల్‌లను గుర్తించడానికి PyTorch Profilerను ఉపయోగించండి.

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: NVIDIA Nsight Compute (ncu)తో సూక్ష్మ స్థాయి Roofline విశ్లేషణ

torch.profiler నెమ్మదైన కర్నల్‌ను గుర్తించిన తర్వాత, Streaming Multiprocessors (SMs)పై హార్డ్‌వేర్ పనితీరు కౌంటర్లను నేరుగా పరిశీలించడానికి టెర్మినల్ నుంచి ncu నడపండి:

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

kernel_report.ncu-repలోని Speed of Light (SOL), Roofline Chartలను పరిశీలించేటప్పుడు రెండు సంఖ్యలను చూడండి:

హార్డ్‌వేర్ కొలమానంమెమరీ పరిమిత కర్నల్ (ఉదా., LayerNorm, Softmax, Decode)గణన పరిమిత కర్నల్ (ఉదా., పెద్ద బ్యాచ్ GEMM, Prefill)
గణన (SM) త్రూపుట్తక్కువ (< 25%) - Tensor Cores ఖాళీగా ఉంటాయి.ఎక్కువ (> 75%) - Tensor Cores గరిష్ఠ FLOPSకు దగ్గరగా నడుస్తాయి.
మెమరీ (HBM) త్రూపుట్ఎక్కువ (> 75%) - HBM బస్ పూర్తిగా నిండిపోతుంది.తక్కువ నుంచి మధ్యస్థం (< 50%) - డేటా ఆన్-చిప్ SRAM క్యాష్‌లను తిరిగి ఉపయోగిస్తుంది.
ప్రధాన పరిష్కారంకర్నల్ ఫ్యూజన్ (Triton/torch.compile), క్వాంటైజేషన్ (FP8/INT4), లేదా బ్యాచ్ పరిమాణాన్ని పెంచడం.తక్కువ ప్రెసిషన్ (FP8/NVFP4), Tensor Core టైల్ అలైన్‌మెంట్ (64/128 గుణిజాలు), లేదా పెద్ద GPUలు.

3. ఎడ్జ్ & మొబైల్ GPU అమలు: Apple Metal & Vulkan Compute

స్మార్ట్‌ఫోన్లు, ల్యాప్‌టాప్‌లు, ఎంబెడెడ్ పరికరాలపై న్యూరల్ నెట్‌వర్క్‌లను డిప్లాయ్ చేయాలంటే NVIDIA డ్రైవర్లు లేదా భారీ విద్యుత్ బడ్జెట్‌లు లేకుండానే నడపాలి. దానికి బదులుగా Unified Memory Architectures (UMA)తో Apple Metal, Vulkan Computeపై ఆధారపడాలి.

  • యూనిఫైడ్ మెమరీ ఆర్కిటెక్చర్ (జీరో-కాపీ అమలు).
  • CPU RAM నుంచి VRAMకు PCIe మీద టెన్సర్‌లను కాపీ చేయాల్సిన డిస్క్రీట్ NVIDIA GPUలలా కాకుండా, Apple Silicon (M-series / A-series), మొబైల్ SoCలు (Qualcomm Snapdragon, ARM Mali) CPU, GPU, NPUల మధ్య ఒకే భౌతిక LPDDR5/LPDDR5X మెమరీ పూల్‌ను పంచుకుంటాయి.
  • Apple MLX, llama.cpp, ExecuTorch వంటి ఫ్రేమ్‌వర్క్‌లు మోడల్ వెయిట్‌లను నేరుగా షేర్డ్ అడ్రస్ స్పేస్ (MTLResourceStorageModeShared)లో మ్యాప్ చేసి, హోస్ట్ నుంచి పరికరానికి బదిలీ లేటెన్సీని పూర్తిగా తొలగిస్తాయి.
  • Apple Metal & Metal Performance Shaders (MPS).
  • macOS, iOSలపై CUDA స్థానంలో Metal ఉంటుంది. డెవలపర్లు C++14 నుంచి రూపొందిన Metal Shading Language (MSL)లో కంప్యూట్ షేడర్లను రాసి, Apple GPU కోర్ల మీద థ్రెడ్‌గ్రూప్‌లను, Simdgroup Matrix సూచనలను (NVIDIA Tensor Coresకు Apple సమానమైనవి) పంపిస్తారు.
  • PyTorchలో device="mps" అమర్చితే టెన్సర్ ఆపరేషన్లు Apple యొక్క MPSGraph కంపైలర్ ద్వారా వెళ్తాయి. అది ఆపరేషన్లను డైనమిక్‌గా కలిపి GPU అమలు యూనిట్ల మీద పనిని షెడ్యూల్ చేస్తుంది.
  • వివిధ ప్లాట్‌ఫారమ్‌లపై Vulkan Compute & SPIR-V.
  • Android, Windows, Linux, AMD/Intel/Qualcomm GPUలన్నింటిలో Vulkan Compute సార్వత్రిక, విక్రేత-తటస్థ GPU బ్యాకెండ్‌గా పనిచేస్తుంది.
  • కంప్యూట్ కర్నల్‌లను (GLSL, HLSLలో రాసినవి, లేదా MLIR/IREE నుంచి కంపైల్ చేసినవి) SPIR-V బైట్‌కోడ్‌గా కంపైల్ చేస్తారు. Cooperative Matrix ఎక్స్‌టెన్షన్‌లను (VK_KHR_cooperative_matrix) ఉపయోగించి, ఒకే పోర్టబుల్ బైనరీతో Qualcomm Adreno, ARM Mali, AMD RDNA, Intel Arc GPUలలోని హార్డ్‌వేర్ మ్యాట్రిక్స్ గుణకార యూనిట్లను Vulkan కర్నల్‌లు నేరుగా ఉపయోగిస్తాయి.

మరిన్ని వార్తలు: AI & టెక్నాలజీ