फ़ाइन-ट्यूनिंग टूल्स तुलना

Clore.ai GPU सर्वरों पर LLMs को प्रशिक्षित करने के लिए सही fine-tuning framework चुनें।

फाइन-ट्यूनिंग एक पूर्व-प्रशिक्षित LLM को आपके विशिष्ट कार्य या डोमेन के अनुसार अनुकूलित करती है। यह गाइड चार प्रमुख ओपन-सोर्स टूल्स की तुलना करती है: Unsloth, Axolotl, LLaMA-Factory, और TRL — गति, मेमोरी दक्षता, समर्थित मॉडल, और उपयोग में आसानी को कवर करते हुए।

---

त्वरित निर्णय मैट्रिक्स

	Unsloth	Axolotl	LLaMA-Factory	TRL
इसके लिए सर्वश्रेष्ठ	गति + मेमोरी	कॉन्फ़िगरेशन-आधारित प्रशिक्षण	शुरुआती लोगों के लिए अनुकूल	अनुसंधान + RLHF
गति बनाम आधाररेखा	2-5× तेज	~1× (मानक)	~1× (मानक)	~1× (मानक)
मेमोरी में कमी	70-80% कम	QLoRA मानक	QLoRA मानक	मानक
RLHF/DPO/PPO	बेसिक	✅	✅	✅ (मूल)
वेबUI	❌	❌	✅	❌
GitHub स्टार्स	23K+	9K+	37K+	10K+
लाइसेंस	LGPL (गैर-व्यावसायिक उपयोग के लिए मुफ्त)	Apache 2.0	Apache 2.0	Apache 2.0

---

अवलोकन

Unsloth

Unsloth का पूरा ध्यान एक ही चीज़ पर है: फाइन-ट्यूनिंग को जितना संभव हो उतना तेज़ और मेमोरी-कुशल बनाना। यह Triton में प्रमुख ऑपरेशनों को पुनर्लेखित करता है और CUDA kernels को अनुकूलित करता है।

दर्शन: अधिकतम गति, न्यूनतम VRAM — कोई समझौता नहीं।

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.2-8B-Instruct",
    max_seq_length=2048,
    load_in_4bit=True,  # 4-बिट क्वांटाइज़ेशन
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,              # LoRA रैंक
    target_modules=["q_proj", "k_proj", "v_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",  # ~30% अधिक बैच साइज़
    random_state=42,
)

Axolotl

Axolotl HuggingFace Transformers को YAML-आधारित कॉन्फ़िगरेशन सिस्टम के साथ लपेटता है। यह प्रशिक्षण सेटअप की जटिलता को संभालता है ताकि आप डेटा और हाइपरपैरामीटर्स पर ध्यान दे सकें।

दर्शन: सब कुछ YAML में, नीचे पूरी लचीलापन।

# config.yml
base_model: meta-llama/Meta-Llama-3-8B
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

datasets:
  - path: mhenrichsen/alpaca_data_cleaned
    type: alpaca

load_in_4bit: true
adapter: qlora

lora_r: 32
lora_alpha: 16
lora_target_modules:
  - q_proj
  - k_proj
  - v_proj
  - o_proj

num_epochs: 3
micro_batch_size: 2
gradient_accumulation_steps: 4
learning_rate: 2e-4

LLaMA-Factory

LLaMA-Factory सबसे व्यापक मॉडल रेंज (100+) और प्रशिक्षण विधियों को सपोर्ट करता है, साथ ही कॉन्फ़िगरेशन के लिए एक वेब UI भी देता है। यह गैर-शोधकर्ताओं के लिए सबसे सुलभ विकल्प है।

दर्शन: सब कुछ काम करता है, सभी के लिए।

# कमांड लाइन के माध्यम से ट्रेन करें
llamafactory-cli train \\
  --model_name_or_path meta-llama/Meta-Llama-3-8B \\
  --stage sft \\
  --do_train \\
  --dataset alpaca_gpt4_en \\
  --template llama3 \\
  --finetuning_type lora \
  --lora_rank 8 \\
  --output_dir saves/llama3-8b-lora \\
  --num_train_epochs 3.0 \\
  --per_device_train_batch_size 2

# या WebUI का उपयोग करें
llamafactory-cli webui

TRL (Transformer Reinforcement Learning)

TRL HuggingFace की आधिकारिक RLHF लाइब्रेरी है। यह PPO, DPO, ORPO, और अन्य alignment training methods के लिए मानक है।

