Bài 28: Self-consistency và Tree-of-Thoughts (intro)

Sau bài học, bạn sẽ:

• Phân biệt được CoT (Bài 27), Self-Consistency và Tree-of-Thoughts về cơ chế và mục đích.
• Giải thích được vì sao Self-Consistency cải thiện accuracy: nhiều đường reasoning hội tụ về đáp án đúng.
• Biết bốn thành phần của ToT: thought decomposition, thought generator, state evaluator, search algorithm.
• Đọc được kết quả gốc Wang 2022 (GSM8K 56% → 74%) và Yao 2023 (Game of 24 4% → 74%).
• Ước lượng được chi phí của Self-Consistency và ToT so với CoT đơn lẻ.
• Quyết định được khi nào nên dùng Self-Consistency, khi nào ToT, khi nào nên chuyển hẳn sang reasoning model (o1, o3, R1, Claude thinking).
• Implement được Self-Consistency với asyncio parallel cho task math / classification.

Chain-of-Thought (Bài 27) đã giúp LLM trả lời tốt hơn ở task reasoning bằng cách yêu cầu suy nghĩ từng bước. Nhưng CoT một lần vẫn có hai hạn chế rõ:

• Một chuỗi reasoning có thể sai ở một bước — sai số tích luỹ, đáp án cuối sai theo.
• Không có cơ chế tự sửa — model "đi thẳng" từ đầu đến cuối, không quay lại đánh giá lại các nhánh khác.

Hai hướng cải thiện chính:

• Sample nhiều chuỗi rồi vote → Self-Consistency.
• Khám phá nhiều nhánh có đánh giá / tỉa cành → Tree-of-Thoughts, Graph-of-Thoughts.

Cả hai đều phải trả giá bằng cost và latency. Cùng giai đoạn, dòng reasoning model (o1, R1, Claude thinking) chọn cách "đẩy search vào trong model" — phần cuối bài sẽ so sánh.

Self-Consistency (Wang et al., "Self-Consistency Improves Chain of Thought Reasoning in Language Models", arXiv:2203.11171, 2022) là biến thể của CoT với 4 bước:

• Soạn 1 prompt CoT bình thường (zero-shot CoT "Let's think step by step" hoặc few-shot CoT).
• Gọi model N lần với cùng prompt, temperature > 0 (thường 0.5 - 0.8) để mỗi lần ra một chuỗi reasoning khác nhau. N hay dùng: 5, 10, 20, 40.
• Extract đáp án cuối ở mỗi lần.
• Lấy majority vote — đáp án xuất hiện nhiều nhất chính là output cuối cùng.

So với CoT đơn lẻ thường dùng temperature=0 (deterministic), Self-Consistency cố ý tăng diversity rồi tận dụng "đường khác nhau, cùng kết quả".

Trực giác của Wang et al.: với một câu hỏi reasoning, thường có nhiều cách hợp lý để đi đến đáp án đúng, trong khi sai lầm có xu hướng phân tán (mỗi lần sai một kiểu khác).

• Nếu lấy mẫu 10 chuỗi CoT khác nhau, các chuỗi đúng thường hội tụ về một đáp án.
• Các chuỗi sai mỗi cái lệch một kiểu, ít trùng nhau.
• Majority vote nâng tỉ lệ đáp án đúng được chọn.

Bản chất giống ensemble trong ML cổ điển: bagging nhiều "estimator" yếu hơn để thành một estimator mạnh hơn. Khác biệt: ở đây các estimator chính là các lần gọi cùng model với seed / temperature khác.

Bài toán: "Một cửa hàng có 50 quả táo. Bán đi 12 quả buổi sáng, 18 quả buổi chiều. Tối hôm đó nhập thêm 22 quả. Hiện còn bao nhiêu?"

Chạy CoT 5 lần với temperature=0.7:

Sample 1: 50 - 12 = 38; 38 - 18 = 20; 20 + 22 = 42. → 42
Sample 2: 50 - (12 + 18) = 20; 20 + 22 = 42.        → 42
Sample 3: 50 - 12 = 38; 38 - 18 = 20; 20 + 22 = 40. → 40 (cộng sai)
Sample 4: 12 + 18 = 30; 50 - 30 = 20; 20 + 22 = 42. → 42
Sample 5: 50 - 30 = 20; 20 + 22 = 38.               → 38 (cộng sai)

Vote: 42 (3/5), 40 (1/5), 38 (1/5) → final = 42.

Đáp án đúng 42 được chọn dù có 2/5 lần model tính sai. Một CoT đơn lẻ với temperature=0 có thể rơi đúng vào lần sai nếu kém may, Self-Consistency làm giảm rủi ro đó.

Trong paper gốc, Self-Consistency cải thiện rõ rệt nhiều benchmark reasoning. Một số con số đáng nhớ (PaLM-540B):

• GSM8K (math word problem): 56% (CoT) → 74% (CoT + Self-Consistency, N=40).
• AQuA (algebra multi-choice): 35% → 48%.
• SVAMP (math): 79% → 86%.
• StrategyQA (commonsense reasoning): 75% → 81%.

Improvement rõ nhất ở task math và logic — nơi đáp án rời rạc, dễ đếm phiếu. Với task open-ended (vd generation tự do), Self-Consistency gần như không áp dụng được vì khái niệm "majority" không rõ.

• Cost gấp N lần: cùng prompt, N completion → input token có thể được prompt caching giảm bớt nhưng output token thì cộng dồn.
• Latency gấp N lần nếu gọi tuần tự. Khi gọi parallel (asyncio, threading) thì latency tổng xấp xỉ bằng lần gọi chậm nhất.
• Quality tăng: thường +5 đến +20 điểm % accuracy ở task math / logic; ít tác dụng với task đã gần bão hoà.
• Variance giảm: output ổn định hơn giữa các lần chạy.

Quy tắc tham khảo: bắt đầu N = 5, nếu cần thêm độ tin cậy thì tăng lên 10 hoặc 20. Sau 20-40, improvement giảm dần (diminishing return).

• Task có đáp án rời rạc, dễ extract: math, multi-choice, classification, code có test case.
• Quality quan trọng hơn cost: y tế, tài chính, pháp lý, ra quyết định tự động.
• Có khả năng gọi parallel để giữ latency.
• Model còn rẻ so với budget (vd Sonnet 4.5, GPT-4o-mini).
• Bộ đánh giá extract_answer đã chắc — không sai bước parse.

• Open-ended generation: bài viết, email, sáng tạo — không có "majority" rõ.
• Task subjective: đánh giá phong cách, dịch văn học — vote không có nghĩa.
• Real-time chat với SLA latency thấp.
• Budget chật: cost gấp N có thể không kham nổi cho workload lớn.
• Task đã đạt accuracy gần trần — improvement biên rất nhỏ.

Self-Consistency tuần tự N=10 với mỗi call mất 3 s → 30 s tổng. Không chấp nhận được trong nhiều ứng dụng. Cách giảm:

• asyncio + httpx: gửi N request đồng thời, await all.
• SDK batch API: một số provider có endpoint batch (vd OpenAI Batch API, Anthropic Message Batches) — rẻ hơn 50% nhưng latency vài giờ; chỉ phù hợp offline.
• n parameter: OpenAI chat completion có n=5 nhận N completion trong 1 request — đỡ overhead nhưng vẫn tính tiền N lần output.

Trong sản phẩm real-time, asyncio parallel là lựa chọn chuẩn — latency tổng ≈ latency 1 call, cost vẫn N lần.

Tree-of-Thoughts (ToT) (Yao et al., "Tree of Thoughts: Deliberate Problem Solving with Large Language Models", arXiv:2305.10601, 2023) tổng quát hoá CoT theo hướng khác Self-Consistency:

• CoT = một chuỗi (chain) các thought tuyến tính.
• Self-Consistency = nhiều chuỗi độc lập rồi vote.
• ToT = một cây các thought, có nhánh, có đánh giá, có tỉa cành.

Mỗi node của cây là một thought — một bước reasoning trung gian (vd "thử cộng 4 + 9 trước"). Model sinh ra nhiều thought ứng viên cho cùng một state, một bộ đánh giá rate chất lượng từng nhánh, một search algorithm (BFS / DFS / A* …) quyết định nhánh nào đào sâu, nhánh nào bỏ.

• Thought decomposition: chia bài toán thành các bước phù hợp để model sinh từng bước (vd với Game of 24, mỗi bước là 1 phép toán trên 2 số → còn lại 3 số → 2 số → 1 số).
• Thought generator: với mỗi state, gọi LLM sinh k thought ứng viên (vd k=5 phép toán khác nhau).
• State evaluator: gọi LLM (hoặc heuristic) chấm mỗi state: "sure / likely / impossible" hoặc score 1-10. Đây là tín hiệu để tỉa cành.
• Search algorithm: BFS giữ b state tốt nhất ở mỗi depth; DFS đi sâu, backtrack khi state bị đánh giá "impossible". A* / beam search là các biến thể.

