Fine-tune LLM siêu tốc: Hướng dẫn dùng thư viện Unsloth (Python) để huấn luyện Llama 3 theo văn phong riêng miễn phí

[AI Hunter]

Fine-tune LLM siêu tốc: Hướng dẫn dùng thư viện Unsloth (Python) để huấn luyện Llama 3 theo văn phong riêng miễn phí

Bạn muốn có một trợ lý AI viết code theo chuẩn của công ty?
Hay một AI chatbot nói chuyện "xéo xắt" theo phong cách Gen Z thay vì giọng văn nghiêm túc của ChatGPT?

Giải pháp là **Fine-tuning (Tinh chỉnh)**.
Tuy nhiên, Fine-tuning thường đắt đỏ và chậm chạp. Đó là lý do **Unsloth** ra đời. Đây là thư viện Python tối ưu hóa việc tính toán đạo hàm, giúp bạn huấn luyện Llama 3 (8B) nhanh gấp 2-5 lần và nhét vừa vặn vào bộ nhớ VRAM khiêm tốn của Google Colab (T4 GPU).

1. Tại sao lại là Unsloth?​

• Siêu nhanh: Viết lại các kernel của GPU (trên OpenAI Triton) giúp quá trình Backpropagation nhanh chóng mặt.
• Tiết kiệm VRAM: Giảm tới 60% bộ nhớ sử dụng nhờ kỹ thuật lượng tử hóa thông minh.
• Hỗ trợ LoRA: Chỉ huấn luyện 1% trọng số của model (Low-Rank Adaptation) nhưng hiệu quả tương đương huấn luyện toàn bộ.

2. Chuẩn bị môi trường​

Tốt nhất bạn nên chạy trên **Google Colab (chọn Runtime type là T4 GPU)**.

# Cài đặt Unsloth và các thư viện hỗ trợ
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps xformers trl peft accelerate bitsandbytes

3. Triển khai Code (Python)​

Tạo file notebook finetune_llama3.ipynb.

Bước 1: Load Model & Tokenizer​

Chúng ta sẽ load Llama-3-8b ở chế độ 4-bit để tiết kiệm RAM.

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048
dtype = None # Tự động phát hiện (Float16 cho T4/V100, Bfloat16 cho Ampere)
load_in_4bit = True # QUAN TRỌNG: Giảm bộ nhớ xuống 4 lần

print("⏳ Đang tải Llama 3...")
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/llama-3-8b-bnb-4bit", # Bản đã tối ưu 4-bit
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
)

# Thêm adapter LoRA (Đây là phần chúng ta sẽ train)
model = FastLanguageModel.get_peft_model(
    model,
    r = 16, # Rank càng cao train càng kỹ nhưng tốn VRAM
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 16,
    lora_dropout = 0, # Đặt bằng 0 để tối ưu tốc độ
    bias = "none",
    use_gradient_checkpointing = "unsloth", # Tối ưu hóa cực mạnh của Unsloth
    random_state = 3407,
)

Bước 2: Chuẩn bị dữ liệu (Dataset)​

Giả sử bạn muốn dạy AI trả lời theo phong cách "Chuyên gia Python". Dữ liệu cần định dạng JSONL.

from datasets import Dataset

# Dữ liệu mẫu (Instruction - Input - Output)
data = [
    {
        "instruction": "Viết hàm tính tổng trong Python.",
        "input": "",
        "output": "Dĩ nhiên. Dùng `sum()` hoặc vòng lặp. Đây là cách Pythonic nhất:\n```python\ndef calc_sum(lst):\n    return sum(lst)\n```"
    },
    {
        "instruction": "Giải thích GIL là gì?",
        "input": "",
        "output": "Global Interpreter Lock (GIL) là cơ chế khóa của CPython, ngăn chặn đa luồng chạy song song thực sự trên một core CPU. Nó là 'đặc sản' gây tranh cãi nhất của Python."
    }
]

# Định dạng prompt theo chuẩn Alpaca
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.

### Instruction:
{}

### Input:
{}

### Response:
{}"""

def formatting_prompts_func(examples):
    instructions = examples["instruction"]
    inputs       = examples["input"]
    outputs      = examples["output"]
    texts = []
    for i, inp, out in zip(instructions, inputs, outputs):
        text = alpaca_prompt.format(i, inp, out) + tokenizer.eos_token
        texts.append(text)
    return { "text" : texts, }

dataset = Dataset.from_list(data)
dataset = dataset.map(formatting_prompts_func, batched = True)

Bước 3: Bắt đầu Huấn luyện (Training)​

Sử dụng `SFTTrainer` (Supervised Fine-tuning Trainer) từ thư viện TRL.

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,
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        max_steps = 60, # Demo chạy 60 bước (Thực tế cần khoảng 500-1000)
        learning_rate = 2e-4,
        fp16 = not torch.cuda.is_bf16_supported(),
        bf16 = torch.cuda.is_bf16_supported(),
        logging_steps = 1,
        optim = "adamw_8bit", # Optimizer 8-bit tiết kiệm bộ nhớ
        output_dir = "outputs",
    ),
)

print("🚀 Bắt đầu Fine-tune...")
trainer.train()

Bước 4: Chạy thử (Inference) và Lưu model​

Sau khi train xong, bạn có thể hỏi thử ngay lập tức.

# Chuyển sang chế độ Inference
FastLanguageModel.for_inference(model)

inputs = tokenizer(
    [
        alpaca_prompt.format(
            "Làm sao để đọc file CSV trong Python?", # Instruction
            "", # Input
            "", # Output (để trống cho AI điền)
        )
    ], return_tensors = "pt").to("cuda")

outputs = model.generate(**inputs, max_new_tokens = 64, use_cache = True)
print(tokenizer.batch_decode(outputs))

# Lưu Model (chỉ lưu Adapter LoRA cho nhẹ, khoảng 100MB)
model.save_pretrained("lora_model")
print("✅ Đã lưu model thành công!")

4. Kết quả​

Nếu bạn cung cấp đủ dữ liệu (khoảng 500-1000 dòng), model sẽ bắt chước văn phong và kiến thức đặc thù của bạn cực tốt. Thời gian train trên Colab T4 chỉ mất khoảng 15-30 phút cho một dataset nhỏ.

Kết luận​

Unsloth đã "bình dân hóa" việc training AI. Giờ đây, sức mạnh để tạo ra các mô hình ngôn ngữ chuyên biệt không còn nằm độc quyền trong tay các ông lớn công nghệ nữa, mà nằm ngay trên laptop của bạn.