# LLaMA-Factory

LLaMA-Factory सबसे व्यापक ओपन-सोर्स फाइन-ट्यूनिंग फ्रेमवर्क है, जो सभी LLaMA वेरिएंट्स, Qwen, Mistral, Phi, Falcon, ChatGLM और अन्य सहित 100+ भाषा मॉडलों का समर्थन करता है। यह LoRA, QLoRA, पूर्ण फाइन-ट्यूनिंग, RLHF, DPO और PPO प्रदान करता है — सभी एक सहज वेब इंटरफेस (LLaMA Board) या CLI के माध्यम से। CLORE.AI के ऑन-डिमांड GPU सर्वर इसे क्लाउड प्रदाताओं की लागत के एक छोटे हिस्से पर फाइन-ट्यूनिंग जॉब लॉन्च करने के लिए एक आदर्श प्लेटफ़ॉर्म बनाते हैं।

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

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

| पैरामीटर | न्यूनतम          | अनुशंसित       |
| -------- | ---------------- | -------------- |
| RAM      | 16 GB            | 32 GB+         |
| VRAM     | 8 GB (QLoRA)     | 24 GB+         |
| डिस्क    | 50 GB            | 200 GB+        |
| GPU      | NVIDIA RTX 2080+ | A100, RTX 4090 |

{% hint style="info" %}
**ट्रेनिंग विधि GPU आवश्यकताओं को निर्धारित करती है:**

* **QLoRA (4-बिट)**: 7B मॉडलों के लिए 8 GB VRAM, 13B के लिए 16 GB
* **LoRA (float16)**: 7B मॉडलों के लिए 16 GB VRAM, 13B के लिए 40 GB
* **पूर्ण फाइन-ट्यूनिंग**: 7B पैरामीटर के लिए \~14 GB VRAM प्रति मॉडल (+ ऑप्टिमाइज़र स्टेट्स)
* Multi-GPU (DeepSpeed/FSDP) किसी भी संख्या के GPUs पर स्केल करता है
  {% endhint %}

## CLORE.AI पर त्वरित तैनाती

**Docker इमेज:** `hiyouga/llamafactory:latest`

**पोर्ट्स:** `22/tcp`, `7860/http`

**पर्यावरण चर:**

| चर                     | उदाहरण      | विवरण                                   |
| ---------------------- | ----------- | --------------------------------------- |
| `HF_TOKEN`             | `hf_xxx...` | गेटेड मॉडलों के लिए HuggingFace टोकन    |
| `WANDB_API_KEY`        | `xxx...`    | प्रयोग ट्रैकिंग के लिए Weights & Biases |
| `CUDA_VISIBLE_DEVICES` | `0,1`       | उपयोग करने के लिए GPUs                  |

## चरण-दर-चरण सेटअप

### 1. CLORE.AI पर एक GPU सर्वर किराए पर लें

पर जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) और अपने कार्य के आधार पर चुनें:

| कार्य      | VRAM        | सिफारिश की गई GPU |
| ---------- | ----------- | ----------------- |
| QLoRA 7B   | 8 GB        | RTX 3070/2080     |
| QLoRA 13B  | 16 GB       | RTX 3090/A4000    |
| LoRA 7B    | 16 GB       | RTX 3090/A4000    |
| LoRA 13B   | 40 GB       | A6000/A100 40GB   |
| Full FT 7B | 80 GB       | A100 80GB         |
| Multi-GPU  | भिन्न-भिन्न | 2-8× किसी भी GPU  |

### 2. अपने सर्वर में SSH करें

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. कार्य निर्देशिकाएँ बनाएं

```bash
mkdir -p /root/llamafactory/{data,models,output,saves}
```

### 4. Docker इमेज खींचें

```bash
docker pull hiyouga/llamafactory:latest
```

### 5. LLaMA-Factory लॉन्च करें

**वेब UI (LLaMA Board) के साथ लॉन्च करें:**

```bash
docker run -d \
  --name llamafactory \
  --gpus all \
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \
  -v /root/llamafactory/models:/root/.cache/huggingface \
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \
  -v /root/llamafactory/saves:/app/LLaMA-Factory/saves \
  -e HF_TOKEN=hf_your_token_here \
  hiyouga/llamafactory:latest \
  llamafactory-cli webui
```

**Weights & Biases ट्रैकिंग के साथ:**

