فاین‌تیونینگ مدل‌های زبانی بزرگ با LoRA و QLoRA: راهنمای عملی با Python

چرا فاین‌تیونینگ مدل‌های زبانی بزرگ اهمیت دارد؟

مدل‌های زبانی بزرگ (LLM) مثل Llama، Mistral و Qwen توانایی‌های عمومی خیره‌کننده‌ای دارن، ولی واقعیت اینه که برای کاربردهای تخصصی — مثلاً طبقه‌بندی اسناد حقوقی یا پاسخ‌دهی به سؤالات پزشکی — عملکردشون اون‌قدری که انتظار دارید خوب نیست. اینجاست که فاین‌تیونینگ وارد بازی می‌شه.

فاین‌تیونینگ (Fine-Tuning) یعنی گرفتن یه مدل پیش‌آموزش‌دیده و آموزش دادنش روی داده‌های اختصاصی خودتون تا تو حوزه مورد نظرتون بهتر عمل کنه. ایده ساده‌ست، ولی مشکل اصلی هزینه محاسباتیشه.

فکرش رو بکنید: آموزش تمام پارامترهای یه مدل ۷ میلیارد پارامتری به حداقل ۵۶ گیگابایت حافظه GPU نیاز داره. خب، اکثر ما دسترسی به این حجم سخت‌افزار رو نداریم، درسته؟ اینجاست که تکنیک‌های LoRA و QLoRA نجات‌بخش می‌شن و فاین‌تیونینگ رو حتی روی سخت‌افزارهای مصرفی ممکن می‌کنن.

LoRA چیست و چگونه کار می‌کند؟

LoRA (Low-Rank Adaptation) یه تکنیک فاین‌تیونینگ پارامتر-کارآمد (PEFT) هست که به جای به‌روزرسانی تمام وزن‌های مدل، فقط دو ماتریس کوچک آداپتر (A و B) رو آموزش می‌ده. ایده پشتش اینه که تغییرات لازم در وزن‌های مدل ذاتاً بعد پایینی (Low-Rank) دارن و می‌شه اونها رو با ماتریس‌های خیلی کوچک‌تر تقریب زد.

صادقانه بگم، وقتی اولین بار این مقاله LoRA رو خوندم، از سادگی و هوشمندی ایده‌ش شگفت‌زده شدم.

مکانیزم ریاضی LoRA

فرض کنید ماتریس وزن اصلی مدل W₀ باشه با ابعاد d × k. تو فاین‌تیونینگ سنتی، تغییرات ΔW هم ابعاد d × k داره. ولی LoRA این تغییرات رو به صورت حاصل‌ضرب دو ماتریس کوچک‌تر تجزیه می‌کنه:

ΔW = A × B
A: d × r    (r << d)
B: r × k    (r << k)

W_new = W₀ + ΔW = W₀ + A × B

پارامتر r (rank) معمولاً بین ۸ تا ۶۴ انتخاب می‌شه. بذارید با یه مثال عددی واضح‌ترش کنم: اگه ابعاد وزن اصلی 4096 × 4096 باشه (حدود ۱۶.۸ میلیون پارامتر)، با r=16 فقط 4096×16 + 16×4096 = 131,072 پارامتر آموزش می‌بینن — یعنی کمتر از ۱٪ پارامترهای اصلی. این عدد واقعاً چشمگیره.

مزایای کلیدی LoRA

• کاهش چشمگیر حافظه: فقط ۰.۲ تا ۰.۳ درصد پارامترها آموزش می‌بینن
• سرعت آموزش بالاتر: محاسبات گرادیان برای پارامترهای کمتر، خیلی سریع‌تره
• کاهش خطر Overfitting: تعداد کم پارامترهای قابل آموزش، مدل رو از بیش‌برازش محافظت می‌کنه
• قابلیت ترکیب: می‌تونید چندین آداپتر LoRA مختلف رو برای وظایف مختلف آموزش بدید و بدون تغییر مدل پایه بین‌شون جابه‌جا بشید (این واقعاً یه ویژگی فوق‌العاده‌ست)

QLoRA: ترکیب کوانتیزاسیون با LoRA

خب، حالا بریم سراغ QLoRA که یه قدم جلوتر از LoRA می‌ره. QLoRA (Quantized LoRA) مدل پایه رو با دقت ۴ بیتی کوانتیزه می‌کنه. نتیجه؟ مصرف حافظه تا ۴ برابر نسبت به LoRA استاندارد کاهش پیدا می‌کنه و فاین‌تیونینگ مدل‌های بزرگ روی GPU‌های مصرفی ممکن می‌شه.

