LLM Fine-tuning LoRA Remote Work Setup

LLM Fine-tuning LoRA Remote Work Setup คืออะไร

LLM Fine-tuning คือการปรับแต่ง Large Language Model ที่ pre-trained แล้วให้เชี่ยวชาญในงานเฉพาะทาง LoRA (Low-Rank Adaptation) เป็นเทคนิค parameter-efficient fine-tuning ที่ลดจำนวน parameters ที่ต้อง train ลงอย่างมาก ทำให้ fine-tune โมเดลขนาดใหญ่ได้บน GPU ที่มี VRAM จำกัด Remote Work Setup คือการจัดสภาพแวดล้อมให้ทีม ML engineers ทำงาน fine-tuning จากระยะไกลได้อย่างมีประสิทธิภาพ ด้วย cloud GPUs, experiment tracking, model registry และ collaboration tools

LoRA Fundamentals

# lora_basics.py — LoRA fundamentals
import json

class LoRABasics:
    CONCEPTS = {
        "full_finetuning": {
            "name": "Full Fine-tuning",
            "description": "Train ทุก parameters ของโมเดล",
            "params": "7B-70B+ parameters",
            "gpu_req": "4-8x A100 80GB (สำหรับ 7B model)",
            "cost": "สูงมาก",
        },
        "lora": {
            "name": "LoRA (Low-Rank Adaptation)",
            "description": "เพิ่ม low-rank matrices เข้า attention layers แล้ว train เฉพาะส่วนที่เพิ่ม",
            "params": "0.1-1% ของ total parameters",
            "gpu_req": "1x RTX 4090 24GB (สำหรับ 7B model)",
            "cost": "ต่ำมาก",
        },
        "qlora": {
            "name": "QLoRA (Quantized LoRA)",
            "description": "รวม 4-bit quantization + LoRA — ลด VRAM ลงอีก 50%+",
            "params": "0.1-1% + 4-bit base model",
            "gpu_req": "1x RTX 3090 24GB (สำหรับ 7B model)",
            "cost": "ต่ำที่สุด",
        },
    }

    LORA_MATH = """
    LoRA Math:
    
    Original weight matrix W: d × k (e.g., 4096 × 4096 = 16M params)
    
    LoRA decomposition:
    W' = W + BA
    where B: d × r, A: r × k (r = rank, typically 8-64)
    
    Example (r=16):
    B: 4096 × 16 = 65,536 params
    A: 16 × 4096 = 65,536 params
    Total LoRA: 131,072 params (0.8% of original 16M)
    
    → Train เฉพาะ B และ A (freeze W)
    → ลด trainable params 99%+
    """

    def show_concepts(self):
        print("=== Fine-tuning Methods ===\n")
        for key, concept in self.CONCEPTS.items():
            print(f"[{concept['name']}]")
            print(f"  {concept['description']}")
            print(f"  GPU: {concept['gpu_req']} | Cost: {concept['cost']}")
            print()

    def show_math(self):
        print("=== LoRA Math ===")
        print(self.LORA_MATH)

lora = LoRABasics()
lora.show_concepts()
lora.show_math()

Fine-tuning Pipeline

# finetune.py — LoRA fine-tuning pipeline
import json

class FineTunePipeline:
    TRAINING_CODE = """
# train_lora.py — LoRA fine-tuning with Hugging Face
import torch
from transformers import (
    AutoModelForCausalLM, AutoTokenizer,
    TrainingArguments, BitsAndBytesConfig
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer
from datasets import load_dataset

# 1. Load base model with 4-bit quantization (QLoRA)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

model_name = "meta-llama/Llama-3.1-8B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    torch_dtype=torch.bfloat16,
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# 2. Configure LoRA
lora_config = LoraConfig(
    r=16,                    # LoRA rank
    lora_alpha=32,           # Scaling factor
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# Output: trainable params: 83,886,080 || all params: 8,030,261,248 || 1.04%

# 3. Load dataset
dataset = load_dataset("json", data_files="train_data.jsonl", split="train")

# 4. Training arguments
training_args = TrainingArguments(
    output_dir="./output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    warmup_steps=100,
    logging_steps=10,
    save_steps=200,
    bf16=True,
    optim="paged_adamw_8bit",
    report_to="wandb",
)

# 5. Train
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer,
    max_seq_length=2048,
    dataset_text_field="text",
)
trainer.train()

# 6. Save LoRA adapter
model.save_pretrained("./lora-adapter")
tokenizer.save_pretrained("./lora-adapter")
"""

    def show_code(self):
        print("=== LoRA Training Code ===")
        print(self.TRAINING_CODE[:700])

    def hyperparameters(self):
        print(f"\n=== Recommended Hyperparameters ===")
        params = {
            "LoRA rank (r)": "8-64 (16 เป็น default ดี)",
            "LoRA alpha": "2× rank (r=16 → alpha=32)",
            "Learning rate": "1e-4 to 3e-4",
            "Batch size": "4-8 (ใช้ gradient accumulation ถ้า VRAM ไม่พอ)",
            "Epochs": "1-5 (monitor overfitting)",
            "Max seq length": "512-4096 (ตาม task)",
            "Warmup": "5-10% of total steps",
        }
        for p, v in params.items():
            print(f"  {p}: {v}")

