कोई KYC नहीं · कोई ID नहीं, कोई कार्ड नहीं। crypto में भुगतान करें: BTC, USDT, USDC, ETH, SOL, LTC
भाषा: हिन्दी
GPU किराए पर लें

गाइड · Hugging Face TRL कमांड इसके डॉक्स से जाँचे गए · 29 अक्टूबर 2026 के दाम

मैं किराए के GPU पर Llama को फ़ाइन-ट्यून कैसे करूँ?

Llama को अपना डेटा सिखाने का सबसे सस्ता तरीका LoRA या QLoRA एडाप्टर है। यह गाइड GPU चुनती है, Hugging Face TRL से ट्रेनिंग चलाती है, और डिस्क मिटने से पहले एडाप्टर मशीन से बाहर निकाल देती है।

अंतिम अपडेट: · 8 मिनट पढ़ें

तुरंत जवाब

मैं किराए के GPU पर Llama को फ़ाइन-ट्यून कैसे करूँ?

किराए के GPU पर Llama को फाइन-ट्यून करने के लिए Hugging Face TRL से LoRA या QLoRA एडाप्टर ट्रेन करें। Llama 3.1 8B को QLoRA में लगभग 6 GB और LoRA में 19.2 GB चाहिए, इसलिए एक 24 GB RTX 4090 काफी है; Llama 3.1 70B को QLoRA में लगभग 52.5 GB चाहिए, यानी एक A100 80GB। इंस्टेंस डिलीट करने से पहले एडाप्टर कॉपी कर लें। 29 अक्टूबर 2026 तक, GPUwithCrypto RTX 4090 को $0.28/घंटा में किराए पर देता है, भुगतान क्रिप्टो में।

Llama को फाइन-ट्यून करने के लिए मुझे कौन सा GPU चाहिए?

मेमोरी हमारी VRAM गाइड के नियमों से: QLoRA ≈ 0.75 GB प्रति अरब पैरामीटर, LoRA = 2 बाइट प्रति पैरामीटर × 1.2, फुल फाइन-ट्यूनिंग 16–18 बाइट प्रति पैरामीटर। हमारे 29 अक्टूबर 2026 के दाम।

ModelविधिVRAM (नियम)GPUGPUwithCrypto प्रति घंटा
Llama 3.1 8BQLoRA6 GB1× RTX 4090 (24 GB)$0.28/घंटा
Llama 3.1 8BLoRA (BF16 बेस)19.2 GB1× RTX 4090 (24 GB)$0.28/घंटा
Llama 3.1 8Bफुल फाइन-ट्यून128–144 GB + activations1× B200 (180 GB)$4.61/घंटा
Llama 3.1 70BQLoRA52.5 GB1× A100 80GB या 1× H100$0.92/घंटा या $2.32/घंटा
Llama 3.1 70BLoRA (BF16 बेस)168 GB1× B200 या 2× H200$4.61/घंटा या $6.14/घंटा

कीमतें को जांची गईं

डिस्क: Llama 3.1 8B Instruct के वेट 16.1 GB लेते हैं, 70B Instruct के वेट 141.1 GB। चेकपॉइंट के लिए जगह छोड़ें।

मैं Llama 3.1 8B का QLoRA फाइन-ट्यून कैसे चलाऊँ?

