Bài tập lý thuyết

Một lời giải cần cho người đọc kiểm được

Trong CP, chứng minh thuật toán thường có invariant và độ phức tạp. Với AI, lời giải cũng cần một đường kiểm tra: đề cho gì, mô hình giả định gì, dùng định nghĩa nào và kết quả có ý nghĩa gì. Chẳng hạn “$p=0.9$” chưa đủ; phải nói đây là $P(\text{cảnh báo}\mid\text{có lỗi})$ hay $P(\text{có lỗi}\mid\text{cảnh báo})$.

Ta dùng quy trình bốn bước:

1. Xác định đại lượng cần trả lời, không tính ngay số dễ có nhất.
2. Viết ký hiệu cùng miền giá trị, shape hoặc đơn vị.
3. Biến đổi công thức trước khi thế số, để người đọc nhận ra phép tính dùng định nghĩa nào.
4. Kiểm bằng một trường hợp nhỏ hoặc code độc lập, rồi diễn giải kết quả.

Code là công cụ đối chiếu; dòng True không thay thế lời giải thích vì sao.

Hai chiều của việc kiểm không cân nhau. Một khẳng định “với mọi $\mathbf w$” không được chứng minh bằng hữu hạn lần chạy, dù nhiều đến đâu. Ngược lại, một phản ví dụ nhỏ, chạy đúng, đủ để bác bỏ nó.

Xác suất: điều kiện nằm ở phía nào?

Giả sử một tập kiểm có đúng 1000 bài nộp: 20 bài có lỗi và 980 bài không lỗi. Detector cảnh báo 18 trong 20 bài lỗi, đồng thời cảnh báo nhầm 98 trong 980 bài sạch.

Chọn ngẫu nhiên đều một bài trong tập này. Gọi $B$ là biến cố “bài có lỗi”, $F$ là “bị cảnh báo”. Ta có $P(B)=20/1000=0.02$, $P(F\mid B)=18/20=0.9$ và $P(F\mid\neg B)=98/980=0.1$. Bayes đảo chiều điều kiện:

Mẫu số dùng total probability:

Vậy $P(B\mid F)=0.018/0.116=18/116\approx0.1552$, chỉ khoảng 15.5%. Khi lỗi hiếm, một tỉ lệ báo nhầm nhỏ trên nhóm sạch lớn vẫn sinh nhiều cảnh báo hơn nhóm lỗi. Không có mâu thuẫn với recall 90%; hai câu hỏi dùng hai tập làm mẫu số khác nhau. Recall và tỉ lệ báo nhầm là tính chất của detector; $P(B\mid F)$ còn phụ thuộc tỉ lệ lỗi $P(B)$ của nơi đem detector ra dùng.

Bộ phân loại Bayes chọn lớp có xác suất hậu nghiệm lớn nhất; không có đặc trưng nào thì chỉ còn tiền nghiệm, nên với hai lớp chiếm 2/3 và 1/3 ta đoán lớp đông.

import numpy as np

tp, fn, fp, tn = 18, 2, 98, 882
total = tp + fn + fp + tn
prior = (tp + fn) / total
sensitivity = tp / (tp + fn)
false_alarm_rate = fp / (fp + tn)
alarm_probability = sensitivity * prior + false_alarm_rate * (1 - prior)
posterior = sensitivity * prior / alarm_probability
print(f"P(lỗi)={prior:.4f}, P(cảnh báo)={alarm_probability:.4f}")
print(f"P(lỗi | cảnh báo)={posterior:.4f}")
assert np.isclose(posterior, tp / (tp + fp))

Kết quảP(lỗi)=0.0200, P(cảnh báo)=0.1160
P(lỗi | cảnh báo)=0.1552

Muốn nhân hai xác suất cho hai thuộc tính, phải kiểm điều kiện độc lập tương ứng. Công thức luôn đúng là $P(A\cap B)=P(A\mid B)P(B)$; chỉ khi độc lập mới đổi thành $P(A)P(B)$. Một feature xuất hiện nhiều trong bài lỗi không tự động độc lập với feature khác, cũng không chứng minh quan hệ nhân quả.

Vài phép đếm cơ bản: xúc xắc cân đối ra mặt từ 5 trở lên có xác suất $2/6$; xác suất có điều kiện chỉ đếm trong nhóm điều kiện, nên lớp có 12 bạn nữ, 3 bạn nữ đeo kính cho $P(\text{kính} \mid \text{nữ}) = 3/12$.

