TRL (RLHF/DPO प्रशिक्षण)

TRL (Transformer Reinforcement Learning) HuggingFace की आधिकारिक लाइब्रेरी है जो रिइन्फोर्समेंट लर्निंग तकनीकों के साथ भाषा मॉडलों को प्रशिक्षण देने के लिए है। 10K+ GitHub स्टार्स के साथ, यह RLHF, DPO, PPO, GRPO और LLMs के लिए अन्य संरेखण एल्गोरिदम के अत्याधुनिक कार्यान्वयन प्रदान करती है।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है CLORE.AI मार्केटप्लेस.

---

TRL क्या है?

TRL आज के कई सर्वश्रेष्ठ-संरेखित भाषा मॉडलों के पीछे की लाइब्रेरी है। यह प्रदान करती है:

• SFT (Supervised Fine-Tuning) — ChatML फॉर्मेट के साथ मानक निर्देश ट्यूनिंग

• RLHF/PPO — रिवॉर्ड मॉडल के साथ क्लासिक Proximal Policy Optimization

• DPO — Direct Preference Optimization (किसी रिवॉर्ड मॉडल की आवश्यकता नहीं!)

• GRPO — Group Relative Policy Optimization (DeepSeek-R1 की विधि)

• KTO — Kahneman-Tversky Optimization (अनपेयर किए गए प्राथमिकताओं के साथ काम करता है)

• रिवॉर्ड मॉडलिंग — मानव प्राथमिकता डेटा से एक रिवॉर्ड मॉडल ट्रेन करें

• IterativeSFT — सरल सेटअप के साथ ऑनलाइन RL

• ORPO — Odds Ratio Preference Optimization

TRL मूल रूप से HuggingFace पारिस्थितिकी तंत्र के साथ एकीकृत है: transformers, peft, datasets, accelerateऔर bitsandbytes.

आपको कौन सा एल्गोरिथम उपयोग करना चाहिए?

• DPO — सबसे सरल, सबसे स्थिर। जब आपके पास पेयर्ड प्राथमिकता डेटा हो (चुना/खारिज) तो उपयोग करें।

• PPO — सबसे शक्तिशाली लेकिन जटिल। जब आपके पास रिवॉर्ड मॉडल या स्कोरिंग फ़ंक्शन हो तो उपयोग करें।

• GRPO — तर्क/गणित कार्यों के लिए शानदार। DeepSeek-R1 की प्रशिक्षण विधि।

• SFT — किसी भी RL विधि को लागू करने से पहले हमेशा यहीं से शुरू करें।

---

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

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

कार्य के अनुसार 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 एक प्रशिक्षण लाइब्रेरी है — यह CLI/Python स्क्रिप्ट के रूप में चलता है, किसी वेब सर्वर की आवश्यकता नहीं।

---

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

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

1. जाएँ Clore.ai मार्केटप्लेस

2. फिल्टर करें VRAM ≥ 24 GB (RTX 3090, A100, या H100)

3. एक चुनें PyTorch या CUDA 12.1 बेस इमेज

4. चुनें स्टोरेज ≥ 200 GB मॉडलों और डेटासेट्स के लिए

5. खुला पोर्ट 22 SSH एक्सेस के लिए

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

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

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

# Python वर्चुअल एन्वायरनमेंट बनाएं
python3 -m venv /opt/trl
source /opt/trl/bin/activate

# सभी निर्भरताओं के साथ TRL इंस्टॉल करें
pip install trl

# पूर्ण वर्कफ़्लो के लिए अतिरिक्त निर्भरताएँ इंस्टॉल करें
pip install \
    transformers \
    datasets \
    peft \
    accelerate \
    bitsandbytes \
    wandb \
    scipy \
    sentencepiece \
    protobuf

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

चरण 4 — HuggingFace प्रमाणीकरण

# गेटेड मॉडल्स (Llama, Gemma) तक पहुंच के लिए लॉगिन करें
huggingface-cli login
# https://huggingface.co/settings/tokens से अपना HF टोकन दर्ज करें

# या एन्वायरनमेंट वेरिएबल सेट करें
export HF_TOKEN=hf_your-token-here

