> 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/comparisons/finetuning-comparison.md).

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

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

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

***

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

|                          | 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 — कोई समझौता नहीं।

```python
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 में, नीचे पूरी लचीलापन।

```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 भी देता है। यह गैर-शोधकर्ताओं के लिए सबसे सुलभ विकल्प है।

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

```bash
# कमांड लाइन के माध्यम से ट्रेन करें
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 मूल रूप से शामिल।

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

{% hint style="success" %}
**Unsloth का लाभ वास्तविक है**: 2-5× गति attention, cross-entropy, RoPE, और LoRA के लिए कस्टम Triton kernels से आती है। केवल मार्केटिंग नहीं।
{% endhint %}

### 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 पर स्थापना

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

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

```python
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 चमकता है:

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

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

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

***

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

### WebUI वॉकथ्रू

```bash
# इंस्टॉल करें
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 प्रशिक्षण उदाहरण

```bash
# 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 के लिए पसंदीदा टूल है:

```python
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 अनुशंसाएँ

{% 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     | अनुशंसित     | टूल             |
| ----------------- | --------------- | ------------ | --------------- |
| 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](https://github.com/unslothai/unsloth) — 23K+ stars
* [Axolotl GitHub](https://github.com/axolotl-ai-cloud/axolotl) — 9K+ stars
* [LLaMA-Factory GitHub](https://github.com/hiyouga/LLaMA-Factory) — 37K+ stars
* [TRL GitHub](https://github.com/huggingface/trl) — 10K+ stars
* [HuggingFace PEFT Docs](https://huggingface.co/docs/peft)

***

## सारांश

| टूल               | इसके लिए सर्वश्रेष्ठ                | मुख्य लाभ                   |
| ----------------- | ----------------------------------- | --------------------------- |
| **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 की आवश्यकता हो।


---

# 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/comparisons/finetuning-comparison.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.