# Fine-tuning टूल्स तुलना

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