Vision AI 2026: Dạy LLaVA "nhìn" ra lỗi sản phẩm trên dây chuyền (Fine-tuning VLM)

[AI Hunter]

Bạn là giám đốc sản xuất. Dây chuyền lắp ráp điện thoại của bạn đang có tỷ lệ lỗi 5%. Thuê công nhân ngồi soi kính lúp thì chậm và tốn kém. Dùng camera công nghiệp truyền thống (CV cổ điển) thì khó cài đặt với các lỗi phức tạp.

Giải pháp 2026: Dùng **Multimodal AI (AI đa phương thức)**.
Chúng ta sẽ lấy mô hình **LLaVA** (Large Language and Vision Assistant - mô hình vừa hiểu ảnh vừa hiểu chữ), và dạy cho nó biết thế nào là một sản phẩm "lỗi" trong dây chuyền cụ thể của bạn.

1. LLaVA hoạt động thế nào?​

LLaVA thực chất là sự kết hợp của 2 phần:

• Vision Encoder (Đôi mắt): Thường là mô hình CLIP của OpenAI, nhiệm vụ biến bức ảnh thành các vector số.
• Language Model (Bộ não): Thường là Llama hoặc Vicuna, nhiệm vụ nhận vector ảnh và câu hỏi của bạn, rồi sinh ra câu trả lời.

Khi Fine-tune LLaVA, chúng ta chủ yếu dạy "Bộ não" cách diễn giải thông tin từ "Đôi mắt" theo nghiệp vụ cụ thể (ví dụ: nhìn vết xước trên màn hình).

2. Chuẩn bị dữ liệu (Phần khó nhất)​

Khác với fine-tune text, dữ liệu vision phức tạp hơn. Bạn cần cặp Hình ảnh + Hội thoại JSON.

Ví dụ: Bạn muốn dạy AI phát hiện lỗi trên bo mạch (PCB).
File `train.json`:

[
  {
    "id": "pcb_error_001",
    "image": "images/pcb_ng_1.jpg", // Đường dẫn tới ảnh bị lỗi
    "conversations": [
      {
        "from": "human",
        "value": "<image>\nHãy kiểm tra bo mạch này và liệt kê các lỗi nếu có."
      },
      {
        "from": "gpt",
        "value": "Phát hiện lỗi: Thiếu linh kiện tụ điện tại vị trí C12. Mối hàn tại chân IC U3 bị nứt."
      }
    ]
  },
  {
    "id": "pcb_good_002",
    "image": "images/pcb_ok_1.jpg", // Ảnh sản phẩm tốt
    "conversations": [
      {
        "from": "human",
        "value": "<image>\nBo mạch này có đạt chuẩn không?"
      },
      {
        "from": "gpt",
        "value": "Bo mạch đạt chuẩn. Không phát hiện lỗi visible nào."
      }
    ]
  }
]

*Mẹo: Bạn cần khoảng 100-200 ảnh mẫu (cả tốt và xấu) để đạt hiệu quả ban đầu.*

3. Thực hành Fine-tuning (Dùng Unsloth trên Colab)​

Unsloth là cứu tinh cho GPU yếu. Nó giúp train VLM nhanh hơn và tốn ít VRAM hơn.

Bước 1: Cài đặt môi trường​

# Cài đặt Unsloth phiên bản hỗ trợ Vision
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps "xformers<0.0.27" "trl<0.9.0" peft accelerate bitsandbytes

Bước 2: Load Model LLaVA (4-bit)​

Chúng ta dùng phiên bản LLaVA 1.5 7B (đủ nhẹ cho Colab T4).

from unsloth import FastVisionModel # Lưu ý dùng FastVisionModel
import torch

# Load model và tokenizer
model, tokenizer = FastVisionModel.from_pretrained(
    "unsloth/llava-v1.6-mistral-7b-hf", # Hoặc llava-1.5-7b-hf
    load_in_4bit = True, # Quan trọng để chạy trên T4 GPU
    use_gradient_checkpointing = True,
)

# Thêm LoRA Adapters cho cả phần Vision và Language
model = FastVisionModel.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,
    bias = "none",
    use_gradient_checkpointing = True,
    random_state = 3407,
    use_rslora = False,
    loftq_config = None,
)

Bước 3: Load Dataset và Train​

(Phần code xử lý dataset vision khá dài, tôi sẽ tóm lược phần chính dùng `SFTTrainer` của thư viện `trl` đã được Unsloth tối ưu).

from trl import SFTTrainer, SFTConfig

# Cấu hình tham số train
training_args = SFTConfig(
    output_dir = "llava_defect_detection",
    per_device_train_batch_size = 2,
    gradient_accumulation_steps = 4,
    warmup_steps = 5,
    max_steps = 60, # Train demo nhanh (Tăng lên với dữ liệu thật)
    learning_rate = 2e-4,
    fp16 = not torch.cuda.is_bf16_supported(),
    bf16 = torch.cuda.is_bf16_supported(),
    logging_steps = 1,
    optim = "adamw_8bit",
    seed = 3407,
    remove_unused_columns = False,
    dataset_text_field = "", # Vision dataset xử lý khác text thuần
    dataset_kwargs = {"skip_prepare_dataset": True}, # Bỏ qua bước chuẩn bị mặc định
)

# Khởi tạo Trainer
trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = YOUR_VISION_DATASET, # Biến chứa dataset đã load ở trên
    args = training_args,
    # ... các cấu hình data collator chuyên biệt cho vision ...
)

# Bắt đầu train
trainer.train()

Bước 4: Kiểm tra thành quả (Inference)​

Sau khi train xong, hãy đưa cho nó một bức ảnh bo mạch lỗi mới mà nó chưa từng thấy.

from PIL import Image

# Load ảnh test
image = Image.open("test_images/pcb_ng_new.jpg")
instruction = "<image>\nHãy kiểm tra bo mạch này."

# Chạy model
FastVisionModel.for_inference(model) # Tối ưu cho inference
inputs = tokenizer(
    [instruction],
    images=[image],
    return_tensors="pt",
    padding=True
).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=128, use_cache=True)
print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])

Kết quả mong đợi: AI sẽ chỉ đích danh vị trí lỗi thay vì mô tả chung chung.

Kết luận​

Fine-tuning Multimodal AI đang mở ra một kỷ nguyên mới cho tự động hóa công nghiệp. Không chỉ là nhìn thấy, AI giờ đây có thể "hiểu" được các lỗi phức tạp trong sản xuất mà trước đây chỉ mắt người mới nhận ra được.