ft = FineTunePipeline()
ft.show_code()
ft.hyperparameters()

Remote GPU Setup

# remote_gpu.py — Remote GPU setup for fine-tuning
import json

class RemoteGPUSetup:
    PROVIDERS = {
        "runpod": {
            "name": "RunPod",
            "gpus": ["A100 80GB", "H100", "RTX 4090"],
            "price": "$0.44-2.49/hr (on-demand)",
            "features": "Serverless, templates, persistent storage",
        },
        "lambda": {
            "name": "Lambda Cloud",
            "gpus": ["A100 80GB", "H100"],
            "price": "$1.10-2.49/hr",
            "features": "Simple UI, SSH access, persistent storage",
        },
        "vast_ai": {
            "name": "Vast.ai",
            "gpus": ["A100", "RTX 4090", "RTX 3090"],
            "price": "$0.20-1.50/hr (marketplace)",
            "features": "Cheapest, marketplace model, variable availability",
        },
        "colab_pro": {
            "name": "Google Colab Pro+",
            "gpus": ["A100 40GB", "T4", "V100"],
            "price": "$49.99/month",
            "features": "Notebooks, easy sharing, Google Drive integration",
        },
        "aws_sagemaker": {
            "name": "AWS SageMaker",
            "gpus": ["A100", "A10G", "T4"],
            "price": "$1.20-32.77/hr",
            "features": "Enterprise, managed training, MLOps integration",
        },
    }

    SETUP_SCRIPT = """
# setup_remote.sh — Remote GPU environment setup
#!/bin/bash

# Update and install basics
apt-get update && apt-get install -y git curl htop nvtop tmux

# Install Python packages
pip install --upgrade pip
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install transformers datasets accelerate peft trl bitsandbytes
pip install wandb tensorboard evaluate scikit-learn
pip install flash-attn --no-build-isolation

# Login to services
huggingface-cli login --token $HF_TOKEN
wandb login $WANDB_API_KEY

# Clone training repo
git clone https://github.com/company/llm-finetune.git
cd llm-finetune

# Download base model (cache)
python -c "from transformers import AutoModelForCausalLM; AutoModelForCausalLM.from_pretrained('meta-llama/Llama-3.1-8B-Instruct')"

echo "Setup complete!"
"""

    def show_providers(self):
        print("=== GPU Cloud Providers ===\n")
        for key, provider in self.PROVIDERS.items():
            print(f"[{provider['name']}]")
            print(f"  GPUs: {', '.join(provider['gpus'][:2])}")
            print(f"  Price: {provider['price']}")
            print()

    def show_setup(self):
        print("=== Setup Script ===")
        print(self.SETUP_SCRIPT[:400])

gpu = RemoteGPUSetup()
gpu.show_providers()
gpu.show_setup()

Experiment Tracking & Collaboration

# experiment.py — Experiment tracking for remote teams
import json
import random

