Buckets:
| # تمرین عملی: GRPO با Unsloth | |
| در این تمرین، با استفاده از Unsloth یک مدل را با GRPO (بهینهسازی خطمشی نسبی گروهی) ریزتنظیم میکنید تا تواناییهای استدلالی آن بهبود یابد. GRPO را در [فصل ۳](/course/chapter3/3) بررسی کردیم. | |
| Unsloth کتابخانهای است که ریزتنظیم LLM را شتاب میدهد و آموزش مدلها را با سرعت بیشتر و منابع محاسباتی کمتر ممکن میکند. Unsloth به TRL متصل میشود؛ بنابراین بر مطالب بخشهای قبلی تکیه میکنیم و آنها را با ویژگیهای Unsloth سازگار میسازیم. | |
| > [!TIP] | |
| > این تمرین را میتوان روی GPU رایگان T4 در Google Colab اجرا کرد. برای بهترین تجربه، همراه با نوتبوک لینکشده در بالا پیش بروید و خودتان آن را امتحان کنید. | |
| ## نصب وابستگیها | |
| ابتدا کتابخانههای لازم را نصب میکنیم. برای ریزتنظیم شتابیافته به Unsloth و برای استنتاج سریع به vLLM نیاز داریم. | |
| ```bash | |
| pip install unsloth vllm | |
| pip install --upgrade pillow | |
| ``` | |
| ## راهاندازی Unsloth | |
| Unsloth کلاسی (`FastLanguageModel`) ارائه میدهد که transformers را با بهینهسازیهای Unsloth یکپارچه میکند. بیایید آن را وارد کنیم: | |
| ```python | |
| from unsloth import FastLanguageModel | |
| ``` | |
| حالا مدل Gemma 3 1B Instruct گوگل را بارگذاری و برای ریزتنظیم پیکربندی میکنیم: | |
| ```python | |
| from unsloth import FastLanguageModel | |
| import torch | |
| max_seq_length = 1024 # Can increase for longer reasoning traces | |
| lora_rank = 32 # Larger rank = smarter, but slower | |
| model, tokenizer = FastLanguageModel.from_pretrained( | |
| model_name="google/gemma-3-1b-it", | |
| max_seq_length=max_seq_length, | |
| load_in_4bit=True, # False for LoRA 16bit | |
| fast_inference=True, # Enable vLLM fast inference | |
| max_lora_rank=lora_rank, | |
| gpu_memory_utilization=0.6, # Reduce if out of memory | |
| ) | |
| model = FastLanguageModel.get_peft_model( | |
| model, | |
| r=lora_rank, # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128 | |
| target_modules=[ | |
| "q_proj", | |
| "k_proj", | |
| "v_proj", | |
| "o_proj", | |
| "gate_proj", | |
| "up_proj", | |
| "down_proj", | |
| ], # Remove QKVO if out of memory | |
| lora_alpha=lora_rank, | |
| use_gradient_checkpointing="unsloth", # Enable long context finetuning | |
| random_state=3407, | |
| ) | |
| ``` | |
| این کد مدل را برای صرفهجویی در حافظه با کوانتیزهسازی ۴ بیتی بارگذاری میکند و برای ریزتنظیم کارآمد، LoRA (سازگارسازی کمرتبه) را اعمال میکند. پارامتر `target_modules` لایههایی از مدل را که باید ریزتنظیم شوند مشخص میکند و `use_gradient_checkpointing` آموزش با زمینههای طولانیتر را فعال میسازد. | |
| > [!TIP] | |
| > در این فصل جزئیات LoRA را بررسی نمیکنیم، اما میتوانید در [فصل ۱۱](/course/chapter11/3) بیشتر دربارهٔ آن بیاموزید. | |
| ## آمادهسازی دادهها | |
| برای این تمرین از مجموعهدادهٔ GSM8K استفاده میکنیم که شامل مسائل ریاضی مقطع ابتدایی است. دادهها را طوری قالببندی میکنیم که مدل پیش از ارائهٔ پاسخ، استدلال خود را نشان دهد. | |
| ابتدا قالب پرامپتها و پاسخها را تعریف میکنیم: | |
| ```python | |
| # Define the system prompt that instructs the model to use a specific format | |
| SYSTEM_PROMPT = """ | |
| Respond in the following format: | |
| <reasoning> | |
| ... | |
| </reasoning> | |
| <answer> | |
| ... | |
| </answer> | |
| """ | |
| XML_COT_FORMAT = """\ | |
| <reasoning> | |
| {reasoning} | |
| </reasoning> | |
| <answer> | |
| {answer} | |
| </answer> | |
| """ | |
| ``` | |
| حالا مجموعهداده را آماده میکنیم: | |
| ```python | |
| import re | |
| from datasets import load_dataset, Dataset | |
| # Helper functions to extract answers from different formats | |
| def extract_xml_answer(text: str) -> str: | |
| answer = text.split("<answer>")[-1] | |
| answer = answer.split("</answer>")[0] | |
| return answer.strip() | |
| def extract_hash_answer(text: str) -> str | None: | |
| if "####" not in text: | |
| return None | |
| return text.split("####")[1].strip() | |
| # Function to prepare the GSM8K dataset | |
| def get_gsm8k_questions(split="train") -> Dataset: | |
| data = load_dataset("openai/gsm8k", "main")[split] | |
| data = data.map( | |
| lambda x: { | |
| "prompt": [ | |
| {"role": "system", "content": SYSTEM_PROMPT}, | |
| {"role": "user", "content": x["question"]}, | |
| ], | |
| "answer": extract_hash_answer(x["answer"]), | |
| } | |
| ) | |
| return data | |
| dataset = get_gsm8k_questions() | |
| ``` | |
| مجموعهداده با استخراج پاسخ از دادهها و قالببندی آن بهصورت رشته آماده میشود. | |
| ## تعریف توابع پاداش | |
| همانطور که در [یک صفحهی پیشین](/course/chapter13/4) گفتیم، GRPO میتواند با تکیه بر معیارهای قابلراستیآزمایی مانند طول و قالببندی، از توابع پاداش برای هدایت یادگیری مدل استفاده کند. | |
| در این تمرین چند تابع پاداش تعریف میکنیم که جنبههای مختلف استدلال خوب را تقویت میکنند. برای نمونه، به مدل برای ارائهٔ پاسخ بهصورت عدد صحیح و پیروی از قالب دقیق پاداش میدهیم. | |
| ```python | |
| # Reward function that checks if the answer is correct | |
| def correctness_reward_func(prompts, completions, answer, **kwargs) -> list[float]: | |
| responses = [completion[0]["content"] for completion in completions] | |
| q = prompts[0][-1]["content"] | |
| extracted_responses = [extract_xml_answer(r) for r in responses] | |
| print( | |
| "-" * 20, | |
| f"Question:\n{q}", | |
| f"\nAnswer:\n{answer[0]}", | |
| f"\nResponse:\n{responses[0]}", | |
| f"\nExtracted:\n{extracted_responses[0]}", | |
| ) | |
| return [2.0 if r == a else 0.0 for r, a in zip(extracted_responses, answer)] | |
| # Reward function that checks if the answer is an integer | |
| def int_reward_func(completions, **kwargs) -> list[float]: | |
| responses = [completion[0]["content"] for completion in completions] | |
| extracted_responses = [extract_xml_answer(r) for r in responses] | |
| return [0.5 if r.isdigit() else 0.0 for r in extracted_responses] | |
| # Reward function that checks if the completion follows the strict format | |
| def strict_format_reward_func(completions, **kwargs) -> list[float]: | |
| pattern = r"^<reasoning>\n.*?\n</reasoning>\n<answer>\n.*?\n</answer>\n$" | |
| responses = [completion[0]["content"] for completion in completions] | |
| matches = [re.match(pattern, r) for r in responses] | |
| return [0.5 if match else 0.0 for match in matches] | |
| # Reward function that checks if the completion follows a more relaxed format | |
| def soft_format_reward_func(completions, **kwargs) -> list[float]: | |
| pattern = r"<reasoning>.*?</reasoning>\s*<answer>.*?</answer>" | |
| responses = [completion[0]["content"] for completion in completions] | |
| matches = [re.match(pattern, r) for r in responses] | |
| return [0.5 if match else 0.0 for match in matches] | |
| # Reward function that counts XML tags and penalizes extra content | |
| def count_xml(text) -> float: | |
| count = 0.0 | |
| if text.count("<reasoning>\n") == 1: | |
| count += 0.125 | |
| if text.count("\n</reasoning>\n") == 1: | |
| count += 0.125 | |
| if text.count("\n<answer>\n") == 1: | |
| count += 0.125 | |
| count -= len(text.split("\n</answer>\n")[-1]) * 0.001 | |
| if text.count("\n</answer>") == 1: | |
| count += 0.125 | |
| count -= (len(text.split("\n</answer>")[-1]) - 1) * 0.001 | |
| return count | |
| def xmlcount_reward_func(completions, **kwargs) -> list[float]: | |
| contents = [completion[0]["content"] for completion in completions] | |
| return [count_xml(c) for c in contents] | |
| ``` | |
| این توابع پاداش هدفهای متفاوتی دارند: | |
| | تابع پاداش | هدف | | |
| |------------|-----| | |
| | `correctness_reward_func` | وقتی پاسخ مدل با پاسخ درست مطابقت دارد، به مدل پاداش میدهد | | |
| | `int_reward_func` | برای ارائهی یک پاسخ عددی به مدل پاداش میدهد | | |
| | `strict_format_reward_func` و `soft_format_reward_func` | برای رعایت قالب مشخصشده به مدل پاداش میدهد | | |
| | `xmlcount_reward_func` | استفادهی درست از برچسبهای XML را پاداش میدهد و محتوای اضافی پس از برچسبهای بستهشدن را جریمه میکند | | |
| ## آموزش با GRPO | |
| حالا آموزشدهندهٔ GRPO را با مدل، توکنساز و توابع پاداش خود راهاندازی میکنیم. این بخش همان رویکرد [تمرین قبلی](/course/chapter12/5) را دنبال میکند. | |
| ```python | |
| from trl import GRPOConfig, GRPOTrainer | |
| max_prompt_length = 256 | |
| training_args = GRPOConfig( | |
| learning_rate=5e-6, | |
| adam_beta1=0.9, | |
| adam_beta2=0.99, | |
| weight_decay=0.1, | |
| warmup_ratio=0.1, | |
| lr_scheduler_type="cosine", | |
| optim="paged_adamw_8bit", | |
| logging_steps=1, | |
| per_device_train_batch_size=1, | |
| gradient_accumulation_steps=1, # Increase to 4 for smoother training | |
| num_generations=6, # Decrease if out of memory | |
| max_prompt_length=max_prompt_length, | |
| max_completion_length=max_seq_length - max_prompt_length, | |
| # num_train_epochs = 1, # Set to 1 for a full training run | |
| max_steps=250, | |
| save_steps=250, | |
| max_grad_norm=0.1, | |
| report_to="none", # Can use Weights & Biases | |
| output_dir="outputs", | |
| ) | |
| trainer = GRPOTrainer( | |
| model=model, | |
| processing_class=tokenizer, | |
| reward_funcs=[ | |
| xmlcount_reward_func, | |
| soft_format_reward_func, | |
| strict_format_reward_func, | |
| int_reward_func, | |
| correctness_reward_func, | |
| ], | |
| args=training_args, | |
| train_dataset=dataset, | |
| ) | |
| ``` | |
| `GRPOConfig` ابرپارامترهای مختلف آموزش را تنظیم میکند: | |
| - `use_vllm`: استنتاج سریع با vLLM را فعال میکند. | |
| - `learning_rate`: سرعت یادگیری مدل را کنترل میکند. | |
| - `num_generations`: تعداد تکمیلهایی که برای هر پرامپت تولید میشوند. | |
| - `max_steps`: تعداد کل گامهای آموزشی که باید انجام شوند. | |
| حالا آموزش را شروع میکنیم: | |
| ```python | |
| trainer.train() | |
| ``` | |
| > [!WARNING] | |
| > آموزش ممکن است مدتی طول بکشد. شاید افزایش پاداشها را بلافاصله نبینید؛ ممکن است ۱۵۰ تا ۲۰۰ گام طول بکشد تا بهبودها ظاهر شوند. صبور باشید! | |
| ## آزمایش مدل | |
| پس از آموزش، مدل را آزمایش میکنیم تا عملکرد آن را ببینیم. ابتدا وزنهای LoRA را ذخیره میکنیم: | |
| ```python | |
| model.save_lora("grpo_saved_lora") | |
| ``` | |
| حالا مدل را با یک پرسش جدید آزمایش میکنیم: | |
| ```python | |
| from vllm import SamplingParams | |
| text = tokenizer.apply_chat_template( | |
| [ | |
| {"role": "system", "content": SYSTEM_PROMPT}, | |
| {"role": "user", "content": "Calculate pi."}, | |
| ], | |
| tokenize=False, | |
| add_generation_prompt=True, | |
| ) | |
| sampling_params = SamplingParams( | |
| temperature=0.8, | |
| top_p=0.95, | |
| max_tokens=1024, | |
| ) | |
| output = ( | |
| model.fast_generate( | |
| text, | |
| sampling_params=sampling_params, | |
| lora_request=model.load_lora("grpo_saved_lora"), | |
| )[0] | |
| .outputs[0] | |
| .text | |
| ) | |
| print(output) | |
| ``` | |
| باید ببینید که مدل اکنون از قالب مشخصشده پیروی میکند و پیش از ارائهٔ پاسخ، استدلال خود را نشان میدهد. | |
| ## ذخیرهٔ مدل | |
| Unsloth چند گزینه برای ذخیرهٔ مدل ریزتنظیمشدهٔ شما ارائه میدهد، اما بر رایجترین گزینه تمرکز میکنیم. | |
| ```python | |
| # Save to 16-bit precision | |
| model.save_pretrained_merged("model", tokenizer, save_method="merged_16bit") | |
| ``` | |
| ## ارسال به Hugging Face Hub | |
| مدل را با استفاده از متد `push_to_hub_merged` به Hugging Face Hub ارسال میکنیم. این متد اجازه میدهد مدل را در چند قالب کوانتیزهسازی ارسال کنیم. | |
| ```python | |
| # Push to Hugging Face Hub (requires a token) | |
| model.push_to_hub_merged( | |
| "your-username/model-name", tokenizer, save_method="merged_16bit", token="your-token" | |
| ) | |
| ``` | |
| Unsloth همچنین ذخیرهسازی در قالب GGUF را برای استفاده با llama.cpp پشتیبانی میکند: | |
| ```python | |
| model.push_to_hub_gguf( | |
| "your-username/model-name", | |
| tokenizer, | |
| quantization_method=["q4_k_m", "q8_0", "q5_k_m"], | |
| token="your-token", | |
| ) | |
| ``` | |
| فایلهای GGUF را میتوان با llama.cpp یا سامانههای مبتنی بر رابط کاربری مانند Jan و Open WebUI استفاده کرد. | |
| ## جمعبندی | |
| در این تمرین یاد گرفتید چگونه: | |
| 1. Unsloth را برای ریزتنظیم شتابیافته راهاندازی کنید. | |
| 2. دادهها را برای آموزش GRPO آماده کنید. | |
| 3. توابع پاداش سفارشی برای هدایت یادگیری مدل تعریف کنید. | |
| 4. مدلی را با استفاده از GRPO آموزش دهید. | |
| 5. مدل ریزتنظیمشده را آزمایش کنید. | |
| 6. مدل را در قالبهای مختلف ذخیره کنید. | |
| GRPO روشی قدرتمند برای همراستا کردن مدلهای زبانی با رفتارهای مشخص است و Unsloth آن را حتی روی سختافزار محدود نیز در دسترس میکند. با ترکیب چند تابع پاداش، میتوانید مدل را به پیروی از قالبی مشخص هدایت کنید و همزمان تواناییهای استدلالی آن را بهبود دهید. | |
| برای اطلاعات و منابع بیشتر، این موارد را ببینید: | |
| - [مستندات Unsloth](https://docs.unsloth.ai/) | |
| - [دیسکورد Unsloth](https://discord.gg/unsloth) | |
| - [گیتهاب Unsloth](https://github.com/unslothai/unsloth) | |
Xet Storage Details
- Size:
- 15 kB
- Xet hash:
- 3199b51cd751a9a9a2a4b11480529b4d625cc003f44e539b109132988c347ac3
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.