कमांड Hugging Face TRL और Hub के डॉक्स से। 80 GB GPU पर 70B मॉडल को इसी तरह ट्रेन करने के लिए मॉडल id की जगह meta-llama/Llama-3.1-70B-Instruct डालें। किराए के GPU पर नए हैं? AI के लिए GPU कैसे किराए पर लें अकाउंट, SSH और पहला जॉब समझाता है।

  1. GPU किराए पर लें

    8B मॉडल के लिए 1× RTX 4090 इंस्टेंस शुरू करें, या 70B के लिए 1× A100 80GB। हर इंस्टेंस आपको पूरे GPU देता है, कभी time-shared स्लाइस या MIG पार्टीशन नहीं। आपको Ubuntu पर root SSH access मिलता है जिसमें NVIDIA driver, CUDA और PyTorch इंस्टॉल हैं, या आप अपनी Docker image से शुरू कर सकते हैं।

  2. Llama तक एक्सेस लें

    Hugging Face पर meta-llama रिपॉज़िटरी gated हैं: मॉडल पेज पर एक्सेस माँगें और Meta का लाइसेंस स्वीकार करें, फिर इंस्टेंस पर read टोकन के साथ hf auth login चलाएँ।

  3. TRL, PEFT और bitsandbytes इंस्टॉल करें

    pip install "trl[peft]" bitsandbytes। bitsandbytes वह 4-bit लोडिंग देता है जो QLoRA को चाहिए।

  4. डेटासेट चुनें

    Hugging Face डेटासेट id या बातचीत की अपनी फ़ाइल इस्तेमाल करें। उदाहरण में trl-lib/Capybara है, वही डेटासेट जो TRL के अपने उदाहरणों में है।

  5. एडाप्टर ट्रेन करें

    नीचे दी trl sft कमांड tmux के अंदर चलाएँ। --load_in_4bit बेस को 4-bit में लोड करता है, --use_peft LoRA एडाप्टर जोड़ता है, और चेकपॉइंट --output_dir में बनते हैं।

  6. एडाप्टर टेस्ट करें

    बेस मॉडल लोड करें, PEFT से एडाप्टर जोड़ें और अपने प्रॉम्प्ट पर बेस मॉडल से जवाबों की तुलना करें।

  7. एडाप्टर कॉपी करें, फिर डिलीट करें

    हर इंस्टेंस में local NVMe डिस्क होती है, जो उसके GPU के लिए साइज़ की गई है और शुरू करने से पहले दिखाई जाती है। इंस्टेंस डिलीट करने पर डिस्क मिट जाती है, इसलिए पहले अपने checkpoints बाहर कॉपी कर लें। आउटपुट फ़ोल्डर अपने कंप्यूटर पर कॉपी करें या प्राइवेट Hugging Face रिपॉज़िटरी में पुश करें, फिर इंस्टेंस डिलीट करें।

train-qlora.sh
pip install "trl[peft]" bitsandbytes
hf auth login

trl sft \
  --model_name_or_path meta-llama/Llama-3.1-8B-Instruct \
  --dataset_name trl-lib/Capybara \
  --load_in_4bit \
  --use_peft \
  --lora_r 32 \
  --lora_alpha 16 \
  --lora_target_modules q_proj k_proj v_proj o_proj gate_proj up_proj down_proj \
  --learning_rate 2.0e-4 \
  --num_train_epochs 1 \
  --per_device_train_batch_size 1 \
  --gradient_accumulation_steps 16 \
  --gradient_checkpointing \
  --save_strategy steps \
  --save_steps 200 \
  --output_dir llama-3.1-8b-qlora

मुख्य ट्रेनिंग फ्लैग क्या करते हैं?

  • --lora_r 32 --lora_alpha 16: एडाप्टर की rank और scaling, TRL के PEFT उदाहरणों वाली वैल्यू। Llama 3.1 8B की सातों लीनियर लेयर पर rank 32 लगभग 84 मिलियन पैरामीटर ट्रेन करता है, मॉडल का लगभग 1%।
  • --learning_rate 2.0e-4: TRL का डॉक्स LoRA के लिए फुल फाइन-ट्यूनिंग दर (2.0e-5) का लगभग 10 गुना सुझाता है।
  • --per_device_train_batch_size 1 --gradient_accumulation_steps 16: batch 1 की मेमोरी में batch 16 का असर।
  • --gradient_checkpointing: एक्टिवेशन स्टोर करने के बजाय दोबारा गिनता है, मेमोरी के बदले समय देता है।
  • --save_strategy steps --save_steps 200: हर 200 स्टेप पर चेकपॉइंट लिखता है, इसलिए क्रैश होने पर ज़्यादा से ज़्यादा 200 स्टेप का नुकसान होता है।