Naive Bayes (bài 6.1) dùng đúng giả định độc lập khi đã biết lớp, nên chỉ ước lượng từng $P(x_j \mid y)$: $d$ đặc trưng nhị phân, hai lớp cần $2d + 1$ tham số. Nếu không có giả định này, ta phải đếm mọi tổ hợp, mà tổ hợp đủ $n$ từ khóa của một thư mới thường không có thư nào trong train. Cái giá: nhân đôi một cột thì bằng chứng ấy bị đếm hai lần và xác suất thành quá tự tin.

Kỳ vọng và log-loss: trước khi biết đáp án

Một biến Bernoulli $Y\in\{0,1\}$ có $P(Y=1)=q$ thì $\E[Y]=q$, vì $0(1-q)+1q=q$. Do $Y^2=Y$, phương sai là $\operatorname{Var}(Y)=q-q^2=q(1-q)$. Với $q=0.02$, hai số lần lượt là $0.02$ và $0.0196$. Kỳ vọng mô tả trung bình qua nhiều lần rút; một nhóm 50 bài cụ thể vẫn có thể có 0, 1 hay 3 bài lỗi.

Nếu model xuất xác suất $p$ của lớp 1 và nhãn thật là $y$, binary cross-entropy là

Ta dùng logarithm tự nhiên nên loss có đơn vị nats. Khi $y=1$, $p=0.8$ cho loss $-\log0.8\approx0.2231$; dự đoán tự tin sai $p=0.2$ cho khoảng $1.6094$. Accuracy không thấy mức tự tin này nếu hai xác suất vẫn ở cùng một phía threshold.

BCE chính là $-\log$ của xác suất mà model gán cho nhãn thật, tức negative log-likelihood của một mẫu Bernoulli. Vì $\log$ tăng ngặt, tham số làm likelihood của cả tập lớn nhất cũng làm tổng log-loss nhỏ nhất: maximum likelihood và tối thiểu log-loss là cùng một bài toán.

Trước khi biết $Y$, kỳ vọng loss của dự đoán cố định $p$ là $-q\log p-(1-q)\log(1-p)$. Giá trị nhỏ nhất đạt tại $p=q$ khi $0<q<1$; thay vào cho entropy $H(q)$. Nói cách khác, biết tỉ lệ lớp thật thì xác suất phản ánh tỉ lệ đó là dự đoán tối ưu cho log-loss, chưa chắc là quyết định tối ưu cho mọi chi phí hành động.

def expected_log_loss(q, p):
    return -q * np.log(p) - (1 - q) * np.log(1 - p)

q = 0.02
print(f"E[Y]={q:.4f}, Var(Y)={q * (1 - q):.4f}")
print(f"y=1: loss tại p=0.8 là {-np.log(0.8):.4f}; tại p=0.2 là {-np.log(0.2):.4f}")
print(f"E[loss] tại p=0.02: {expected_log_loss(q, 0.02):.4f}")
print(f"E[loss] tại p=0.50: {expected_log_loss(q, 0.50):.4f}")
assert expected_log_loss(q, q) < expected_log_loss(q, 0.5)

Kết quảE[Y]=0.0200, Var(Y)=0.0196
y=1: loss tại p=0.8 là 0.2231; tại p=0.2 là 1.6094
E[loss] tại p=0.02: 0.0980
E[loss] tại p=0.50: 0.6931

Không lấy log(0) trong code tính tay; nó cho vô cùng. Với logits, thư viện có loss gộp sigmoid hoặc softmax để tính ổn định hơn. Một vector xác suất phải không âm và tổng bằng 1; một vector logits không có hai điều kiện này. Khi trình bày, cần nói model đang xuất đại lượng nào.

Đại số tuyến tính: phép nhân mô tả việc gì?

Ta có hai mẫu, mỗi mẫu hai feature, xếp thành hàng của $X$. Linear model với $\mathbf w=(2,-1)$ và $b=1$ cho

Hàng đầu có $1\cdot2+2\cdot(-1)+1=1$; hàng sau có $3\cdot2+4\cdot(-1)+1=3$. Bias cộng vào mỗi mẫu. Shape của $X$ là (2, 2), của $\mathbf w$ là (2,), của kết quả là (2,). Vector một chiều trong NumPy không tự thành cột hai chiều như cách vẽ trên giấy.

X = np.array([[1.0, 2.0], [3.0, 4.0]])
w_linear = np.array([2.0, -1.0])
b_linear = 1.0
prediction = X @ w_linear + b_linear
print("Shape:", X.shape, w_linear.shape, prediction.shape)
print("Dự đoán:", prediction)
assert np.allclose(prediction, [1.0, 3.0])

dependent = np.array([[1.0, 2.0], [2.0, 4.0]])
null_direction = np.array([2.0, -1.0])
print("Hướng không thay đổi dự đoán:", dependent @ null_direction)
print("Hạng ma trận:", np.linalg.matrix_rank(dependent))

Kết quảShape: (2, 2) (2,) (2,)
Dự đoán: [1. 3.]
Hướng không thay đổi dự đoán: [0. 0.]
Hạng ma trận: 1

Ma trận dependent có cột thứ hai gấp đôi cột thứ nhất, nên hạng bằng 1. Thêm $t(2,-1)$ vào trọng số không đổi dự đoán, vì tích với hướng ấy bằng 0. Bởi vậy một nghiệm hệ số chưa chắc duy nhất; muốn dùng nghịch đảo hay nói “nghiệm duy nhất”, phải kiểm điều kiện hạng. Đây là lý do ở bài 2.1 ta cần least squares và regularization khi feature phụ thuộc.

Tích vô hướng $\mathbf u^\top\mathbf v$ vừa dùng để dự đoán, vừa đo quan hệ hình học. Với hai vector khác 0, cosine similarity chia tích vô hướng cho tích độ dài. Nó không đổi khi nhân một vector với số dương; khoảng cách Euclidean thường đổi.

Vì vậy similarity và khoảng cách cần được chọn theo ý nghĩa của embedding, không chỉ theo công thức thuận tay. Vector 0 không có hướng nên cosine của nó không được định nghĩa bằng phép chia thông thường.

Gradient: chia sai số về đúng tham số

Giờ dùng một mẫu phân loại: $\mathbf x=(1,2)$, nhãn $y=1$, trọng số $\mathbf w=(0.2,-0.1)$, bias $b=0$. Logit $z=\mathbf w^\top\mathbf x+b=0$, xác suất $p=\sigma(z)=0.5$. Loss là $\log2\approx0.6931$.

Chain rule nói đạo hàm qua nhiều phép tính là tích các đạo hàm cục bộ. Với binary cross-entropy và sigmoid ghép đúng, các số hạng rút gọn thành

Vậy gradient của $\mathbf w$ là $(-0.5,-1)$, của $b$ là $-0.5$. Gradient descent với $\eta=0.1$ cho $\mathbf w'=(0.25,0)$, $b'=0.05$. Logit mới bằng $0.3$, xác suất tăng lên khoảng $0.5744$, loss giảm còn khoảng $0.5544$. Nhãn là 1 nên dấu thay đổi có nghĩa: model cần tăng xác suất lớp 1.

Ta gộp $\boldsymbol\theta=(w_1,w_2,b)$ để kiểm cả ba thành phần bằng sai phân trung tâm. logaddexp(0, z) tính $\log(1+e^z)$ ổn định; loss từ logit là biểu thức đó trừ $yz$.

x = np.array([1.0, 2.0])
y = 1.0
theta = np.array([0.2, -0.1, 0.0])

def logistic_loss(parameters):
    z = x @ parameters[:2] + parameters[2]
    return float(np.logaddexp(0.0, z) - y * z)

def logistic_gradient(parameters):
    z = x @ parameters[:2] + parameters[2]
    p = 1.0 / (1.0 + np.exp(-z))
    return np.append((p - y) * x, p - y)

gradient = logistic_gradient(theta)
h = 1e-5
numerical = np.zeros_like(theta)
for j in range(len(theta)):
    shift = np.zeros_like(theta)
    shift[j] = h
    numerical[j] = (logistic_loss(theta + shift) - logistic_loss(theta - shift)) / (2 * h)
new_theta = theta - 0.1 * gradient
print("Gradient:", gradient)
print("Tham số mới:", new_theta)
print(f"Loss: {logistic_loss(theta):.4f} -> {logistic_loss(new_theta):.4f}")
print("Sai phân khớp:", np.allclose(gradient, numerical, atol=1e-8))
assert np.allclose(gradient, [-0.5, -1.0, -0.5])
assert logistic_loss(new_theta) < logistic_loss(theta)

Kết quảGradient: [-0.5 -1.  -0.5]
Tham số mới: [0.25 0.   0.05]
Loss: 0.6931 -> 0.5544
Sai phân khớp: True

Gradient cho xấp xỉ bậc nhất $L(\boldsymbol\theta+\boldsymbol\Delta)\approx L(\boldsymbol\theta)+\nabla L^\top\boldsymbol\Delta$ khi $\boldsymbol\Delta$ nhỏ. Đạo hàm âm theo một tham số nghĩa là tăng tham số ấy một chút thì loss giảm, nên bước descent $\boldsymbol\Delta=-\eta\nabla L$ làm nó tăng.

Tình huống loss tăng ở đầu bài thường có một trong hai nguyên nhân: cộng gradient thay vì trừ, hoặc bước quá lớn, vượt khỏi vùng mà xấp xỉ tuyến tính còn dùng được.

Gradient bằng 0 là điểm dừng, không tự chứng minh đó là cực tiểu toàn cục của một mạng phi tuyến. Với loss lồi, như MSE của linear regression hay log-loss của logistic regression, mọi điểm dừng đều là cực tiểu toàn cục; cần nói rõ lớp hàm đang xét.

Nếu thêm penalty $\lambda\lVert\mathbf w\rVert^2$ thì gradient theo $\mathbf w$ có thêm $2\lambda\mathbf w$. Nếu đề dùng $\lambda\lVert\mathbf w\rVert^2/2$, số 2 biến mất. Trên một batch, loss lấy trung bình cũng làm gradient có hệ số $1/n$. Viết rõ loss trước khi đạo hàm là cách tránh chép nhầm quy ước.

Kiến trúc mạng: đếm shape trước khi đếm tham số

Một câu lý thuyết về CNN thường chỉ cần phân biệt số mẫu, channel và không gian. Với convolution không dilation, input cao $H$, kernel $k$, padding $p$, stride $s$, chiều cao đầu ra là

Input (N, C, H, W) = (4, 3, 8, 8), hai output channel, $k=3$, $p=1$, $s=2$ cho $H_{\text{out}}=W_{\text{out}}=4$. Shape output là (4, 2, 4, 4). Mỗi output channel dùng $3\cdot3\cdot3=27$ weight và một bias, tổng $2(27+1)=56$ tham số.

Tổng quát, Conv2d có $C_{\text{out}}(C_{\text{in}}k^2+1)$ tham số, bỏ số 1 khi bias=False; cách đặt này thường gặp khi BatchNorm đứng ngay sau, vì BatchNorm đã có tham số dịch riêng. Batch size và số vị trí ảnh không nhân vào số tham số: các weight được dùng lại ở nhiều vị trí.

import torch

torch.manual_seed(0)
conv = torch.nn.Conv2d(3, 2, kernel_size=3, stride=2, padding=1)
images = torch.zeros(4, 3, 8, 8)
with torch.no_grad():
    conv_output = conv(images)
parameter_count = sum(parameter.numel() for parameter in conv.parameters())
print("Output shape:", tuple(conv_output.shape))
print("Số tham số:", parameter_count)
assert tuple(conv_output.shape) == (4, 2, 4, 4)
assert parameter_count == 56

Kết quảOutput shape: (4, 2, 4, 4)
Số tham số: 56

Một forward trên tensor toàn 0 đủ để kiểm shape và số tham số; không cần train. Nếu đề có dilation $d$, thay $k$ bằng effective size $d(k-1)+1$. Kernel $1\times1$ vẫn có $C_{\text{in}}C_{\text{out}}$ weight: nó không nhìn lân cận nhưng trộn các channel tại từng vị trí. Pooling thường không có weight học được; residual addition yêu cầu shape hai nhánh khớp hoặc có projection để đưa về cùng shape.

Attention: một hàng là một cách lấy trung bình

Với một head, $Q$ có shape (Tq, dk), $K$ có shape (Tk, dk), $V$ có shape (Tk, dv). Ma trận score $QK^\top/\sqrt{d_k}$ có shape (Tq, Tk). Softmax theo trục key tạo một phân phối cho mỗi query, rồi nhân $V$ để lấy tổng có trọng số:

Ta chọn $Q=K=I_2$, tức ma trận đơn vị 2 chiều, và hai value là $(2,0)$, $(0,4)$. Score của query đầu là $(1/\sqrt2,0)$. Softmax cho trọng số khoảng $(0.6698,0.3302)$, nên output đầu là $(1.3395,1.3210)$. Đây là vector giá trị pha trộn, không phải index của một token được chọn.

Q = np.eye(2)
K = np.eye(2)
values = np.array([[2.0, 0.0], [0.0, 4.0]])

def row_softmax(scores):
    shifted = scores - scores.max(axis=1, keepdims=True)
    exponentials = np.exp(shifted)
    return exponentials / exponentials.sum(axis=1, keepdims=True)

scores = Q @ K.T / np.sqrt(Q.shape[1])
weights = row_softmax(scores)
attention_output = weights @ values
print("Trọng số:\n", weights.round(4))
print("Output:\n", attention_output.round(4))
assert np.allclose(weights.sum(axis=1), 1.0)

masked_scores = scores.copy()
masked_scores[0, 1] = -np.inf       # query đầu không nhìn token tương lai
causal_weights = row_softmax(masked_scores)
print("Output đầu với causal mask:", (causal_weights @ values)[0])
assert np.allclose(causal_weights[0], [1.0, 0.0])

Kết quảTrọng số:
 [[0.6698 0.3302]
 [0.3302 0.6698]]
Output:
 [[1.3395 1.321 ]
 [0.6605 2.679 ]]
Output đầu với causal mask: [2. 0.]

Đặt mask vào score trước softmax làm xác suất bị cấm bằng 0 rồi chuẩn hóa lại phần được phép. Đặt một weight về 0 sau softmax mà không chuẩn hóa lại làm tổng hàng nhỏ hơn 1. Nếu một query bị mask toàn bộ key, softmax không có phân phối hợp lệ; cần xử lý theo thiết kế của model, không mong phép tính tự hiểu padding.

Trong một layer thật, $Q=XW_Q$, $K=XW_K$, $V=XW_V$ với $X$ shape (T, d_model), rồi các head được nối lại và đi qua một phép chiếu ra. Tham số nằm ở các ma trận chiếu, nên số tham số không phụ thuộc độ dài chuỗi $T$; ngược lại, ma trận score (T, T) tăng theo $T^2$. Đếm tham số và đếm bộ nhớ là hai câu hỏi khác nhau.

Đánh giá: trở lại detector đầu bài

Bảng 1000 bài có $TP=18$, $FN=2$, $FP=98$, $TN=882$. Recall bằng $TP/(TP+FN)=0.9$, trả lời “bắt được bao nhiêu bài lỗi?”. Precision bằng $TP/(TP+FP)=18/116\approx0.1552$, trả lời “cảnh báo đáng tin tới đâu?”. Hai số đúng là hai xác suất có điều kiện đã gặp ở đầu bài.

Accuracy bằng $(TP+TN)/1000=0.9$. Nhưng baseline luôn đoán sạch có accuracy $0.98$ và recall 0. Không thể từ một số 0.98 kết luận baseline giải quyết mục tiêu tìm lỗi tốt hơn; cũng không thể bỏ qua 98 cảnh báo nhầm vì recall cao. Metric cần phản ánh yêu cầu và chi phí kiểm thủ công của bài.

F1 dùng trung bình điều hòa của precision và recall, tương đương

Để đối chiếu với scikit-learn, ta dựng lại vector nhãn và vector dự đoán đúng theo bốn ô của bảng.

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

labels = np.array([1] * (tp + fn) + [0] * (fp + tn))
predicted = np.array([1] * tp + [0] * fn + [1] * fp + [0] * tn)
accuracy = (tp + tn) / total
precision = tp / (tp + fp)
recall = tp / (tp + fn)
f1 = 2 * tp / (2 * tp + fp + fn)
library = np.array([
    accuracy_score(labels, predicted), precision_score(labels, predicted),
    recall_score(labels, predicted), f1_score(labels, predicted),
])
assert np.allclose(library, [accuracy, precision, recall, f1])
print(f"Accuracy={accuracy:.4f}, precision={precision:.4f}, recall={recall:.4f}, F1={f1:.4f}")
print(f"Baseline sạch: accuracy={(fp + tn) / total:.4f}, recall=0.0000")
print("Tính tay khớp thư viện:", True)

Kết quảAccuracy=0.9000, precision=0.1552, recall=0.9000, F1=0.2647
Baseline sạch: accuracy=0.9800, recall=0.0000
Tính tay khớp thư viện: True

Khi chấm model thật, chỉ dùng train để fit tham số; chọn threshold, kiến trúc và hyperparameter bằng validation phù hợp, rồi giữ test để đánh giá cuối.

Với nhiều bài của cùng một người hoặc cùng một nguồn, random split có thể lọt kiểu viết giữa train và validation; lúc ấy cần group split. Nếu mục tiêu dự đoán ở tương lai, cách chia theo thời gian có thể phù hợp hơn. Stratification giữ tỉ lệ lớp nhưng không tự chữa leakage theo nhóm.

Một điểm trên tập nhỏ có sai số lấy mẫu. Nếu 1000 kết quả đúng hay sai thật sự độc lập và cùng xác suất đúng 0.9, độ lệch chuẩn của accuracy mẫu là $\sqrt{0.9\cdot0.1/1000}\approx0.0095$. Giả thiết độc lập là phần quan trọng: nếu nhiều mẫu đến từ cùng một người, chúng tương quan và độ bất định thật lớn hơn con số này.

Hai model nên được so trên cùng split và đọc loại lỗi của chúng, không chỉ xếp hạng một điểm duy nhất.