> 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/training/litgpt.md).

# LitGPT

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

LitGPT में प्रत्येक मॉडल लगभग 1,000 लाइनों का साफ़ PyTorch है — 10 स्तर गहरी inheritance chains नहीं, कोई जादू नहीं। आप Llama 3 implementation को एक दोपहर में end-to-end पढ़ सकते हैं और उसे आत्मविश्वास के साथ संशोधित कर सकते हैं।

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

***

## LitGPT क्या है?

LitGPT एक एकीकृत प्रशिक्षण इंटरफ़ेस के साथ state-of-the-art LLMs के production-ready implementations प्रदान करता है:

* **20+ समर्थित मॉडल** — Llama 3, Gemma 2, Mistral, Phi-3, Falcon, StableLM, और अधिक
* **शुरुआत से प्रीट्रेन करें** — Flash Attention, FSDP, और gradient checkpointing के साथ पूर्ण प्रीट्रेनिंग
* **कुशलता से फाइनट्यून करें** — पूर्ण फाइनट्यूनिंग, LoRA, QLoRA, और एडाप्टर विधियाँ
* **आत्मविश्वास के साथ सर्व करें** — क्वांटाइज़ेशन के साथ अंतर्निहित इन्फ़रेंस सर्वर
* **मल्टी-GPU समर्थन** — DDP, FSDP, tensor parallelism तुरंत उपलब्ध
* **मेमोरी-कुशल** — 4-बिट क्वांटाइज़ेशन, gradient checkpointing, activation checkpointing

***

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

| घटक     | न्यूनतम          | अनुशंसित           |
| ------- | ---------------- | ------------------ |
| GPU     | RTX 3090 (24 GB) | A100 80 GB / H100  |
| VRAM    | 16 GB (7B LoRA)  | 80 GB+ (70B पूर्ण) |
| RAM     | 32 GB            | 64 GB+             |
| CPU     | 8 कोर            | 16+ cores          |
| स्टोरेज | 100 GB           | 500 GB+            |
| ओएस     | Ubuntu 20.04+    | Ubuntu 22.04       |
| Python  | 3.10+            | 3.11               |
| CUDA    | 12.8+            | 12.8+              |

### कार्य के अनुसार 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 के साथ त्वरित शुरुआत

```bash
# आधिकारिक 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 मार्केटप्लेस](https://clore.ai/marketplace)
2. इसके लिए फ़िल्टर करें **VRAM ≥ 24 GB** (RTX 3090 या बेहतर)
3. चुनें **PyTorch** या **CUDA 12.8** बेस इमेज
4. पोर्ट खोलें **22** और **8000** अपने ऑर्डर सेटिंग्स में
5. चुनें **स्टोरेज ≥ 200 GB** मॉडल वेट्स के लिए

### चरण 2 — SSH के माध्यम से कनेक्ट करें

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

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

```bash
# pip के माध्यम से इंस्टॉल करें (अनुशंसित)
pip install litgpt

# सभी एक्स्ट्रा के साथ (quantization, server, आदि)
pip install 'litgpt[all]'

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

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

```bash
litgpt --help
```

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

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

***

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

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

```bash
# उपलब्ध मॉडल सूचीबद्ध करें
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 टोकन सेट करें

```bash
# गेटेड मॉडल्स (Llama, Gemma) के लिए
export HF_TOKEN=hf_your-token-here

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

***

## इन्फ़रेंस (Chat & Generate)

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

# एकल जनरेशन
litgpt generate \\
  --prompt "सरल शब्दों में GPU कंप्यूटिंग समझाएँ" \\
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \\
  --max_new_tokens 200

# टेम्परेचर और सैंपलिंग के साथ
litgpt generate \\
  --prompt "सूची को सॉर्ट करने के लिए एक Python फ़ंक्शन लिखें" \\
  --checkpoint_dir checkpoints/mistralai/Mistral-7B-Instruct-v0.3 \\
  --temperature 0.7 \\
  --top_p 0.9 \\
  --max_new_tokens 500