save-adapter.sh
# from your computer: copy the adapter folder before you delete the instance
rsync -avP -e "ssh -p SSH_PORT" root@HOST:/root/llama-3.1-8b-qlora/ ./llama-3.1-8b-qlora/

# or, on the instance: create a private repo on huggingface.co first, then upload
hf upload your-name/llama-3.1-8b-qlora ./llama-3.1-8b-qlora .

# later, serve the base model with the adapter in vLLM
vllm serve meta-llama/Llama-3.1-8B-Instruct \
  --enable-lora --max-lora-rank 32 \
  --lora-modules my-adapter=./llama-3.1-8b-qlora

किराए के GPU पर Llama को फाइन-ट्यून करने का खर्च कितना है?

खर्च = GPUs × घंटे × प्रति GPU-घंटा दाम। नीचे के घंटे उदाहरण के लिए माने गए अनुमान हैं, मापे गए समय नहीं: रन टाइम आपके डेटासेट के टोकन, सीक्वेंस लंबाई और batch size पर निर्भर करता है। हमने वे घंटे चुने जो हमारे 10 और 24 GPU-घंटे के ब्लॉक से मेल खाते हैं। GPU-घंटे एक GPU मॉडल के लिए 10, 24, 168 या 720 घंटे के ब्लॉक में, उसी घंटे के रेट पर बेचे जाते हैं; उस GPU के इंस्टेंस उनसे प्रति मिनट खर्च करते हैं, और बिना इस्तेमाल हुए घंटे कभी खत्म नहीं होते। हर GPU और ब्लॉक GPU कीमत पर सूचीबद्ध है।

छोटा GPU सबसे बड़ी बचत है। GPUwithCrypto के 29 अक्टूबर 2026 के दाम जाँच के अनुसार, सबसे सस्ता self-serve on-demand RTX 4090 $0.33 प्रति घंटा था (Salad) और सबसे सस्ता H100 $2.73 (Massed Compute): 8.3 गुना ज़्यादा, ऐसे 8B QLoRA जॉब के लिए जो दोनों हालत में 24 GB में फिट हो जाता है। RTX 4090 कीमत पेज उन प्रोवाइडर को सूचीबद्ध करता है जिन्हें हमने जाँचा।

अनुमानित घंटों के आधार पर रन-लागत अनुमान

जॉबConfigurationअनुमानित घंटे (मापे नहीं गए)GPU-घंटेGPUwithCrypto लागत
Llama 3.1 8B, QLoRA1× RTX 40901010$2.80
Llama 3.1 8B, LoRA1× RTX 40902424$6.72
Llama 3.1 70B, QLoRA1× A100 80GB2424$22.08
Llama 3.1 70B, LoRA2× H2001224$73.68

कीमतें को जांची गईं

किराए पर लिए GPU पर काम कैसे न खोएं?

बार-बार सेव करें, जल्दी कॉपी करें और बैलेंस पर नज़र रखें। इंस्टेंस on-demand हैं, spot नहीं: जब तक आपका balance उसे कवर करता है, कोई आपका GPU वापस नहीं ले सकता, और इंस्टेंस तब तक चलता है जब तक आप उसे रोकते नहीं। जब किसी GPU के GPU-घंटे खत्म हो जाते हैं, उसके इंस्टेंस रुक जाते हैं और उनकी डिस्क रखी जाती हैं; घंटों का नया ब्लॉक आपको उन्हें फिर से शुरू करने देता है। अगर कोई रन रुक जाए, तो Python से trainer.train(resume_from_checkpoint=True) कॉल करने पर Hugging Face का Trainer आउटपुट फ़ोल्डर में आखिरी checkpoint से फिर शुरू हो जाता है। Unsloth और Axolotl दो अन्य जाने-माने LoRA टूल हैं; यह गाइड TRL का उपयोग करती है क्योंकि इसके command-line flags Hugging Face के अपने पेजों पर दस्तावेज़ित हैं।

