LLaMA-Factory

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

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

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

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

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

ट्रेनिंग विधि 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 पर स्केल करता है

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 मार्केटप्लेस और अपने कार्य के आधार पर चुनें:

कार्य	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 करें

ssh -p <PORT> root@<SERVER_IP>

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

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

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

docker pull hiyouga/llamafactory:latest

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

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

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 ट्रैकिंग के साथ:

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):

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 प्राप्त करें:

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 तैयार करें:

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 फॉर्मेट में एक कस्टम डेटासेट बनाएं:

# डेटासेट फ़ाइल बनाएं
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)

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

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

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

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

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

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

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:

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):

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

24 GB VRAM (RTX 3090/4090):

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

80 GB VRAM (A100):

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

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

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

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

3. Gradient Checkpointing

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

gradient_checkpointing: true

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

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

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

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

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

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

# एक अलग टर्मिनल में
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 सेट है

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

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

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

• बैच साइज बढ़ाएँ

• Flash Attention का उपयोग करें: flash_attn: fa2

• हटाएँ gradient_checkpointing यदि VRAM अनुमति देता है

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

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

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

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

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

# डेटासेट सत्यापित करें
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 सर्वर शुरू किया है:

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

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

---

लिंक

• GitHub

• दस्तावेज़ीकरण

• Docker Hub (hiyouga)

• समर्थित मॉडल

• डेटासेट फॉर्मेट

• CLORE.AI मार्केटप्लेस

---

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