# TRL (RLHF/DPO प्रशिक्षण) **TRL** (Transformer Reinforcement Learning) HuggingFace की आधिकारिक लाइब्रेरी है जो रिइन्फोर्समेंट लर्निंग तकनीकों के साथ भाषा मॉडलों को प्रशिक्षण देने के लिए है। 10K+ GitHub स्टार्स के साथ, यह RLHF, DPO, PPO, GRPO और LLMs के लिए अन्य संरेखण एल्गोरिदम के अत्याधुनिक कार्यान्वयन प्रदान करती है। {% hint style="success" %} सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} *** ## 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`. {% hint style="info" %} **आपको कौन सा एल्गोरिथम उपयोग करना चाहिए?** * **DPO** — सबसे सरल, सबसे स्थिर। जब आपके पास पेयर्ड प्राथमिकता डेटा हो (चुना/खारिज) तो उपयोग करें। * **PPO** — सबसे शक्तिशाली लेकिन जटिल। जब आपके पास रिवॉर्ड मॉडल या स्कोरिंग फ़ंक्शन हो तो उपयोग करें। * **GRPO** — तर्क/गणित कार्यों के लिए शानदार। DeepSeek-R1 की प्रशिक्षण विधि। * **SFT** — किसी भी RL विधि को लागू करने से पहले हमेशा यहीं से शुरू करें। {% endhint %} *** ## सर्वर आवश्यकताएँ | घटक | न्यूनतम | अनुशंसित | | ------- | ------------------------- | -------------------------- | | 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 मार्केटप्लेस](https://clore.ai/marketplace) 2. फिल्टर करें **VRAM ≥ 24 GB** (RTX 3090, A100, या H100) 3. एक चुनें **PyTorch** या **CUDA 12.1** बेस इमेज 4. चुनें **स्टोरेज ≥ 200 GB** मॉडलों और डेटासेट्स के लिए 5. खुला पोर्ट **22** SSH एक्सेस के लिए ### चरण 2 — SSH के माध्यम से कनेक्ट करें ```bash ssh root@ -p ``` ### चरण 3 — TRL इंस्टॉल करें ```bash # 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 प्रमाणीकरण ```bash # गेटेड मॉडल्स (Llama, Gemma) तक पहुंच के लिए लॉगिन करें huggingface-cli login # https://huggingface.co/settings/tokens से अपना HF टोकन दर्ज करें # या एन्वायरनमेंट वेरिएबल सेट करें export HF_TOKEN=hf_your-token-here ``` ### चरण 5 — वैकल्पिक: Weights & Biases ट्रैकिंग ```bash # प्रयोग ट्रैकिंग सेट अप करें (कठोर रूप से अनुशंसित) pip install wandb wandb login # https://wandb.ai/settings से अपना W&B API की दर्ज करें # या W&B को अक्षम करें export WANDB_DISABLED=true ``` *** ## Supervised Fine-Tuning (SFT) SFT किसी भी RL तकनीक से पहले हमेशा पहला कदम होता है। ### अपना डेटासेट तैयार करें ```python # फॉर्मेट: '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 प्रशिक्षण स्क्रिप्ट ```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 क्वांटाइजेशन कॉन्फ़िग 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") ``` ```bash # प्रशिक्षण चलाएँ python3 sft_train.py ``` *** ## DPO (Direct Preference Optimization) DPO सबसे लोकप्रिय संरेखण विधि है — किसी रिवॉर्ड मॉडल की आवश्यकता नहीं, केवल प्राथमिकता जोड़े चाहिए। ### DPO डेटासेट तैयार करें ```python # फॉर्मेट: प्रत्येक उदाहरण में '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 प्रशिक्षण स्क्रिप्ट ```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 मॉडल से शुरू करें! # 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 दृष्टिकोण है — जब आपके पास रिवॉर्ड सिग्नल हो तब उपयोग करें: ```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" # पॉलिसी मॉडल (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 में तर्क प्रशिक्षण के लिए उपयोग किया जाता है: ```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) # गणित डेटासेट 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` वितरित प्रशिक्षण के लिए: ```bash # मल्टी-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 कमांड प्रदान करता है: ```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 सिफारिशें 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 ```bash # बैच साइज घटाएँ 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 है ```bash # सामान्य कारण: लर्निंग रेट बहुत उच्च 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` गलत है ```bash # इसका मतलब मॉडल अस्वीकार किए गए उत्तरों को प्राथमिकता देता है — ओवरफिटिंग या खराब डेटा # समाधान: # 1. अपने डेटासेट की गुणवत्ता जांचें # 2. बीटा घटाएँ (कम KL पेनल्टी) # 3. लर्निंग रेट घटाएँ # 4. DPO से पहले अधिक SFT प्रशिक्षण जोड़ें beta=0.05 # छोटे मान आज़माएँ ``` ### प्रशिक्षण बहुत धीमा है ```bash # फ्लैश अटेन्शन 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` चेतावनी ```bash # Llama/Mistral टोकनाइज़र के लिए मानक समाधान tokenizer.pad_token = tokenizer.eos_token tokenizer.padding_side = "right" # प्रशिक्षण स्थिरता के लिए महत्वपूर्ण ``` ### अनुमति अस्वीकृत / HuggingFace 401 ```bash # पुनः लॉगिन करें huggingface-cli login # पर्यावरण में टोकन सेट करें export HF_TOKEN=hf_your-token # प्राइवेट मॉडल/डेटासेट के लिए, सुनिश्चित करें कि आपकी पहुँच है: # जाएँ https://huggingface.co/meta-llama/Llama-3.2-8B-Instruct # "Request access" पर क्लिक करें और लाइसेंस स्वीकार करें ``` *** ## अपने मॉडल को सहेजना और साझा करना ```bash # 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**: ⭐ 10K+ * **दस्तावेज़ीकरण**: * **DPO पेपर**: * **GRPO / DeepSeek-R1**: * **PPO पेपर (RLHF)**: * **HuggingFace PEFT**: * **Weights & Biases**: * **Flash Attention**: * **Clore.ai मार्केटप्लेस**: