QLoRA คืออะไรและช่วยประหยัดหน่วยความจำได้อย่างไร

QLoRA คือเทคนิคการปรับแต่งโมเดลที่รวม Low-Rank Adaptation (LoRA) เข้ากับการควอนไทซ์ 4-bit โดยใช้รูปแบบ NormalFloat 4 (NF4) เทคนิคนี้ช่วยลดการใช้หน่วยความจำลงอย่างมาก ทำให้สามารถฝึกโมเดลขนาดใหญ่บนฮาร์ดแวร์ระดับผู้บริโภคได้ โดยยังคงประสิทธิภาพไว้ได้ 95-98% เมื่อเทียบกับการฝึกแบบเต็มรูปแบบ

GPU ขนาด 24GB สามารถฝึกโมเดล LLM ขนาดใหญ่ได้สูงสุดกี่พารามิเตอร์

ด้วยเทคนิค QLoRA และเฟรมเวิร์กอย่าง Unsloth GPU ที่มี VRAM 24GB เช่น NVIDIA RTX 3090 หรือ RTX 4090 สามารถฝึกโมเดลได้ตั้งแต่ 7B ไปจนถึง 33B พารามิเตอร์ ซึ่งเป็นการขยายขีดจำกัดจากเดิมที่ทำได้เพียงโมเดลขนาดเล็กมาก

ไฟล์ผลลัพธ์จากการฝึกด้วย QLoRA มีขนาดเท่าไร

ไฟล์อะแดปเตอร์ที่ได้จากการฝึกด้วย QLoRA มีขนาดเล็กมาก โดยทั่วไปอยู่ระหว่าง 10MB ถึง 50MB ซึ่งเล็กกว่าจุดตรวจสอบ (checkpoint) ของโมเดลเต็มรูปแบบที่อาจมีขนาด 14-26GB อย่างมีนัยสำคัญ ทำให้การแชร์และใช้งานทำได้ง่ายกว่า

การปรับแต่งโมเดล LLM บน GPU 24GB: คู่มือ QLoRA แบบทีละขั้นตอน

สรุปสั้น: QLoRA ช่วยลดการใช้ VRAM ลงกว่า 99% ทำให้ปรับแต่งโมเดล LLM ขนาด 7B-33B บน GPU 24GB ได้ โดยยังคงประสิทธิภาพไว้ 95-98% เมื่อเทียบกับการฝึกแบบเต็มรูปแบบ

ข้อเท็จจริงสำคัญ

การปรับแต่งแบบเต็มรูปแบบ (Full fine-tuning) โมเดล 7B ใน FP16 ต้องการ VRAM ประมาณ 56GB
QLoRA ใช้เทคนิคควอนไทซ์ 4-bit (NF4) ร่วมกับ LoRA เพื่อลดพารามิเตอร์ที่ต้องฝึกฝนลงกว่า 99%
GPU ระดับผู้บริโภคที่มี VRAM 24GB เช่น NVIDIA RTX 3090 และ RTX 4090 สามารถรองรับการฝึกโมเดลได้สูงสุด 33B พารามิเตอร์
ไฟล์อะแดปเตอร์จาก QLoRA มีขนาดเพียง 10-50MB เทียบกับจุดตรวจสอบ (checkpoint) แบบเต็มรูปแบบที่หนัก 14-26GB
เฟรมเวิร์ก Unsloth อ้างว่าสามารถเร่งความเร็วการฝึก LoRA/QLoRA ได้ 2 เท่า และลดการใช้หน่วยความจำลง 60%
การใช้ตัวปรับให้เหมาะสมแบบแบ่งหน้า (PagedAdamW) สามารถเพิ่มประสิทธิภาพการประมวลผลได้สูงสุด 25% เมื่อเทียบกับ AdamW มาตรฐาน
การฝึกด้วย QLoRA บน GPU 8GB สามารถรองรับความยาวลำดับ (sequence length) ได้สูงถึง 2048 โทเค็น

การทำให้การพัฒนา LLM เข้าถึงได้ง่ายขึ้น