```bash
docker run -d \
  --name llamafactory \
  --gpus all \
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \
  -v /root/llamafactory/models:/root/.cache/huggingface \
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \
  -v /root/llamafactory/saves:/app/LLaMA-Factory/saves \
  -e HF_TOKEN=hf_your_token_here \
  -e WANDB_API_KEY=your_wandb_key \
  hiyouga/llamafactory:latest \
  llamafactory-cli webui
```

**DeepSpeed के साथ Multi-GPU (4 GPUs):**

```bash
docker run -d \
  --name llamafactory \
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \
  -v /root/llamafactory/models:/root/.cache/huggingface \
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \
  -e CUDA_VISIBLE_DEVICES=0,1,2,3 \
  hiyouga/llamafactory:latest \
  bash -c "llamafactory-cli webui"
```

### 6. वेब इंटरफेस तक पहुँचें

लॉग जांचें और URL प्राप्त करें:

```bash
docker logs -f llamafactory
```

पोर्ट 7860 के लिए आपका CLORE.AI http\_pub URL:

```
https://<order-id>-7860.clore.ai/
```

***

## उपयोग के उदाहरण

### उदाहरण 1: वेब UI (LLaMA Board) के जरिए LoRA फाइन-ट्यूनिंग

1. अपने CLORE.AI URL पर LLaMA Board खोलें
2. पर जाएँ **Train** टैब
3. कॉन्फ़िगर करें:
   * **मॉडल नाम**: `LLaMA-3` → `Meta-Llama-3-8B-Instruct`
   * **ट्रेनिंग चरण**: `Supervised Fine-Tuning`
   * **डेटासेट**: अपना डेटासेट चुनें (या कस्टम अपलोड करें)
   * **फाइन-ट्यूनिंग विधि**: `lora`
   * **LoRA रैंक**: `8` (अधिक = अधिक प्रशिक्षित पैरामीटर)
   * **लर्निंग रेट**: `1e-4`
   * **एपॉक्स**: `3`
   * **आउटपुट निर्देशिका**: `llama3-finetuned`
4. पर क्लिक करें **शुरू करें** ट्रेनिंग प्रारंभ करने के लिए
5. लॉस कर्व मॉनिटर करें **Loss** चार्ट

### उदाहरण 2: CLI-आधारित QLoRA फाइन-ट्यूनिंग

एक ट्रेनिंग कॉन्फ़िग YAML तैयार करें:

```bash
docker exec -it llamafactory bash

cat > /app/LLaMA-Factory/configs/qlora_mistral.yaml << 'EOF'
### Model
model_name_or_path: mistralai/Mistral-7B-Instruct-v0.3

### Method
stage: sft
do_train: true
finetuning_type: lora
lora_target: all
lora_rank: 16
lora_alpha: 32
lora_dropout: 0.05

### Dataset
dataset: alpaca_en
template: mistral
cutoff_len: 2048
max_samples: 1000
overwrite_cache: true
preprocessing_num_workers: 16

### Output
output_dir: saves/mistral-qlora
logging_steps: 10
save_steps: 500
plot_loss: true
overwrite_output_dir: true

### Train
per_device_train_batch_size: 2
gradient_accumulation_steps: 8
learning_rate: 0.0001
num_train_epochs: 3.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
fp16: true

### Quantization
quantization_method: bitsandbytes
quantization_bit: 4
EOF

# प्रशिक्षण चलाएँ
llamafactory-cli train /app/LLaMA-Factory/configs/qlora_mistral.yaml
```

### उदाहरण 3: कस्टम डेटासेट अपलोड करें

Alpaca फॉर्मेट में एक कस्टम डेटासेट बनाएं:

