# Mô hình trả lời đúng, test LLM vẫn đỏ

> So khớp chuỗi gãy trước những biến thể hợp lệ; assert theo thuộc tính như cấu trúc JSON hay số kết quả, ngay trong pytest, sẽ sửa được.

Bản gốc: https://fdetimes.net/vi/bach-khoa/thuc-hanh-kiem-thu-dau-ra-llm-bang-pytest-theo-thuoc-tinh/

Mô hình trả về `{"listings":[{"id":42}]}`, đúng căn hộ người dùng cần, và test vẫn đỏ, vì đáp án mẫu có thêm dấu cách sau dấu hai chấm. Dữ liệu đúng hoàn toàn. Chỗ hỏng nằm ở bài test.

Cái bẫy này dễ sa vào vì bạn quen viết unit test có một đáp án đúng duy nhất. Thế là bạn tự nhiên đem output của LLM so với một chuỗi mẫu.

Nhóm kỹ sư của Anthropic gọi thẳng điểm yếu của cách làm này: grader viết bằng code dễ gãy trước những biến thể hợp lệ không khớp đúng mẫu đã định.

Cách sửa dùng ngay công cụ bạn đã quen. Hamel Husain, trong bài viết về eval cho sản phẩm AI, định nghĩa unit test cho LLM đơn giản là các assertion, giống như khi viết pytest. Cái cần thay đổi là thứ bạn assert, còn công cụ thì giữ nguyên.

## Bạn sẽ xây gì, cần chuẩn bị gì?

Ví dụ xuyên suốt lấy cảm hứng từ bài viết của Husain: một tính năng tìm nhà đất, người dùng gõ câu hỏi tự nhiên, LLM trả về danh sách bất động sản.

Bạn sẽ viết năm test qua năm bước, bắt đầu từ một test so khớp chuỗi để thấy nó hỏng ra sao. Kịch bản chính: người dùng tìm theo đúng một địa chỉ thì phải nhận về đúng một kết quả.

Bạn cần Python, pytest và một hàm gọi LLM bất kỳ. Đoạn code dưới đây đã được rút gọn. Hàm `call_model` là chỗ để bạn cắm client thật của mình vào.

```python
# llm_app.py — bản rút gọn, thay call_model bằng client thật
def call_model(prompt: str) -> str:
    raise NotImplementedError("Gọi LLM của bạn ở đây")

def search_listings(query: str) -> str:
    prompt = ('Trả về JSON dạng {"listings": [...]} '
              f"cho truy vấn: {query}")
    return call_model(prompt)
```

## Bước 1: nhìn rõ vì sao so khớp chuỗi thất bại

Tài liệu của Anthropic mô tả exact match đúng như cách nhiều người đang làm: so output với một đáp án đúng định sẵn, thường sau khi chuẩn hoá khoảng trắng và chữ hoa thường. Đoạn test dưới đây làm đúng như vậy.

```python
GOLDEN = '{"listings": [{"id": 42}]}'

def test_exact_match():
    out = search_listings("căn hộ số 12 đường A")
    assert out.strip().lower() == GOLDEN.strip().lower()
```

Lưu ý rằng `strip()` chỉ cắt khoảng trắng ở hai đầu chuỗi, còn dấu cách bên trong JSON vẫn giữ nguyên. Vì thế bản JSON viết liền ở đầu bài vẫn không khớp với đáp án mẫu.

**Kiểm tra:** cho `call_model` tạm trả về `'{"listings":[{"id":42}]}'` (không có dấu cách) và test sẽ đỏ. Đến khi mô hình tự thêm một trường `"price"` thì test cũng đỏ theo. Vì vậy bạn giữ test này lại chỉ để nhắc mình đừng viết kiểu đó nữa.

## Bước 2: test cấu trúc trước, vì nó rẻ nhất

Theo một bài phân tích về property-based testing cho LLM trên blog tianpan.co, tính chất dễ kiểm tra nhất là cấu trúc. Ví dụ quen thuộc là output phải là JSON hợp lệ. Việc kiểm tra này không cần gọi thêm LLM nào để chấm.