Bốn thành phần này được customise theo task. Yao 2023 dùng BFS với beam = 5 cho Game of 24 và creative writing, DFS cho mini crossword.

Game of 24: cho 4 số, dùng +, -, ×, ÷ và ngoặc để tạo ra 24. Mỗi số dùng đúng 1 lần.

Ví dụ: 4, 9, 10, 13. Đáp án: (13 - 9) × (10 - 4) = 4 × 6 = 24.

Cách ToT giải:

Depth 0: state = [4, 9, 10, 13]

Depth 1: sinh k=5 phép toán trên 2 số trong state
  4 + 9 = 13   → state [10, 13, 13]   → eval: likely
  4 × 9 = 36   → state [10, 13, 36]   → eval: impossible (vượt xa)
  13 - 9 = 4   → state [4, 4, 10]     → eval: likely
  10 + 13 = 23 → state [4, 9, 23]     → eval: likely
  13 - 4 = 9   → state [9, 9, 10]     → eval: likely

Giữ b=3 nhánh "likely". Tỉa nhánh "impossible".

Depth 2 (trên nhánh [4, 4, 10]):
  10 - 4 = 6 → state [4, 6]  → eval: sure (4 × 6 = 24)
  ...

Depth 3 (trên [4, 6]):
  4 × 6 = 24 → tìm được nghiệm.

Reconstruct: (13 - 9) = 4; (10 - 4) = 6; 4 × 6 = 24.

Mỗi lần gọi LLM ở vai trò "generator" hoặc "evaluator". Tổng số call cho 1 bài có thể lên hàng chục — đắt hơn CoT đơn lẻ rất nhiều, đổi lại tỉ lệ giải được tăng vọt.

Trên GPT-4 (bản 2023):

• Game of 24: 4% (CoT) → 9% (CoT + Self-Consistency) → 74% (ToT BFS b=5).
• Creative writing (4 paragraph coherence): ToT cho preference rate cao hơn CoT khi đánh giá bằng cả LLM lẫn human.
• Mini crossword 5×5: 1% (CoT) → 16% (CoT + IO) → 60% letter-level / 20% game-level (ToT DFS).

Bài học: ở task cần lập kế hoạch và quay lui, ToT hơn xa Self-Consistency vì search có hướng. Ở task math word problem (GSM8K) thông thường, Self-Consistency vẫn là lựa chọn tốt vì rẻ và đơn giản.

• Cost rất cao: vài chục đến vài trăm LLM call mỗi bài. Game of 24 trong paper Yao ước tính ~100 call/bài.
• Latency cao: tree exploration cần nhiều round nối tiếp; chỉ song song được trong phạm vi 1 depth.
• Complexity: cần code search, state representation, evaluator prompt, parser — không còn là "1 prompt".
• Hiệu quả phụ thuộc evaluator: state evaluator dở → tỉa nhầm nhánh đúng, kết quả tệ hơn cả CoT.

Vì lý do này, ToT trong 2024-2026 ít được dùng trực tiếp ở production app phổ thông, mà chủ yếu xuất hiện trong nghiên cứu, framework agent, hoặc các bài toán dạng planning offline.

• Hard reasoning problem mà CoT và Self-Consistency vẫn fail (math olympiad, puzzle, planning đa bước).
• Task có state rõ ràng để evaluator đánh giá (số còn lại, vị trí trên grid…).
• Research / offline batch, cost không phải ràng buộc cứng.
• Phía sau agent framework cần explore-exploit (vd tool use planning).

KHÔNG hợp với: real-time chat, classification thông thường, generation text dài, các task mà reasoning model đã giải tốt với 1 call.

• Graph-of-Thoughts (GoT) — Besta et al., "Graph of Thoughts: Solving Elaborate Problems with Large Language Models", arXiv:2308.09687, 2023. Tổng quát hoá ToT từ cây thành graph có hướng: cho phép merge hai thought thành một, loop để refine. Phù hợp task có cấu trúc tổng hợp (sorting, set operation, document merging). Đắt hơn ToT.
• Algorithm of Thoughts (AoT) — Sel et al., "Algorithm of Thoughts: Enhancing Exploration of Ideas in Large Language Models", arXiv:2308.10379, 2023. Thay vì search bên ngoài, ép model tự bắt chước cấu trúc thuật toán (vd DFS) trong nội bộ một chuỗi reasoning duy nhất. Cost gần CoT đơn lẻ, kết quả tiệm cận ToT ở nhiều task.