```bash
# डेटासेट फ़ाइल बनाएं
cat > /root/llamafactory/data/my_dataset.json << 'EOF'
[
  {
    "instruction": "आप एक टेक कंपनी के ग्राहक सेवा एजेंट हैं। सहायक तरीके से उत्तर दें.",
    "input": "अपडेट के बाद मेरा लैपटॉप चालू नहीं हो रहा है। मुझे क्या करना चाहिए?",
    "output": "मैं समझता हूँ कि यह कितना निराशाजनक हो सकता है। आइए चरण-दर-चरण समस्याएँ हल करें:\n\n1. **पावर बटन को 10 सेकंड तक दबाकर रखें** ताकि जबरदस्ती शटडाउन हो जाए\n2. **पावर केबल निकालें** और यदि बैटरी हटाने योग्य है तो बैटरी निकालकर 30 सेकंड प्रतीक्षा करें\n3. **पावर पुनः कनेक्ट करें** और चालू करने का प्रयास करें\n4. यदि अभी भी कोई प्रतिक्रिया नहीं है, तो बूट के दौरान **F8/F11** दबाकर रिकवरी मोड तक पहुँचें\n\nक्या आप चाहेंगे कि मैं इनमें से किसी भी चरण को विस्तार से समझाऊँ?"
  },
  {
    "instruction": "आप एक टेक कंपनी के ग्राहक सेवा एजेंट हैं.",
    "input": "मैं अपना पासवर्ड कैसे रीसेट करूं?",
    "output": "अपने पासवर्ड को रीसेट करना आसान है! तरीका इस प्रकार है:\n\n1. लॉगिन पृष्ठ पर जाएँ और **'Forgot Password'** पर क्लिक करें\n2. अपना **पंजीकृत ईमेल पता** दर्ज करें\n3. रीसेट लिंक के लिए अपने ईमेल की जांच करें (स्पैम फोल्डर भी देखें)\n4. लिंक पर क्लिक करें और **नया पासवर्ड बनाएं**\n\nरीसेट लिंक 24 घंटे में समाप्त हो जाता है। यदि आपको 5 मिनट के भीतर ईमेल प्राप्त नहीं होता है, तो हमारी सपोर्ट टीम से संपर्क करें।"
  }
]
EOF

# dataset_info.json में डेटासेट रजिस्टर करें
docker exec -it llamafactory bash -c "
cat >> /app/LLaMA-Factory/data/dataset_info.json << 'EOF2'
,
\"my_dataset\": {
  \"file_name\": \"/root/llamafactory/data/my_dataset.json\"
}
EOF2
"
```

फिर चुनें `my_dataset` LLaMA Board के Dataset ड्रॉपडाउन में।

### उदाहरण 4: DPO (Direct Preference Optimization)

```yaml
### configs/dpo_llama.yaml

model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct

### Method - DPO
stage: dpo
do_train: true
finetuning_type: lora
lora_rank: 8

### DPO-विशिष्ट
pref_beta: 0.1
pref_loss: sigmoid  # sigmoid, hinge, ipo

### Dataset (पसंद फ़ॉर्मेट होना चाहिए)
dataset: dpo_en_demo
template: llama3
cutoff_len: 2048

### Output
output_dir: saves/llama3-dpo
logging_steps: 10
save_steps: 100

### Train
per_device_train_batch_size: 1
gradient_accumulation_steps: 8
learning_rate: 5e-5
num_train_epochs: 1.0
fp16: true
```

```bash
docker exec -it llamafactory bash -c "llamafactory-cli train /configs/dpo_llama.yaml"
```

### उदाहरण 5: फाइन-ट्यून किए गए मॉडल के साथ इन्फ़रेंस

ट्रेनिंग के बाद, अपने मॉडल का परीक्षण करें:

```bash
docker exec -it llamafactory bash

# इंटरैक्टिव चैट
llamafactory-cli chat \
  --model_name_or_path mistralai/Mistral-7B-Instruct-v0.3 \
  --adapter_name_or_path /app/LLaMA-Factory/saves/mistral-qlora \
  --template mistral \
  --finetuning_type lora
```

या मर्ज्ड मॉडल निर्यात करें:

```bash
llamafactory-cli export \
  --model_name_or_path mistralai/Mistral-7B-Instruct-v0.3 \
  --adapter_name_or_path /app/LLaMA-Factory/saves/mistral-qlora \
  --template mistral \
  --finetuning_type lora \
  --export_dir /app/LLaMA-Factory/output/mistral-merged \
  --export_size 4 \
  --export_legacy_format false
```

***

## कॉन्फ़िगरेशन

### मुख्य ट्रेनिंग पैरामीटर