ตลอดหลายปีที่ผ่านมา การปรับแต่งโมเดลภาษาขนาดใหญ่ (LLMs) เป็นพื้นที่เฉพาะของศูนย์ข้อมูลที่มีเงินทุน การปรับแต่งแบบเต็มรูปแบบ (Full fine-tuning) โมเดลขนาด 7B พารามิเตอร์ใน FP16 ต้องการหน่วยความจำ VRAM ประมาณ 56GB เพียงเพื่อสถานะการฝึกฝน [7] ข้อจำกัดนี้ได้กีดกันนักวิจัยอิสระและสตาร์ทอัพขนาดเล็กออกไปอย่างมีประสิทธิภาพ บังคับให้พวกเขาต้องพึ่งพาคลัสเตอร์บนคลาวด์ที่มีราคาแพงหรือบริการ API [6]

อย่างไรก็ตาม ภูมิทัศน์ได้เปลี่ยนไป ด้วยความก้าวหน้าของวิธีการปรับแต่งที่มีประสิทธิภาพด้านพารามิเตอร์ (PEFT) เช่น Low-Rank Adaptation (LoRA) และรูปแบบควอนไทซ์ของมันคือ QLoRA ทำให้ตอนนี้สามารถปรับแต่งโมเดลที่มีพารามิเตอร์หลายพันล้านตัวบนฮาร์ดแวร์ระดับผู้บริโภคได้แล้ว [3] โดยเฉพาะอย่างยิ่ง GPU ที่มี VRAM 24GB เช่น NVIDIA RTX 3090 และ RTX 4090 ได้กลายเป็นมาตรฐานใหม่สำหรับการพัฒนา AI ที่เข้าถึงได้ [7]

LoRA ทำงานโดยการตรึงน้ำหนักของโมเดลเดิมและฝึกฝนเฉพาะเมทริกซ์อะแดปเตอร์ขนาดเล็กที่มีอันดับต่ำ (low-rank) ที่ถูกฉีดเข้าไปในเลเยอร์เฉพาะ [3] แนวทางนี้ลดจำนวนพารามิเตอร์ที่ต้องฝึกฝนลงกว่า 99% ในขณะที่ยังคงประสิทธิภาพไว้ได้ 95-98% เมื่อเทียบกับการปรับแต่งแบบเต็มรูปแบบ [5] ในคู่มือนี้ เราจะพาคุณผ่านกระบวนการปรับแต่งโมเดล 7B บน GPU ขนาด 24GB ตัวเดียว และสำรวจว่า QLoRA สามารถผลักดันขีดจำกัดนี้ไปถึง 33B พารามิเตอร์ได้อย่างไร

ทำไมต้อง QLoRA? ข้อได้เปรียบด้านหน่วยความจำ

LoRA มาตรฐานมีประสิทธิภาพด้านหน่วยความจำอยู่แล้ว แต่ QLoRA นำมันไปไกลกว่านั้นโดยการรวม LoRA เข้ากับการควอนไทซ์ 4-bit โดยใช้ NormalFloat 4 (NF4) [7] เทคนิคนี้ช่วยให้สามารถฝึกฝนโมเดลขนาด 7B พารามิเตอร์บน GPU ขนาด 24GB ตัวเดียวได้ และด้วย QLoRA คุณสามารถปรับแต่งโมเดลขนาดใหญ่ถึง 33B พารามิเตอร์บนฮาร์ดแวร์ชุดเดียวกันได้ [3]

ประโยชน์ขยายออกไปเกินกว่าการฝึกฝน ไฟล์อะแดปเตอร์ที่ได้มีขนาดเล็กลงอย่างมีนัยสำคัญ โดยทั่วไปมีขนาดระหว่าง 10MB ถึง 50MB เมื่อเทียบกับ 14-26GB ที่จำเป็นสำหรับจุดตรวจสอบ (checkpoints) ของโมเดลเต็มรูปแบบ [3] สิ่งนี้ทำให้การกระจายและการใช้งานเป็นเรื่องง่าย

การวิเคราะห์ประสิทธิภาพล่าสุดบนฮาร์ดแวร์ระดับผู้บริโภค เช่น RTX 4060 ชี้ให้เห็นว่าแม้ภายใต้ข้อจำกัดที่เข้มงวดกว่า (VRAM 8GB) ความยาวลำดับ (sequence lengths) สูงถึง 2048 โทเค็นก็สามารถทำได้โดยใช้กลยุทธ์เหล่านี้ [2] นอกจากนี้ การใช้ตัวปรับให้เหมาะสมแบบแบ่งหน้า (paged optimizers) เช่น PagedAdamW สามารถเพิ่มปริมาณงาน (throughput) ได้สูงสุด 25% เมื่อเทียบกับ AdamW มาตรฐานบน GPU ระดับผู้บริโภค [2]