```python
import json

def test_output_is_valid_json():
    raw = search_listings("căn hộ số 12 đường A")
    data = json.loads(raw)  # ném lỗi nếu không phải JSON
    assert "listings" in data
    assert isinstance(data["listings"], list)
```

**Kiểm tra:** cho `call_model` trả về `'Tìm thấy 1 căn'` và test phải đỏ vì `json.loads` báo lỗi. Đổi sang JSON có hoặc không có dấu cách thì test đều xanh. Từ đây bộ test của bạn không còn phụ thuộc vào định dạng chuỗi.

## Bước 3: assert thuộc tính theo từng kịch bản

Husain khuyên nên chia phạm vi LLM thành các tính năng và kịch bản, đừng dùng một phép kiểm tra chung cho tất cả. Ví dụ của ông cho tìm kiếm bất động sản chỉ cần một dòng: `len(listing_array) == 1`.

```python
def test_exact_address_returns_one_listing():
    data = json.loads(search_listings("căn hộ số 12 đường A"))
    assert len(data["listings"]) == 1
```

Hãy để ý test này không quan tâm mô hình viết mô tả căn hộ ra sao. Nó chỉ khẳng định điều mà người dùng thật sự cần: tìm đúng địa chỉ thì không được ra năm căn, cũng không được ra danh sách rỗng. Kịch bản khác sẽ có thuộc tính khác. Chẳng hạn truy vấn mơ hồ có thể phải trả về nhiều hơn một kết quả.

**Điểm mấu chốt:** Hãy kiểm tra đầu ra có đúng tính chất cần có, đừng đòi nó đúng từng chữ.

## Bước 4: một lần chạy chưa nói lên điều gì

Bước 3 xanh chưa có nghĩa là xong. Nhóm của Anthropic cảnh báo một tác vụ đạt ở lần chạy eval này vẫn có thể trượt ở lần sau, vì LLM không tất định. Bài viết trên tianpan.co đề xuất chạy mỗi test nhiều lần và đòi một tỉ lệ đạt tối thiểu, ví dụ phải đạt 8 trên 10 lần chạy.

```python
RUNS = 10
MIN_PASS = 8

def passes_once(query: str) -> bool:
    try:
        data = json.loads(search_listings(query))
    except json.JSONDecodeError:
        return False
    return len(data.get("listings", [])) == 1

def test_exact_address_pass_rate():
    ok = sum(passes_once("căn hộ số 12 đường A") for _ in range(RUNS))
    assert ok >= MIN_PASS, f"chỉ đạt {ok}/{RUNS} lần"
```

Thử tính một ví dụ. Mười lần chạy có 7 lần ra đúng một căn, 2 lần ra hai căn và 1 lần trả về văn bản thay vì JSON.

Như vậy là 7/10, tức 70%, dưới ngưỡng 8, nên test đỏ kèm thông báo "chỉ đạt 7/10 lần". Con số này có ích hơn nhiều so với một test chập chờn lúc xanh lúc đỏ mà không ai giải thích được.

**Kiểm tra:** chạy test này hai lần liền với mô hình thật. Nếu kết quả dao động quanh ngưỡng thì bạn vừa đo được độ ổn định thật của tính năng.

## Ngưỡng 8/10 do ai quyết định?

Kỹ sư không nên tự chốt con số này. Husain viết rằng tỉ lệ đạt là một quyết định sản phẩm, tuỳ vào những lỗi bạn chấp nhận được. Unit test truyền thống đòi 100%, còn ở đây ngưỡng phản ánh chuyện kinh doanh. Tìm nhà sai một căn có thể chấp nhận được, còn tóm tắt hợp đồng sai một điều khoản thì không.

Cũng đừng nhầm tỉ lệ đạt với pass@k. Theo Anthropic, pass@k đo xác suất có ít nhất một lời giải đúng trong k lần thử. Chỉ số này hợp khi người dùng được thử lại hoặc hệ thống tự chọn kết quả tốt nhất.

Với tính năng chỉ trả lời một lần, chạy 10 lần mà có một lần đúng đã đủ cho pass@10, nhưng người dùng thì nhận về 9 câu sai. Đó là lý do ví dụ ở bước 4 đếm số lần đạt thay vì dùng pass@k.

## Bước 5: khi thuộc tính là ý nghĩa, không phải cấu trúc