| पैरामीटर                      | सामान्य मान | विवरण                                   |
| ----------------------------- | ----------- | --------------------------------------- |
| `lora_rank`                   | 8–64        | LoRA रैंक (उच्च = अधिक अभिव्यक्तिपूर्ण) |
| `lora_alpha`                  | 2× रैंक     | LoRA alpha स्केलिंग                     |
| `lora_dropout`                | 0.0–0.1     | LoRA लेयर्स के लिए ड्रॉपआउट             |
| `lora_target`                 | `all`       | किस लेयर पर LoRA लागू करना है           |
| `learning_rate`               | `1e-4`      | प्रारंभिक लर्निंग रेट                   |
| `num_train_epochs`            | 1–5         | ट्रेनिंग एपॉक्स                         |
| `per_device_train_batch_size` | 1–4         | प्रति GPU बैच साइज                      |
| `gradient_accumulation_steps` | 4–16        | प्रभावी बैच गुणक                        |
| `cutoff_len`                  | 1024–4096   | अधिकतम सीक्वेंस लंबाई                   |
| `quantization_bit`            | 4 या 8      | QLoRA क्वांटाइज़ेशन बिट्स               |
| `warmup_ratio`                | 0.05–0.1    | LR वॉर्मअप भाग                          |
| `lr_scheduler_type`           | `cosine`    | LR शेड्यूल                              |

### समर्थित फाइन-ट्यूनिंग विधियाँ

| विधि                 | मेमोरी उपयोग | गुणवत्ता   | कब उपयोग करें             |
| -------------------- | ------------ | ---------- | ------------------------- |
| `full`               | बहुत उच्च    | सबसे अच्छा | असीमित VRAM               |
| `freeze`             | मध्यम        | अच्छा      | बेस लेयर्स को फ्रीज़ करें |
| `lora`               | कम           | बहुत अच्छा | डिफ़ॉल्ट विकल्प           |
| `qlora` (lora+quant) | सबसे कम      | अच्छा      | सीमित VRAM                |

### Multi-GPU DeepSpeed ट्रेनिंग

कई GPUs पर ट्रेनिंग के लिए, इसके साथ लॉन्च करें `torchrun`:

```bash
docker exec -it llamafactory bash -c "
FORCE_TORCHRUN=1 NNODES=1 RANK=0 MASTER_ADDR=127.0.0.1 MASTER_PORT=29500 \
llamafactory-cli train configs/qlora_mistral.yaml \
  --deepspeed examples/deepspeed/ds_z3_config.json
"
```

***

## प्रदर्शन सुझाव

### 1. GPU के अनुसार सर्वोतम QLoRA सेटिंग्स

**8 GB VRAM (RTX 3070):**

```yaml
quantization_bit: 4
per_device_train_batch_size: 1
gradient_accumulation_steps: 8
cutoff_len: 1024
```

**24 GB VRAM (RTX 3090/4090):**

```yaml
quantization_bit: 4  # बड़े बैच आकार के लिए अभी भी QLoRA का उपयोग करें
per_device_train_batch_size: 4
gradient_accumulation_steps: 4
cutoff_len: 2048
```

**80 GB VRAM (A100):**

```yaml
# क्वांटाइज़ेशन की आवश्यकता नहीं — सीधे LoRA का उपयोग करें
finetuning_type: lora
per_device_train_batch_size: 8
gradient_accumulation_steps: 2
cutoff_len: 4096
fp16: true
```

### 2. लंबे कॉन्टेक्स्ट के लिए Flash Attention 2

```yaml
flash_attn: fa2  # Ampere+ GPU आवश्यक
```

यह समान VRAM पर 2× लंबे सीक्वेंस के साथ ट्रेनिंग सक्षम करता है।

### 3. Gradient Checkpointing

लगभग \~20% धीमी ट्रेनिंग की कीमत पर VRAM बचाता है:

```yaml
gradient_checkpointing: true
```

### 4. सही LoRA टारगेट चुनें

```yaml
lora_target: all  # सभी लाइनियर लेयर्स (डिफ़ॉल्ट, सर्वोत्तम गुणवत्ता)
# या
lora_target: q_proj,v_proj  # न्यूनतम, सबसे तेज़, कम गुणवत्ता
```

### 5. तेज़ अनुकूलन के लिए ऊपर की लेयर्स फ्रीज़ करें

```yaml
finetuning_type: freeze
freeze_trainable_layers: 2   # केवल शीर्ष 2 लेयर्स प्रशिक्षित करें
freeze_trainable_modules: all
```