दर्शन: अनुसंधान-प्रथम, alignment training मूल रूप से शामिल।

from trl import SFTTrainer, SFTConfig
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset

model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B")

training_args = SFTConfig(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    logging_steps=10,
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    args=training_args,
    train_dataset=load_dataset("tatsu-lab/alpaca", split="train"),
)

trainer.train()

---

गति बेंचमार्क

प्रशिक्षण गति तुलना (tokens/second)

टेस्ट सेटअप: LLaMA 3.1 8B, LoRA r=16, 4-बिट क्वांटाइज़ेशन, बैच साइज़ 4, A100 80GB

टूल	टोकन/सेकंड	बनाम आधाररेखा	मेमोरी (VRAM)
Unsloth (4-बिट)	~4,200	2.8×	~8GB
Axolotl (QLoRA)	~1,500	1.0×	~16GB
LLaMA-Factory (QLoRA)	~1,480	~1.0×	~16GB
TRL (QLoRA)	~1,450	~0.97×	~18GB
Unsloth (पूर्ण 16-बिट)	~2,800	1.9×	~22GB

Unsloth का लाभ वास्तविक है: 2-5× गति attention, cross-entropy, RoPE, और LoRA के लिए कस्टम Triton kernels से आती है। केवल मार्केटिंग नहीं।

VRAM उपयोग तुलना

LLaMA 3.1 8B को प्रशिक्षित करते समय, अनुक्रम लंबाई 2048:

विधि	Unsloth	Axolotl	LLaMA-Factory	TRL
पूर्ण fine-tune (bf16)	60GB	70GB	72GB	74GB
LoRA (bf16)	18GB	24GB	25GB	26GB
QLoRA (4-बिट)	8GB	16GB	16GB	18GB
QLoRA (4-बिट, लंबा ctx)	12GB	24GB	24GB	26GB

8B मॉडल के लिए न्यूनतम GPU:

• Unsloth: RTX 3080 (10GB) ✅

• अन्य: RTX 3090 (24GB) आवश्यक

---

समर्थित मॉडल

मॉडल समर्थन मैट्रिक्स

मॉडल परिवार	Unsloth	Axolotl	LLaMA-Factory	TRL
LLaMA 3.x	✅	✅	✅	✅
LLaMA 2	✅	✅	✅	✅
Mistral	✅	✅	✅	✅
Mixtral MoE	✅	✅	✅	✅
Gemma 2	✅	✅	✅	✅
Phi-3/3.5	✅	✅	✅	✅
Qwen 2.5	✅	✅	✅	✅
DeepSeek	✅	✅	✅	✅
Falcon	✅	✅	✅	✅
GPT-NeoX	आंशिक	✅	✅	✅
T5/FLAN	❌	✅	✅	✅
BERT/RoBERTa	❌	✅	✅	✅
विज़न LLMs	आंशिक	आंशिक	✅	✅

प्रशिक्षण विधि समर्थन

विधि	Unsloth	Axolotl	LLaMA-Factory	TRL
पूर्ण फाइन-ट्यून	✅	✅	✅	✅
LoRA	✅	✅	✅	✅
QLoRA	✅	✅	✅	✅
DoRA	✅	✅	✅	❌
PEFT	✅	✅	✅	✅
SFT	✅	✅	✅	✅ (मूल)
DPO	✅	✅	✅	✅ (मूल)
PPO	❌	✅	✅	✅ (मूल)
ORPO	✅	✅	✅	✅
KTO	❌	✅	✅	✅ (मूल)
GRPO	✅	❌	✅	✅
CPT (निरंतर pretraining)	✅	✅	✅	✅

---

Unsloth: गहन विश्लेषण

इसे तेज़ क्या बनाता है

1. Triton kernels: Flash Attention, cross-entropy loss, और LoRA को Triton में पुनर्लेखित करता है

2. फ्यूज्ड ऑपरेशन्स: कई CUDA ops को एक kernel में जोड़ता है

3. स्मार्ट gradient checkpointing: "unsloth" mode ~30% अधिक मेमोरी बचाता है

4. कुशल backprop: बड़े मध्यवर्ती tensors को materialize करने से बचता है

Clore.ai पर स्थापना

# CUDA 12.8
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

# या conda के साथ
conda create --name unsloth_env python=3.11
conda activate unsloth_env
conda install pytorch-cuda=12.1 pytorch cudatoolkit xformers -c pytorch -c nvidia -c xformers -y
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

पूर्ण प्रशिक्षण स्क्रिप्ट

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset
import torch