سه نوآوری کلیدی QLoRA

1. 4-bit NormalFloat (NF4): یه نوع داده جدید که برای توزیع نرمال وزن‌های شبکه عصبی بهینه شده و دقت بالاتری نسبت به کوانتیزاسیون ۴ بیتی معمولی داره
2. Double Quantization: کوانتیزه کردن خود ثابت‌های کوانتیزاسیون! بله درست خوندید — حدود ۰.۳۷ بیت به‌ازای هر پارامتر صرفه‌جویی اضافی ایجاد می‌کنه
3. Paged Optimizers: استفاده از حافظه CPU برای مدیریت جهش‌های حافظه GPU هنگام پردازش بچ‌های بزرگ

یه نکته مهم که خیلیا ازش غافلن: تو QLoRA، ماتریس‌های آداپتر LoRA همچنان با دقت BFloat16 یا Float16 آموزش می‌بینن. فقط مدل پایه کوانتیزه‌ست. پس کیفیت آموزش حفظ می‌شه.

مقایسه LoRA و QLoRA: کدوم رو انتخاب کنیم؟

ویژگی	LoRA	QLoRA
دقت مدل پایه	fp16 / bf16	4-bit NF4
مصرف حافظه (مدل 7B)	~16 GB VRAM	~6 GB VRAM
سرعت آموزش	سریع‌تر	۳۰-۴۰٪ کندتر (به دلیل dequantization)
کیفیت خروجی	بالا	تقریباً برابر LoRA (اختلاف ۱-۲٪)
سخت‌افزار مورد نیاز	GPU میان‌رده (24GB+)	GPU مصرفی (8-12GB)
بهترین کاربرد	وقتی GPU کافی دارید	منابع محدود، GPU مصرفی، Google Colab

قاعده سرانگشتی: اگه GPU با حافظه ۲۴ گیگابایت یا بیشتر دارید، برید سراغ LoRA. ولی اگه مثل خیلی از ما فقط به GPU‌های رایگان مثل T4 تو Google Colab دسترسی دارید، QLoRA قطعاً انتخاب بهتریه.

پیش‌نیازها و نصب ابزارها

سخت‌افزار مورد نیاز

• حداقل: GPU با ۸ گیگابایت VRAM (مثل NVIDIA RTX 3060) یا Google Colab رایگان با T4
• پیشنهادی: GPU با ۱۲-۲۴ گیگابایت VRAM (مثل RTX 4070 Ti یا RTX 3090)
• RAM سیستم: حداقل ۱۶ گیگابایت

نصب کتابخانه‌ها

pip install unsloth
pip install --upgrade transformers datasets accelerate peft bitsandbytes trl

کتابخانه Unsloth هسته اصلی کارمونه و آموزش رو تا ۲.۷ برابر سریع‌تر و مصرف حافظه رو تا ۶۰٪ کمتر می‌کنه. من شخصاً بعد از تست Unsloth دیگه برنگشتم سراغ روش‌های قبلی — تفاوت سرعتش واقعاً محسوسه.

بقیه کتابخانه‌ها هم هر کدوم نقش مشخصی دارن:

• peft: پیاده‌سازی LoRA و QLoRA
• bitsandbytes: کوانتیزاسیون ۴ بیتی
• trl: ابزار SFTTrainer برای Supervised Fine-Tuning
• datasets: بارگذاری و پردازش دیتاست‌ها

پیاده‌سازی گام‌به‌گام: فاین‌تیونینگ با QLoRA و Unsloth

خب، بریم سراغ بخش عملی. اینجا قراره قدم‌به‌قدم یه مدل رو با QLoRA فاین‌تیون کنیم.

گام ۱: بارگذاری مدل با کوانتیزاسیون ۴ بیتی

from unsloth import FastLanguageModel
import torch

# تنظیمات اصلی
max_seq_length = 2048
dtype = None  # تشخیص خودکار (bf16 برای Ampere+, fp16 برای قدیمی‌تر)
load_in_4bit = True  # فعال‌سازی QLoRA

# بارگذاری مدل
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.1-8B-Instruct",
    max_seq_length=max_seq_length,
    dtype=dtype,
    load_in_4bit=load_in_4bit,
)

print(f"Model loaded. GPU memory used: {torch.cuda.memory_allocated()/1e9:.2f} GB")