सरल कार्य अनुकूलन के लिए पूर्ण LoRA की तुलना में बहुत तेज़।

### 6. TensorBoard से मॉनिटर करें

```bash
# एक अलग टर्मिनल में
docker exec -it llamafactory bash -c "
tensorboard --logdir /app/LLaMA-Factory/saves --host 0.0.0.0 --port 6006
"
```

TensorBoard तक पहुँचने के लिए अपने CLORE.AI ऑर्डर में पोर्ट 6006 जोड़ें।

***

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

### समस्या: ट्रेनिंग के दौरान "CUDA out of memory"

1. बैच साइज कम करें: `per_device_train_batch_size: 1`
2. Gradient checkpointing सक्षम करें: `gradient_checkpointing: true`
3. कॉण्टेक्स्ट लंबाई कम करें: `cutoff_len: 512`
4. QLoRA (4-बिट) का उपयोग करें: `quantization_bit: 4`
5. LoRA रैंक कम करें: `lora_rank: 4`

### समस्या: ट्रेनिंग लॉस घट नहीं रहा

* लर्निंग रेट जांचें — आज़माएँ `5e-5` इमेज जेनरेट करें `2e-4`
* सुनिश्चित करें कि डेटासेट फॉर्मेट टेम्पलेट से मेल खाता है
* बढ़ाएँ `lora_rank` (8→16→32)
* जांचें कि `lora_target: all` सेट है

### समस्या: धीमी ट्रेनिंग गति

```bash
# कंटेनर के अंदर GPU उपयोग जांचें
docker exec -it llamafactory bash -c "watch -n 1 nvidia-smi"
```

यदि GPU < 80% उपयोग में है:

* बैच साइज बढ़ाएँ
* Flash Attention का उपयोग करें: `flash_attn: fa2`
* हटाएँ `gradient_checkpointing` यदि VRAM अनुमति देता है

### समस्या: वेब UI में मॉडल नहीं मिला

```bash
# कैश वॉल्यूम में पहले से डाउनलोड करें
docker exec -it llamafactory bash -c "
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3
"
```

फिर LLaMA Board में मॉडल सूची रिफ्रेश करें।

### समस्या: डेटासेट फॉर्मेट त्रुटियाँ

सभी डेटासेट फॉर्मेट्स को मिलना चाहिए `dataset_info.json` विशिष्टरण:

```bash
# डेटासेट सत्यापित करें
docker exec -it llamafactory python3 -c "
import json
with open('/app/LLaMA-Factory/data/my_dataset.json') as f:
    data = json.load(f)
print(f'Dataset has {len(data)} samples')
print('First sample keys:', list(data[0].keys()))
"
```

### समस्या: WebUI पोर्ट पहुँच योग्य नहीं

सुनिश्चित करें कि LLaMA-Factory ने Gradio सर्वर शुरू किया है:

```bash
docker logs llamafactory 2>&1 | grep -E "Running on|Error|Traceback"
```

लॉन्च कमांड में जोड़ें `--share` एक सार्वजनिक Gradio URL के लिए फ़्लैग के रूप में वैकल्पिक।

***

## लिंक

* [GitHub](https://github.com/hiyouga/LLaMA-Factory)
* [दस्तावेज़ीकरण](https://llamafactory.readthedocs.io)
* [Docker Hub (hiyouga)](https://hub.docker.com/r/hiyouga/llamafactory)
* [समर्थित मॉडल](https://github.com/hiyouga/LLaMA-Factory?tab=readme-ov-file#supported-models)
* [डेटासेट फॉर्मेट](https://github.com/hiyouga/LLaMA-Factory/blob/main/data/README.md)
* [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)

***

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

| उपयोग केस              | सिफारिश की गई GPU | Clore.ai पर अनुमानित लागत |
| ---------------------- | ----------------- | ------------------------- |
| डेवलपमेंट/टेस्टिंग     | RTX 3090 (24GB)   | \~$0.12/gpu/hr            |
| फाइन-ट्यूनिंग (7B–13B) | RTX 4090 (24GB)   | \~$0.70/gpu/hr            |
| बड़े मॉडल (70B+)       | A100 80GB         | \~$1.20/gpu/hr            |
| मल्टी-GPU ट्रेनिंग     | 2-4x A100 80GB    | \~$2.40–$4.80/hr          |

> 💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं [Clore.ai](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।