Buckets:

|
download
raw
15 kB

تمرین عملی: GRPO با Unsloth

در این تمرین، با استفاده از Unsloth یک مدل را با GRPO (بهینه‌سازی خط‌مشی نسبی گروهی) ریزتنظیم می‌کنید تا توانایی‌های استدلالی آن بهبود یابد. GRPO را در فصل ۳ بررسی کردیم.

Unsloth کتابخانه‌ای است که ریزتنظیم LLM را شتاب می‌دهد و آموزش مدل‌ها را با سرعت بیشتر و منابع محاسباتی کمتر ممکن می‌کند. Unsloth به TRL متصل می‌شود؛ بنابراین بر مطالب بخش‌های قبلی تکیه می‌کنیم و آن‌ها را با ویژگی‌های Unsloth سازگار می‌سازیم.

این تمرین را می‌توان روی GPU رایگان T4 در Google Colab اجرا کرد. برای بهترین تجربه، همراه با نوت‌بوک لینک‌شده در بالا پیش بروید و خودتان آن را امتحان کنید.

نصب وابستگی‌ها

ابتدا کتابخانه‌های لازم را نصب می‌کنیم. برای ریزتنظیم شتاب‌یافته به Unsloth و برای استنتاج سریع به vLLM نیاز داریم.

pip install unsloth vllm
pip install --upgrade pillow

راه‌اندازی Unsloth

Unsloth کلاسی (FastLanguageModel) ارائه می‌دهد که transformers را با بهینه‌سازی‌های Unsloth یکپارچه می‌کند. بیایید آن را وارد کنیم:

from unsloth import FastLanguageModel

حالا مدل Gemma 3 1B Instruct گوگل را بارگذاری و برای ریزتنظیم پیکربندی می‌کنیم:

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 آموزش با زمینه‌های طولانی‌تر را فعال می‌سازد.

در این فصل جزئیات LoRA را بررسی نمی‌کنیم، اما می‌توانید در فصل ۱۱ بیشتر دربارهٔ آن بیاموزید.

آماده‌سازی داده‌ها

برای این تمرین از مجموعه‌دادهٔ GSM8K استفاده می‌کنیم که شامل مسائل ریاضی مقطع ابتدایی است. داده‌ها را طوری قالب‌بندی می‌کنیم که مدل پیش از ارائهٔ پاسخ، استدلال خود را نشان دهد.

ابتدا قالب پرامپت‌ها و پاسخ‌ها را تعریف می‌کنیم:

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

حالا مجموعه‌داده را آماده می‌کنیم:

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

مجموعه‌داده با استخراج پاسخ از داده‌ها و قالب‌بندی آن به‌صورت رشته آماده می‌شود.

تعریف توابع پاداش

همان‌طور که در یک صفحه‌ی پیشین گفتیم، GRPO می‌تواند با تکیه بر معیارهای قابل‌راستی‌آزمایی مانند طول و قالب‌بندی، از توابع پاداش برای هدایت یادگیری مدل استفاده کند.

در این تمرین چند تابع پاداش تعریف می‌کنیم که جنبه‌های مختلف استدلال خوب را تقویت می‌کنند. برای نمونه، به مدل برای ارائهٔ پاسخ به‌صورت عدد صحیح و پیروی از قالب دقیق پاداش می‌دهیم.

# 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 را با مدل، توکن‌ساز و توابع پاداش خود راه‌اندازی می‌کنیم. این بخش همان رویکرد تمرین قبلی را دنبال می‌کند.

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: تعداد کل گام‌های آموزشی که باید انجام شوند.

حالا آموزش را شروع می‌کنیم:

trainer.train()

آموزش ممکن است مدتی طول بکشد. شاید افزایش پاداش‌ها را بلافاصله نبینید؛ ممکن است ۱۵۰ تا ۲۰۰ گام طول بکشد تا بهبودها ظاهر شوند. صبور باشید!

آزمایش مدل

پس از آموزش، مدل را آزمایش می‌کنیم تا عملکرد آن را ببینیم. ابتدا وزن‌های LoRA را ذخیره می‌کنیم:

model.save_lora("grpo_saved_lora")

حالا مدل را با یک پرسش جدید آزمایش می‌کنیم:

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 چند گزینه برای ذخیرهٔ مدل ریزتنظیم‌شدهٔ شما ارائه می‌دهد، اما بر رایج‌ترین گزینه تمرکز می‌کنیم.

# 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 ارسال می‌کنیم. این متد اجازه می‌دهد مدل را در چند قالب کوانتیزه‌سازی ارسال کنیم.

# 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 پشتیبانی می‌کند:

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 آن را حتی روی سخت‌افزار محدود نیز در دسترس می‌کند. با ترکیب چند تابع پاداش، می‌توانید مدل را به پیروی از قالبی مشخص هدایت کنید و هم‌زمان توانایی‌های استدلالی آن را بهبود دهید.

برای اطلاعات و منابع بیشتر، این موارد را ببینید:

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.