# 1. Unsloth अनुकूलन के साथ मॉडल लोड करें
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct",
    max_seq_length=2048,
    dtype=None,        # स्वचालित रूप से पहचानें
    load_in_4bit=True,
)

# 2. LoRA एडाप्टर जोड़ें
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
)

# 3. डेटासेट लोड और फ़ॉर्मैट करें
dataset = load_dataset("tatsu-lab/alpaca", split="train")

def format_prompt(example):
    return {"text": f"### Instruction:\n{example['instruction']}\n\n### Response:\n{example['output']}"}

dataset = dataset.map(format_prompt)

# 4. ट्रेन करें
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        num_train_epochs=1,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=1,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
    ),
)
trainer.train()

# 5. सेव करें
model.save_pretrained("lora_model")
model.save_pretrained_gguf("model_gguf", tokenizer, quantization_method="q4_k_m")

कमज़ोरियाँ: कोई PPO नहीं, केवल समर्थित मॉडल सूची तक सीमित, LGPL लाइसेंस (व्यावसायिक उपयोग के लिए जाँचें)

---

Axolotl: गहन विश्लेषण

कॉन्फ़िगरेशन-प्रथम दृष्टिकोण

जब आप पुनरुत्पादनीय, संस्करण-नियंत्रित प्रशिक्षण कॉन्फ़िगरेशन चाहते हैं, तब Axolotl चमकता है:

# axolotl_config.yml — पूरा उदाहरण
base_model: meta-llama/Meta-Llama-3-8B-Instruct
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

# डेटा
datasets:
  - path: tatsu-lab/alpaca
    type: alpaca
  - path: ./my_custom_data.jsonl
    type: sharegpt
dataset_prepared_path: ./prepared_data
val_set_size: 0.01

# क्वांटाइज़ेशन
load_in_4bit: true
adapter: qlora
bf16: true
tf32: true

# LoRA
lora_r: 32
lora_alpha: 16
lora_dropout: 0.05
lora_target_modules:
  - q_proj
  - v_proj
  - k_proj
  - o_proj
  - gate_proj
  - up_proj
  - down_proj

# प्रशिक्षण
sequence_len: 4096
sample_packing: true  # दक्षता के लिए छोटी sequences को पैक करता है
pad_to_sequence_len: true
micro_batch_size: 2
gradient_accumulation_steps: 4
num_epochs: 3
learning_rate: 0.0002
optimizer: adamw_bnb_8bit
lr_scheduler: cosine

# लॉगिंग
logging_steps: 10
eval_steps: 100
save_steps: 100
output_dir: ./outputs/my-model

# wandb
wandb_project: my-fine-tune
wandb_run_id: run-001

# इंस्टॉल करें और चलाएँ
pip install axolotl[flash-attn,deepspeed]
axolotl train axolotl_config.yml

इसके लिए सर्वश्रेष्ठ: जो टीमें पुनरुत्पादनीय, config-versioned training runs चाहती हैं

---

LLaMA-Factory: गहन विश्लेषण

WebUI वॉकथ्रू

# इंस्टॉल करें
pip install llamafactory

# WebUI लॉन्च करें
llamafactory-cli webui
# http://localhost:7860 खोलें

WebUI टैब्स:

1. ट्रेन — base model, dataset, method कॉन्फ़िगर करें

2. मूल्यांकन करें — MMLU, CMMLU बेंचमार्क चलाएँ

3. चैट — इंटरैक्टिव inference

4. एक्सपोर्ट — LoRA को merge करें, GGUF में quantize करें

CLI प्रशिक्षण उदाहरण

# Supervised Fine-Tuning
llamafactory-cli train \\
  --stage sft \\
  --model_name_or_path meta-llama/Meta-Llama-3-8B \\
  --dataset alpaca_gpt4_en,glaive_toolcall_en \\
  --template llama3 \\
  --finetuning_type lora \
  --lora_rank 8 \\
  --lora_alpha 16 \\
  --lora_target all \\
  --output_dir saves/llama3-lora \\
  --num_train_epochs 3 \\
  --per_device_train_batch_size 2 \\
  --gradient_accumulation_steps 4 \\
  --learning_rate 2e-4 \\
  --quantization_bit 4 \\
  --flash_attn fa2

# DPO प्रशिक्षण
llamafactory-cli train \\
  --stage dpo \\
  --model_name_or_path meta-llama/Meta-Llama-3-8B \\
  --dataset dpo_mix_en \\
  --template llama3 \\
  --finetuning_type lora \
  --output_dir saves/llama3-dpo