Hai biến thể này hiếm gặp trong sản phẩm thật, nhưng đáng nhớ tên khi đọc paper / blog 2023-2024.

Một xu hướng song song và quan trọng hơn cho practitioner: các reasoning model built-in CoT / search bên trong:

• OpenAI o1, o3 (2024-2025): training riêng cho reasoning, sinh "reasoning token" ẩn rồi đưa answer.
• DeepSeek-R1 (2025): open weight, train bằng RL với reward verifiable, đạt mức o1 ở nhiều benchmark.
• Claude 3.7 / 4 thinking: chế độ extended thinking, đưa scratch pad reasoning vào API.
• Gemini 2.5 thinking: tương tự.

Đối với người dùng, các model này biến Self-Consistency và ToT trở thành nội bộ — bạn chỉ cần 1 prompt bình thường, model tự "search". API đơn giản hơn nhiều so với tự build ToT. Đổi lại: token reasoning vẫn tính tiền (thường gấp 3-10 lần model thường), latency cao hơn.

Với phần lớn ứng dụng năm 2024-2026, lựa chọn thực dụng cho task khó là: thử reasoning model trước, chỉ rơi vào Self-Consistency / ToT khi không có lựa chọn (vd phải dùng SLM local) hoặc cần kiểm soát thuật toán chặt.

Một thủ thuật nhẹ hơn cả Self-Consistency và ToT: thêm verification step sau khi có answer:

[Câu hỏi gốc]

Reasoning:
[CoT của model]

Đáp án: 42.

Hãy verify đáp án ở trên bằng cách:
1. Đọc lại đề.
2. Tính lại từ đầu theo cách khác.
3. So sánh hai cách.
Nếu phát hiện sai, đưa ra đáp án đúng.

Cost chỉ tăng ~2 lần (1 reasoning + 1 verify) thay vì N lần như Self-Consistency. Hiệu quả khiêm tốn hơn nhưng dễ tích hợp. Một số framework gọi đây là self-check hoặc self-refine (Madaan et al., arXiv:2303.17651, 2023).

Đặt C = cost 1 CoT call thông thường. Tham khảo:

• CoT đơn lẻ: 1 × C.
• Verification: ~2 × C.
• Self-Consistency N=5: 5 × C; N=10: 10 × C; N=40: 40 × C.
• ToT với breadth b, depth d, mỗi node tốn 2 call (generator + evaluator): xấp xỉ 2 × b^d × C. Ví dụ b=5, d=3 → ~250 × C.
• Reasoning model: tuỳ provider, thường 3-10 × C (so với model thường cùng họ) nhờ reasoning token.

Nguyên tắc: trước khi áp dụng Self-Consistency / ToT, nhân chi phí ước lượng với traffic. Hỏi lại: cải thiện 5-10% accuracy có đáng tăng cost N lần không?

• Dùng Self-Consistency cho task không có "đúng" rõ: dịch văn, sáng tạo, đánh giá phong cách — vote vô nghĩa.
• Extract answer ẩu: cùng đáp án nhưng format khác (42 vs 42 quả) bị đếm như khác nhau, majority sai.
• Temperature quá cao (≥ 1.2): reasoning rời rạc, đáp án phân tán, vote không hội tụ.
• Temperature = 0: cả N call ra y hệt, vote không có ý nghĩa.
• ToT overkill cho task đơn giản — đốt tiền vô ích.
• Tự code ToT mà evaluator yếu → tệ hơn CoT. Evaluator phải được test riêng.
• Bỏ qua reasoning model: tự build ToT phức tạp trong khi 1 call o3 / R1 đủ.

• tree-of-thoughts (repo Princeton-NLP, kèm theo paper Yao 2023): reference implementation cho Game of 24, mini crossword, creative writing.
• LangChain / LangGraph: framework agent, có abstraction cho self-consistency, tree search, multi-step planner.
• DSPy (Stanford NLP): "programming, not prompting" — định nghĩa module reasoning rồi để framework tự tối ưu prompt; hỗ trợ ensemble và bootstrap.
• LiteLLM / OpenRouter: gọi nhiều provider qua 1 API — tiện khi cần parallel call hoặc fallback giữa các reasoning model.

Không bắt buộc dùng framework — Self-Consistency tự implement bằng asyncio chỉ ~30 dòng Python.

• App thông thường: zero-shot (Bài 25) hoặc zero-shot CoT là đủ. Không cần Self-Consistency.
• Reasoning critical (math, code, multi-step planning): thử reasoning model trước (o1 / o3 / R1 / Claude thinking). 1 call thường đủ.
• Quality vẫn không đạt: thêm Self-Consistency N=5-10 trên top reasoning model — biên cải thiện tiếp.
• Research / olympiad / planning đặc thù: cân nhắc ToT với evaluator tự thiết kế.
• SLM local: với 7B-14B param, Self-Consistency thường cải thiện rõ hơn so với top tier (do baseline yếu hơn).

Ba ví dụ: Self-Consistency synchronous, Self-Consistency async parallel, pseudocode ToT cho Game of 24.

# 1) Self-Consistency synchronous đơn giản
import re
from collections import Counter
from openai import OpenAI

client = OpenAI()

def extract_answer(text: str) -> str:
    # Heuristic: lấy số cuối cùng trong câu trả lời.
    matches = re.findall(r"-?\d+(?:\.\d+)?", text)
    return matches[-1] if matches else ""

def self_consistency(question: str, n: int = 5, temperature: float = 0.7) -> str:
    prompt = f"Câu hỏi: {question}\n\nLet's think step by step."
    answers = []
    for _ in range(n):
        resp = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            temperature=temperature,
        )
        answers.append(extract_answer(resp.choices[0].message.content))
    return Counter(answers).most_common(1)[0][0]

print(self_consistency(
    "Một cửa hàng có 50 quả táo, bán 12 buổi sáng, "
    "18 buổi chiều, tối nhập thêm 22. Còn bao nhiêu?",
    n=5,
))
# → "42"

# 2) Self-Consistency với asyncio parallel (latency ≈ 1 call)
import asyncio
from openai import AsyncOpenAI

aclient = AsyncOpenAI()

async def one_call(prompt: str, temperature: float) -> str:
    resp = await aclient.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=temperature,
    )
    return extract_answer(resp.choices[0].message.content)

async def self_consistency_async(question: str, n: int = 10) -> str:
    prompt = f"Câu hỏi: {question}\n\nLet's think step by step."
    results = await asyncio.gather(
        *[one_call(prompt, 0.7) for _ in range(n)]
    )
    return Counter(results).most_common(1)[0][0]

answer = asyncio.run(self_consistency_async(
    "12 × 5 - 18 + 22 = ?", n=10
))
print(answer)  # → "64"

# 3) Pseudocode Tree-of-Thoughts cho Game of 24
# - state = list số còn lại
# - thought = phép toán trên 2 số trong state
# - generator: prompt LLM sinh k phép toán khả thi
# - evaluator: prompt LLM chấm "sure / likely / impossible"

def tot_game24(numbers, beam_b=5, depth_d=3):
    frontier = [(numbers, [])]   # (state, history)
    for _ in range(depth_d):
        candidates = []
        for state, history in frontier:
            thoughts = llm_generate_ops(state, k=beam_b)  # 1 call
            for t in thoughts:
                new_state = apply(state, t)
                score = llm_evaluate(new_state)           # 1 call
                if score != "impossible":
                    candidates.append(
                        (new_state, history + [t], score)
                    )
        # giữ b candidate điểm cao nhất
        frontier = [
            (s, h) for s, h, _ in
            sorted(candidates, key=lambda x: x[2], reverse=True)[:beam_b]
        ]
        # check goal
        for state, history in frontier:
            if len(state) == 1 and abs(state[0] - 24) < 1e-6:
                return history
    return None

# expression = tot_game24([4, 9, 10, 13])
# → [(13, 9, '-'), (10, 4, '-'), (4, 6, '×')]

Production-ready cần thêm: prompt template cho generator / evaluator, parser chắc chắn, cache, timeout, fallback. Tổng số LLM call cho 1 bài Game of 24 dao động 50-150 tuỳ beam.

Bài 1 — Self-Consistency cho sentiment. Cài đặt Self-Consistency cho task phân loại sentiment 3 nhãn (positive / negative / neutral) trên 30 review tiếng Việt tự chọn. Dùng temperature=0.7. So sánh accuracy giữa N=1 (CoT đơn), N=5, N=10. Vẽ đồ thị accuracy theo N.

Bài 2 — Cost vs accuracy. Trên dataset Bài 1, đo thời gian thực thi (synchronous vs async) và tổng số token (input + output) cho N=1, 5, 10. Tính cost USD ước lượng theo giá API hiện hành. Vẽ đồ thị cost-accuracy và xác định điểm "sweet spot" cho bài toán của bạn.

Bài 3 — Pseudocode ToT. Chọn 1 task reasoning bạn quan tâm (vd Sudoku 4×4, lập kế hoạch 5 bước, mini crossword). Viết pseudocode ToT: định nghĩa state, thought, generator prompt, evaluator prompt, search algorithm. Không cần chạy thật — chỉ cần thiết kế.

Bài 4 — So sánh với reasoning model. Lấy 10 bài toán math word problem (gợi ý: GSM8K bản dịch tiếng Việt). Chạy 3 cấu hình: (a) CoT đơn lẻ với gpt-4o-mini, (b) Self-Consistency N=10 với gpt-4o-mini, (c) 1 call với o3-mini hoặc DeepSeek-R1. So sánh accuracy, latency, cost. Viết kết luận ngắn về lựa chọn nào tối ưu cho use case của bạn.

Bài 5 — Verification step (optional). Thêm 1 verify step sau CoT trên dataset Bài 1. So sánh kết quả với Self-Consistency N=5. Cùng cost ~2× CoT, cái nào tốt hơn trên dataset của bạn?

• Beyond CoT có hai hướng: sample nhiều chuỗi rồi vote (Self-Consistency), explore cây có đánh giá / tỉa cành (Tree-of-Thoughts).
• Self-Consistency (Wang et al., arXiv:2203.11171, 2022): chạy CoT N lần với temperature > 0, extract answer, majority vote. N hay dùng: 5-40.
• Cơ chế: nhiều đường reasoning hội tụ về đáp án đúng, sai lầm phân tán. Bản chất giống ensemble trong ML cổ điển.
• Kết quả paper gốc: GSM8K 56% → 74% (PaLM-540B, N=40); AQuA 35% → 48%; SVAMP 79% → 86%.
• Trade-off Self-Consistency: cost gấp N, latency gấp N nếu tuần tự, ≈ 1 lần nếu parallel (asyncio).
• Dùng Self-Consistency: task đáp án rời rạc, quality quan trọng, có thể parallel. Không dùng: open-ended generation, task subjective, real-time SLA chặt.
• Tree-of-Thoughts (Yao et al., arXiv:2305.10601, 2023): tổng quát hoá CoT thành cây với 4 thành phần — thought decomposition, thought generator, state evaluator, search algorithm (BFS / DFS).
• Kết quả: Game of 24 trên GPT-4: 4% (CoT) → 74% (ToT BFS). Crossword 5×5: 1% → 60% letter-level.
• Trade-off ToT: cost rất cao (vài chục đến vài trăm call/bài), latency cao, complexity lớn, hiệu quả phụ thuộc evaluator.
• Graph-of-Thoughts (Besta 2023): tổng quát hơn thành graph, cho phép merge / loop. Algorithm of Thoughts (Sel 2023): ép model bắt chước cấu trúc thuật toán trong 1 chuỗi, rẻ hơn ToT.
• Verification step: thêm bước "verify lại đáp án" — cost chỉ ~2× CoT, dễ tích hợp, hiệu quả khiêm tốn.
• Reasoning model 2024-2026 (o1, o3, DeepSeek-R1, Claude 3.7 / 4 thinking, Gemini 2.5 thinking): built-in search bên trong, API đơn giản, cost gấp 3-10 lần model thường — thường là lựa chọn đầu tiên cho task khó.
• Pitfall: vote cho task subjective, extract answer ẩu, temperature sai (quá cao hoặc = 0), tự build ToT với evaluator yếu, overkill cho task đơn giản.
• Lựa chọn 2024-2026: app thường — zero-shot CoT; reasoning critical — reasoning model trước; vẫn chưa đủ — Self-Consistency N=5-10; research / planning đặc thù — ToT.
• Thư viện: tree-of-thoughts repo Princeton-NLP, LangChain / LangGraph, DSPy. Self-Consistency tự implement bằng asyncio chỉ ~30 dòng.
• Bài 29 sẽ trở lại chủ đề output: structured output bằng JSON schema, function calling, mode JSON / strict.