> 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 सबसे व्यापक ओपन-सोर्स फाइन-ट्यूनिंग फ्रेमवर्क है, जो सभी 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 ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।


---

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