LLM Fine-Tuning LoRA Capacity Planning — วางแผน Resource สำหรับ LoRA Training

LoRA Fine-Tuning คืออะไร

LoRA (Low-Rank Adaptation) เป็นเทคนิค parameter-efficient fine-tuning สำหรับ Large Language Models (LLMs) แทนที่จะ train ทุก parameters ของ model (ซึ่งอาจมีหลายพันล้าน parameters) LoRA เพิ่ม trainable low-rank matrices เข้าไปใน attention layers ทำให้ train เฉพาะ parameters ใหม่ที่เพิ่มเข้ามา (ปกติ 0.1-1% ของ original parameters)

ข้อดีของ LoRA ได้แก่ ใช้ VRAM น้อยกว่า full fine-tuning 60-80%, training เร็วกว่า 2-3 เท่า, LoRA adapters มีขนาดเล็ก (10-100MB แทน model เต็มหลาย GB), สามารถ swap adapters ได้ (ใช้ base model เดียวกับหลาย adapters), ไม่ทำให้ base model เสียหาย (catastrophic forgetting น้อยกว่า)

QLoRA เป็น extension ของ LoRA ที่ quantize base model เป็น 4-bit ก่อน แล้ว train LoRA adapters บน quantized model ลด VRAM ได้อีก 50% ทำให้ fine-tune 7B model ได้บน GPU 16GB และ 70B model ได้บน GPU 48GB

Capacity Planning สำคัญเพราะ VRAM เป็น bottleneck หลัก ต้องรู้ว่า model size, batch size, sequence length และ LoRA rank ต้องการ VRAM เท่าไหร เพื่อเลือก hardware ที่เหมาะสมและ optimize training configuration

เนื้อหาเกี่ยวข้อง — บทความที่เกี่ยวข้อง: Elixir Ecto High Availability HA Setup —

Capacity Planning สำหรับ LoRA Training

คำนวณ resource requirements

ติดตั้งและเตรียม Training Environment

เตรียมสภาพแวดล้อมสำหรับ LoRA training

แนะนำเพิ่มเติม — iCafeForex

Fine-Tune LLM ด้วย LoRA

Training script สำหรับ LoRA fine-tuning

Monitoring และ Resource Optimization

Monitor training และ optimize resources

เนื้อหาเกี่ยวข้อง — อ่านต่อ: Pi Network — คู่มือ IT Infrastructure 2026

Production Deployment และ Serving

Deploy LoRA model สำหรับ production

# === LoRA Model Deployment ===

# 1. Merge LoRA Adapter with Base Model
# ===================================
#!/usr/bin/env python3
# merge_and_export.py

# from transformers import AutoModelForCausalLM, AutoTokenizer
# from peft import PeftModel
# import torch
#
# base_model_id = "mistralai/Mistral-7B-Instruct-v0.3"
# lora_path = "./lora-output"
# merged_path = "./merged-model"
#
# # Load base model
# model = AutoModelForCausalLM.from_pretrained(
# base_model_id, torch_dtype=torch.bfloat16, device_map="cpu"
# )
# tokenizer = AutoTokenizer.from_pretrained(base_model_id)
#
# # Load and merge LoRA
# model = PeftModel.from_pretrained(model, lora_path)
# model = model.merge_and_unload()
#
# # Save merged model
# model.save_pretrained(merged_path)
# tokenizer.save_pretrained(merged_path)
# print(f"Merged model saved to {merged_path}")

# 2. Convert to GGUF for llama.cpp
# ===================================
# git clone https://github.com/ggerganov/llama.cpp
# cd llama.cpp
# pip install -r requirements.txt
#
# python convert_hf_to_gguf.py ../merged-model --outfile model.gguf --outtype f16
#
# # Quantize for smaller size
# ./llama-quantize model.gguf model-q4_k_m.gguf Q4_K_M

# 3. Serve with vLLM
# ===================================
pip install vllm

# Serve merged model
# python -m vllm.entrypoints.openai.api_server \
# --model ./merged-model \
# --dtype bfloat16 \
# --max-model-len 4096 \
# --port 8000

# Or serve base model + LoRA adapter (dynamic loading)
# python -m vllm.entrypoints.openai.api_server \
# --model mistralai/Mistral-7B-Instruct-v0.3 \
# --enable-lora \
# --lora-modules my-lora=./lora-output \
# --max-lora-rank 32

# Test API
curl -s http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "my-lora",
 "messages": [{"role": "user", "content": "Hello"}],
 "max_tokens": 100
 }' | python -m json.tool

# 4. Docker Deployment
# ===================================
# Dockerfile
# FROM nvidia/cuda:12.1.0-runtime-ubuntu22.04
# RUN pip install vllm transformers peft
# COPY merged-model /app/model
# EXPOSE 8000
# CMD ["python", "-m", "vllm.entrypoints.openai.api_server", \
# "--model", "/app/model", "--port", "8000"]

# docker build -t lora-server .
# docker run --gpus all -p 8000:8000 lora-server

# 5. Kubernetes Deployment
# ===================================
# apiVersion: apps/v1
# kind: Deployment
# metadata:
# name: lora-server
# spec:
# replicas: 1
# selector:
# matchLabels:
# app: lora-server
# template:
# spec:
# containers:
# - name: vllm
# image: lora-server:latest
# ports:
# - containerPort: 8000
# resources:
# limits:
# nvidia.com/gpu: 1
# memory: 32Gi
# volumeMounts:
# - name: model-storage
# mountPath: /app/model
# volumes:
# - name: model-storage
# persistentVolumeClaim:
# claimName: model-pvc

echo "Deployment configured"

FAQ คำถามที่พบบ่อย

Q: LoRA rank ตั้งเท่าไหรดี?

A: rank 8-16 เพียงพอสำหรับ simple tasks เช่น classification, sentiment ใช้ VRAM น้อย training เร็ว rank 32-64 สำหรับ complex tasks เช่น instruction following, code generation ใช้ VRAM มากขึ้น แต่ quality ดีกว่า rank 128+ สำหรับ domain-specific knowledge injection ต้อง GPU ใหญ่ เริ่มจาก rank 16 แล้วเพิ่มถ้า quality ไม่พอ อย่าลืมปรับ alpha ตาม (alpha = 2x rank เป็น starting point ที่ดี)

แนะนำเพิ่มเติม — อีบุ๊กการลงทุน SiamCafeBook

เนื้อหาเกี่ยวข้อง — ทำความเข้าใจ Tailscale Mesh Incident Management — ทุกสิ่งที่ต้องรู้ในปี 2026

Q: ต้องการ training data เท่าไหร?

A: ขั้นต่ำ 100-500 examples สำหรับ simple task adaptation, 1,000-5,000 examples สำหรับ instruction following ที่ดี, 10,000+ examples สำหรับ domain-specific fine-tuning ที่ quality สูง คุณภาพสำคัญกว่าปริมาณ 1,000 examples ที่ clean และ high-quality ดีกว่า 10,000 examples ที่มี noise ใช้ format ที่ consistent และ diverse examples

Q: QLoRA กับ LoRA ต่างกันอย่างไร?

A: LoRA train LoRA adapters บน base model ที่เป็น fp16/bf16 ใช้ VRAM ตาม model size (7B model ~14GB) QLoRA quantize base model เป็น 4-bit ก่อน แล้ว train LoRA adapters ใช้ VRAM น้อยกว่ามาก (7B model ~6GB) Quality ของ QLoRA ใกล้เคียง LoRA (ต่างกัน 1-2% ใน benchmarks) สำหรับ GPU 16GB ขึ้นไป ใช้ QLoRA กับ 7B models สำหรับ GPU 24GB+ ใช้ LoRA ตรงๆ ได้

เนื้อหาเกี่ยวข้อง — บทความที่เกี่ยวข้อง: LangChain Agent Edge Computing

Q: Training ใช้เวลาเท่าไหร?

A: ขึ้นกับหลายปัจจัย dataset size, sequence length, batch size, GPU speed, number of epochs สำหรับ 7B model กับ QLoRA rank 16, batch 4, 1,000 examples, 3 epochs บน RTX 4090 ใช้เวลาประมาณ 15-30 นาที บน A100 80GB เร็วกว่า 2-3 เท่า สำหรับ 70B model ใช้เวลา 5-10 เท่าของ 7B Cloud GPU (A100/H100) คิดค่าใช้จ่ายประมาณ $2-5/ชั่วโมง สำหรับ training ง่ายๆ ไม่กี่ดอลลาร์