चरण 5 — वैकल्पिक: Weights & Biases ट्रैकिंग

# प्रयोग ट्रैकिंग सेट अप करें (कठोर रूप से अनुशंसित)
pip install wandb
wandb login  # https://wandb.ai/settings से अपना W&B API की दर्ज करें

# या W&B को अक्षम करें
export WANDB_DISABLED=true

---

Supervised Fine-Tuning (SFT)

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

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

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

data = [
    {
        "messages": [
            {"role": "system", "content": "You are a helpful GPU cloud assistant."},
            {"role": "user", "content": "How do I rent a GPU on Clore.ai?"},
            {"role": "assistant", "content": "Visit clore.ai/marketplace, filter by GPU specs, select a server, and click Rent. SSH access is provided immediately after payment."}
        ]
    },
    # ... और उदाहरण
]

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

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

# 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 क्वांटाइजेशन कॉन्फ़िग
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 = 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 = 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 = SFTTrainer(
    model=model,
    args=training_config,
    train_dataset=dataset,
    peft_config=lora_config,
    tokenizer=tokenizer,
)

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

# प्रशिक्षण चलाएँ
python3 sft_train.py

---

DPO (Direct Preference Optimization)

DPO सबसे लोकप्रिय संरेखण विधि है — किसी रिवॉर्ड मॉडल की आवश्यकता नहीं, केवल प्राथमिकता जोड़े चाहिए।

DPO डेटासेट तैयार करें

# फॉर्मेट: प्रत्येक उदाहरण में 'prompt', 'chosen', 'rejected' हो
from datasets import Dataset

data = [
    {
        "prompt": "Explain how to optimize GPU utilization",
        "chosen": "To optimize GPU utilization: 1) Use larger batch sizes to maximize occupancy, 2) Enable mixed precision (bf16/fp16), 3) Profile with nvidia-smi to identify bottlenecks, 4) Use CUDA streams for parallel operations.",
        "rejected": "Just use more GPUs."
    },
    # ... और पसंद जोड़े
]

dataset = Dataset.from_list(data)

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

# 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 मॉडल से शुरू करें!

# SFT मॉडल लोड करें (पॉलिसी जिसे संरेखित करना है)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# संदर्भ मॉडल (SFT मॉडल की फ्रीज़ कॉपी)
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

# प्राथमिकता डेटासेट लोड करें
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 पेनल्टी गुणांक
    loss_type="sigmoid",          # मानक DPO लॉस
    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 क्लासिक RLHF दृष्टिकोण है — जब आपके पास रिवॉर्ड सिग्नल हो तब उपयोग करें:

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

# पॉलिसी मॉडल (PPO के लिए वैल्यू हेड के साथ)
model = AutoModelForCausalLMWithValueHead.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
)

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

# रिवॉर्ड मॉडल (कोई भी स्कोरिंग फ़ंक्शन हो सकता है)
sentiment_pipe = pipeline(
    "sentiment-analysis",
    model="distilbert/distilbert-base-uncased-finetuned-sst-2-english",
    device=0,
)

def reward_fn(texts):
    """प्रत्येक प्रतिक्रिया का स्कोर करें। रिवॉर्ड टेन्सर्स की सूची वापस करें।"""
    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,  # आरंभिक मॉडल की ऑटो-कॉपी संदर्भ के रूप में
    tokenizer=tokenizer,
)

# प्रशिक्षण लूप
dataset = load_dataset("imdb", split="train[:1000]")
for epoch in range(3):
    for batch in trainer.dataloader:
        queries = batch["input_ids"]
        
        # प्रतिक्रियाएँ जनरेट करें
        responses = trainer.generate(queries, max_new_tokens=100)
        
        # प्रतिक्रियाओं का स्कोर करें
        texts = tokenizer.batch_decode(responses, skip_special_tokens=True)
        rewards = reward_fn(texts)
        
        # PPO अपडेट
        stats = trainer.step(queries, responses, rewards)
        trainer.log_stats(stats, batch, rewards)

---

GRPO (Group Relative Policy Optimization)