Có những tính chất không thể đếm được, ví dụ "bản diễn đạt lại phải giữ nguyên ý". Bài viết trên tianpan.co gợi ý so độ tương đồng embedding và assert từ 0.8 trở lên.

Cần hiểu 0.8 chỉ là ngưỡng kinh nghiệm, bạn phải hiệu chỉnh trên dữ liệu của chính mình. Đoạn dưới là giả mã, `similarity` là hàm bạn tự viết bằng mô hình embedding đang dùng.

```python
# Giả mã: similarity() do bạn tự cài đặt
def test_paraphrase_keeps_meaning():
    original = "Căn hộ 2 phòng ngủ gần trường học"
    rewritten = rewrite(original)
    assert similarity(original, rewritten) >= 0.8
```

Cùng bài viết đó dùng thư viện Hypothesis của Python để sinh đầu vào tự động, giúp tìm ra những lỗi mà bộ eval viết tay không nghĩ tới. Hãy để bước này sau cùng. Khi bước 2 và bước 4 còn chưa ổn định thì việc sinh thêm đầu vào chỉ làm bạn có thêm test đỏ.

## Những lỗi hay gặp

Lỗi đầu tiên là gom mọi thứ vào một test khổng lồ. Khi test đó đỏ, bạn không biết kịch bản nào hỏng, vì thế hãy viết mỗi kịch bản một test như Husain khuyên.

Lỗi thứ hai là để ngoại lệ JSON làm sập cả vòng lặp ở bước 4. Một lần mô hình trả về văn bản phải được tính là một lần trượt, không được làm dừng cả lượt chạy.

Lỗi thứ ba khó thấy hơn: vội vàng gọi LLM ra để chấm. Anthropic khuyên nên thiết kế câu hỏi sao cho chấm tự động được bằng code ở mức tối đa. Kiểm tra JSON và đếm phần tử thì rẻ, nhanh, và kết quả không dao động giữa các lần chấm.

## Kỹ năng này xuất hiện ở đâu khi làm cho khách hàng?

Hãy hình dung tuần thứ hai của một engagement. Khách hàng hỏi "bot có ổn không?", và câu trả lời mơ hồ sẽ làm mất lòng tin.

Với bộ test ở trên, bạn có thể nói cụ thể: kịch bản tìm theo địa chỉ đạt 7/10 lần, nhóm có muốn chấp nhận mức này hay cần 9/10?

Câu hỏi đó biến một cảm giác thành một quyết định sản phẩm có người chịu trách nhiệm.

Khi đưa kỹ năng này vào CV, thay vì ghi "viết test cho tính năng AI", hãy ghi rõ bạn đã chuyển test so khớp chuỗi sang assert thuộc tính, đặt ngưỡng tỉ lệ đạt cùng khách hàng, và tỉ lệ đó đã thay đổi thế nào sau khi sửa prompt.

Một repo nhỏ với năm bước trên là bằng chứng dễ mang vào phỏng vấn.

Khi đọc lại một test đang đỏ, đừng vội hỏi mô hình sai ở đâu. Trước hết hãy xem test có đang đòi mô hình làm một việc mà người dùng thật ra không cần hay không.

**Thử ngay tuần này:**

- Chọn một tính năng LLM bạn đang làm, liệt kê ba kịch bản và viết một assert thuộc tính cho mỗi kịch bản.
- Bọc một test trong vòng lặp 10 lần, ghi lại tỉ lệ đạt thực tế rồi mang con số đó vào buổi họp với khách hàng.
- Thay một test so khớp chuỗi trong repo bằng test kiểm tra JSON hợp lệ và trường bắt buộc.

## Nguồn

- [Your AI Product Needs Evals](https://hamel.dev/blog/posts/evals/)

- [Define success criteria and build evaluations](https://platform.claude.com/docs/en/test-and-evaluate/develop-tests)

- [Demystifying evals for AI agents](https://anthropic.com/engineering/demystifying-evals-for-ai-agents)

- [Property-Based Testing for LLM Outputs: Finding the Bugs Your Eval Set Never Imagined](https://tianpan.co/blog/2026-04-17-property-based-testing-llm-outputs)