```

***

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

### LoRA फाइनट्यूनिंग (अनुशंसित)

LoRA छोटे-सेट adapter पैरामीटर (आमतौर पर कुल वेट्स का 0.1–1%) प्रशिक्षित करता है, जबकि बेस मॉडल frozen रहता है। 10K उदाहरणों पर Llama 3 8B LoRA को RTX 3090 पर लगभग 2 घंटे लगते हैं, के साथ `r=16`.

```bash
# अपना डेटासेट तैयार करें
# फ़ॉर्मेट: {"instruction": "...", "input": "...", "output": "..."} के साथ JSON lines
cat > data/train.json << 'EOF'
{"instruction": "GPU क्लाउड कंप्यूटिंग क्या है?", "input": "", "output": "GPU क्लाउड कंप्यूटिंग इंटरनेट के माध्यम से GPU हार्डवेयर तक ऑन-डिमांड पहुँच प्रदान करती है, जिससे भौतिक हार्डवेयर के बिना AI प्रशिक्षण और इन्फ़रेंस संभव होता है."}
{"instruction": "Clore.ai पर GPU कैसे किराए पर लूँ?", "input": "", "output": "clore.ai/marketplace पर जाएँ, GPU स्पेसिफिकेशनों के अनुसार फ़िल्टर करें, एक सर्वर चुनें, पोर्ट कॉन्फ़िगर करें, और rent पर क्लिक करें. 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 loss, learning rate, और ETA के साथ लॉग आउटपुट करता है
```

### QLoRA (4-बिट + LoRA)

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

```bash
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
```

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

```bash
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
```

### Multi-GPU Training

```bash
# कई 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)

```bash
# इन्फ़रेंस सर्वर शुरू करें
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 क्लाइंट

```python
import requests

response = requests.post(
    "http://<server-ip>:8000/predict",
    json={
        "prompt": "reinforcement learning समझाएँ",
        "max_new_tokens": 500,
        "temperature": 0.8,
        "top_p": 0.9,
    }
)
print(response.json()["output"])
```

***

## शुरुआत से प्रीट्रेनिंग

अपनी स्वयं की डेटा पर शुरुआत से कस्टम LLM प्रशिक्षित करने के लिए:

```bash
# प्रीट्रेनिंग डेटा तैयार करें (tokenized और chunked)
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
```

***

## मॉडल्स को कन्वर्ट और एक्सपोर्ट करना

```bash
# LoRA weights को base model में merge करें
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 conversion script का उपयोग करें
python llama.cpp/convert.py hf_model/ --outfile model.gguf
```

***

## मॉडल्स का मूल्यांकन

```bash
# 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 अनुशंसाएँ

{% hint style="warning" %}
**Clore.ai marketplace पर multi-GPU 80GB-class rigs सूचीबद्ध नहीं हैं।** आज सूचीबद्ध सबसे बड़े boxes 4× RTX PRO 6000 Blackwell (प्रत्येक 96GB, कुल 380GB) और 8–11× RTX 5090 (प्रत्येक 32GB) हैं। A100 / H200 / B200 क्षमता [bare metal](https://clore.ai/bare-metal) के रूप में अनुरोध पर बेची जाती है। देखें [GPU मूल्य और उपलब्धता](/guides/guides_v2-hi/getting-started/pricing.md) किसी deployment का आकार तय करने से पहले।
{% endhint %}

LitGPT तीन अलग-अलग workloads को कवर करता है — inference, LoRA finetuning, और full pretraining — जिनमें प्रत्येक की GPU आवश्यकताएँ अलग होती हैं।

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

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

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

***

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

### CUDA मेमोरी समाप्त

```bash
# बैच आकार कम करें
--train.micro_batch_size 1

# gradient checkpointing सक्षम करें
--train.gradient_checkpointing true

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

# GPU memory जांचें
nvidia-smi
```

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

```bash
# 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
```

### Training loss कम नहीं हो रही

```bash
# अपना डेटा फ़ॉर्मेट जाँचें — यह वैध 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('सभी लाइनें वैध हैं')
"

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

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

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

```bash
# जाँचें कि सर्वर सुन रहा है
ss -tlnp | grep 8000

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

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

### मल्टी-GPU प्रशिक्षण अटक जाता है

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

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

# NCCL environment variables सेट करें
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 मॉडल**: <https://huggingface.co/models>
* **Discord**: <https://discord.gg/lightning-ai>
* **Clore.ai मार्केटप्लेस**: <https://clore.ai/marketplace>


---

# 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/training/litgpt.md?ask=<question>&goal=<endgoal>
```

`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.