Tối ưu hóa chất lượng dữ liệu cho huấn luyện LLM với thư viện trl

Trong quy trình huấn luyện các mô hình ngôn ngữ lớn, độ tinh khiết và tính chính xác của tập dữ liệu đóng vai trò quyết định đến năng lực cuối đầu ra. Thư viện trl (Transformer Reinforcement Learning) từ Hugging Face cung cấp bộ công cụ mạnh mẽ để tích hợp các bước tiền xử lý, lọc và giám sát dữ liệu trước khi đưa vào các thuật toán tinh chỉnh như SFT hoặc DPO.

1. Ba trụ cột đánh giá chất lượng bộ dữ liệu

Trước khi chạy mô hình, cần thiết lập các tiêu chuẩn rõ ràng để sàng lọc thông tin:

• Tính liên quan (Relevance): Mức độ phù hợp giữa nội dung dữ liệu và nhiệm vụ mục tiêu. Dữ liệu ngoài chuyên ngành dễ gây nhiễu ngữ cảnh.
• Độ đồng nhất (Consistency): Sự thống nhất trong cấu trúc prompt, định dạng nhãn và quy tắc ghi chú. Thiếu đồng nhất sẽ làm mất ổn định quá trình cập nhật trọng số.
• Độ tinh khiết (Purity): Loại bỏ các mẫu bị cắt xén, chứa mã độc, nội dung độc hại hoặc trùng lặp thừa. Dữ liệu sạch giúp mô hình hội tụ nhanh hơn và tránh ghi nhớ mẫu (memorization).

2. Quy trình tiền xử lý và lọc dữ liệu tích hợp

Thay vì chỉ dựa vào lệnh dòng lệnh, việc cấu hình trực tiếp qua đối số Python giúp kiểm soát chặt chẽ hơn pipeline dữ liệu. Dưới đây là cách thiết lập bộ lọc cơ bản kết hợp với SFTTrainer:

from datasets import load_dataset
from trl import SFTConfig, SFTTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

raw_corpus = load_dataset("imdb", split="train[:5000]")

def prepare_and_filter(examples):
    cleaned = []
    lengths = []
    for text in examples["text"]:
        normalized = " ".join(text.lower().strip().split())
        if len(normalized.split()) > 20:
            cleaned.append(normalized)
            lengths.append(len(normalized.split()))
        else:
            cleaned.append("")
            lengths.append(0)
    return {"text_clean": cleaned, "token_count": lengths}

processed_corpus = raw_corpus.map(prepare_and_filter, batched=True)
filtered_corpus = processed_corpus.filter(lambda x: x["token_count"] > 0)

training_args = SFTConfig(
    model_name_or_path="microsoft/phi-2",
    dataset_text_field="text_clean",
    output_dir="./sft_outputs",
    per_device_train_batch_size=4,
    max_steps=100
)

model = AutoModelForCausalLM.from_pretrained("microsoft/phi-2")
tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-2")
tokenizer.pad_token = tokenizer.eos_token

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    args=training_args,
    train_dataset=filtered_corpus
)

Việc định nghĩa hàm tiền xử lý cho phép linh hoạt áp dụng biểu thức chính quy, kiểm tra độ dài token, hoặc gán nhãn trước khi dữ liệu được chuyển vào bộ đệm huấn luyện.

3. Chiến lược đánh giá và loại bỏ mẫu lỗi

Mặc dù trl tập trung vào cơ chế huấn luyện, nhưng việc xây dựng lớp kiểm soát chất lượng có thể thực hiện qua các phương pháp sau:

• Lọc dựa trên ngưỡng: Sử dụng tính năng .filter() của thư viện datasets để giữ lại các bản ghi thỏa mãn điều kiện ngữ pháp hoặc độ dài token tối thiểu.
• Đánh giá bằng mô hình phụ trợ: Tính toán độ bất ngờ (perplexity) hoặc entropy của câu đầu vào bằng một mô hình ngôn ngữ cơ bản. Các mẫu có điểm số quá cao thường là tiếng ồn hoặc văn bản tự động tạo kém chất lượng.
• Lấy mẫu xác thực: Tách một phân vùng kiểm thử nhỏ (train_test_split) để đánh giá thủ công tỷ lệ mẫu lỗi trước khi mở rộng quy mô toàn bộ tập dữ liệu.

4. Áp dụng thực tế cho huấn luyện tối ưu hóa ưu tiên trực tiếp (DPO)

Thuật toán DPO cực kỳ nhạy cảm với cấu trúc cặp dữ liệu. Một sai sót nhỏ trong định dạng có thể dẫn đến việc mô hình học ngược ý định. Quy trình chuẩn bị dữ liệu cho DPO cần tập trung vào ba điểm:

def validate_dpo_records(batch):
    valid_rows = []
    for item in batch:
        chosen_text = str(item.get("chosen", "")).strip()
        rejected_text = str(item.get("rejected", "")).strip()
        
        if chosen_text and rejected_text:
            if len(rejected_text) <= len(chosen_text) * 2.5:
                valid_rows.append(True)
            else:
                valid_rows.append(False)
        else:
            valid_rows.append(False)
    return {"is_valid": valid_rows}

cleaned_dpo_data = dpo_dataset.map(validate_dpo_records, batched=True)
final_dpo_set = cleaned_dpo_data.filter(lambda x: x["is_valid"])

Đoạn mã trên minh họa cách kiểm tra tính hợp lệ của cặp dữ liệu, đồng thời loại bỏ các trường hợp chênh lệch độ dài bất thường gây lệch gradient. Ngoài ra, cần thường xuyên kiểm tra phân bố độ dài prompt và label để cân bằng batch huấn luyện.

5. Giám sát liên tục và vòng lặp cải tiến

Chất lượng dữ liệu không dừng lại ở bước tiền xử lý ban đầu. Hệ thống logging tích hợp trong trl cho phép theo dõi các chỉ số như phân phối chiều dài sequence, tốc độ mất mát (loss spike) bất thường hay chênh lệch hiệu năng giữa tập train/validation. Khi phát hiện gradient dao động mạnh ở các epoch cụ thể, hãy truy vết ngược lại để xác định nhóm mẫu dữ liệu gây nhiễu.

Để đảm bảo khả năng tái tạo, nên tích hợp công cụ quản lý phiên bản dữ liệu như DVC hoặc hệ thống lên version trên Hugging Face Hub. Xây dựng pipeline tự động bao gồm các bước: tải raw data -> chạy bộ lọc cấu trúc -> tính điểm chất lượng -> tách tập tin -> ghi log phiên bản, sẽ giúp quy trình tinh chỉnh trở nên ổn định và có thể mở rộng.

6. Nguyên tắc vàng khi làm việc với dữ liệu LLM

• Ưu tiên chất lượng hơn số lượng: Một tập mẫu được kiểm chứng chặt chẽ thường cho kết quả vượt trội so với tập dữ liệu hỗn độn có quy mô lớn.
• Định hướng theo miền ứng dụng: Không dùng dữ liệu tổng hợp cho các tác vụ chuyên sâu. Hãy thu thập hoặc sinh dữ liệu gắn liền với ngữ cảnh nghiệp vụ thực tế.
• Lặp lại dựa trên phản hồi: Đánh giá đầu ra mô hình sau mỗi lần train, trích xuất các lỗi hệ thống và bổ sung dữ liệu đối chứng vào vòng lặp tiếp theo.