با فعال بودن load_in_4bit، مدل ۸ میلیارد پارامتری Llama 3.1 فقط حدود ۵-۶ گیگابایت حافظه GPU مصرف می‌کنه. این یعنی حتی روی یه T4 رایگان تو Colab هم جا می‌شه.

گام ۲: اضافه کردن آداپتر LoRA

# اضافه کردن آداپترهای LoRA به مدل
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                          # رتبه LoRA
    target_modules=[               # لایه‌های هدف
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha=16,                 # ضریب مقیاس‌دهی
    lora_dropout=0,                # Unsloth بهینه‌شده بدون dropout
    bias="none",
    use_gradient_checkpointing="unsloth",  # صرفه‌جویی ۳۰٪ حافظه
    random_state=42,
    use_rslora=False,              # برای r بالا True کنید
    loftq_config=None,
)

# بررسی تعداد پارامترهای قابل آموزش
model.print_trainable_parameters()

خروجی نمونه: trainable params: 41,943,040 || all params: 8,030,261,248 || trainable%: 0.5223

دقت کنید — فقط ۰.۵٪ از کل پارامترها رو آموزش می‌دیم. همین باعث می‌شه سرعت و مصرف حافظه به شدت بهبود پیدا کنه.

راهنمای انتخاب پارامتر r

• r=8: برای وظایف ساده مثل تغییر سبک نوشتار یا فرمت خروجی
• r=16: پیش‌فرض پیشنهادی برای اکثر کاربردها (دسته‌بندی، خلاصه‌سازی، پاسخ به سؤال)
• r=32-64: برای وظایف پیچیده‌تر مثل استدلال ریاضی یا تولید کد

گام ۳: آماده‌سازی دیتاست

from datasets import load_dataset

# بارگذاری دیتاست نمونه (می‌توانید دیتاست خودتان را جایگزین کنید)
dataset = load_dataset("yahma/alpaca-cleaned", split="train")

# تعریف قالب پرامپت
alpaca_prompt = (
    "Below is an instruction that describes a task, paired with an input "
    "that provides further context. Write a response that appropriately "
    "completes the request.\n\n"
    "### Instruction:\n{}\n\n### Input:\n{}\n\n### Response:\n{}"
)

# تابع فرمت‌دهی
def formatting_prompts_func(examples):
    instructions = examples["instruction"]
    inputs = examples["input"]
    outputs = examples["output"]
    texts = []
    for instruction, input_text, output in zip(instructions, inputs, outputs):
        text = alpaca_prompt.format(instruction, input_text, output)
        texts.append(text)
    return {"text": texts}

# اعمال فرمت‌دهی
dataset = dataset.map(formatting_prompts_func, batched=True)
print(f"Dataset size: {len(dataset)} examples")
print(f"Sample:\n{dataset[0]['text'][:300]}...")

ساخت دیتاست اختصاصی

اگه می‌خواید بهترین نتیجه رو بگیرید، حتماً دیتاست واقعی و تخصصی خودتون رو بسازید. ساختار پیشنهادی به این شکله:

// نمونه دیتاست اختصاصی (JSON)
[
    {
        "instruction": "این متن حقوقی را خلاصه کن",
        "input": "ماده ۱۹۰ قانون مدنی: برای صحت هر معامله شرایط ذیل اساسی است...",
        "output": "ماده ۱۹۰ چهار شرط اساسی معامله را بیان می‌کند: ..."
    }
]

یه نکته خیلی مهم: کیفیت دیتاست همیشه از حجمش مهم‌تره. ۱۰۰۰ نمونه باکیفیت، خیلی بهتر از ۱۰,۰۰۰ نمونه بی‌کیفیت عمل می‌کنه. این رو از تجربه می‌گم — بارها دیدم که با فیلتر کردن و پاکسازی دیتاست، نتیجه بهتری گرفتم.

گام ۴: آموزش مدل با SFTTrainer

from trl import SFTTrainer
from transformers import TrainingArguments
from unsloth import is_bfloat16_supported

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=max_seq_length,
    dataset_num_proc=2,
    packing=False,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,    # batch مؤثر = 2 × 4 = 8
        warmup_steps=5,
        num_train_epochs=1,               # برای شروع ۱ epoch کافی است
        learning_rate=2e-4,               # نرخ یادگیری پیشنهادی ۲۰۲۶
        fp16=not is_bfloat16_supported(),
        bf16=is_bfloat16_supported(),
        logging_steps=10,
        optim="adamw_8bit",               # بهینه‌ساز ۸ بیتی برای صرفه‌جویی حافظه
        weight_decay=0.01,
        lr_scheduler_type="cosine",       # زمان‌بندی کسینوسی
        seed=42,
        output_dir="outputs",
        report_to="none",
    ),
)