इसके लिए सर्वश्रेष्ठ: शुरुआती लोग, वे टीमें जो WebUI चाहती हैं, बिना गहरे शोध ज्ञान के DPO/RLHF

---

TRL: गहन विश्लेषण

RLHF पाइपलाइन उदाहरण

TRL alignment training के लिए पसंदीदा टूल है:

from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from trl import DPOTrainer, DPOConfig
from datasets import load_dataset

# DPO (Direct Preference Optimization) — सबसे सामान्य alignment method
model_name = "meta-llama/Meta-Llama-3-8B-Instruct"

dpo_config = DPOConfig(
    model_name_or_path=model_name,
    output_dir="dpo_outputs",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    beta=0.1,             # KL penalty coefficient
    loss_type="sigmoid",  # or "hinge", "ipo", "kto_pair"
    learning_rate=5e-7,
)

# preference dataset लोड करें (prompt + chosen + rejected)
dataset = load_dataset("Anthropic/hh-rlhf", split="train")

trainer = DPOTrainer(
    model=model_name,
    args=dpo_config,
    train_dataset=dataset,
)
trainer.train()

इसके लिए सर्वश्रेष्ठ: alignment research, RLHF, DPO, PPO, ORPO implementations

---

सही टूल चुनना

निर्णय प्रवाह

अधिकतम गति/न्यूनतम VRAM चाहिए?
  → हाँ → Unsloth (2-5× तेज, छोटे GPUs पर फिट बैठता है)

alignment training (DPO/PPO/RLHF) चाहिए?
  → हाँ → TRL या LLaMA-Factory
  → शोध/कस्टम → TRL
  → प्रोडक्शन/आसान → LLaMA-Factory

कॉन्फ़िगरेशन-प्रथम पुनरुत्पादनीयता चाहिए?
  → हाँ → Axolotl

गैर-तकनीकी टीम या WebUI चाहते हैं?
  → हाँ → LLaMA-Factory

बस जल्दी शुरू करना चाहते हैं?
  → LLaMA-Factory या Unsloth

टीम प्रकार के अनुसार

टीम	सिफारिश	कारण
व्यक्तिगत शोधकर्ता	Unsloth	गति + Jupyter notebooks
ML engineer	Axolotl	कॉन्फ़िग-चालित, पुनरुत्पादनीय
उत्पाद टीम	LLaMA-Factory	WebUI, व्यापक मॉडल समर्थन
alignment टीम	TRL	मूल RLHF primitives
स्टार्टअप	Unsloth + TRL	ज़रूरत पड़ने पर गति + alignment

---

Clore.ai GPU अनुशंसाएँ

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 के रूप में अनुरोध पर बेची जाती है। देखें GPU मूल्य और उपलब्धता किसी deployment का आकार तय करने से पहले।

कार्य	न्यूनतम GPU	अनुशंसित	टूल
7-8B LoRA (QLoRA)	RTX 3080 (10GB)	RTX 3090	Unsloth
13B LoRA	RTX 3090 (24GB)	A6000 (48GB)	Unsloth/Axolotl
70B LoRA	A100 (80GB)	2×A100	Axolotl/TRL
8B पूर्ण FT	A100 (40GB)	A100 (80GB)	कोई भी
DPO/PPO 7B	RTX 4090 (24GB)	A6000 (48GB)	TRL

---

उपयोगी लिंक

• Unsloth GitHub — 23K+ stars

• Axolotl GitHub — 9K+ stars

• LLaMA-Factory GitHub — 37K+ stars

• TRL GitHub — 10K+ stars

• HuggingFace PEFT Docs

---

सारांश

टूल	इसके लिए सर्वश्रेष्ठ	मुख्य लाभ
Unsloth	गति-महत्वपूर्ण प्रशिक्षण, छोटे GPUs	2-5× तेज, 70% कम VRAM
Axolotl	कॉन्फ़िग-चालित, पुनरुत्पादनीय रन	YAML-first, कई डेटा formats
LLaMA-Factory	100+ मॉडल, WebUI, शुरुआती लोग	सबसे अधिक मॉडल समर्थन, GUI
TRL	RLHF, DPO, alignment research	मूल alignment training

अधिकांश Clore.ai उपयोग मामलों के लिए: शुरू करें Unsloth (गति + मेमोरी दक्षता), जोड़ें TRL यदि आपको DPO या PPO alignment training की आवश्यकता हो।