> 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/training/trl.md).

# TRL (RLHF/DPO ट्रेनिंग)

**TRL** (Transformer Reinforcement Learning) HuggingFace की आधिकारिक लाइब्रेरी है, जिसका उपयोग reinforcement learning तकनीकों के साथ language models को प्रशिक्षित करने के लिए किया जाता है। GitHub पर 10K+ stars के साथ, यह RLHF, DPO, PPO, GRPO, और LLMs के लिए अन्य alignment algorithms के state-of-the-art implementations प्रदान करती है।

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

***

## TRL क्या है?

TRL आज के कई सबसे अच्छी तरह aligned language models के पीछे की लाइब्रेरी है। यह प्रदान करती है:

* **SFT (Supervised Fine-Tuning)** — ChatML format के साथ standard instruction tuning
* **RLHF/PPO** — reward model के साथ classic Proximal Policy Optimization
* **DPO** — Direct Preference Optimization (reward model की जरूरत नहीं!)
* **GRPO** — Group Relative Policy Optimization (DeepSeek-R1 की विधि)
* **KTO** — Kahneman-Tversky Optimization (unpaired preferences के साथ काम करता है)
* **Reward Modeling** — मानवीय preference data से reward model को प्रशिक्षित करें
* **IterativeSFT** — सरल सेटअप के साथ online RL
* **ORPO** — Odds Ratio Preference Optimization

TRL HuggingFace ecosystem के साथ स्वाभाविक रूप से integrate होता है: `transformers`, `peft`, `datasets`, `accelerate`, और `bitsandbytes`.

{% hint style="info" %}
**आपको कौन-सा algorithm उपयोग करना चाहिए?**

* **DPO** — सबसे सरल, सबसे स्थिर। जब आपके पास paired preference data (chosen/rejected) हो, तब इसका उपयोग करें।
* **PPO** — सबसे शक्तिशाली लेकिन जटिल। जब आपके पास reward model या scoring function हो, तब इसका उपयोग करें।
* **GRPO** — reasoning/math tasks के लिए बेहतरीन। DeepSeek-R1 की training method.
* **SFT** — किसी भी RL method को लागू करने से पहले हमेशा यहीं से शुरू करें।
  {% endhint %}

***

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

| घटक     | न्यूनतम                   | अनुशंसित                  |
| ------- | ------------------------- | ------------------------- |
| GPU     | RTX 3090 (24 GB)          | A100 80 GB / H100         |
| VRAM    | 16 GB (SFT/DPO 7B + LoRA) | 80 GB (पूर्ण finetune 7B) |
| RAM     | 32 GB                     | 64 GB+                    |
| CPU     | 8 कोर                     | 16+ cores                 |
| स्टोरेज | 100 GB                    | 300 GB+                   |
| ओएस     | Ubuntu 20.04+             | Ubuntu 22.04              |
| Python  | 3.9+                      | 3.11                      |
| CUDA    | 12.8+                     | 12.8+                     |

### कार्य के अनुसार VRAM

| कार्य | मॉडल        | विधि        | VRAM             |
| ----- | ----------- | ----------- | ---------------- |
| SFT   | Llama 3 8B  | QLoRA 4-bit | \~8 GB           |
| DPO   | Llama 3 8B  | LoRA        | \~20 GB          |
| PPO   | Llama 3 8B  | पूर्ण       | \~80 GB (2×A100) |
| GRPO  | Qwen 7B     | LoRA        | \~24 GB          |
| SFT   | Llama 3 70B | QLoRA 4-bit | \~48 GB          |
| DPO   | Llama 3 70B | LoRA        | \~80 GB          |

***

## पोर्ट्स

| पोर्ट | सेवा | नोट्स                                      |
| ----- | ---- | ------------------------------------------ |
| 22    | SSH  | टर्मिनल एक्सेस, फ़ाइल ट्रांसफ़र, मॉनिटरिंग |

TRL एक training library है — यह CLI/Python script के रूप में चलता है, web server की आवश्यकता नहीं होती।

***

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

### चरण 1 — सर्वर किराए पर लें

