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

# Fine-tuning Tools की तुलना

Clore.ai GPU सर्वरों पर LLMs का प्रशिक्षण करने के लिए सही फाइन-ट्यूनिंग फ्रेमवर्क चुनें।

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

***

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

|                          | एक मॉडल को फाइन-ट्यून करें                | Axolotl                   | 🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ — | 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 एक चीज़ पर तीक्ष्ण रूप से केंद्रित है: फाइन-ट्यूनिंग को यथासंभव तेज़ और मेमोरी-कुशल बनाना। यह Triton में प्रमुख ऑपरेशनों को पुनर्लिखता है और CUDA कर्नेल को अनुकूलित करता है।

**दर्शन**: अधिकतम गति, न्यूनतम 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
```

### 🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —

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 और अन्य एलाइन्मेंट प्रशिक्षण विधियों के लिए मानक है।

**दर्शन**: अनुसंधान-प्रथम, एलाइन्मेंट प्रशिक्षण मूल रूप से मौजूद।

```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()
```

***

## स्पीड बेंचमार्क

### प्रशिक्षण गति तुलना (टोकन/सेकेंड)

परीक्षण सेटअप: 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× गति ध्यान, क्रॉस-एंट्रॉपी, RoPE, और LoRA के लिए कस्टम Triton कर्नेल से आती है। सिर्फ़ मार्केटिंग नहीं।
{% endhint %}

### VRAM उपयोग तुलना

LLaMA 3.1 8B का प्रशिक्षण, अनुक्रम लंबाई 2048:

| विधि                       | एक मॉडल को फाइन-ट्यून करें | Axolotl | 🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ — | TRL  |
| -------------------------- | -------------------------- | ------- | ------------------------------------------------------------------------------------- | ---- |
| पूर्ण फाइन-ट्यून (bf16)    | 60GB                       | 70GB    | 72GB                                                                                  | 74GB |
| LoRA (bf16)                | 18GB                       | 24GB    | 25GB                                                                                  | 26GB |
| QLoRA (4-बिट)              | **8GB**                    | 16GB    | 16GB                                                                                  | 18GB |
| QLoRA (4-बिट, लंबी संदर्भ) | 12GB                       | 24GB    | 24GB                                                                                  | 26GB |

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

* Unsloth: RTX 3080 (10GB) ✅
* अन्य: RTX 3090 (24GB) आवश्यक

***

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

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

| मॉडल परिवार  | एक मॉडल को फाइन-ट्यून करें | Axolotl | 🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ — | 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   | आंशिक                      | आंशिक   | ✅                                                                                     | ✅   |

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

| विधि                       | एक मॉडल को फाइन-ट्यून करें | Axolotl | 🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ — | TRL     |
| -------------------------- | -------------------------- | ------- | ------------------------------------------------------------------------------------- | ------- |
| पूर्ण फाइन-ट्यून           | ✅                          | ✅       | ✅                                                                                     | ✅       |
| LoRA                       | ✅                          | ✅       | ✅                                                                                     | ✅       |
| QLoRA                      | ✅                          | ✅       | ✅                                                                                     | ✅       |
| DoRA                       | ✅                          | ✅       | ✅                                                                                     | ❌       |
| PEFT                       | ✅                          | ✅       | ✅                                                                                     | ✅       |
| SFT                        | ✅                          | ✅       | ✅                                                                                     | ✅ (मूल) |
| DPO                        | ✅                          | ✅       | ✅                                                                                     | ✅ (मूल) |
| PPO                        | ❌                          | ✅       | ✅                                                                                     | ✅ (मूल) |
| ORPO                       | ✅                          | ✅       | ✅                                                                                     | ✅       |
| KTO                        | ❌                          | ✅       | ✅                                                                                     | ✅ (मूल) |
| GRPO                       | ✅                          | ❌       | ✅                                                                                     | ✅       |
| CPT (जारी पूर्व-प्रशिक्षण) | ✅                          | ✅       | ✅                                                                                     | ✅       |

***

## Unsloth: गहन परिचय

### क्यों यह तेज़ है

1. **Triton कर्नेल**: Flash Attention, क्रॉस-एंट्रॉपी लॉस, और LoRA को Triton में पुनर्लिखता है
2. **फ्यूज़्ड ऑपरेशन्स**: कई CUDA ऑप्स को एक कर्नेल में संयोजित करता है
3. **स्मार्ट ग्रेडिएंट चेकपॉइंटिंग**: "unsloth" मोड \~30% अधिक मेमोरी बचाता है
4. **कुशल बैकप्रोप**: बड़े मध्यवर्ती टेन्सरों को मटेरियलाइज़ करने से बचता है

### Clore.ai पर इंस्टॉलेशन

```bash
# CUDA 12.1
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  # छोटे अनुक्रमों को दक्षता के लिए पैक करता है
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
```

**उत्तम हेतु**: टीमों के लिए जो पुनरुत्पादनशील, कॉन्फ़िग-संस्करणीकृत प्रशिक्षण रन चाहती हैं

***

## LLaMA-Factory: गहन परिचय

### WebUI वॉकथ्रू

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

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

WebUI टैब:

1. **Train** — बेस मॉडल, डेटासेट, विधि कॉन्फ़िगर करें
2. **मूल्यांकन** — MMLU, CMMLU बेंचमार्क चलाएँ
3. **चैट** — इंटरैक्टिव इनफ़रेंस
4. **निर्यात** — LoRA मर्ज करें, GGUF में क्वांटाइज़ करें

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

```bash
# सुपरवाइज्ड फाइन-ट्यूनिंग
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 एलाइन्मेंट प्रशिक्षण के लिए जाने-माने विकल्प है:

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