class ExperimentTracking:
    TOOLS = {
        "wandb": {
            "name": "Weights & Biases (W&B)",
            "features": ["Experiment tracking", "Model registry", "Team dashboards", "Artifact versioning"],
            "price": "Free (personal), $50/user/month (team)",
        },
        "mlflow": {
            "name": "MLflow",
            "features": ["Experiment tracking", "Model registry", "Self-hosted", "Open source"],
            "price": "Free (self-hosted), Databricks managed",
        },
        "huggingface_hub": {
            "name": "Hugging Face Hub",
            "features": ["Model hosting", "Dataset hosting", "Spaces (demos)", "Collaboration"],
            "price": "Free (public), $9/month (private)",
        },
    }

    WANDB_INTEGRATION = """
# wandb_tracking.py — W&B experiment tracking
import wandb

# Initialize
wandb.init(
    project="llm-finetune",
    name="lora-r16-llama3-thai",
    config={
        "model": "meta-llama/Llama-3.1-8B-Instruct",
        "lora_r": 16,
        "lora_alpha": 32,
        "learning_rate": 2e-4,
        "epochs": 3,
        "batch_size": 4,
        "dataset": "thai-instruction-50k",
        "gpu": "A100-80GB",
    },
    tags=["lora", "thai", "llama3"],
)

# Log metrics during training (automatic with TrainingArguments report_to="wandb")
# Manual logging:
wandb.log({"eval/loss": 0.85, "eval/accuracy": 0.92, "step": 1000})

# Log model artifact
artifact = wandb.Artifact("lora-adapter", type="model")
artifact.add_dir("./lora-adapter")
wandb.log_artifact(artifact)

wandb.finish()
"""

    def show_tools(self):
        print("=== Experiment Tracking Tools ===\n")
        for key, tool in self.TOOLS.items():
            print(f"[{tool['name']}]")
            print(f"  Features: {', '.join(tool['features'][:3])}")
            print(f"  Price: {tool['price']}")
            print()

    def show_wandb(self):
        print("=== W&B Integration ===")
        print(self.WANDB_INTEGRATION[:500])

    def experiment_dashboard(self):
        print(f"\n=== Experiment Dashboard ===")
        experiments = [
            {"name": "lora-r8-llama3", "loss": f"{random.uniform(0.5, 1.2):.3f}", "acc": f"{random.uniform(0.80, 0.95):.2f}", "gpu_hrs": f"{random.uniform(1, 8):.1f}h"},
            {"name": "lora-r16-llama3", "loss": f"{random.uniform(0.4, 1.0):.3f}", "acc": f"{random.uniform(0.85, 0.96):.2f}", "gpu_hrs": f"{random.uniform(2, 12):.1f}h"},
            {"name": "lora-r32-llama3", "loss": f"{random.uniform(0.3, 0.9):.3f}", "acc": f"{random.uniform(0.87, 0.97):.2f}", "gpu_hrs": f"{random.uniform(4, 16):.1f}h"},
            {"name": "qlora-r16-mistral", "loss": f"{random.uniform(0.4, 1.1):.3f}", "acc": f"{random.uniform(0.82, 0.94):.2f}", "gpu_hrs": f"{random.uniform(1, 6):.1f}h"},
        ]
        print(f"  {'Name':<25} {'Loss':>8} {'Acc':>6} {'GPU Hours':>10}")
        for e in experiments:
            print(f"  {e['name']:<25} {e['loss']:>8} {e['acc']:>6} {e['gpu_hrs']:>10}")

exp = ExperimentTracking()
exp.show_tools()
exp.show_wandb()
exp.experiment_dashboard()

Dataset Preparation

# dataset.py — Dataset preparation for fine-tuning
import json

class DatasetPrep:
    FORMATS = {
        "instruction": {
            "name": "Instruction Format (Alpaca-style)",
            "example": '{"instruction": "แปลภาษาอังกฤษเป็นไทย", "input": "Hello world", "output": "สวัสดีชาวโลก"}',
        },
        "chat": {
            "name": "Chat Format (ChatML)",
            "example": '{"messages": [{"role": "system", "content": "คุณเป็น AI ผู้ช่วย"}, {"role": "user", "content": "Python คืออะไร"}, {"role": "assistant", "content": "Python เป็นภาษาโปรแกรม..."}]}',
        },
        "completion": {
            "name": "Completion Format",
            "example": '{"text": "[INST] คำถาม [/INST] คำตอบ"}',
        },
    }

    PREP_SCRIPT = """
# prepare_dataset.py — Dataset preparation
import json
from datasets import Dataset

def prepare_chat_dataset(input_file, output_file):
    data = []
    with open(input_file) as f:
        for line in f:
            item = json.loads(line)
            
            # Format as chat template
            messages = item.get("messages", [])
            if not messages:
                messages = [
                    {"role": "system", "content": "คุณเป็น AI ผู้ช่วยภาษาไทย ตอบคำถามอย่างถูกต้องและเป็นประโยชน์"},
                    {"role": "user", "content": item.get("instruction", "") + " " + item.get("input", "")},
                    {"role": "assistant", "content": item.get("output", "")},
                ]
            
            # Apply chat template
            text = ""
            for msg in messages:
                if msg["role"] == "system":
                    text += f"<|system|>\\n{msg['content']}\\n"
                elif msg["role"] == "user":
                    text += f"