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 प्रदान करती है।

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

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.

आपको कौन-सा algorithm उपयोग करना चाहिए?

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

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

घटक

न्यूनतम

अनुशंसित

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+

कार्य के अनुसार 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

पोर्ट्स

पोर्ट

सेवा

नोट्स

SSH

टर्मिनल एक्सेस, फ़ाइल ट्रांसफ़र, मॉनिटरिंग

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

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

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

पर जाएँ Clore.ai मार्केटप्लेस
इसके लिए फ़िल्टर करें VRAM ≥ 24 GB (RTX 3090, A100, या H100)
चुनें PyTorch या CUDA 12.8 बेस इमेज
चुनें Storage ≥ 200 GB मॉडलों और डेटासेट्स के लिए
पोर्ट खोलें 22 SSH access के लिए

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

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

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

# 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

# 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

# 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 हमेशा पहला कदम है।

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

# प्रारूप: '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

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

# training चलाएँ
python3 sft_train.py

DPO (Direct Preference Optimization)

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

DPO Dataset तैयार करें

# प्रारूप: प्रत्येक 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

# 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 हो, तब इसका उपयोग करें:

# 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 के लिए किया जाता है:

# 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 के लिए:

# 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 कमांड प्रदान करता है:

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

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 के रूप में अनुरोध पर बेची जाती है। देखें GPU मूल्य और उपलब्धता किसी deployment का आकार तय करने से पहले।

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 मेमोरी समाप्त

# बैच आकार कम करें
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 है

# सामान्य कारण: 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 है

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

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

# 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` चेतावनी

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

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

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

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

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

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

# 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

पिछलाMergekit मॉडल मर्जिंग

अगलाअवलोकन

अंतिम अपडेट 23 दिन पहले

क्या यह उपयोगी था?

TRL क्या है?

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

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

पोर्ट्स

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

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

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

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

चरण 4 — HuggingFace Authentication

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

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

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

SFT Training Script

DPO (Direct Preference Optimization)

DPO Dataset तैयार करें

DPO Training Script

PPO (Proximal Policy Optimization)

GRPO (Group Relative Policy Optimization)

Multi-GPU Training

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

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

Clore.ai GPU अनुशंसाएँ

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

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

Loss NaN है

DPO: chosen_rewards > rejected_rewards False है

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

tokenizer.pad_token चेतावनी

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

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

उपयोगी लिंक

DPO: `chosen_rewards > rejected_rewards` False है

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