# شروع آموزش
trainer_stats = trainer.train()

print(f"Training time: {trainer_stats.metrics['train_runtime']:.2f} seconds")
print(f"Peak memory: {torch.cuda.max_memory_allocated()/1e9:.2f} GB")

یه توضیح درباره gradient_accumulation_steps=4: چون batch size رو ۲ گذاشتیم و gradient accumulation رو ۴، بچ مؤثر می‌شه ۸. این ترفند کمک می‌کنه که بدون نیاز به حافظه بیشتر، از مزایای بچ بزرگ‌تر استفاده کنیم.

گام ۵: تست مدل فاین‌تیون‌شده

# فعال‌سازی حالت استنتاج (۲ برابر سریع‌تر)
FastLanguageModel.for_inference(model)

# تست مدل
messages = [
    {"role": "user", "content": "تفاوت قرارداد لازم و جایز را توضیح بده."}
]

inputs = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
).to("cuda")

outputs = model.generate(
    input_ids=inputs,
    max_new_tokens=512,
    temperature=0.7,
    top_p=0.9,
)

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

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

گام ۶: ذخیره و اکسپورت مدل

# ذخیره آداپتر LoRA (فایل کوچک ~100MB)
model.save_pretrained("lora_model")
tokenizer.save_pretrained("lora_model")

# آپلود به Hugging Face Hub (اختیاری)
# model.push_to_hub("your-username/my-finetuned-model", token="hf_...")

# اکسپورت GGUF برای استفاده با llama.cpp و Ollama
model.save_pretrained_gguf(
    "model_gguf",
    tokenizer,
    quantization_method="q4_k_m",  # تعادل خوب کیفیت و حجم
)

# اکسپورت برای vLLM (استنتاج سریع سروری)
model.save_pretrained_merged(
    "model_merged",
    tokenizer,
    save_method="merged_16bit",
)

نکته جالب: فایل آداپتر LoRA فقط حدود ۱۰۰ مگابایته! یعنی می‌تونید چندین آداپتر برای وظایف مختلف نگه دارید بدون اینکه دیسکتون پر بشه. اکسپورت GGUF هم اگه می‌خواید مدل رو با Ollama روی لپ‌تاپ اجرا کنید خیلی کاربردیه.

بهترین تنظیمات هایپرپارامتر در ۲۰۲۶

بعد از صدها ساعت آزمایش و مطالعه بنچمارک‌های مختلف، تنظیمات زیر رو به عنوان پیش‌فرض پیشنهادی ۲۰۲۶ معرفی می‌کنم:

پارامتر	مقدار پیشنهادی	توضیح
r (rank)	16	تعادل بهینه بین کیفیت و مصرف حافظه
lora_alpha	16 (یا 2×r)	ضریب مقیاس‌دهی آداپتر
target_modules	all-linear	اعمال روی تمام لایه‌های خطی مدل
learning_rate	2e-4	نرخ یادگیری با warmup کسینوسی
batch_size (مؤثر)	8-16	از gradient_accumulation برای شبیه‌سازی بچ بزرگ‌تر استفاده کنید
epochs	1-3	معمولاً ۱ epoch برای دیتاست‌های بزرگ کافیه
optimizer	adamw_8bit	صرفه‌جویی حافظه بدون کاهش کیفیت
scheduler	cosine	کاهش تدریجی نرخ یادگیری

نکات تنظیم r بر اساس نوع وظیفه

یه چیزی که تو تنظیم هایپرپارامترها خیلی مهمه: وظایف مختلف به رتبه‌های متفاوتی نیاز دارن.

• تغییر سبک یا فرمت خروجی: r=8-16 کافیه (تغییرات سطحی‌ان)
• دسته‌بندی و استخراج اطلاعات: r=16 مناسبه
• انتقال توانایی استدلال: r=32-64 لازمه (تغییرات عمیق‌تر تو رفتار مدل)
• فاین‌تیونینگ چندزبانه: r=32+ پیشنهاد می‌شه

ارزیابی مدل فاین‌تیون‌شده

