LitGPT

LitGPT PyTorch Lightning पर निर्मित 20+ बड़े भाषा मॉडलों के प्रीट्रेनिंग, फाइनट्यूनिंग और डिप्लॉयमेंट के लिए एक उच्च-प्रदर्शन लाइब्रेरी है। 12K+ GitHub स्टार्स के साथ, यह उन इंजीनियरों के लिए एक पसंदीदा टूलकिट है जिन्हें HuggingFace Transformers के abstraction ओवरहेड के बिना साफ़, हैक करने योग्य LLM ट्रेनिंग कोड चाहिए।

LitGPT में प्रत्येक मॉडल ~1,000 पंक्तियों का साफ़ PyTorch है — न तो 10 स्तर गहरी इनहेरिटेंस चेनें, न ही कोई जादू। आप दोपहर में Llama 3 इम्प्लीमेंटेशन को शुरू से अंत तक पढ़ सकते हैं और आत्मविश्वास से संशोधन कर सकते हैं।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया जा सकता है CLORE.AI मार्केटप्लेस.

---

LitGPT क्या है?

LitGPT एकीकृत ट्रेनिंग इंटरफेस के साथ राज्य-के-कलाकार (state-of-the-art) LLMs के प्रोडक्शन-रेडी इम्प्लीमेंटेशन प्रदान करता है:

• 20+ समर्थित मॉडल — Llama 3, Gemma 2, Mistral, Phi-3, Falcon, StableLM, और अधिक

• शून्य से प्रीट्रेन करें — Flash Attention, FSDP, और gradient checkpointing के साथ पूर्ण प्रीट्रेनिंग

• प्रभावी रूप से फाइनट्यून करें — पूर्ण फाइनट्यूनिंग, LoRA, QLoRA, और Adapter विधियाँ

• विश्वास के साथ सर्व करें — क्वांटाइज़ेशन के साथ बिल्ट-इन इन्फरेंस सर्वर

• मल्टी-GPU समर्थन — बॉक्स से बाहर DDP, FSDP, टेंसर पैरेललिज्म

• मेमोरी प्रभावी — 4-बिट क्वांटाइज़ेशन, ग्रेडिएंट चेकपॉइंटिंग, एक्टिवेशन चेकपॉइंटिंग

---

सर्वर आवश्यकताएँ

घटक	न्यूनतम	अनुशंसित
GPU	RTX 3090 (24 GB)	A100 80 GB / H100
वीरैम (VRAM)	16 GB (7B LoRA)	80 GB+ (70B फुल)
रैम	32 GB	64 GB+
CPU	8 कोर	16+ कोर
स्टोरेज	100 GB	500 GB+
ऑपरेटिंग सिस्टम	Ubuntu 20.04+	Ubuntu 22.04
Python	3.10+	3.11
CUDA	11.8+	12.1+

कार्य के अनुसार VRAM आवश्यकताएँ

कार्य	मॉडल	वीरैम (VRAM)
इन्फरेंस (4-बिट)	Llama-3 8B	~6 GB
LoRA फाइनट्यून	Llama-3 8B	~16 GB
फुल फाइनट्यून	Llama-3 8B	~80 GB
LoRA फाइनट्यून	Llama-3 70B	~48 GB (2×A100)
फुल फाइनट्यून	Llama-3 70B	~640 GB (8×A100)
QLoRA फाइनट्यून	Llama-3 8B	~8 GB

---

पोर्ट्स

पोर्ट	सेवा	नोट्स
22	SSH	टर्मिनल एक्सेस और फ़ाइल ट्रांसफ़र
8000	LitGPT इन्फरेंस सर्वर	मॉडल सर्विंग के लिए REST API

---

Docker के साथ क्विक स्टार्ट

# आधिकारिक LitGPT इमेज खींचें
docker pull pytorchlightning/litgpt:latest

# GPU के साथ इंटरैक्टिव कंटेनर चलाएँ
docker run -it --gpus all \
  -p 8000:8000 \
  -v $(pwd)/checkpoints:/checkpoints \
  -v $(pwd)/data:/data \
  pytorchlightning/litgpt:latest \
  bash

# या एक विशिष्ट कमांड सीधे चलाएँ
docker run --gpus all \
  -v $(pwd)/checkpoints:/checkpoints \
  pytorchlightning/litgpt:latest \
  litgpt download --repo_id meta-llama/Llama-3.2-3B-Instruct

---

Clore.ai पर इंस्टॉलेशन

चरण 1 — एक सर्वर किराए पर लें

1. जाएँ Clore.ai मार्केटप्लेस