ขั้นตอนทีละขั้นตอน: การปรับแต่งโมเดลด้วย Unsloth และ PEFT

เพื่อเพิ่มประสิทธิภาพสูงสุด เราจะใช้เฟรมเวิร์ก Unsloth ซึ่งอ้างว่าสามารถปรับแต่ง LoRA/QLoRA ได้เร็วขึ้น 2 เท่า และลดการใช้หน่วยความจำลง 60% ผ่านเคอร์เนลที่ผ่านการปรับให้เหมาะสม [7] เราจะใช้ไลบรารี PEFT, TRL และ bitsandbytes จาก Hugging Face ด้วย [3]

ขั้นตอนที่ 1: การตั้งค่าสภาพแวดล้อม

ก่อนอื่น ให้ตรวจสอบว่ามีการติดตั้งไลบรารีที่จำเป็นแล้ว คุณจะต้องมี transformers, peft, trl, bitsandbytes, datasets และ accelerate [3] สำหรับการสาธิตครั้งนี้ เราจะใช้ Unsloth เนื่องจากมีการเพิ่มความเร็วให้ [8]

!pip install unsloth trl peft bitsandbytes transformers datasets accelerate

ขั้นตอนที่ 2: โหลดโมเดลพื้นฐานด้วยการควอนไทซ์ 4-Bit

เราจะโหลดโมเดลโดยใช้ bitsandbytes เพื่อควอนไทซ์ความแม่นยำลงเหลือ 4-bit นี่คือหัวใจของ QLoRA ซึ่งช่วยให้เราสามารถโหลดโมเดลขนาดใหญ่ลงบน VRAM ได้ [7]

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048
dtype = None
load_in_4bit = True

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Llama-3-8b-bnb-4bit",
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
)

ขั้นตอนที่ 3: ตั้งค่า LoRA Adapters

ถัดมา เราจะใช้ LoRA adapters โดยกำหนดเป้าหมายไปที่โมดูลเฉพาะ ซึ่งโดยทั่วไปคือ q_proj และ v_proj เพื่อฉีดเมทริกซ์อันดับต่ำ (low-rank matrices) [3]

model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 16,
    lora_dropout = 0, # รองรับค่าใดก็ได้ แต่ = 0 จะได้รับการปรับให้เหมาะสมที่สุด
    bias = "none",    # รองรับค่าใดก็ได้ แต่ = "none" จะได้รับการปรับให้เหมาะสมที่สุด
    use_gradient_checkpointing = "unsloth",
    random_state = 3407,
    use_rslora = False,  # เราสนับสนุน Rank Stabilized LoRA
    loftq_config = None, # และ LoftQ
)

ขั้นตอนที่ 4: เตรียมชุดข้อมูล

เราต้องการชุดข้อมูลในรูปแบบการปรับแต่งด้วยคำสั่ง (instruction-tuning format) ไลบรารี datasets มีความสำคัญอย่างยิ่งในขั้นตอนนี้ [3]

dataset = load_dataset("yahma/alpaca-cleaned", split = "train")

def formatting_prompts_func(examples):
    instructions = examples["instruction"]
    inputs       = examples["input"]
    outputs      = examples["output"]
    texts = []
    for instruction, input, output in zip(instructions, inputs, outputs):
        text = f"<|start_header_id|>user<|end_header_id|>\n\n{instruction}\n{input}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n{output}<|eot_id|>"
        texts.append(text)
    return { "text" : texts, }

dataset = dataset.map(formatting_prompts_func, batched = True,)

### ขั้นตอนที่ 5: ฝึกสอนโมเดล