فاین‌تیونینگ بدون ارزیابی مثل رانندگی با چشم‌بسته‌ست. باید کیفیت مدل رو با معیارهای مشخص بسنجید:

from datasets import load_dataset
import json

# بارگذاری دیتاست ارزیابی
eval_dataset = load_dataset("your_eval_dataset", split="test")

# ارزیابی دستی با نمونه‌های تست
results = []
FastLanguageModel.for_inference(model)

for example in eval_dataset.select(range(100)):
    messages = [{"role": "user", "content": example["instruction"]}]
    inputs = tokenizer.apply_chat_template(
        messages, tokenize=True,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to("cuda")

    outputs = model.generate(
        input_ids=inputs,
        max_new_tokens=256,
        temperature=0.1,  # دمای پایین برای ارزیابی دقیق‌تر
    )

    prediction = tokenizer.decode(outputs[0], skip_special_tokens=True)
    results.append({
        "instruction": example["instruction"],
        "expected": example["output"],
        "predicted": prediction,
    })

# ذخیره نتایج برای بررسی دستی
with open("eval_results.json", "w", encoding="utf-8") as f:
    json.dump(results, f, ensure_ascii=False, indent=2)

print(f"Evaluation complete. {len(results)} examples processed.")

معیارهای کلیدی ارزیابی

• دقت وظیفه‌محور: برای دسته‌بندی از Accuracy و F1-Score استفاده کنید
• کیفیت تولید متن: ROUGE و BERTScore برای مقایسه خروجی با مرجع خیلی مفیدن
• ارزیابی انسانی: همیشه یه نمونه از خروجی‌ها رو به صورت دستی بررسی کنید — هیچ معیار خودکاری جایگزین چشم انسان نمی‌شه
• مقایسه A/B: خروجی مدل فاین‌تیون‌شده رو کنار مدل پایه بذارید تا بهبود واقعی رو ببینید

تکنیک‌های پیشرفته: DoRA، LoftQ و PiSSA

اکوسیستم فاین‌تیونینگ پارامتر-کارآمد تو ۲۰۲۶ فقط به LoRA و QLoRA محدود نیست. سه تکنیک پیشرفته هست که ارزش آشنایی دارن — حتی اگه الان بهشون نیاز ندارید، خوبه بدونید وجود دارن.

DoRA (Weight-Decomposed Low-Rank Adaptation)

DoRA وزن‌ها رو به دو بخش جهت (direction) و بزرگی (magnitude) تجزیه می‌کنه و LoRA رو فقط روی بخش جهت اعمال می‌کنه. نتیجه‌ش؟ عملکرد نزدیک‌تری به فاین‌تیونینگ کامل:

# فعال‌سازی DoRA در Unsloth
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
    use_dora=True,     # فعال‌سازی DoRA
    lora_alpha=16,
    lora_dropout=0,
)

LoftQ (LoRA-Fine-Tuning-aware Quantization)

LoftQ یه مشکل جدی QLoRA رو حل می‌کنه: خطای کوانتیزاسیون. به جای مقداردهی اولیه تصادفی، ماتریس‌های LoRA رو طوری مقداردهی می‌کنه که خطای کوانتیزاسیون رو به حداقل برسونه. تو تجربه من، روی بعضی دیتاست‌ها واقعاً فرق محسوسی ایجاد کرده.

PiSSA (Principal Singular values and Singular vectors Adaptation)

PiSSA ماتریس‌های A و B رو از مؤلفه‌های اصلی (principal components) ماتریس وزن مقداردهی اولیه می‌کنه. این باعث می‌شه آداپتر از همون ابتدا مهم‌ترین ساختار وزن‌ها رو تو خودش داشته باشه.

توصیه عملی ۲۰۲۶: ترکیب QLoRA + DoRA بهترین نسبت کیفیت به مصرف منابع رو ارائه می‌ده. اگه با محدودیت شدید حافظه مواجهید و کیفیت حداکثری می‌خواید، LoftQ رو هم حتماً امتحان کنید.

نکات عملی و خطاهای رایج

بذارید چند تا از مشکلاتی که احتمالاً باهاشون مواجه می‌شید رو با هم مرور کنیم. اینا چیزاییه که تقریباً همه تو شروع کار باهاشون دست‌وپنجه نرم می‌کنن.

مشکلات رایج و راه‌حل‌ها

