> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/advanced/multi-gpu-setup.md). # Multi-GPU Setup CLORE.AI पर कई GPUs में बड़े AI मॉडल चलाएँ। {% hint style="success" %} मल्टी-GPU सर्वर ढूंढ़ें: [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} ## आपको कब मल्टी-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:** ```bash 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:** ```bash 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 के लिए):** ```bash 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 का उपयोग करता है: ```bash # उपलब्ध GPUs जांचें nvidia-smi # Ollama सभी GPUs को स्वचालित रूप से पहचानकर उपयोग करेगा ollama run llama3.1:70b ``` **विशिष्ट GPUs पर सीमित करें:** ```bash CUDA_VISIBLE_DEVICES=0,1 ollama run llama3.1:70b ``` ### Text Generation Inference (TGI) ```bash 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 ```bash # प्रत्येक डिवाइस के लिए 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 पर ऑफलोड कर सकता है: ```python # ComfyUI वर्कफ़्लो में # डिवाइस पैरामीटर के साथ "Load Checkpoint" का उपयोग करें # पहले GPU के लिए device: "cuda:0" # दूसरे GPU के लिए device: "cuda:1" ``` **VAE को अलग GPU पर चलाएँ:** ```python # मुख्य मॉडल GPU 0 पर # VAE GPU 1 पर # VRAM दबाव कम करता है ``` ### Stable Diffusion WebUI **webui-user.sh में मल्टी-GPU सक्षम करें:** ```bash export COMMANDLINE_ARGS="--device-id 0" # या विशिष्ट मॉडलों के लिए: export COMMANDLINE_ARGS="--lowvram --device-id 0,1" ``` ### FLUX मल्टी-GPU ```python 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 डिस्ट्रिब्यूटेड ```python 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]) # ट्रेनिंग लूप सामान्य रूप से ``` **लॉन्च:** ```bash torchrun --nproc_per_node=2 train.py ``` ### DeepSpeed ```python import deepspeed model, optimizer, _, _ = deepspeed.initialize( model=model, config={ "train_batch_size": 32, "fp16": {"enabled": True}, "zero_optimization": {"stage": 2} } ) ``` **लॉन्च:** ```bash deepspeed --num_gpus=2 train.py ``` ### Accelerate (HuggingFace) ```python from accelerate import Accelerator accelerator = Accelerator() model, optimizer, dataloader = accelerator.prepare( model, optimizer, dataloader ) ``` **कॉन्फ़िगर करें:** ```bash accelerate config # इंटरैक्टिव सेटअप accelerate launch train.py ``` ### Kohya ट्रेनिंग (LoRA) ```bash # मल्टी-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 जांचें ```bash # सभी GPUs सूचीबद्ध करें nvidia-smi # विस्तृत जानकारी nvidia-smi -L # मेमोरी उपयोग nvidia-smi --query-gpu=index,memory.used,memory.total --format=csv ``` ### विशिष्ट GPUs चुनें **पर्यावरण वेरिएबल:** ```bash # केवल 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 में:** ```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 स्थिति जांचें:** ```bash nvidia-smi nvlink --status ``` ### इष्टतम कॉन्फ़िगरेशन | GPUs | TP आकार | PP आकार | नोट्स | | ---- | ------- | ------- | ------------------ | | 2 | 2 | 1 | सरल टेनसर पैरेलल | | 4 | 4 | 1 | NVLink आवश्यक | | 4 | 2 | 2 | PCIe-अनुकूल | | 8 | 8 | 1 | पूर्ण टेनसर पैरेलल | | 8 | 4 | 2 | मिक्स्ड पैरेललिज्म | ### मेमोरी संतुलन **समान विभाजन (डिफ़ॉल्ट):** ```bash --tensor-parallel-size 2 ``` **कस्टम विभाजन (असमान GPUs):** ```bash # vLLM असमान का समर्थन नहीं करता, llama.cpp का उपयोग करें: ./llama-server --tensor-split 0.6,0.4 ``` *** ## समस्याओं का निवारण ### "NCCL त्रुटि" ```bash # NCCL डिबग सेट करें export NCCL_DEBUG=INFO # अलग NCCL एल्गोरिदम आज़माएँ export NCCL_ALGO=Ring ``` ### "GPU X पर मेमोरी समाप्त" ```bash # प्रति GPU मेमोरी जांचें nvidia-smi # बैच साइज घटाएँ --max-batch-size 1 # ग्रेडिएंट चेकपॉइंटिंग सक्षम करें (ट्रेनिंग) --gradient-checkpointing ``` ### "मल्टी-GPU प्रदर्शन धीमा" 1. NVLink कनेक्टिविटी जांचें 2. टेनसर पैरेलल आकार घटाएँ 3. इसके बजाय पाइपलाइन पैरेललिज्म का उपयोग करें 4. CPU बॉटलनेक जांचें ### "GPUs नहीं मिले" ```bash # 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 चैट सर्वर ```bash # 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) ```bash # 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 पाइपलाइन ```bash # 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 गाइड](/guides/guides_v2-hi/language-models/vllm.md) - प्रोडक्शन LLM सर्विंग * [GPU तुलना](/guides/guides_v2-hi/getting-started/gpu-comparison.md) - अपने GPUs चुनें * [API एकीकरण](/guides/guides_v2-hi/advanced/api-integration.md) - एप्लीकेशंस बनाएं * [कॉस्ट कैलकुलेटर](/guides/guides_v2-hi/getting-started/cost-calculator.md) - लागत का अनुमान लगाएँ --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-hi/advanced/multi-gpu-setup.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.