# DPO (डायरेक्ट प्रेफरेंस ऑप्टिमाइज़ेशन) — सबसे सामान्य एलाइन्मेंट विधि
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 दंड गुणांक
    loss_type="sigmoid",  # या "hinge", "ipo", "kto_pair"
    learning_rate=5e-7,
)

# प्रेफरेंस डेटासेट लोड करें (प्रॉम्प्ट + चयनित + अस्वीकृत)
dataset = load_dataset("Anthropic/hh-rlhf", split="train")

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

**उत्तम हेतु**: एलाइन्मेंट अनुसंधान, RLHF, DPO, PPO, ORPO कार्यान्वयन

***

## सही टूल चुनना

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

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

क्या आपको एलाइन्मेंट प्रशिक्षण (DPO/PPO/RLHF) की आवश्यकता है?
  → हाँ → TRL या LLaMA-Factory
  → अनुसंधान/कस्टम → TRL
  → उत्पादन/आसान → LLaMA-Factory

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

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

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

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

| टीम                | सिफारिश                                                                               | कारण                            |
| ------------------ | ------------------------------------------------------------------------------------- | ------------------------------- |
| व्यक्तिगत शोधकर्ता | एक मॉडल को फाइन-ट्यून करें                                                            | गति + Jupyter नोटबुक            |
| ML इंजीनियर        | Axolotl                                                                               | कॉन्फ़िग-आधारित, पुनरुत्पादनशील |
| प्रोडक्ट टीम       | 🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ — | WebUI, विस्तृत मॉडल समर्थन      |
| एलाइन्मेंट टीम     | TRL                                                                                   | मूल RLHF प्रिमिटिव्स            |
| स्टार्टअप          | Unsloth + TRL                                                                         | जरूरत पड़ने पर गति + एलाइन्मेंट |

***

## Clore.ai GPU सिफारिशें

| कार्य             | न्यूनतम GPU     | अनुशंसित     | टूल                        |
| ----------------- | --------------- | ------------ | -------------------------- |
| 7-8B LoRA (QLoRA) | RTX 3080 (10GB) | RTX 3090     | एक मॉडल को फाइन-ट्यून करें |
| 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+ सितारे
* [Axolotl GitHub](https://github.com/axolotl-ai-cloud/axolotl) — 9K+ सितारे
* [LLaMA-Factory GitHub](https://github.com/hiyouga/LLaMA-Factory) — 37K+ सितारे
* [TRL GitHub](https://github.com/huggingface/trl) — 10K+ सितारे
* [HuggingFace PEFT दस्तावेज़](https://huggingface.co/docs/peft)

***

## सारांश

| टूल                                                                                       | उत्तम हेतु                         | मुख्य लाभ                      |
| ----------------------------------------------------------------------------------------- | ---------------------------------- | ------------------------------ |
| **एक मॉडल को फाइन-ट्यून करें**                                                            | गति-क्रिटिकल प्रशिक्षण, छोटे GPUs  | 2-5× तेज़, 70% कम VRAM         |
| **Axolotl**                                                                               | कॉन्फ़िग-आधारित, पुनरुत्पादनशील रन | YAML-प्रथम, कई डेटा फ़ॉर्मेट्स |
| **🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —** | 100+ मॉडल, WebUI, शुरुआती          | अधिकतर मॉडल समर्थन, GUI        |
| **TRL**                                                                                   | RLHF, DPO, एलाइन्मेंट अनुसंधान     | मूल एलाइन्मेंट प्रशिक्षण       |

अधिकांश Clore.ai उपयोग मामलों के लिए: शुरुआत करें **एक मॉडल को फाइन-ट्यून करें** (गति + मेमोरी दक्षता), जोड़ें **TRL** यदि आपको DPO या PPO एलाइन्मेंट प्रशिक्षण की आवश्यकता है।


---

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