1. पर जाएँ [Clore.ai मार्केटप्लेस](https://clore.ai/marketplace)
2. इसके लिए फ़िल्टर करें **VRAM ≥ 24 GB** (RTX 3090, A100, या H100)
3. चुनें **PyTorch** या **CUDA 12.8** बेस इमेज
4. चुनें **Storage ≥ 200 GB** मॉडलों और डेटासेट्स के लिए
5. पोर्ट खोलें **22** SSH access के लिए

### चरण 2 — SSH के माध्यम से कनेक्ट करें

```bash
ssh root@<server-ip> -p <ssh-port>
```

### चरण 3 — TRL इंस्टॉल करें

```bash
# Python virtual environment बनाएं
python3 -m venv /opt/trl
source /opt/trl/bin/activate

# सभी dependencies के साथ TRL इंस्टॉल करें
pip install trl

# पूर्ण workflows के लिए अतिरिक्त dependencies इंस्टॉल करें
pip install \\
    transformers \\
    datasets \\
    peft \\
    accelerate \\
    bitsandbytes \\
    wandb \\
    scipy \\
    sentencepiece \\
    protobuf

# GPU support सत्यापित करें
python3 -c "import torch; print(f'CUDA: {torch.cuda.is_available()}, GPU: {torch.cuda.get_device_name(0)}')"
```

### चरण 4 — HuggingFace Authentication

```bash
# gated models (Llama, Gemma) तक पहुँचने के लिए लॉगिन करें
huggingface-cli login
# अपना HF token यहाँ दर्ज करें: https://huggingface.co/settings/tokens

# या environment variable सेट करें
export HF_TOKEN=hf_your-token-here
```

### चरण 5 — वैकल्पिक: Weights & Biases Tracking

```bash
# experiment tracking सेट करें (बहुत अनुशंसित)
pip install wandb
wandb login  # अपना W&B API key यहाँ दर्ज करें: https://wandb.ai/settings

# या W&B को disable करें
export WANDB_DISABLED=true
```

***

## पर्यवेक्षित Fine-Tuning (SFT)

किसी भी RL तकनीक से पहले SFT हमेशा पहला कदम है।

### अपना डेटासेट तैयार करें

```python
# प्रारूप: 'messages' या 'text' कॉलम वाली datasets लाइब्रेरी
# ChatML प्रारूप (अनुशंसित)
from datasets import Dataset

data = [
    {
        "messages": [
            {"role": "system", "content": "आप एक सहायक GPU क्लाउड सहायक हैं."},
            {"role": "user", "content": "मैं Clore.ai पर GPU कैसे किराए पर लूँ?"},
            {"role": "assistant", "content": "clore.ai/marketplace पर जाएँ, GPU specs के अनुसार फ़िल्टर करें, एक server चुनें, और Rent पर क्लिक करें। भुगतान के तुरंत बाद SSH access प्रदान किया जाता है."}
        ]
    },
    # ... और उदाहरण
]

dataset = Dataset.from_list(data)
dataset.save_to_disk("data/sft_dataset")
dataset.push_to_hub("your-username/my-sft-dataset")  # वैकल्पिक
```

### SFT Training Script

```python
# sft_train.py
from trl import SFTTrainer, SFTConfig
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model
from datasets import load_dataset
import torch

# मॉडल कॉन्फ़िगरेशन
model_name = "meta-llama/Llama-3.2-8B-Instruct"

# QLoRA: 4-bit quantization config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

# मॉडल लोड करें
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)

# tokenizer लोड करें
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

# LoRA कॉन्फ़िगरेशन
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

# dataset लोड करें
dataset = load_dataset("trl-lib/ultrachat_200k", split="train_sft[:10%]")

# प्रशिक्षण कॉन्फ़िगरेशन
training_config = SFTConfig(
    output_dir="./sft_output",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    warmup_ratio=0.05,
    lr_scheduler_type="cosine",
    fp16=False,
    bf16=True,
    max_seq_length=2048,
    dataset_text_field="messages",
    logging_steps=10,
    save_steps=100,
    save_total_limit=3,
    push_to_hub=False,
    report_to="wandb",  # या "none"
)

# trainer प्रारंभ करें
trainer = SFTTrainer(
    model=model,
    args=training_config,
    train_dataset=dataset,
    peft_config=lora_config,
    tokenizer=tokenizer,
)

# प्रशिक्षण करें
trainer.train()
trainer.save_model("./sft_final")
```

```bash
# training चलाएँ
python3 sft_train.py
```

***

## DPO (Direct Preference Optimization)

DPO सबसे लोकप्रिय alignment method है — reward model की आवश्यकता नहीं, केवल preference pairs चाहिए।

### DPO Dataset तैयार करें

```python
# प्रारूप: प्रत्येक example में 'prompt', 'chosen', 'rejected' होते हैं
from datasets import Dataset

data = [
    {
        "prompt": "GPU utilization को optimize कैसे करें, समझाइए",
        "chosen": "GPU utilization को optimize करने के लिए: 1) occupancy अधिकतम करने हेतु बड़े batch sizes का उपयोग करें, 2) mixed precision (bf16/fp16) सक्षम करें, 3) bottlenecks पहचानने के लिए nvidia-smi के साथ profile करें, 4) parallel operations के लिए CUDA streams का उपयोग करें.",
        "rejected": "बस और GPUs का उपयोग करें."
    },
    # ... और preference pairs
]

dataset = Dataset.from_list(data)
```

### DPO Training Script

```python
# dpo_train.py
from trl import DPOTrainer, DPOConfig
from transformers import AutoTokenizer, AutoModelForCausalLM
from datasets import load_dataset
import torch

model_name = "./sft_final"  # अपने SFT model से शुरू करें!

# SFT model लोड करें (align करने वाली policy)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# Reference model (SFT model की frozen copy)
ref_model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# preference dataset लोड करें
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train[:5%]")

# DPO कॉन्फ़िगरेशन
dpo_config = DPOConfig(
    output_dir="./dpo_output",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=5e-7,           # SFT से कहीं कम
    beta=0.1,                     # KL penalty coefficient
    loss_type="sigmoid",          # Standard DPO loss
    max_length=2048,
    max_prompt_length=512,
    bf16=True,
    logging_steps=10,
    save_steps=50,
    report_to="wandb",
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=dpo_config,
    train_dataset=dataset,
    tokenizer=tokenizer,
)

trainer.train()
trainer.save_model("./dpo_final")
```

***

## PPO (Proximal Policy Optimization)

PPO classic RLHF approach है — जब आपके पास reward signal हो, तब इसका उपयोग करें:

```python
# ppo_train.py
from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from transformers import AutoTokenizer, pipeline
from datasets import load_dataset
import torch

model_name = "./sft_final"

# Policy model (PPO के लिए value head के साथ)
model = AutoModelForCausalLMWithValueHead.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
)

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# Reward model (कोई भी scoring function हो सकती है)
sentiment_pipe = pipeline(
    "sentiment-analysis",
    model="distilbert/distilbert-base-uncased-finetuned-sst-2-english",
    device=0,
)

def reward_fn(texts):
    """हर response को score करें। reward tensors की सूची लौटाएँ."""
    results = sentiment_pipe(texts)
    rewards = []
    for result in results:
        score = result["score"] if result["label"] == "POSITIVE" else -result["score"]
        rewards.append(torch.tensor(score))
    return rewards

ppo_config = PPOConfig(
    output_dir="./ppo_output",
    learning_rate=1.41e-5,
    mini_batch_size=1,
    batch_size=4,
    gradient_accumulation_steps=4,
    kl_penalty="kl",
    target_kl=6.0,
    cliprange=0.2,
    vf_coef=0.1,
)

trainer = PPOTrainer(
    config=ppo_config,
    model=model,
    ref_model=None,  # प्रारंभिक model की स्वचालित reference copy बनाता है
    tokenizer=tokenizer,
)

# प्रशिक्षण लूप
dataset = load_dataset("imdb", split="train[:1000]")
for epoch in range(3):
    for batch in trainer.dataloader:
        queries = batch["input_ids"]
        
        # responses generate करें
        responses = trainer.generate(queries, max_new_tokens=100)
        
        # responses को score करें
        texts = tokenizer.batch_decode(responses, skip_special_tokens=True)
        rewards = reward_fn(texts)
        
        # PPO update
        stats = trainer.step(queries, responses, rewards)
        trainer.log_stats(stats, batch, rewards)
```

***

## GRPO (Group Relative Policy Optimization)

GRPO का उपयोग DeepSeek-R1 में reasoning training के लिए किया जाता है:

```python
# grpo_train.py
from trl import GRPOTrainer, GRPOConfig
from transformers import AutoTokenizer, AutoModelForCausalLM
from datasets import Dataset
import re, torch

model_name = "Qwen/Qwen2.5-7B-Instruct"

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Math dataset
def make_math_dataset():
    examples = [
        {"prompt": "2+2 कितना है?", "answer": "4"},
        {"prompt": "15 * 7 कितना है?", "answer": "105"},
        # ... और math problems
    ]
    return Dataset.from_list(examples)

dataset = make_math_dataset()

def correctness_reward(completions, answer, **kwargs):
    """यदि उत्तर सही हो तो 1.0 reward दें, अन्यथा 0.0."""
    rewards = []
    for completion in completions:
        # completion से अंतिम number निकालें
        numbers = re.findall(r'\d+', completion[-1]["content"])
        if numbers and numbers[-1] == answer:
            rewards.append(1.0)
        else:
            rewards.append(0.0)
    return rewards

grpo_config = GRPOConfig(
    output_dir="./grpo_output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    num_generations=8,       # GRPO प्रत्येक prompt के लिए G responses generate करता है
    learning_rate=5e-7,
    bf16=True,
    logging_steps=10,
)

trainer = GRPOTrainer(
    model=model,
    args=grpo_config,
    train_dataset=dataset,
    reward_funcs=correctness_reward,
    tokenizer=tokenizer,
)

trainer.train()
```

***

## Multi-GPU Training

उपयोग करें `accelerate` distributed training के लिए:

```bash
# multi-GPU के लिए accelerate कॉन्फ़िगर करें
accelerate config

# 4 GPUs के लिए उदाहरण कॉन्फ़िगरेशन:
# - compute_environment: LOCAL_MACHINE
# - distributed_type: MULTI_GPU
# - num_processes: 4
# - mixed_precision: bf16

# सभी GPUs पर training शुरू करें
accelerate launch sft_train.py
accelerate launch dpo_train.py

# या GPU को स्पष्ट रूप से निर्दिष्ट करें
CUDA_VISIBLE_DEVICES=0,1,2,3 accelerate launch \
  --num_processes 4 \
  --mixed_precision bf16 \
  sft_train.py
```

***

## TRL CLI का उपयोग करना

TRL सुविधाजनक CLI कमांड प्रदान करता है:

```bash
# CLI के माध्यम से SFT
trl sft \
  --model_name_or_path meta-llama/Llama-3.2-8B-Instruct \
  --dataset_name trl-lib/ultrachat_200k \
  --dataset_text_field messages \
  --output_dir ./cli_sft_output \
  --num_train_epochs 3 \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 4 \
  --learning_rate 2e-4 \
  --bf16 \
  --use_peft \
  --lora_r 16 \
  --lora_alpha 32

# CLI के माध्यम से DPO
trl dpo \
  --model_name_or_path ./cli_sft_output \
  --dataset_name trl-lib/ultrafeedback_binarized \
  --output_dir ./cli_dpo_output \
  --num_train_epochs 1 \
  --beta 0.1 \
  --bf16
```

***

## प्रशिक्षण की निगरानी

```bash
# GPU उपयोगिता देखें
watch -n 1 nvidia-smi

# प्रशिक्षण हानि की निगरानी करें (यदि W&B का उपयोग कर रहे हों)
# ब्राउज़र में https://wandb.ai/your-username खोलें

# चेकपॉइंट्स के लिए आउटपुट डायरेक्टरी जांचें
ls -lh sft_output/checkpoint-*/

# चेकपॉइंट से पुनः शुरू करें
python3 sft_train.py --resume_from_checkpoint sft_output/checkpoint-500/
```

***

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

TRL प्रशिक्षण सबसे अधिक VRAM-गहन कार्यभारों में से एक है। मॉडल आकार और विधि के आधार पर अपना GPU चुनें:

| कार्य                                          | GPU                | नोट्स                                                                                     |
| ---------------------------------------------- | ------------------ | ----------------------------------------------------------------------------------------- |
| 7–8B पर SFT / DPO (QLoRA)                      | **RTX 3090** 24 GB | \~8 GB QLoRA 4-बिट के लिए; आराम से फिट होता है; Clore.ai पर $0.07–0.21/घंटा               |
| 7–8B पर SFT / DPO (LoRA bf16)                  | **RTX 4090** 24 GB | 3090 जितनी ही VRAM, लेकिन 30% तेज़ compute; iteration speed के लिए बहुत अच्छा             |
| 7B पर पूर्ण SFT या 13B पर DPO                  | **A100 40 GB**     | 40 GB 7B full-precision training के लिए पर्याप्त है; ECC memory silent errors से बचाती है |
| PPO / 7B का full finetune, या कोई भी 70B QLoRA | **A100 80 GB**     | PPO को VRAM में policy+ref model का 2× चाहिए; 80 GB दोनों को OOM के बिना चलाता है         |

**व्यावहारिक सुझाव:** प्रयोग के लिए RTX 3090 पर QLoRA से शुरू करें — 10K उदाहरणों पर लगभग 2 घंटे में Llama 3 8B प्रशिक्षित करें। जब आप pipeline की पुष्टि कर लें, तो full-precision runs या 70B models के लिए A100 80GB पर जाएँ।

**गति संख्याएँ (Llama 3 8B SFT, QLoRA, batch=4, seq=2048):**

* RTX 3090: \~1,100 tokens/sec training throughput
* RTX 4090: \~1,450 tokens/sec
* A100 80GB: \~2,800 tokens/sec (पूर्ण bf16, बिना quantization)

***

## समस्या निवारण

### CUDA मेमोरी समाप्त

```bash
# बैच आकार कम करें
per_device_train_batch_size=1
gradient_accumulation_steps=16  # प्रभावी बैच आकार को समान रखें

# 4-बिट quantization (QLoRA) का उपयोग करें
# load_in_4bit=True के साथ BitsAndBytesConfig जोड़ें

# gradient checkpointing सक्षम करें
gradient_checkpointing=True

# अनुक्रम लंबाई कम करें
max_seq_length=1024  # 2048+ के बजाय

# GPU memory जांचें
nvidia-smi --query-gpu=memory.used,memory.total --format=csv
```

### Loss NaN है

```bash
# सामान्य कारण: learning rate बहुत अधिक होना
learning_rate=1e-5  # कम मान आज़माएँ

# सामान्य कारण: खराब डेटा (empty strings, None values)
# डेटासेट सत्यापित करें:
python3 -c \"
from datasets import load_from_disk
ds = load_from_disk('data/sft_dataset')
print(ds[0])
print(f'Length: {len(ds)}')
# None की जांच करें
none_count = sum(1 for x in ds if x.get('messages') is None)
print(f'None count: {none_count}')
"

# fp16 के बजाय bf16 सक्षम करें (अधिक स्थिर)
bf16=True
fp16=False
```

### DPO: `chosen_rewards > rejected_rewards` False है

```bash
# इसका मतलब है कि मॉडल अस्वीकृत उत्तरों को प्राथमिकता देता है — ओवरफिटिंग या खराब डेटा
# समाधान:
# 1. अपने डेटासेट की गुणवत्ता जांचें
# 2. beta कम करें (कम KL दंड)
# 3. learning rate कम करें
# 4. DPO से पहले और अधिक SFT प्रशिक्षण जोड़ें
beta=0.05  # छोटे मान आज़माएँ
```

### प्रशिक्षण बहुत धीमा है

```bash
# Flash Attention 2 सक्षम करें
pip install flash-attn --no-build-isolation

# अपने कोड में:
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    attn_implementation="flash_attention_2",
    torch_dtype=torch.bfloat16,
)

# Ampere+ GPU (A100, RTX 3000+) पर fp16 के बजाय bf16 का उपयोग करें
bf16=True

# DataLoader workers बढ़ाएँ
dataloader_num_workers=4

# जांचें कि क्या वास्तव में GPU का उपयोग हो रहा है
nvidia-smi  # उच्च GPU उपयोगिता दिखनी चाहिए
```

### `tokenizer.pad_token` चेतावनी

```bash
# Llama/Mistral tokenizers के लिए मानक समाधान
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"  # प्रशिक्षण स्थिरता के लिए महत्वपूर्ण
```

### अनुमति अस्वीकृत / HuggingFace 401

```bash
# पुनः लॉगिन करें
huggingface-cli login

# टोकन को environment में सेट करें
export HF_TOKEN=hf_your-token

# निजी models/datasets के लिए, सुनिश्चित करें कि आपके पास पहुंच है:
# https://huggingface.co/meta-llama/Llama-3.2-8B-Instruct पर जाएँ
# "Request access" पर क्लिक करें और लाइसेंस स्वीकार करें
```

***

## अपने मॉडल को सहेजना और साझा करना

```bash
# LoRA weights को base model में merge करें
python3 << 'EOF'
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.2-8B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
model = PeftModel.from_pretrained(base_model, "./sft_final")
merged = model.merge_and_unload()
merged.save_pretrained("./merged_model")

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-8B-Instruct")
tokenizer.save_pretrained("./merged_model")
print("Merged model saved!")
EOF

# HuggingFace पर push करें
huggingface-cli upload your-username/my-trl-model ./merged_model
```

***

## उपयोगी लिंक

* **GitHub**: <https://github.com/huggingface/trl> ⭐ 10K+
* **दस्तावेज़ीकरण**: <https://huggingface.co/docs/trl>
* **DPO पेपर**: <https://arxiv.org/abs/2305.18290>
* **GRPO / DeepSeek-R1**: <https://arxiv.org/abs/2501.12599>
* **PPO पेपर (RLHF)**: <https://arxiv.org/abs/2203.02155>
* **HuggingFace PEFT**: <https://github.com/huggingface/peft>
* **Weights & Biases**: <https://wandb.ai>
* **Flash Attention**: <https://github.com/Dao-AILab/flash-attention>
* **Clore.ai मार्केटप्लेस**: <https://clore.ai/marketplace>


---

# 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/training/trl.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.