เราใช้ `SFTTrainer` จากไลบรารี TRL เพื่อจัดการกระบวนการฝึกสอนภายใต้การดูแล (supervised fine-tuning) [\[3\]](https://machinelearningplus.com/deep-learning/fine-tune-llms-with-lora-python/)

```python
from trl import SFTTrainer
from transformers import TrainingArguments

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, # สามารถทำให้การฝึกสอนเร็วขึ้น 5 เท่าสำหรับลำดับข้อมูลสั้นๆ
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        max_steps = 60,
        learning_rate = 2e-4,
        fp16 = not torch.cuda.is_bf16_supported(),
        bf16 = torch.cuda.is_bf16_supported(),
        logging_steps = 1,
        optim = "paged_adamw_8bit", # เพิ่มประสิทธิภาพการประมวลผลได้สูงสุดถึง 25% [\[2\]](https://arxiv.org/html/2509.12229v1)
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = "outputs",
    ),
)

trainer.train()

โปรดสังเกตการใช้ paged_adamw_8bit ในตัวปรับค่า (optimizer) ตามที่การศึกษาล่าสุดระบุไว้ วิธีนี้สามารถเพิ่มประสิทธิภาพการประมวลผลได้สูงสุดถึง 25% บน GPU สำหรับผู้บริโภค เมื่อเทียบกับ AdamW มาตรฐาน [2]

ขั้นตอนที่ 6: บันทึกและรวมโมเดล

สุดท้าย ให้บันทึกน้ำหนักของอะแดปเตอร์ ไฟล์เหล่านี้จะมีขนาดเล็ก โดยทั่วไปอยู่ที่ 10-50MB [3]

model.save_pretrained("lora_model") # การบันทึกแบบท้องถิ่น
tokenizer.save_pretrained("lora_model")

หากคุณต้องการรวมอะแดปเตอร์กลับเข้าไปในโมเดลพื้นฐานเพื่อการอนุมาน (inference) คุณสามารถทำได้ดังนี้:

model.save_pretrained_merged("merged_model", tokenizer, save_method = "merged_16bit")

บทสรุป

การฝึกสอนโมเดลภาษาขนาดใหญ่ (LLMs) บน GPU สำหรับผู้บริโภคที่มีหน่วยความจำ 24GB ไม่ใช่เพียงการทดลองทางทฤษฎีอีกต่อไป ด้วยการนำ QLoRA, PEFT และเฟรมเวิร์กที่ผ่านการปรับแต่งเช่น Unsloth มาใช้ นักพัฒนาอิสระสามารถปรับแต่งโมเดลที่มีพารามิเตอร์ตั้งแต่ 7B ถึง 33B ได้โดยไม่ต้องใช้เงินมหาศาล [7] อะแดปเตอร์ที่ได้จากกระบวนการนี้มีขนาดเล็ก ฝึกสอนได้รวดเร็ว และยังคงรักษาความสามารถส่วนใหญ่ของโมเดลพื้นฐานไว้ได้ [5] ในขณะที่ฮาร์ดแวร์ยังคงพัฒนาต่อไป วิธีการเหล่านี้จะยังคงมีความสำคัญต่อการทำให้การพัฒนา AI เป็นประชาธิปไตยมากขึ้น

สำหรับผู้ที่ VRAM น้อยกว่านั้น เช่น RTX 4060 ที่มี 8GB เทคนิคเหล่านี้ยังคงอนุญาตให้ทำการฝึกสอนที่เป็นไปได้จริงด้วยลำดับความยาวสูงสุดถึง 2048 โทเค็น [2] กำแพงกั้นทางเข้าไม่เคยต่ำเท่านี้มาก่อน

แหล่งที่มา

LoRA & QLoRA Fine-Tuning: Build Custom LLMs on a Single GPU [2026 Guide] | Meta Intelligence (www.meta-intelligence.tech) — 2025-08-07
How can I fine-tune large language models on a budget using LoRA and QLoRA on cloud GPUs? (www.runpod.io) — 2025-07-03
How to Fine-Tune LLMs with LoRA in Python — A Complete Guide - machinelearningplus (machinelearningplus.com) — 2026-03-06
LoRA Fine-Tuning: 7 Steps to Adapt Any LLM on One GPU (decodethefuture.org) — 2026-03-16
Profiling LoRA/QLoRA Fine-Tuning Efficiency on Consumer GPUs: An RTX 4060 Case Study (arxiv.org) — 2021-01-01
How to Fine-Tune LLMs in 2026: Costs, GPUs, and Code | Spheron Blog (www.spheron.network) — 2026-03-05