मल्टी-GPU सेटअप

Clore.ai पर कई GPUs में बड़े AI मॉडल चलाएँ

CLORE.AI पर कई GPUs में बड़े AI मॉडल चलाएँ।

मल्टी-GPU सर्वर ढूंढ़ें: CLORE.AI मार्केटप्लेस.

आपको कब मल्टी-GPU की आवश्यकता होती है?

मॉडल आकार	एकल GPU विकल्प	मल्टी-GPU विकल्प
≤13B	RTX 3090 (Q4)	ज़रूरत नहीं
30B	RTX 4090 (Q4)	2x RTX 3090
70B	A100 40GB (Q4)	2x RTX 4090
70B FP16	-	2x A100 80GB
100B+	-	4x A100 80GB
405B	-	8x A100 80GB

---

मल्टी-GPU अवधारणाएँ

टेनसर पैरेललिज्म (TP)

मॉडल की लेयर्स को GPUs में विभाजित करें। इनफेरेंस के लिए सर्वोत्तम।

GPU 0: लेयर्स 1-20
GPU 1: लेयर्स 21-40

फायदे: कम विलंबता, सरल सेटअप नुकसान: उच्च-गति इंटरकनेक्ट की आवश्यकता

पाइपलाइन पैरेललिज्म (PP)

विभिन्न बैचों को अलग-अलग GPUs पर प्रोसेस करें।

GPU 0: बैच 1 → GPU 1: बैच 1
GPU 0: बैच 2 → GPU 1: बैच 2

फायदे: उच्च थ्रूपुट नुकसान: उच्च विलंबता, अधिक जटिल

डाटा पैरेललिज्म (DP)

एक ही मॉडल कई GPUs पर, अलग डेटा के साथ।

GPU 0: बैच A प्रोसेस करें
GPU 1: बैच B प्रोसेस करें

फायदे: सरल, रैखिक स्केलिंग नुकसान: प्रत्येक GPU को पूरा मॉडल चाहिए

---

LLM मल्टी-GPU सेटअप

vLLM (सिफारिश की गई)

2 GPUs:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 2 \
    --host 0.0.0.0

4 GPUs:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 4 \
    --host 0.0.0.0

8 GPUs (405B के लिए):

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-405B-Instruct \
    --tensor-parallel-size 8 \
    --host 0.0.0.0

Ollama मल्टी-GPU

Ollama उपलब्ध होने पर स्वचालित रूप से कई GPUs का उपयोग करता है:

# उपलब्ध GPUs जांचें
nvidia-smi

# Ollama सभी GPUs को स्वचालित रूप से पहचानकर उपयोग करेगा
ollama run llama3.1:70b

विशिष्ट GPUs पर सीमित करें:

CUDA_VISIBLE_DEVICES=0,1 ollama run llama3.1:70b

Text Generation Inference (TGI)

docker run --gpus all -p 8080:80 \
    ghcr.io/huggingface/text-generation-inference:latest \
    --model-id meta-llama/Llama-3.1-70B-Instruct \
    --num-shard 2

llama.cpp

# प्रत्येक डिवाइस के लिए GPU लेयर्स निर्दिष्ट करें
./llama-server \
    -m llama-3.1-70b-q4.gguf \
    -ngl 999 \
    --split-mode layer \
    --tensor-split 0.5,0.5

---

इमेज जनरेशन मल्टी-GPU

ComfyUI

ComfyUI विभिन्न मॉडल्स को अलग-अलग GPUs पर ऑफलोड कर सकता है:

# ComfyUI वर्कफ़्लो में
# डिवाइस पैरामीटर के साथ "Load Checkpoint" का उपयोग करें
# पहले GPU के लिए device: "cuda:0"
# दूसरे GPU के लिए device: "cuda:1"

VAE को अलग GPU पर चलाएँ:

# मुख्य मॉडल GPU 0 पर
# VAE GPU 1 पर
# VRAM दबाव कम करता है

Stable Diffusion WebUI

webui-user.sh में मल्टी-GPU सक्षम करें:

export COMMANDLINE_ARGS="--device-id 0"
# या विशिष्ट मॉडलों के लिए:
export COMMANDLINE_ARGS="--lowvram --device-id 0,1"

FLUX मल्टी-GPU

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)

# GPUs में वितरित करें
pipe.enable_model_cpu_offload()  # या
pipe.to("cuda:0")  # स्पष्ट GPU चयन

---

ट्रेनिंग मल्टी-GPU

PyTorch डिस्ट्रिब्यूटेड

import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

# आरंभ करें
dist.init_process_group("nccl")
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)

# मॉडल लपेटें
model = YourModel().to(local_rank)
model = DDP(model, device_ids=[local_rank])

# ट्रेनिंग लूप सामान्य रूप से

लॉन्च:

torchrun --nproc_per_node=2 train.py

DeepSpeed

import deepspeed

model, optimizer, _, _ = deepspeed.initialize(
    model=model,
    config={
        "train_batch_size": 32,
        "fp16": {"enabled": True},
        "zero_optimization": {"stage": 2}
    }
)

लॉन्च:

deepspeed --num_gpus=2 train.py

Accelerate (HuggingFace)

from accelerate import Accelerator

accelerator = Accelerator()
model, optimizer, dataloader = accelerator.prepare(
    model, optimizer, dataloader
)

कॉन्फ़िगर करें:

accelerate config  # इंटरैक्टिव सेटअप
accelerate launch train.py

Kohya ट्रेनिंग (LoRA)

# मल्टी-GPU LoRA ट्रेनिंग
accelerate launch --num_processes=2 train_network.py \
    --pretrained_model_name_or_path="model.safetensors" \
    --train_data_dir="./images" \
    --output_dir="./output"

---

GPU चयन

उपलब्ध GPUs जांचें

# सभी GPUs सूचीबद्ध करें
nvidia-smi

# विस्तृत जानकारी
nvidia-smi -L

# मेमोरी उपयोग
nvidia-smi --query-gpu=index,memory.used,memory.total --format=csv

विशिष्ट GPUs चुनें

पर्यावरण वेरिएबल:

# केवल GPU 0 और 1 का उपयोग करें
export CUDA_VISIBLE_DEVICES=0,1
python your_script.py

# केवल GPU 2 का उपयोग करें
export CUDA_VISIBLE_DEVICES=2
python your_script.py

Python में:

import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"

# या torch के साथ
import torch
device = torch.device("cuda:0")  # पहला दिखाई देने वाला GPU
device = torch.device("cuda:1")  # दूसरा दिखाई देने वाला GPU

---

प्रदर्शन अनुकूलन

NVLink बनाम PCIe

कनेक्शन	बैंडविड्थ	उत्तम हेतु
NVLink	600 GB/s	टेंसर पैरालेलिज़्म
PCIe 4.0	32 GB/s	डेटा पैरेललिज्म
PCIe 5.0	64 GB/s	मिक्स्ड वर्कलोड़

NVLink स्थिति जांचें:

nvidia-smi nvlink --status

इष्टतम कॉन्फ़िगरेशन

GPUs	TP आकार	PP आकार	नोट्स
2	2	1	सरल टेनसर पैरेलल
4	4	1	NVLink आवश्यक
4	2	2	PCIe-अनुकूल
8	8	1	पूर्ण टेनसर पैरेलल
8	4	2	मिक्स्ड पैरेललिज्म

मेमोरी संतुलन

समान विभाजन (डिफ़ॉल्ट):

--tensor-parallel-size 2

कस्टम विभाजन (असमान GPUs):

# vLLM असमान का समर्थन नहीं करता, llama.cpp का उपयोग करें:
./llama-server --tensor-split 0.6,0.4

---

समस्याओं का निवारण

"NCCL त्रुटि"

# NCCL डिबग सेट करें
export NCCL_DEBUG=INFO

# अलग NCCL एल्गोरिदम आज़माएँ
export NCCL_ALGO=Ring

"GPU X पर मेमोरी समाप्त"

# प्रति GPU मेमोरी जांचें
nvidia-smi

# बैच साइज घटाएँ
--max-batch-size 1

# ग्रेडिएंट चेकपॉइंटिंग सक्षम करें (ट्रेनिंग)
--gradient-checkpointing

"मल्टी-GPU प्रदर्शन धीमा"

1. NVLink कनेक्टिविटी जांचें

2. टेनसर पैरेलल आकार घटाएँ

3. इसके बजाय पाइपलाइन पैरेललिज्म का उपयोग करें

4. CPU बॉटलनेक जांचें

"GPUs नहीं मिले"

# CUDA सत्यापित करें
nvidia-smi

# जांचें कि PyTorch GPUs देखता है
python -c "import torch; print(torch.cuda.device_count())"

# आवश्यकता होने पर CUDA ड्राइवर्स पुनर्स्थापित करें

---

लागत अनुकूलन

जब मल्टी-GPU उपयोगी होता है

परिदृश्य	एकल GPU	मल्टी-GPU	विजेता
70B कभी-कभार उपयोग	A100 80GB ($0.25/घं)	2x RTX 4090 ($0.20/घं)	मल्टी
70B उत्पादन	A100 40GB ($0.17/घं)	2x A100 40GB ($0.34/घं)	एकल (Q4)
7B ट्रेनिंग	RTX 4090 ($0.10/घं)	2x RTX 4090 ($0.20/घं)	समय पर निर्भर करता है

लागत-प्रभावी कॉन्फ़िगरेशन

उपयोग का मामला	कॉन्फ़िगरेशन	~लागत/घं
70B इनफेरेंस	2x RTX 3090	$0.12
70B तेज इनफेरेंस	2x A100 40GB	$0.34
70B FP16	2x A100 80GB	$0.50
13B ट्रेनिंग	2x RTX 4090	$0.20

---

उदाहरण कॉन्फ़िगरेशन

70B चैट सर्वर

# 2x A100 40GB सेटअप
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 2 \
    --max-model-len 8192 \
    --host 0.0.0.0 \
    --port 8000

DeepSeek-V3 (671B)

# 8x A100 80GB आवश्यक
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0

इमेज + LLM पाइपलाइन

# GPU 0: Stable Diffusion
CUDA_VISIBLE_DEVICES=0 python comfyui/main.py --port 8188 &

# GPU 1: प्रॉम्प्ट्स के लिए LLM
CUDA_VISIBLE_DEVICES=1 python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct --port 8000

---

अगले कदम

• vLLM गाइड - प्रोडक्शन LLM सर्विंग

• GPU तुलना - अपने GPUs चुनें

• API एकीकरण - एप्लीकेशंस बनाएं

• कॉस्ट कैलकुलेटर - लागत का अनुमान लगाएँ