> 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 Training) **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 मार्केटप्लेस**: --- # 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=&goal= ``` `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.