• خطای Out of Memory: اول gradient_accumulation_steps رو افزایش بدید و per_device_train_batch_size رو به ۱ کاهش بدید. اگه حل نشد، max_seq_length رو کم کنید
• Loss کاهش نمی‌یابد: نرخ یادگیری رو بررسی کنید. اگه خیلی بالاست Loss نوسان می‌کنه، اگه خیلی پایینه Loss ثابت می‌مونه
• خروجی بی‌معنی پس از فاین‌تیونینگ: احتمالاً Overfitting رخ داده. تعداد epoch رو کم کنید یا حجم دیتاست رو بیشتر کنید
• Catastrophic Forgetting: اگه مدل دانش عمومیش رو از دست داده، r رو کاهش بدید و یه مقداری داده عمومی به دیتاست آموزش اضافه کنید

بهترین شیوه‌ها

• همیشه اول با یه زیرمجموعه کوچیک از دیتاست آزمایش کنید — نرید سراغ آموزش کامل قبل از اینکه مطمئن بشید همه‌چیز درست کار می‌کنه
• هزینه فاین‌تیونینگ ابری رو حساب کنید: یه آزمایش QLoRA روی GPU ابری حدود ۱۰ دلار هزینه داره (البته بسته به مدل و حجم دیتاست متفاوته)
• مدل پایه رو با دقت انتخاب کنید: مدل‌های Instruct برای وظایف مکالمه‌ای و مدل‌های Base برای وظایف تخصصی مناسب‌ترن
• از نسخه Unsloth مدل‌ها استفاده کنید چون از قبل برای آموزش بهینه شدن

پرسش‌های متداول

آیا فاین‌تیونینگ با LoRA واقعاً به اندازه فاین‌تیونینگ کامل مؤثره؟

کوتاه بگم: بله، تو اکثر کاربردهای عملی. تحقیقات نشون می‌ده که LoRA تو وظایفی مثل دسته‌بندی متن، خلاصه‌سازی و پرسش‌وپاسخ عملکردی رقابتی با فاین‌تیونینگ کامل داره — و فقط ۰.۲ تا ۰.۳ درصد پارامترها رو آموزش می‌ده. اختلاف دقت معمولاً ۱-۲٪ هست که برای بیشتر کاربردها واقعاً ناچیزه.

حداقل حجم دیتاست برای فاین‌تیونینگ چقدره؟

جواب قطعی وجود نداره، ولی به عنوان راهنما: برای تغییر سبک خروجی ۱۰۰-۵۰۰ نمونه، برای وظایف دسته‌بندی ۵۰۰-۲۰۰۰ نمونه، و برای وظایف پیچیده استدلالی ۲۰۰۰-۱۰,۰۰۰ نمونه کافیه. ولی یادتون باشه: کیفیت داده همیشه مهم‌تر از حجمشه.

آیا می‌شه مدل‌های فاین‌تیون‌شده رو تجاری استفاده کرد؟

بستگی به لایسنس مدل پایه داره. مدل‌هایی مثل Llama 3.1 (Meta Community License)، Mistral (Apache 2.0) و Qwen 2.5 (Apache 2.0) اجازه استفاده تجاری می‌دن. ولی همیشه قبل از استفاده تجاری، لایسنس مدل پایه و دیتاست آموزشی رو چک کنید — این خیلی مهمه.

تفاوت فاین‌تیونینگ با RAG چیه و کدوم رو انتخاب کنم؟

فاین‌تیونینگ رفتار و دانش مدل رو تغییر می‌ده و مناسب یادگیری سبک، فرمت یا مهارت جدیده. RAG اطلاعات خارجی رو تو زمان اجرا به مدل ارائه می‌ده و مناسب پاسخ‌دهی بر اساس اسناد به‌روزه. تو عمل، ترکیب هر دو معمولاً بهترین نتیجه رو می‌ده: فاین‌تیونینگ برای یادگیری سبک حوزه و RAG برای دسترسی به داده‌های جاری.

آیا فاین‌تیونینگ مدل‌های بسته مثل GPT-4 هم ممکنه؟

OpenAI و بقیه ارائه‌دهندگان API، امکان فاین‌تیونینگ بعضی مدل‌هاشون رو ارائه می‌دن، ولی این با LoRA/QLoRA فرق داره. تو فاین‌تیونینگ از طریق API، شما داده می‌فرستید و فرایند آموزش سمت سرور انجام می‌شه. LoRA/QLoRA فقط روی مدل‌های اپن‌سورس که دسترسی کامل به وزن‌هاشون دارید قابل اجراست.