2. फ़िल्टर करें VRAM ≥ 24 GB (RTX 3090 या बेहतर)

3. एक चुनें PyTorch या CUDA 12.1 बेस इमेज

4. पोर्ट खोलें 22 और 8000 अपने ऑर्डर सेटिंग्स में

5. चुनें स्टोरेज ≥ 200 GB मॉडल वेट्स के लिए

चरण 2 — SSH के द्वारा कनेक्ट करें

ssh root@<server-ip> -p <ssh-port>

चरण 3 — LitGPT इंस्टॉल करें

# pip के माध्यम से इंस्टॉल करें (सिफारिश की जाती है)
pip install litgpt

# सभी एक्स्ट्रा के साथ (क्वांटाइज़ेशन, सर्वर, आदि)
pip install 'litgpt[all]'

# या नवीनतम फीचर्स के लिए स्रोत से इंस्टॉल करें
git clone https://github.com/Lightning-AI/litgpt.git
cd litgpt
pip install -e '.[all]'

चरण 4 — इंस्टॉलेशन सत्यापित करें

litgpt --help

अपेक्षित आउटपुट:

Usage: litgpt [OPTIONS] COMMAND [ARGS]...
  
Commands:
  chat       मॉडल से चैट करें
  convert    मॉडल वेट्स कनवर्ट करें
  download   मॉडल वेट्स डाउनलोड करें
  evaluate   एक मॉडल का मूल्यांकन करें
  finetune   एक मॉडल फाइनट्यून करें
  generate   टेक्स्ट जनरेट करें
  pretrain   एक मॉडल प्रीट्रेन करें
  serve      इन्फरेंस के लिए एक मॉडल सर्व करें

---

मॉडल डाउनलोड करना

LitGPT Hugging Face से मॉडल डाउनलोड करता है:

# उपलब्ध मॉडलों की सूची बनाएं
litgpt download --list

# Llama 3.2 3B डाउनलोड करें (गेटेड मॉडलों के लिए HF टोकन आवश्यक)
litgpt download \
  --repo_id meta-llama/Llama-3.2-3B-Instruct \
  --checkpoint_dir checkpoints/

# Mistral 7B डाउनलोड करें (ओपन एक्सेस)
litgpt download \
  --repo_id mistralai/Mistral-7B-Instruct-v0.3

# Gemma 2 2B डाउनलोड करें
litgpt download \
  --repo_id google/gemma-2-2b-it \
  --access_token your-hf-token

# Phi-3 डाउनलोड करें (छोटा लेकिन शक्तिशाली)
litgpt download \
  --repo_id microsoft/Phi-3-mini-4k-instruct

HuggingFace टोकन सेट करें

# गेटेड मॉडलों के लिए (Llama, Gemma)
export HF_TOKEN=hf_your-token-here

# या CLI के माध्यम से प्रमाणीकृत करें
pip install huggingface_hub
huggingface-cli login

---

इन्फरेंस (चैट और जनरेट)

# इंटरैक्टिव चैट
litgpt chat \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct

# सिंगल जनरेशन
litgpt generate \
  --prompt "Explain GPU computing in simple terms" \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --max_new_tokens 200

# तापमान और सैंपलिंग के साथ
litgpt generate \
  --prompt "Write a Python function to sort a list" \
  --checkpoint_dir checkpoints/mistralai/Mistral-7B-Instruct-v0.3 \
  --temperature 0.7 \
  --top_p 0.9 \
  --max_new_tokens 500

---

फाइनट्यूनिंग

LoRA फाइनट्यूनिंग (सिफारिश की जाती है)

LoRA बेस मॉडल को फ्रीज़ रखते हुए एक छोटे सेट के एडाप्टर पैरामीटर ट्रेन करता है (आमतौर पर कुल वेट्स का 0.1–1%)। Llama 3 8B LoRA 10K उदाहरणों पर RTX 3090 पर ~2 घंटे लेता है, r=16.

# अपने डेटासेट को तैयार करें
# फ़ॉर्मैट: JSON लाइन्स जिनमें {"instruction": "...", "input": "...", "output": "..."} हो
cat > data/train.json << 'EOF'
{"instruction": "GPU क्लाउड कंप्यूटिंग क्या है?", "input": "", "output": "GPU क्लाउड कंप्यूटिंग इंटरनेट के माध्यम से GPU हार्डवेयर तक ऑन-डिमांड पहुँच प्रदान करती है, जिससे भौतिक हार्डवेयर के बिना ही AI ट्रेनिंग और इन्फरेंस संभव होता है."}
{"instruction": "मैं Clore.ai पर GPU कैसे किराए पर लूँ?", "input": "", "output": "clore.ai/marketplace पर जाएँ, GPU स्पेसिफिकेशन से फ़िल्टर करें, एक सर्वर चुनें, पोर्ट कॉन्फ़िगर करें, और किराए पर क्लिक करें। SSH एक्सेस तुरंत प्रदान किया जाता है."}
EOF

