> 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/llama-factory.md).

# LLaMA-Factory

LLaMA-Factory का उपयोग करके Clore.ai GPUs पर LoRA/QLoRA और वेब UI के साथ 100+ LLMs को फ़ाइन-ट्यून करें

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 (+ ऑप्टिमाइज़र अवस्थाएँ)
* मल्टी-GPU (DeepSpeed/FSDP) किसी भी संख्या के GPU पर स्केल करता है
  {% endhint %}

## CLORE.AI पर त्वरित परिनियोजन

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

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

**Environment Variables:**

| वेरिएबल                | उदाहरण      | विवरण                                   |
| ---------------------- | ----------- | --------------------------------------- |
| `HF_TOKEN`             | `hf_xxx...` | gated models के लिए HuggingFace token   |
| `WANDB_API_KEY`        | `xxx...`    | प्रयोग ट्रैकिंग के लिए Weights & Biases |
| `CUDA_VISIBLE_DEVICES` | `0,1`       | उपयोग की जाने वाली GPUs                 |

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

### 1. CLORE.AI पर GPU Server किराए पर लें

विज़िट करें [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 |
| पूर्ण FT 7B | 80 GB         | A100 80GB       |
| मल्टी-GPU   | भिन्न होता है | 2-8× कोई भी GPU |

### 2. अपने Server में 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 लॉन्च करें

**Web 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 के साथ मल्टी-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: Web UI (LLaMA Board) के माध्यम से LoRA फाइन-ट्यूनिंग

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

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

एक प्रशिक्षण कॉन्फ़िग YAML तैयार करें:

```bash
docker exec -it llamafactory bash

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

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

### डेटासेट
dataset: alpaca_en
template: mistral
cutoff_len: 2048
max_samples: 1000
overwrite_cache: true
preprocessing_num_workers: 16

### आउटपुट
output_dir: saves/mistral-qlora
logging_steps: 10
save_steps: 500
plot_loss: true
overwrite_output_dir: true

### प्रशिक्षण
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_method: bitsandbytes
quantization_bit: 4
EOF

# training चलाएँ
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 (प्रत्यक्ष प्राथमिकता अनुकूलन)

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

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

### विधि - DPO
stage: dpo
do_train: true
finetuning_type: lora
lora_rank: 8

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

### डेटासेट (प्राथमिकता प्रारूप होना चाहिए)
dataset: dpo_en_demo
template: llama3
cutoff_len: 2048

### आउटपुट
output_dir: saves/llama3-dpo
logging_steps: 10
save_steps: 100

### प्रशिक्षण
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 अल्फ़ा स्केलिंग                        |
| `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 अनुसूची                                  |

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

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

### मल्टी-GPU DeepSpeed प्रशिक्षण

एकाधिक GPU पर प्रशिक्षण के लिए, के साथ लॉन्च करें `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 Target चुनें

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

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

***

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

### समस्या: प्रशिक्षण के दौरान "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 अनुशंसाएँ

{% 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 %}

| उपयोग-प्रकरण           | अनुशंसित GPU    | Clore.ai पर अनुमानित लागत                 |
| ---------------------- | --------------- | ----------------------------------------- |
| विकास/परीक्षण          | RTX 3090 (24GB) | $0.07–0.21/gpu/hr                         |
| फाइन-ट्यूनिंग (7B–13B) | RTX 4090 (24GB) | $0.14–0.42/gpu/hr                         |
| बड़े मॉडल (70B+)       | A100 80GB       | [bare metal](https://clore.ai/bare-metal) |
| Multi-GPU Training     | 2-4x A100 80GB  | [bare metal](https://clore.ai/bare-metal) |

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


---

# 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/llama-factory.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.