Lộ trình cấp tốc 6 ngày

Dành cho người còn một ngày nghỉ học trọn và vài buổi tối trước ngày thi. Mỗi bước có link mở thẳng bài cần làm trong tab Luyện đề.

Mẹo làm bài: làm Phần D và các câu nhận biết trước để chắc điểm; câu tự luận và code không bỏ trống, viết đủ ý theo khung là có điểm thành phần; câu tính toán thì ghi từng bước.

Đề thi gồm gì

Số liệu lấy từ 6 đề tổng hợp ĐGNL-01 đến 06 (360 câu) của bộ đề hieubui2409. Bộ AI-TEST có cùng cấu trúc 4 phần nhưng câu dễ hơn nhiều.

Mức độ câu hỏi theo từng phần

Câu nhận biết chỉ chiếm khoảng 18% đề tổng hợp. Phần lớn là câu vận dụng: một tình huống doanh nghiệp (ngân hàng, bệnh viện, sàn TMĐT) kèm số liệu, và bạn phải chọn cách xử lý đúng. Tuy vậy, câu vận dụng nào cũng dựa trên một công thức hoặc định nghĩa nhận biết. Nắm chắc nền tảng thì câu tình huống chỉ còn là đọc kỹ đề.

Dạng câu hỏi

Không được dùng máy tính cầm tay. Số liệu trong đề được chọn để tính nhẩm, nên hãy luyện tính tay: phân số, căn bậc hai đơn giản, e⁻¹ ≈ 0,368, ln 2 ≈ 0,69.

Lộ trình cho người mất gốc

Thứ tự này đi từ chỗ dễ lấy điểm nhất. Mỗi bước có link tới mục tương ứng.

1. Tính nhẩm phần trăm, tỉ lệ, chi phí tokenDạng toán lớp 7 nhưng xuất hiện khắp đề, kể cả Phần C và D. Xem Tỉ lệ, tiền, chi phí.
2. Precision, recall và bài Bayes "tỉ lệ nền"Hai khái niệm này có mặt trong khoảng 40 câu. Học xong là làm được một mảng lớn của Phần A và C. Xem Chỉ số đánh giá và Xác suất.
3. Logic "nếu… thì…" và phủ địnhÍt công thức, chỉ có vài quy tắc cố định, học một buổi là xong. Xem Logic.
4. Các bẫy Python và pandasHọc thuộc khoảng 20 bẫy trong bảng. Câu "đoạn code in ra gì" gần như chỉ xoay quanh chúng. Xem Bẫy Python.
5. Ma trận, đạo hàm, gradient descentCâu nhận biết của Phần A chủ yếu là tính định thức, trị riêng, đạo hàm và một bước GD. Xem Đại số tuyến tính.
6. RAG, agent và an toàn LLMPhần C và D hỏi rất nhiều về RAG, agent và prompt injection. Học theo "nguyên tắc xử lý" thay vì công thức. Xem RAG.
7. Khung trả lời tự luậnLuyện viết 7 ý theo khung có sẵn để không mất điểm oan. Xem Tự luận.

AToán và tư duy định lượng

Phần có nhiều câu nhận biết nhất, nên lấy điểm ở đây trước. Mọi câu đều quy về một công thức.

Tỉ lệ, tiền, chi phí ≈40 câu có tính chi phí

• Phần trăm thay đổi: (mới − cũ) / cũ. Luôn chia cho giá cũ.
• Giảm liên tiếp nhân hệ số, không cộng: giảm 30% rồi 10% → 0,7 × 0,9 = 0,63, tức giảm 37%.
• Điểm phần trăm khác phần trăm tương đối: 4% xuống 3% là giảm 1 điểm %, tức giảm tương đối 25%.
• Trung bình có trọng số: Σ wᵢxᵢ / Σ wᵢ.
• Chia theo tỉ lệ a : b với tổng T: phần a = T · a / (a + b).
• ROI: (lợi ích − chi phí) / chi phí. Hoàn vốn: chi phí ban đầu / (lợi ích tháng − vận hành tháng).
• Hòa vốn: chi phí cố định / (giá − chi phí biến đổi).
• Chi phí LLM: (token_vào × giá_vào + token_ra × giá_ra) / 10⁶ × số request.
• RICE: Reach × Impact × Confidence / Effort.

Đại số tuyến tính CĐ-01

• Tích vô hướng u·v = Σ uᵢvᵢ. Chuẩn L2 ‖v‖ = √Σvᵢ², chuẩn L1 Σ|vᵢ|.
• Cosine u·v / (‖u‖‖v‖). Nhân vector với số dương thì cosine giữ nguyên, tích vô hướng thay đổi. Vector đã chuẩn hóa: ‖u − v‖² = 2 − 2cos.
• Nhân ma trận: (m×n)·(n×p) = m×p. Phần tử (i, j) = hàng i của A nhân vô hướng với cột j của B. (AB)ᵀ = BᵀAᵀ.
• Định thức 2×2: ad − bc. Bằng 0 thì ma trận không khả nghịch. det(kA) = kⁿ·det A với A cỡ n×n, det Aᵀ = det A.
• Nghịch đảo 2×2: 1/(ad−bc) · [[d, −b], [−c, a]].
• Trị riêng 2×2: nghiệm của λ² − (vết)·λ + det = 0. Tổng trị riêng = vết, tích = định thức. Ma trận tam giác: trị riêng nằm trên đường chéo.
• Kiểm tra vector riêng: tính Av rồi xem có bằng λv không.
• PCA/SVD: tỉ lệ phương sai giữ lại = Σ σᵢ² (top k) / Σ σᵢ², hay Σ λᵢ (top k) / Σ λᵢ nếu cho trị riêng hiệp phương sai. Giá trị kỳ dị của X = √(trị riêng của XᵀX). Hạng = số σ khác 0.
• nn.Linear(vào, ra): W có shape ra × vào, batch (B, vào) → (B, ra). LoRA hạng r cho ma trận d×k thêm r·(d + k) tham số.

Giải tích và tối ưu CĐ-02

• (xⁿ)' = n·xⁿ⁻¹, (eˣ)' = eˣ, (ln x)' = 1/x. Quy tắc chuỗi: [f(g(x))]' = f'(g(x))·g'(x).
• Sigmoid: σ'(z) = σ(z)(1 − σ(z)), lớn nhất 0,25. Mạng sâu dùng sigmoid nhân nhiều số ≤ 0,25 nên gradient tiêu biến → dùng ReLU, residual, chuẩn hóa.
• Gradient = vector các đạo hàm riêng, chỉ hướng hàm tăng nhanh nhất. Đạo hàm theo hướng v = ∇f · v/‖v‖.
• Gradient descent: w ← w − η·∇L(w).
• Learning rate quá lớn thì loss tăng vọt rồi ra NaN; quá nhỏ thì giảm rất chậm. Với hàm bậc hai, GD hội tụ khi η < 2/λ_max (λ_max là trị riêng lớn nhất của Hessian).
• Loss zig-zag theo một trục → momentum hoặc Adam. Adam chia bias correction cho 1 − βᵗ để bù lệch về 0 ở các bước đầu.
• Softmax: pᵢ = e^zᵢ / Σ e^z. Logits dạng ln thì dễ: (ln 3, 0, ln 2) → (3, 1, 2)/6. Temperature T chia logits cho T: T tăng thì phân phối phẳng hơn.
• Cross-entropy = −ln(p của lớp đúng). Gradient của softmax + CE theo logits = p − y.
• Điểm dừng có Hessian với trị riêng trái dấu là điểm yên ngựa.

Xác suất ≈10 câu Bayes, CĐ-03

• P(A|B) = P(A∩B) / P(B). P(A∪B) = P(A) + P(B) − P(A∩B).
• Độc lập: P(A∩B) = P(A)·P(B). Hai biến cố xung khắc (có xác suất dương) thì không độc lập.
• Ít nhất một lần xảy ra trong n lần độc lập: 1 − (1 − p)ⁿ. Mọi bước đều thành công: pⁿ.
• Kỳ vọng E[X] = Σ x·p(x), phương sai Var = E[X²] − E[X]². E[aX+b] = aE[X]+b, Var(aX+b) = a²Var(X).
• Biến độc lập: phương sai cộng được, độ lệch chuẩn thì không. Độ lệch chuẩn 3, 4, 12 → tổng có độ lệch chuẩn √(9+16+144) = 13.
• Nhị thức: C(n,k)·pᵏ(1−p)ⁿ⁻ᵏ, kỳ vọng np, phương sai np(1−p). Tổ hợp C(n,k) = n! / (k!(n−k)!).
• Poisson λ: P(k) = e^−λ·λᵏ/k!, kỳ vọng = phương sai = λ. Đổi khung thời gian thì đổi λ theo tỉ lệ: 6 lỗi/giờ = 1 lỗi/10 phút.
• Phân phối chuẩn: quy tắc 68–95–99,7. z = (x − μ)/σ. P95 = μ + 1,645σ.

Dạng "tỉ lệ nền" (Bayes): gặp ở cả Phần A, C và D

Đề cho: tỉ lệ thật sự dương (tỉ lệ bệnh, gian lận, bot), độ nhạy (bắt được bao nhiêu % ca dương) và tỉ lệ báo nhầm. Hỏi: khi bị báo dương, xác suất là dương thật bao nhiêu? Cách nhanh nhất là tưởng tượng 10.000 người rồi đếm.

Thống kê và A/B test ≈34 câu, CĐ-04

• Trung vị bền với ngoại lai, trung bình bị kéo lệch. Dữ liệu lệch (độ trễ, tiền bồi thường) thì báo trung vị và phân vị.
• p95 = 820 ms nghĩa là khoảng 95% request xong trong tối đa 820 ms, 5% còn lại chậm hơn.
• Phương sai mẫu chia cho n − 1. Trong pandas, .var() và .std() mặc định ddof = 1; NumPy np.var mặc định ddof = 0.
• Sai số chuẩn của trung bình s/√n: tăng n gấp 4 thì SE giảm một nửa. SE của tỉ lệ: √(p(1−p)/n).
• Khoảng tin cậy 95% = ước lượng ± 1,96·SE. Chứa 0 thì chưa kết luận được. CI 99% rộng hơn 2,576/1,96 ≈ 1,31 lần.
• p-value là xác suất thấy kết quả cực đoan như vậy nếu H₀ đúng, không phải xác suất H₀ đúng.
• Sai lầm loại I = dương tính giả (khống chế bởi α). Loại II = âm tính giả. Power = 1 − xác suất loại II.
• Cỡ mẫu tỉ lệ với 1/MDE²: muốn phát hiện hiệu ứng nhỏ bằng một nửa thì cần gấp 4 lần mẫu. Công thức nhanh cho α = 5%, power 80%: n/nhóm ≈ 16·p(1−p)/δ².
• Kiểm định 20 chỉ số, mỗi chỉ số ở mức 0,05: xác suất ít nhất một dương tính giả = 1 − 0,95²⁰ ≈ 64%. Hiệu chỉnh Bonferroni dùng α/k, Holm thì dùng α/k, α/(k−1)… lần lượt.
• Xem p-value mỗi ngày rồi dừng khi p < 0,05 (peeking) làm tăng dương tính giả. Phải chốt cỡ mẫu trước.
• SRM: chia 50/50 mà ra lệch (ví dụ 50.600 / 49.400) thì kiểm định chi-bình phương. Lệch có ý nghĩa thì không tin kết quả.
• Kiểm định z hai tỉ lệ: z = (p_B − p_A) / SE, |z| > 1,96 thì có ý nghĩa ở mức 5%.
• Còn hay hỏi: nghịch lý Simpson (gộp nhóm đảo chiều kết quả), biến gây nhiễu (người tự bật tính năng vốn đã khác), guardrail metric (độ trễ, lỗi, khiếu nại), novelty effect (hiệu ứng giảm dần theo tuần).

BLập trình và xử lý dữ liệu

Dạng chính: "đoạn code in ra gì", "chọn biểu thức đúng", "độ phức tạp là gì" và code viết tay. Các câu đoán output gần như luôn xoay quanh những bẫy dưới đây.

Bẫy Python CĐ-05

a = [1,2,3,4,5,6]
a[1:5:2]

def f(x, ds=[]):
    ds.append(x); return ds
f(1); f(2)

g = [[0]*2]*3
g[0][0] = 9

b = a; b.append(7)
c = a[:]; c.append(8)

7 // 2, -7 // 2, -7 % 3

" a  b ".split()
" a  b ".split(" ")
"a,,b".split(",")

d = {"a": 1}
d.get("b"), d.get("b", 0)
d["b"]

g = (x for x in [1,2,3])
sum(g), sum(g)

fs = [lambda: i for i in range(3)]
[f() for f in fs]

t = 5
def f(x=t): return x
t = 30; f()

d = dict.fromkeys(["x","y"], [])
d["x"].append(1)

class C: items = []
a, b = C(), C()
a.items.append(1)

@dataclass
class J: tags: list = []

t = ([1], 2)
t[0] += [3]

def f():
    try: return "a"
    finally: print("b")

f"{1234567:,} {0.0456:.1%}"

sorted(["cam","Tao","bo"])

{**a, **b}   # hoặc a | b

re.match(r"\d+", "id=42")
re.search(r"\d+", "id=42")

Kiểu bất biến (dùng được làm khóa dict): int, float, str, tuple, frozenset, bool. Kiểu thay đổi được: list, dict, set.

pandas ≈35 câu groupby/merge, CĐ-06

• Lọc nhiều điều kiện: df[(df.gia > 1000) & (df.tinh == "HN")]. Dùng & | ~ và phải có ngoặc; and/or sẽ báo lỗi. Lọc theo danh sách: isin([404, 500]). Dùng biến trong query: df.query("tp == @ks").
• loc theo nhãn và lấy cả điểm cuối; iloc theo vị trí và không lấy điểm cuối. Index không bắt đầu từ 0 là bẫy kinh điển.
• groupby(...).size() đếm cả dòng có NaN; .count() bỏ NaN. .transform("sum") trả về Series dài bằng bảng gốc; .agg thu gọn còn mỗi nhóm một dòng. groupby mặc định bỏ các dòng có khóa NaN.
• NaN: s == np.nan luôn False, phải dùng isna(). mean() tự bỏ NaN. fillna(0) làm trung bình thấp sai. value_counts() mặc định bỏ NaN. Cột có NaN không ép được sang int, dùng "Int64".
• merge: how="left" giữ đủ dòng bảng trái. Khóa bên phải bị trùng → số dòng bị nhân lên; phòng bằng validate="m:1". Cột trùng tên → thêm hậu tố _x, _y. Khóa khác kiểu (int và str) → báo lỗi. Dùng inner join khi tính tỉ lệ chuyển đổi sẽ làm mất mẫu số.
• concat giữ index cũ (0,1,2,0,1); cần ignore_index=True.
• Sắp xếp chuỗi số: "100" < "9". Ép kiểu số hoặc dùng to_datetime(format=...) trước khi sắp.
• Giữ bản ghi mới nhất: sort_values("ts").drop_duplicates("id", keep="last").
• Vector hóa: df.a * df.b thay cho apply(lambda r: ...). Câu hỏi về hiệu năng luôn chọn đáp án vector hóa.
• pivot báo lỗi nếu một cặp khóa xuất hiện hai lần; pivot_table thì gộp lại được.

s = pd.Series([10, None, 30, None])
s.mean(), s.fillna(0).mean(), s.isna().sum()

NumPy và độ phức tạp CĐ-07

• shape, ndim (số chiều), size (tổng số phần tử). a.sum(axis=0) gộp theo hàng, kết quả còn một giá trị cho mỗi cột. Mẹo: axis nào được ghi thì chiều đó biến mất.
• Broadcasting: so shape từ phải sang trái, mỗi cặp chiều phải bằng nhau hoặc một bên bằng 1. (3,1) + (4,) → (3,4). (2,3) − (2,) báo lỗi, sửa bằng keepdims=True hoặc [:, None].
• Slice là view: sửa slice thì mảng gốc đổi theo. Fancy indexing (a[[0,2]]) và mask tạo bản sao.
• Chuẩn hóa từng hàng: E / np.linalg.norm(E, axis=1, keepdims=True). Dùng axis=0 là sai.
• Đếm và tỉ lệ: (x > 0.8).sum(), (x >= 400).mean(). np.vectorize không nhanh hơn vòng lặp.
• Bộ nhớ = số phần tử × byte: float32 4 byte, float64 8 byte. 500.000 × 768 × 4 ≈ 1,54 GB.

SQL ≈18 câu về NULL, CĐ-08

• Thứ tự xử lý logic: FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT. Vì vậy điều kiện trên hàm gộp (SUM(amount) > 250) phải đặt trong HAVING.
• NULL: = NULL không bao giờ đúng, dùng IS NULL. status <> 'closed' loại luôn các dòng NULL. COUNT(*) đếm mọi dòng, COUNT(col) bỏ NULL. SUM trên 0 dòng trả NULL (dùng COALESCE). NOT IN với danh sách có NULL trả 0 dòng, nên dùng NOT EXISTS.
• LEFT JOIN mà đặt điều kiện của bảng phải trong WHERE thì thành INNER JOIN. Muốn giữ đủ bảng trái thì đưa điều kiện vào ON.
• CROSS JOIN 3 dòng × 4 dòng = 12 dòng. Join khóa trùng thì nhân dòng, tổng tiền bị đếm hai lần.
• Window function giữ nguyên số dòng. Với điểm 90, 85, 85, 80: ROW_NUMBER 1,2,3,4; RANK 1,2,2,4; DENSE_RANK 1,2,2,3. Tổng lũy kế bị trùng giá trị khi ORDER BY có giá trị hòa, thêm cột phụ để phá hòa.
• Chia hai số nguyên: 1/7 = 0. Nhân 1.0 trước.
• PostgreSQL bắt mọi cột trong SELECT phải nằm trong GROUP BY hoặc hàm gộp (SQLite thì không bắt).
• Index ghép (a, b) phát huy tốt nhất khi điều kiện lọc có cột đầu a. EXPLAIN ANALYZE chạy thật câu lệnh, EXPLAIN chỉ in kế hoạch.

Kỹ thuật phần mềm code review, test, hệ thống

• Code review: phải chặn lỗi đúng sai và bảo mật (SQL ghép chuỗi, thiếu test). Góp ý tên biến ghi là "Nit:" và vẫn approve. PR quá lớn thì đề nghị tách đổi tên, refactor và tính năng mới.
• Test chập chờn (flaky): hàm gọi datetime.now() → truyền thời điểm vào làm tham số. Dùng sleep(2) → thay bằng chờ có điều kiện. Kim tự tháp test: nhiều unit test, ít E2E. Câu SQL ghi vào DB thật cần integration test. Hai team dùng chung API cần contract test. Viết test tại giá trị biên.
• Idempotency: thanh toán, hoàn tiền, chuyển tiền phải kèm khóa idempotency; job chạy lại dùng upsert theo khóa.
• Retry: exponential backoff + jitter, giới hạn số lần, chỉ retry lỗi tạm thời; kèm circuit breaker và fallback.
• Cache-aside: đọc cache → miss thì đọc DB → ghi vào cache. Chống stampede bằng single-flight. Khóa cache phải gồm phiên bản prompt, model, chỉ mục và nhóm quyền.
• Rate limit dùng token bucket. Đỉnh tải dùng hàng đợi. Bước khách chờ (thanh toán) chạy đồng bộ; email, cộng điểm đẩy vào hàng đợi. Read replica có độ trễ, đọc ngay sau khi ghi phải về DB chính.
• hash() của chuỗi trong Python đổi giữa các tiến trình, nên chia nhóm A/B phải dùng hashlib.

CKiến thức AI và tư duy sản phẩm

Phần nhiều điểm nhất (≈37). Phần lớn là tình huống: đề mô tả sự cố, bạn chọn chẩn đoán và cách sửa. Đáp án đúng thường là đáp án đo trước rồi mới sửa đúng chỗ, không phải "đổi model to hơn".

Học máy cơ bản ≈11 câu rò rỉ dữ liệu, CĐ-09

• Có nhãn → có giám sát: nhãn rời rạc là phân loại, số thực là hồi quy. Không nhãn, gom nhóm → phân cụm. Học qua phần thưởng → học tăng cường.
• Train để học, validation để chọn siêu tham số và mô hình, test để đánh giá lần cuối và chỉ dùng một lần.
• Chẩn đoán: train tốt, validation kém → overfitting (variance cao) → regularization, thêm dữ liệu, giảm độ phức tạp, early stopping. Cả train lẫn validation kém so với người → underfitting (bias cao) → dùng mô hình mạnh hơn.
• L1 (Lasso) đẩy nhiều trọng số về đúng 0, nên dùng để chọn đặc trưng. L2 (Ridge) co trọng số nhỏ lại và ổn định khi các biến tương quan mạnh.
• k-fold: huấn luyện k lần, mỗi lần trên (k−1)/k dữ liệu. Lớp mất cân bằng dùng stratified k-fold. Dữ liệu theo thời gian thì chia theo thời gian.
• Rò rỉ dữ liệu: fit scaler, chọn đặc trưng hay oversample trước khi chia; trộn ngẫu nhiên dữ liệu thời gian; dùng đặc trưng chỉ biết sau thời điểm dự đoán (ngày cập nhật trạng thái hủy); cùng một sản phẩm hay khách hàng nằm ở cả train và test (dùng GroupKFold); target encoding không làm out-of-fold. Dấu hiệu chung: điểm offline cao bất thường, chạy thật thì tụt.
• kNN cần chuẩn hóa thang đo. Biến danh mục không thứ tự thì one-hot, không mã hóa 0/1/2.
• Random forest giảm variance của cây sâu. Hệ số β trong logistic: odds nhân với e^β (β = −0,69 → odds giảm một nửa).

Chỉ số đánh giá ≈30 câu precision/recall

• Precision TP/(TP+FP): trong số bị gắn cờ, bao nhiêu là đúng.
• Recall TP/(TP+FN): trong số thật sự dương, bắt được bao nhiêu.
• F1 2PR/(P+R). Accuracy đánh lừa khi lớp mất cân bằng: luôn đoán "không vỡ nợ" với 2% vỡ nợ cho accuracy 98% nhưng recall 0%.
• Chọn chỉ số theo cái giá của lỗi: bỏ sót nguy hiểm (ung thư, gian lận lớn) → ưu tiên recall; báo nhầm tốn kém (tự khóa tài khoản, lọc spam mất email tốt) → ưu tiên precision.
• Hạ ngưỡng quyết định thì recall tăng, precision giảm, số cảnh báo tăng.
• Ngưỡng theo chi phí: tổng = FP × c_FP + FN × c_FN. Ngưỡng lý thuyết trên xác suất đã hiệu chỉnh: p* = c_FP/(c_FP + c_FN).
• ROC-AUC là xác suất mô hình chấm một mẫu dương ngẫu nhiên cao hơn một mẫu âm ngẫu nhiên. AUC cao vẫn có thể cho precision thấp khi tỉ lệ nền nhỏ (xem dạng Bayes).
• Hồi quy: MAE = trung bình |sai số|, RMSE = √(trung bình sai số²), luôn RMSE ≥ MAE vì phạt nặng lỗi lớn.
• class_weight="balanced": trọng số lớp = n_mẫu / (số_lớp × n_lớp_đó).

LLM CĐ-10, ≈32 câu độ trễ

• Token và tokenizer BPE (gộp dần các cặp ký tự hay gặp). Context window là lượng token mô hình xử lý trong một lượt. Hallucination là câu trả lời nghe hợp lý nhưng sai; xử lý bằng RAG có trích dẫn và cho phép từ chối khi thiếu căn cứ.
• Temperature thấp (0–0,2) cho trích xuất và JSON; cao (0,7–1) cho viết sáng tạo.
• max_tokens quá nhỏ thì phản hồi bị cắt (finish_reason = "length") và JSON hỏng. Đầu ra có cấu trúc: dùng JSON Schema, validate, sai thì retry kèm thông báo lỗi.
• Self-attention: softmax(QKᵀ/√d_k)·V. Chia √d_k để softmax không bão hòa. Chi phí tăng theo n²: ngữ cảnh dài gấp 4 thì tốn gấp 16. Bỏ positional encoding thì mô hình không phân biệt được thứ tự từ.
• TTFT (thời gian tới token đầu) tăng theo độ dài prompt. Tổng thời gian ≈ TTFT + số_token_ra / tốc_độ_sinh. Streaming chỉ làm người dùng thấy chữ sớm hơn, không làm xong nhanh hơn.
• Bộ nhớ trọng số = số tham số × byte/tham số: FP16 2 byte, INT8 1 byte, INT4 0,5 byte. Model 7B ở INT4 ≈ 3,5 GB, chưa tính KV cache.
• Lượng tử hóa làm model nhẹ và nhanh hơn nhưng có thể giảm chất lượng, nhất là ở lớp hiếm, nên phải đo lại trên golden set.
• Cache: exact-match an toàn nhưng ít trúng; semantic cache có thể "trúng sai" khi hai câu gần chữ mà ý ngược nhau; prompt caching đặt phần cố định ở đầu prompt.
• Ghim phiên bản model (không dùng alias "latest"). Định tuyến câu dễ sang model nhỏ, câu khó sang model lớn.
• Kiến thức hay thay đổi, cần trích dẫn → RAG. Muốn model học phong cách hay định dạng lặp lại → fine-tune.

RAG ≈42 câu

Pipeline: làm sạch → cắt chunk theo cấu trúc (điều, khoản, mục), overlap 10–20% → embedding → chỉ mục (HNSW là chỉ mục tìm láng giềng gần đúng dạng đồ thị) → truy xuất hybrid BM25 + vector, có lọc metadata (năm, quyền, tenant) → rerank bằng cross-encoder → sinh câu trả lời có trích dẫn → đánh giá.

• BM25 khớp chính xác mã và từ hiếm ("lỗi E-4021"); vector bắt được câu cùng nghĩa khác chữ. Gộp hai bộ bằng RRF: điểm = Σ 1/(k + hạng), không cộng điểm thô khác thang.
• Reranker chỉ sắp lại các ứng viên đã có, không cứu được đoạn nằm ngoài top-N ban đầu.
• Đổi embedding model thì phải index lại toàn bộ. Cập nhật tài liệu thì xóa vector của phiên bản cũ.
• Chỉ số truy xuất: recall@k = số đoạn liên quan trong top-k / tổng số đoạn liên quan; precision@k = số liên quan trong top-k / k; MRR là trung bình 1/(hạng của đoạn đúng đầu tiên); nDCG có tính mức độ liên quan và vị trí.
• Chỉ số sinh: faithfulness = số nhận định suy ra được từ ngữ cảnh / tổng số nhận định; answer relevance = trả lời có đúng câu hỏi không; context precision và context recall.
• Chẩn đoán: context recall thấp → sửa truy xuất (chunk, hybrid, mở rộng truy vấn). Context tốt mà faithfulness thấp → sửa tầng sinh (bắt trích dẫn, cho phép nói "không có thông tin").

Agent ≈37 câu

• ReAct: Thought → Action → Observation, lặp lại. Tool calling: model chỉ sinh tên hàm và tham số JSON; code của ứng dụng mới là thứ chạy hàm. Vòng lặp kết thúc khi model trả lời mà không gọi tool nữa.
• Đặt giới hạn số bước, token và thời gian; phát hiện lặp bằng cách băm tên tool + tham số.
• Validate tham số phía server bằng schema và luật nghiệp vụ (số tiền hoàn ≤ giá trị đơn), không tin con số model điền.
• Con người duyệt trước hành động không đảo ngược được hoặc liên quan tiền (hoàn tiền, xóa hồ sơ). Màn hình duyệt phải do code hiển thị tham số thật, không hiển thị câu do LLM viết.
• Quyền tối thiểu: tool hẹp, chỉ đọc, đúng khách hàng; tách quyền giữa các luồng.
• Nhiều agent nhỏ thì ít chọn nhầm tool hơn, đổi lại thêm bước định tuyến. Các nhánh chạy song song: thời gian = phân tích + nhánh lâu nhất + tổng hợp.
• Xác suất cả chuỗi thành công = tích xác suất từng bước (0,95¹⁰ ≈ 0,60). Ngữ cảnh dài thêm mỗi bước thì tổng token là cấp số cộng.

MLOps và vận hành CĐ-11

• Theo dõi p50, p95, p99 theo SLO. Batch lớn hơn tăng throughput và giảm chi phí mỗi request: chi phí/request = giá giờ / số request mỗi giờ.
• Định luật Little: số request đồng thời = tốc độ đến × thời gian xử lý. 12 req/s × 2,5 s = 30 đồng thời; mỗi replica chịu 8 → cần 4 replica.
• Triển khai: shadow (model mới chỉ ghi log, người dùng vẫn nhận kết quả cũ) → canary (một phần nhỏ lưu lượng) → A/B. Luôn có rollback nhanh bằng artifact bất biến.
• Canary 0 lỗi trên n request: cận trên 95% của tỉ lệ lỗi ≈ 3/n (quy tắc số 3). 0 lỗi trên 150 request chưa chứng minh tốt hơn 0,4%.
• Data drift (covariate shift): P(X) đổi, P(Y|X) giữ nguyên. Concept drift: P(Y|X) đổi, nghĩa là quy luật thay đổi. PSI = Σ (a − e)·ln(a/e): dưới 0,1 ổn, 0,1–0,25 vừa, trên 0,25 lớn.
• Training-serving skew: đặc trưng lúc huấn luyện và lúc chạy thật tính khác nhau → dùng chung code hoặc feature store.
• Tái lập được: DVC (Git chỉ lưu file hash), snapshot dữ liệu, ghim Docker image bằng digest, đặt seed và bật chế độ tất định, version hóa định nghĩa đặc trưng. Dockerfile: copy requirements.txt và cài trước rồi mới COPY . ..
• Golden set dùng đi dùng lại để chọn prompt sẽ bị overfit → cần tập holdout. Đặt ngưỡng không được tụt riêng cho các nhóm quan trọng. Chênh vài câu trên golden set nhỏ có thể chỉ là nhiễu.
• LLM-as-judge có thiên vị vị trí, thiên vị câu dài và tự khen mình. Hiệu chuẩn với nhãn người bằng Cohen's kappa κ = (p_o − p_e)/(1 − p_e).

Tư duy sản phẩm AI

• Chọn công cụ: mẫu cố định (mã bưu chính, 5 điều kiện hoàn tiền) → regex hoặc rule engine; dự đoán xác suất từ dữ liệu bảng → gradient boosting hoặc logistic; văn bản tự do → LLM.
• Đo tác động thật bằng A/B hoặc triển khai so le, không dựa vào AUC offline hay "85% nhân viên có dùng".
• Hệ gợi ý: món mới chưa có tương tác (cold start) → dựa trên nội dung; khách chưa đăng nhập → dùng tín hiệu trong phiên; popularity bias tạo vòng phản hồi → thêm khám phá có kiểm soát; click chỉ là tín hiệu ngầm.
• Duyệt tay theo ngưỡng tin cậy: số hồ sơ duyệt tay = N × tỉ lệ dưới ngưỡng; số lỗi lọt = N × tỉ lệ tự động × (1 − độ chính xác).
• Luôn có baseline không dùng AI để so sánh. Mức sử dụng thấp thường do cả kỹ thuật lẫn con người (độ trễ, độ chính xác, sợ bị chấm điểm).

DLogic, đạo đức và hành vi

Ít câu nhưng nhiều câu vận dụng cao. Đáp án đúng gần như luôn là phương án cân bằng: không cấm hẳn, không làm liều, mà đo lường, giảm thiểu, minh bạch và có người chịu trách nhiệm.

Logic và ngụy biện CĐ-12

• p → q tương đương ¬q → ¬p (phản đảo). Không suy ra được q → p hay ¬p → ¬q.
• "Nếu đạt test thì được phỏng vấn" và biết "X được phỏng vấn" → không kết luận được X có đạt test hay không.
• Phủ định: ¬(mọi x đều P) = có ít nhất một x không P; ¬(có x thỏa P) = mọi x đều không P. De Morgan: ¬(A ∨ B) = ¬A ∧ ¬B, ¬(A ∧ B) = ¬A ∨ ¬B.
• Kiểm tra quy tắc "nếu P thì Q" (bài 4 thẻ của Wason): chỉ cần lật thẻ P và thẻ không Q.
• Bài lời khai "chỉ một người nói thật": giả sử lần lượt từng người nói thật rồi kiểm tra mâu thuẫn. Đếm số trường hợp thỏa: lập bảng chân trị 2ⁿ dòng.
• Ngụy biện hay gặp: post hoc (xảy ra sau nên do cái trước gây ra), tương quan ≠ nhân quả (biến gây nhiễu), ad hominem (công kích người nói), strawman (bóp méo ý đối phương), survivorship bias (chỉ khảo sát người ở lại), p-hacking (soi nhiều phân khúc rồi chọn cái đẹp), nghịch lý Simpson.

Dữ liệu cá nhân, công bằng, luật ≈31 câu quyền riêng tư

• Tối thiểu hóa dữ liệu: chỉ thu cái cần cho mục đích đã nêu. Giới hạn mục đích: muốn dùng cho mục đích mới (quảng cáo) thì xin đồng ý riêng. Đồng ý tách theo từng mục đích, mặc định tắt. Người dùng rút đồng ý thì dừng xử lý từ thời điểm đó.
• Giả danh hóa ≠ ẩn danh hóa. Băm SĐT hay IP bằng SHA-256 không salt vẫn dò ngược được vì số giá trị có hạn. Giữ bảng ánh xạ thì vẫn định danh lại được. k-anonymity: nhóm nhỏ nhất theo các thuộc tính định danh gián tiếp phải có ít nhất k bản ghi.
• Dữ liệu nhạy cảm: sinh trắc học (vân tay, khuôn mặt), sức khỏe, số định danh. Đề nhắc Luật Bảo vệ dữ liệu cá nhân 2025 (91/2025/QH15). Không dán hồ sơ bệnh án vào chatbot công cộng.
• GDPR: rò rỉ dữ liệu phải báo cơ quan giám sát trong 72 giờ.
• Công bằng: demographic parity là tỉ lệ được chọn bằng nhau giữa các nhóm; quy tắc 4/5: tỉ lệ nhóm thấp / nhóm cao < 0,8 là dấu hiệu tác động bất lợi; equal opportunity là TPR bằng nhau; equalized odds là cả TPR và FPR bằng nhau. Mã bưu chính có thể là biến proxy. Đánh giá tách theo nhóm, không chỉ nhìn AUC chung.
• Con người trong vòng lặp: ca rủi ro cao hoặc tin cậy thấp thì chuyển người duyệt. Người duyệt đồng ý 99,7% là thiên lệch tự động hóa → đo tỉ lệ bác bỏ, kiểm tra ngẫu nhiên.
• Minh bạch: báo người dùng đang nói chuyện với AI; khi chặn thì nêu lý do, mã tham chiếu và cách khiếu nại; tài liệu model card; giải thích phản thực ("thay đổi nhỏ nhất để được chấp nhận"); giải thích theo người nhận (bác sĩ, bệnh nhân, kiểm toán cần thông tin khác nhau).
• Thấy sai sót thì ghi bằng chứng và báo ngay người có thẩm quyền, kể cả sát ngày ra mắt. Không dùng dark pattern như "Chỉ còn 2 phòng!" giả.
• EU AI Act: cấm (suy luận cảm xúc nhân viên tại nơi làm việc, chấm điểm xã hội); rủi ro cao (chấm điểm tín dụng, lọc CV, giáo dục; cần quản lý rủi ro, quản trị dữ liệu, nhật ký, con người giám sát); rủi ro hạn chế (chatbot: phải minh bạch); rủi ro tối thiểu (lọc spam). Bên triển khai mua hệ thống rủi ro cao vẫn phải giám sát và lưu nhật ký.

An toàn LLM (OWASP LLM Top 10) ≈13 câu prompt injection

• Nội dung từ ngoài (email, CV, web, kết quả tool) là dữ liệu không tin cậy. Chỉ thêm câu "đừng làm theo chỉ dẫn trong email" vào prompt là không đủ, vì chỉ dẫn và dữ liệu nằm chung một chuỗi token. Chặn tất định ở tầng công cụ: quyền tối thiểu, hạn mức, người duyệt.
• "Bộ ba nguy hiểm": truy cập dữ liệu riêng tư + tiếp xúc nội dung không tin cậy + có kênh gửi dữ liệu ra ngoài. Cấu hình agent có đủ cả ba là rủi ro nhất; bỏ một trong ba.
• Đầu ra Markdown có ảnh trỏ ra domain lạ có thể làm lộ dữ liệu → chỉ render ảnh và link trong allowlist.

Tự luận và code viết tay

Khoảng 25 điểm mỗi đề. Rubric chấm theo từng ý, nên viết đủ ý quan trọng hơn viết hay. Đề thường có 2–3 câu tự luận và 1–2 câu code.

Khung 7 ý cho câu tự luận tình huống

1. Mục tiêu và đầu raHệ thống trả ra cái gì, phục vụ quyết định nào, lỗi loại nào đắt hơn.
2. Dữ liệu và nhãnLấy từ đâu, nhãn có sau bao lâu, chia train/test theo thời gian, cột nào gây rò rỉ.
3. Giải pháp và baselinePipeline cụ thể, so với cách làm hiện tại hoặc rule đơn giản.
4. Đánh giá offline có ngưỡng sốChỉ số chính theo chi phí lỗi, golden set do người gán, tách theo nhóm, ngưỡng chấp nhận ghi bằng con số.
5. Rủi ro và guardrailCông bằng, dữ liệu cá nhân, prompt injection, con người duyệt ca tin cậy thấp, minh bạch và kênh khiếu nại.
6. Triển khai theo giai đoạnShadow → pilot hoặc canary → A/B đo tác động thật trên chỉ số kinh doanh.
7. Giám sát và điều kiện dừngTheo dõi drift, tỉ lệ khiếu nại, chi phí; nêu rõ ngưỡng nào thì rollback và kế hoạch quay về làm tay.

Câu có số liệu: ghi từng bước tính. Chỉ ghi kết quả thì bị điểm thấp, sai số nhưng đúng cách vẫn có điểm. Thiếu dữ kiện thì ghi rõ giả định rồi làm tiếp.

Checklist code viết tay

• Đúng tên hàm và tham số đề yêu cầu, trả đúng kiểu (dict, list, DataFrame có đúng các cột).
• Xử lý trường hợp biên: list rỗng, NaN, chia cho 0, k lớn hơn số phần tử, khóa không tồn tại.
• Không sửa dữ liệu đầu vào (dùng .copy() hoặc assign). Trong pandas dùng phép vector hóa, không lặp từng dòng.
• Sắp xếp có tiêu chí hòa khi đề yêu cầu: sort_values(["doanh_thu","ten"], ascending=[False, True]).
• Tự chạy tay ví dụ trong đề trước khi nộp.

def top_k_doanh_thu(df, k):
    out = (df.assign(doanh_thu=df["so_luong"] * df["don_gia"])
             .groupby("danh_muc", as_index=False)["doanh_thu"].sum()
             .sort_values(["doanh_thu", "danh_muc"], ascending=[False, True])
             .head(k)
             .reset_index(drop=True))
    return out

Luyện tiếp ở đâu

• Tab Luyện đề trên trang này có 32 bộ, 1.472 câu: 2 đề sát thật tự soạn, 2 bài luyện nhanh Toán và Code tay, 18 đề của anh Hiếu, 10 đề AI-TEST. Bạn tự thêm đề của mình được.
• hieubui2409.github.io/ai20k-exam-prep: trang gốc của 18 đề anh Hiếu, có chế độ Luyện kiến thức (đúng/sai ngay từng câu) và mã đề để mentor chữa bài.
• hungbil.github.io/AI-TEST: trang gốc của 10 đề AI-TEST, có thêm cheat sheet. Bộ "Crown" cần mật khẩu của nhóm nên không có ở đây.
• Thứ tự gợi ý: đọc một mục trong sổ tay → làm chuyên đề tương ứng → mỗi tuần làm một đề có hẹn giờ.