GRPO को DeepSeek-R1 में तर्क प्रशिक्षण के लिए उपयोग किया जाता है:

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

# गणित डेटासेट
def make_math_dataset():
    examples = [
        {"prompt": "What is 2+2?", "answer": "4"},
        {"prompt": "What is 15 * 7?", "answer": "105"},
        # ... और गणित की समस्याएँ
    ]
    return Dataset.from_list(examples)

dataset = make_math_dataset()

def correctness_reward(completions, answer, **kwargs):
    """यदि उत्तर सही हो तो 1.0 रिवॉर्ड दें, अन्यथा 0.0।"""
    rewards = []
    for completion in completions:
        # पूर्णता से अंतिम संख्या निकालें
        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 प्रत्येक प्रॉम्प्ट के लिए G प्रतिक्रियाएँ उत्पन्न करता है
    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()

---

मल्टी-GPU प्रशिक्षण

उपयोग करें accelerate वितरित प्रशिक्षण के लिए:

# मल्टी-GPU के लिए accelerate कॉन्फ़िगर करें
accelerate config

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

# सभी GPUs पर प्रशिक्षण लॉन्च करें
accelerate launch sft_train.py
accelerate launch dpo_train.py

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

---

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

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

# 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

---

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

# 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 सिफारिशें

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

कार्य	GPU	नोट्स
SFT / DPO 7–8B पर (QLoRA)	RTX 3090 24 GB	~8 GB QLoRA 4-bit के लिए; आराम से फिट होता है; Clore.ai पर ~$0.12/hr
SFT / DPO 7–8B पर (LoRA bf16)	RTX 4090 24 GB	3090 के समान VRAM पर 30% तेज़ कंप्यूट; इटेरेशन स्पीड के लिए शानदार
पूर्ण SFT 7B पर या DPO 13B पर	A100 40 GB	40 GB 7B पूर्ण-प्रिसिजन प्रशिक्षण के लिए फिट बैठता है; ECC मेमोरी साइलेंट त्रुटियों से बचाती है
PPO / पूर्ण फाइनट्यून 7B, या कोई भी 70B QLoRA	A100 80 GB	PPO को VRAM में 2× पॉलिसी+रेफ मॉडल की आवश्यकता होती है; 80 GB दोनों को OOM के बिना चलाता है

व्यावहारिक सुझाव: परीक्षण के लिए QLoRA के साथ RTX 3090 पर शुरू करें — Llama 3 8B को ~10K उदाहरणों पर ~2 घंटे में ट्रेन करें। एक बार जब आपने पाइपलाइन को सत्यापित कर लिया, तो पूर्ण-प्रिसिजन रन या 70B मॉडलों के लिए A100 80GB पर जाएँ।

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

• RTX 3090: ~1,100 टोकन/सेकंड प्रशिक्षण थ्रूपुट

• RTX 4090: ~1,450 टोकन/सेकंड

• A100 80GB: ~2,800 टोकन/सेकंड (पूर्ण bf16, कोई क्वांटाइज़ेशन नहीं)

---

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

CUDA Out of Memory

# बैच साइज घटाएँ
per_device_train_batch_size=1
gradient_accumulation_steps=16  # प्रभावी बैच आकार समान रखें

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

# ग्रेडिएंट चेकपॉइंटिंग सक्षम करें
gradient_checkpointing=True

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

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

लॉस NaN है

# सामान्य कारण: लर्निंग रेट बहुत उच्च
learning_rate=1e-5  # कम करके देखें

# सामान्य कारण: खराब डेटा (खाली स्ट्रिंग्स, None मान)
# डेटासेट मान्य करें:
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 गलत है

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

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

# फ्लैश अटेन्शन 2 सक्षम करें
pip install flash-attn --no-build-isolation

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

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

# DataLoader वर्कर्स बढ़ाएँ
dataloader_num_workers=4

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

tokenizer.pad_token चेतावनी

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

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

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

# पर्यावरण में टोकन सेट करें
export HF_TOKEN=hf_your-token

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

---

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

# LoRA वज़न को बेस मॉडल में मर्ज करें
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 पर पुश करें
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