Llama fine-tuning से जुड़े सवाल

Llama 3.1 8B को fine-tune करने के लिए कितनी VRAM चाहिए?

BF16 base पर QLoRA के साथ लगभग 6 GB और LoRA के साथ 19.2 GB, इसलिए एक 24 GB RTX 4090 दोनों चला देता है। Full fine-tuning के लिए activations से पहले 128 से 144 GB चाहिए, यानी एक 180 GB B200।

क्या मैं एक GPU पर Llama 70B fine-tune कर सकता हूँ?

हां, 80 GB A100 या H100 पर QLoRA के साथ: अनुमान 52.5 GB है। BF16 base पर LoRA के लिए लगभग 168 GB चाहिए, यानी एक B200 या दो H200। अधिक जानकारी Llama 70B fine-tune करने के लिए सबसे अच्छे GPU में।

मुझे LoRA या QLoRA इस्तेमाल करना चाहिए?

जब memory सीमा हो तो QLoRA: यह base model को 4-bit में लोड करता है और LoRA की तुलना में memory को लगभग तीन गुना कम कर देता है। जब GPU में जगह हो तो LoRA: base BF16 में रहता है। दोनों adapters को अपने खुद के evaluation set पर तुलना करें।

Llama fine-tuning में कितना समय लगता है?

यह training tokens की संख्या, sequence length और batch size पर निर्भर करता है, और हमने कोई रन मापा नहीं है, इसलिए हम कोई समय नहीं देते। लंबे रन से पहले अपने प्रति घंटे के steps मापने के लिए 10 घंटे का ब्लॉक काफ़ी है।

क्या मैं GPU के लिए crypto से भुगतान कर सकता हूँ?

हाँ। GPUwithCrypto $25 top-up से BTC, USDT, USDC, ETH, SOL, LTC लेता है, बिना ID और बिना card। इंस्टेंस चलते समय प्रति मिनट, घंटे के रेट पर बिल किए जाते हैं, उस GPU के लिए आपके खरीदे गए GPU-घंटों से। इंस्टेंस रोकने पर चार्ज तुरंत रुक जाता है।

स्रोत (12)
  1. TRL कमांड लाइन इंटरफ़ेस — Hugging Face (read 2026-10-29)
  2. TRL PEFT एकीकरण (LoRA, QLoRA, adapters सेव करना) — Hugging Face (read 2026-10-29)
  3. Hugging Face CLI गाइड (hf auth login, hf upload) — Hugging Face (read 2026-10-29)
  4. Trainer और TrainingArguments — Hugging Face (read 2026-10-29)
  5. Llama 3.1 8B model card — Meta / Hugging Face (read 2026-10-29)
  6. Llama 3.1 70B मॉडल कार्ड — Meta / Hugging Face (read 2026-10-29)
  7. The Llama 3 Herd of Models (Table 3) — arXiv (read 2026-10-29)
  8. QLoRA: Efficient Finetuning of Quantized LLMs — arXiv (read 2026-10-29)
  9. LoRA: Low-Rank Adaptation of Large Language Models — arXiv (read 2026-10-29)
  10. vLLM recipes (LoRA serving flags) — vLLM project (read 2026-10-29)
  11. SaladCloud मूल्य परिवर्तन, नवंबर 2026 blog.salad.com/saladcloud-price-changes-november-2026 — Salad (read 2026-10-29)
  12. Massed Compute pricing vm.massedcompute.com/pricing — Massed Compute (read 2026-10-29)

H100 $2.32/घंटा से · कोई KYC नहीं

GPU किराए पर लें