# LoRA के साथ फाइनट्यून करें
litgpt finetune lora \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --data JSON \
  --data.json_path data/train.json \
  --train.epochs 3 \
  --train.micro_batch_size 4 \
  --lora_r 8 \
  --lora_alpha 16 \
  --out_dir out/llama-lora-finetuned

# ट्रेनिंग मॉनिटर करें
# LitGPT लॉग्स आउटपुट करता है जिनमें लॉस, लर्निंग रेट, और ETA होते हैं

QLoRA (4-बिट + LoRA)

सीमित VRAM पर बड़े मॉडलों को फाइनट्यून करने के लिए QLoRA का उपयोग करें। Llama 3 8B एकल RTX 3090 (24 GB) पर फिट हो जाता है:

litgpt finetune lora \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-8B-Instruct \
  --quantize bnb.nf4 \
  --train.epochs 3 \
  --train.micro_batch_size 2 \
  --lora_r 16 \
  --lora_alpha 32 \
  --out_dir out/llama-qlora

पूर्ण फाइनट्यूनिंग

litgpt finetune full \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --data JSON \
  --data.json_path data/train.json \
  --train.epochs 2 \
  --train.micro_batch_size 2 \
  --train.accumulate_gradients 8 \
  --out_dir out/llama-full-finetuned

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

# कई GPUs पर FSDP का उपयोग करें
litgpt finetune full \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-8B-Instruct \
  --devices 4 \
  --strategy fsdp \
  --train.epochs 3 \
  --out_dir out/llama-multigpu

---

मॉडल सर्विंग (REST API)

# इन्फरेंस सर्वर शुरू करें
litgpt serve \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --host 0.0.0.0 \
  --port 8000

# API का परीक्षण करें
curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "फ्रांस की राजधानी क्या है?",
    "max_new_tokens": 100,
    "temperature": 0.7
  }'

Python क्लाइंट

import requests

response = requests.post(
    "http://<server-ip>:8000/predict",
    json={
        "prompt": "रिइनफ़ोर्समेंट लर्निंग समझाइए",
        "max_new_tokens": 500,
        "temperature": 0.8,
        "top_p": 0.9,
    }
)
print(response.json()["output"])

---

शून्य से प्रीट्रेनिंग

अपने स्वयं के डेटा पर शून्य से एक कस्टम LLM ट्रेनिंग के लिए:

# प्रीट्रेनिंग डेटा तैयार करें (टोकनाइज़्ड और चंकीकृत)
python scripts/prepare_redpajama.py \
  --source_path /data/raw_text \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --destination_path /data/tokenized

# प्रीट्रेनिंग शुरू करें
litgpt pretrain \
  --model_name Llama-3.2 \
  --data /data/tokenized \
  --train.micro_batch_size 4 \
  --train.max_tokens 10_000_000_000 \
  --devices 8 \
  --strategy fsdp \
  --out_dir out/my-pretrained-llm

---

मॉडल कनवर्ट करना और निर्यात करना

# LoRA वेट्स को बेस मॉडल में मर्ज करें
litgpt merge_lora \
  --checkpoint_dir out/llama-lora-finetuned

# वितरण के लिए HuggingFace फॉर्मैट में कनवर्ट करें
litgpt convert to_hf \
  --checkpoint_dir out/llama-lora-finetuned/final \
  --output_dir hf_model/

# GGUF फॉर्मैट में एक्सपोर्ट करें (Ollama/LlamaCpp के लिए)
# HF एक्सपोर्ट के बाद llama.cpp कन्वर्शन स्क्रिप्ट का उपयोग करें
python llama.cpp/convert.py hf_model/ --outfile model.gguf

---

मॉडल का मूल्यांकन करना

# MMLU बेंचमार्क चलाएँ
litgpt evaluate \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --tasks mmlu \
  --num_fewshot 5

# कई बेंचमार्क चलाएँ
litgpt evaluate \
  --checkpoint_dir out/llama-lora-finetuned/final \
  --tasks "mmlu,hellaswag,truthfulqa_mc"

---

Clore.ai GPU सिफारिशें

LitGPT तीन अलग-लग वर्कलोड कवर करता है — इन्फरेंस, LoRA फाइनट्यूनिंग, और फुल प्रीट्रेनिंग — प्रत्येक के अलग GPU आवश्यकताएँ हैं।

वर्कलोड	GPU	वीरैम (VRAM)	नोट्स
इन्फरेंस / चैट (7–8B मॉडल)	RTX 3090	24 GB	bf16 में Llama 3 8B फिट होता है; ~95 टोक/सेक जेनरेशन
LoRA फाइनट्यून (7–8B मॉडल)	RTX 3090	24 GB	बजट विकल्प; QLoRA VRAM को 10 GB से कम बनाए रखता है
LoRA फाइनट्यून (7–8B), तेज़ इटरेशन	RTX 4090	24 GB	~3090 की तुलना में ~35% तेज़; 2 घंटे के काम को ~1.4 घंटे तक घटाता है
फुल फाइनट्यून (7B) या QLoRA (70B)	A100 40 GB	40 GB	40 GB 7B फुल-प्रिसिशन या 70B 4-बिट फिट कर सकता है
फुल फाइनट्यून (13B+) या प्रीट्रेन रनस के लिए	A100 80 GB	80 GB	उच्चतम थ्रूपुट; 8B पर ~2,800 टोक/सेक ट्रेनिंग

अधिकांश उपयोगकर्ताओं के लिए सिफारिश: RTX 3090 जोड़ी (2×24 GB = FSDP के साथ 48 GB प्रभावी)। QLoRA 70B मॉडलों पर संभालता है, या टेंसर पैरेललिज्म के साथ 7B मॉडलों पर फुल फाइनट्यून। Clore.ai पर लागत: दो 3090s के लिए लगभग $0.25/घंटा।

प्रीट्रेनिंग या >70B फाइनट्यूनिंग के लिए: FSDP के साथ 4×A100 80GB का उपयोग करें। LitGPT का FSDP इंटीग्रेशन शार्डिंग को पारदर्शी रूप से संभालता है — बस पास करें --devices 4 --strategy fsdp.

---

समस्या निवारण

CUDA मेमोरी खत्म (Out of Memory)

# बैच साइज कम करें
--train.micro_batch_size 1

# ग्रेडिएंट चेकपॉइंटिंग सक्षम करें
--train.gradient_checkpointing true

# LoRA के बजाय QLoRA का उपयोग करें
--quantize bnb.nf4

# GPU मेमोरी जांचें
nvidia-smi

डाउनलोड विफल / HuggingFace 401

# HF टोकन सेट करें
export HF_TOKEN=hf_your-token-here
huggingface-cli login

# या सीधे पास करें
litgpt download \
  --repo_id meta-llama/Llama-3.2-3B-Instruct \
  --access_token hf_your-token

ट्रेनिंग लॉस घटता नहीं है

# अपने डेटा फ़ॉर्मैट की जांच करें — मान्य JSON Lines होना चाहिए
python -c "
import json
with open('data/train.json') as f:
    for i, line in enumerate(f):
        json.loads(line)
        if i < 3: print(f'Line {i}: OK')
print('All lines valid')
"

# लर्निंग रेट कम करें
--train.lr 1e-5  # छोटे डेटासेट के लिए डिफ़ॉल्ट अक्सर बहुत अधिक होता है

# डेटा का आकार जांचें — LoRA को कम से कम 100-1000 उदाहरणों की आवश्यकता होती है
wc -l data/train.json

सर्वर पोर्ट 8000 पहुंच योग्य नहीं

# सत्यापित करें कि सर्वर सुन रहा है
ss -tlnp | grep 8000

# फ़ायरवॉल खोलें
ufw allow 8000/tcp

# स्पष्ट रूप से होस्ट के साथ सर्वर पुनःस्टार्ट करें
litgpt serve \
  --checkpoint_dir checkpoints/... \
  --host 0.0.0.0 \
  --port 8000

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

# NCCL कनेक्टिविटी जांचें
python -c "import torch; print(torch.cuda.device_count())"

# छोटे मॉडलों के लिए FSDP के बजाय DDP आज़माएँ
--strategy ddp

# NCCL एन्वायरनमेंट वेरिएबल सेट करें
export NCCL_DEBUG=INFO
export NCCL_IB_DISABLE=1  # यदि InfiniBand उपलब्ध नहीं है तो

---

उपयोगी लिंक

• GitHub: https://github.com/Lightning-AI/litgpt ⭐ 12K+

• डॉक्यूमेंटेशन: https://lightning.ai/docs/litgpt

• PyTorch Lightning: https://lightning.ai

• HuggingFace Models: https://huggingface.co/models

• Discord: https://discord.gg/lightning-ai

• Clore.ai मार्केटप्लेस: https://clore.ai/marketplace