Logistic regression và softmax

Dữ liệu: lọc thư rác

Mỗi email được mô tả bằng hai con số: số đường link và số từ quảng cáo như “miễn phí”, “trúng thưởng”, “khuyến mãi”. Nhãn là $1$ nếu là spam, $0$ nếu là thư thường. Giống bài 2.1, ta tự sinh dữ liệu từ một quy luật đã biết để sau này đối chiếu xem mô hình học được gì. Quy luật dùng hàm sigmoid, sẽ được giải thích ngay ở mục sau; lúc này chỉ cần biết email càng nhiều link và từ quảng cáo thì càng dễ là spam.

import numpy as np

rng = np.random.default_rng(20)
n = 400
links = rng.poisson(2.0, n)                           # số đường link
kw = rng.poisson(1.5, n)                              # số từ quảng cáo
z_true = 1.1 * links + 0.9 * kw - 4.5                 # quy luật thật, mô hình không được biết
y = (rng.random(n) < 1 / (1 + np.exp(-z_true))).astype(float)   # 1 = spam

X = np.column_stack([links, kw]).astype(float)        # (400, 2)
X_tr, X_te, y_tr, y_te = X[:300], X[300:], y[:300], y[300:]
print(X_tr.shape, X_te.shape, " tỉ lệ spam:", y.mean())
print(X[:4], y[:4])

Kết quả(300, 2) (100, 2)  tỉ lệ spam: 0.3125
[[1. 1.]
 [0. 0.]
 [2. 0.]
 [0. 3.]] [0. 0. 0. 0.]

Khoảng một phần ba số email là spam. 300 email đầu dùng để học, 100 email sau để kiểm tra.

Vì sao không dùng linear regression?

Cách nghĩ đầu tiên: nhãn là số $0$ và $1$, vậy cứ chạy linear regression rồi coi đầu ra là xác suất.

from sklearn.linear_model import LinearRegression

lin = LinearRegression().fit(X_tr, y_tr)
p_lin = lin.predict(X_tr)
print("dự đoán nhỏ nhất:", p_lin.min().round(2), " lớn nhất:", p_lin.max().round(2))
print("số email có 'xác suất' ngoài [0, 1]:", np.sum((p_lin < 0) | (p_lin > 1)))

Kết quảdự đoán nhỏ nhất: -0.2  lớn nhất: 1.34
số email có 'xác suất' ngoài [0, 1]: 54

Vấn đề thứ nhất hiện ngay trong output: một phần đáng kể dự đoán nằm ngoài $[0, 1]$. “Xác suất $-0.2$” không có nghĩa gì.

Vấn đề thứ hai nghiêm trọng hơn. Để dễ nhìn, tạm chỉ dùng số link. Linear regression cho một đường thẳng; email được coi là spam khi đường thẳng vượt $0.5$, tức số link vượt một ngưỡng nào đó. Giờ thêm vào tập train 20 email “siêu spam” có từ 15 đến 24 link. Những email này rõ ràng là spam, phân loại chúng chẳng khó gì, nên lẽ ra chúng không được làm thay đổi ranh giới.

def link_threshold(model):
    """Số link tại đó đường thẳng cắt mức 0.5."""
    return (0.5 - model.intercept_) / model.coef_[0]

def accuracy_at(t):
    """Accuracy trên tập test khi coi email có từ t link trở lên là spam."""
    return np.mean((X_te[:, 0] >= t) == y_te)

L_tr = X_tr[:, :1]                                    # chỉ số link, shape (300, 1)
extra = np.repeat(np.arange(15, 25), 2)[:, None]      # 20 email siêu spam
L_more, y_more = np.vstack([L_tr, extra]), np.append(y_tr, np.ones(20))

for name, L, yy in [("300 email gốc    ", L_tr, y_tr), ("thêm 20 siêu spam", L_more, y_more)]:
    t = link_threshold(LinearRegression().fit(L, yy))
    print(f"{name}: ngưỡng = {t:.2f} link   accuracy test = {accuracy_at(t):.2f}")

Kết quả300 email gốc    : ngưỡng = 3.07 link   accuracy test = 0.78
thêm 20 siêu spam: ngưỡng = 6.00 link   accuracy test = 0.68

Ngưỡng nhảy từ khoảng 3 link lên 6 link, và accuracy trên tập test tụt 10 điểm phần trăm. Lý do nằm ở hàm mất mát bình phương: email 24 link có nhãn $1$ nhưng đường thẳng dự đoán cho nó một số lớn hơn $1$ nhiều, nên bị tính là “sai nặng”. Để giảm cái sai vô lý đó, đường thẳng phải thoải xuống, kéo theo ngưỡng dịch sang phải. Mô hình bị phạt vì quá chắc chắn ở chỗ đúng.

Hai vấn đề có chung một gốc: đầu ra không bị chặn trong $(0, 1)$, và hàm mất mát không hợp với xác suất. Hai mục tiếp theo sửa lần lượt từng cái.

Sigmoid và log-odds

Giữ phần tuyến tính $z = \mathbf{w}^\top\mathbf{x} + b$ như cũ, rồi ép nó về khoảng $(0, 1)$ bằng hàm sigmoid:

Sigmoid nhận mọi số thực và trả về một số trong $(0, 1)$. $z = 0$ cho $p = 0.5$; $z = 3$ cho $p \approx 0.95$; $z = -3$ cho $p \approx 0.05$. Đi xa khỏi 0 thì đường cong phẳng dần: tăng $z$ từ 10 lên 20 gần như không đổi $p$. Tên có chữ “hồi quy” vì mô hình hồi quy ra một xác suất, nhưng việc của nó là phân loại: cắt xác suất ở một ngưỡng là có nhãn.

Để hiểu $z$ là gì, giải ngược phương trình trên theo $z$:

Tỉ số $\frac{p}{1-p}$ gọi là odds, cách nói “mấy ăn một” quen thuộc trong cá cược: $p = 0.75$ thì odds là $3$, nghĩa là khả năng spam gấp 3 khả năng không spam. $z$ là log của odds, gọi là log-odds hay logit. Vậy logistic regression là một mô hình tuyến tính, nhưng tuyến tính cho log-odds chứ không cho xác suất. Đi ngược lại cũng dễ: $z = \ln 3$ cho odds 3, tức $p = 3/4$. Muốn lúc đầu mô hình đoán khoảng $0.01$ cho bài chỉ có 1% mẫu dương thì đặt bias bằng $\ln(0.01/0.99) \approx -4.6$.

Hệ quả trực tiếp: tăng $x_j$ thêm một đơn vị thì $z$ tăng $w_j$, nên odds nhân thêm $e^{w_j}$. Bài báo y khoa hay viết “hút thuốc làm odds mắc bệnh tăng gấp 3” chính là đọc hệ số của logistic regression theo cách này.

Ranh giới quyết định

Muốn ra nhãn thì cắt xác suất ở một ngưỡng, mặc định là $0.5$. Vì $\sigma(z) \ge 0.5$ khi và chỉ khi $z \ge 0$, ranh giới giữa hai lớp là tập điểm có

Với hai đặc trưng, đó là một đường thẳng; với $d$ đặc trưng, một siêu phẳng. Sigmoid chỉ quyết định xác suất thay đổi nhanh hay chậm khi đi xuyên qua ranh giới, không làm ranh giới cong đi. Logistic regression vì vậy vẫn là một bộ phân loại tuyến tính. Muốn ranh giới cong thì làm như bài 2.1: thêm đặc trưng $x_1^2, x_2^2, x_1x_2$, khi đó ranh giới thẳng trong không gian đặc trưng mới thành đường cong trong mặt phẳng cũ. Chẳng hạn thêm một cột $x_1^2 + x_2^2$ thì ranh giới là đường tròn, hoặc vẫn là đường thẳng nếu hệ số của cột đó bằng 0.

Với một đặc trưng, ranh giới là một điểm: $x = -b/w$. Nhân cả $\mathbf{w}$ và $b$ với một số dương không đổi dấu của $z$, nên không đổi nhãn nào; chỉ xác suất dốc hơn hay thoải hơn quanh ranh giới. Khoảng cách từ điểm $\mathbf{x}$ tới ranh giới là $|\mathbf{w}^\top\mathbf{x} + b| / \lVert\mathbf{w}\rVert$. Lặp lại thí nghiệm 20 email siêu spam, lần này bằng logistic regression của scikit-learn. Tham số C=np.inf tắt khoản phạt của bài 2.2 để so cho công bằng với linear regression không phạt; mục sau sẽ nói kỹ hơn.

from sklearn.linear_model import LogisticRegression

for name, L, yy in [("300 email gốc    ", L_tr, y_tr), ("thêm 20 siêu spam", L_more, y_more)]:
    m = LogisticRegression(C=np.inf).fit(L, yy)
    t = -m.intercept_[0] / m.coef_[0, 0]
    print(f"{name}: ngưỡng = {t:.2f} link   accuracy test = {accuracy_at(t):.2f}")

Kết quả300 email gốc    : ngưỡng = 3.01 link   accuracy test = 0.78
thêm 20 siêu spam: ngưỡng = 3.01 link   accuracy test = 0.78

Ngưỡng không nhúc nhích, ít nhất đến hai chữ số thập phân. Với email 24 link, mô hình đã cho $p$ rất gần $1$; đúng nhãn và đúng tự tin thì gần như không bị phạt, nên những email này không kéo ranh giới đi đâu cả. Lý do nằm ở hàm mất mát của mục tiếp theo.

Hàm mất mát: cross-entropy

Mô hình gán xác suất $p_i$ cho nhãn $1$ và $1 - p_i$ cho nhãn $0$. Một cách tự nhiên để chấm điểm là hỏi: mô hình gán bao nhiêu xác suất cho đúng cái nhãn đã xảy ra? Với một mẫu, con số đó là $p_i$ nếu $y_i = 1$ và $1 - p_i$ nếu $y_i = 0$, viết gọn là $p_i^{y_i}(1-p_i)^{1-y_i}$. Coi các email độc lập, xác suất cho cả tập dữ liệu là tích của chúng. Chọn tham số làm tích này lớn nhất gọi là maximum likelihood.

Tích của hàng trăm số nhỏ hơn 1 rất khó làm việc, nên ta lấy log để biến tích thành tổng, đổi dấu để thành bài toán cực tiểu, rồi chia cho $n$. Kết quả là binary cross-entropy, còn gọi là log loss:

Trong mỗi số hạng chỉ một trong hai phần còn lại: với email spam là $-\log p_i$, với thư thường là $-\log(1 - p_i)$. Nhìn vào một email spam thật: đoán $p = 0.99$ mất $0.01$; đoán $p = 0.5$ mất $0.69$; đoán $p = 0.01$ mất $4.6$. Khi $p \to 0$, loss tăng vô hạn. Cross-entropy phạt rất nặng sự tự tin sai, và gần như không phạt sự tự tin đúng. Đây chính là lý do 20 email siêu spam không kéo được ranh giới. Với thư thường mà mô hình đoán $p = 0.9$, loss là $-\log 0.1 \approx 2.30$. Nhưng mọi email vẫn góp một khoản dương, dù nhỏ, nên ranh giới phụ thuộc vào tất cả các điểm chứ không chỉ những điểm gần nó.

Tại sao không giữ hàm bình phương $(p - y)^2$ cho quen? Hãy nhìn gradient theo $z$. Với một email spam mà mô hình đang đoán $p = 0.01$, tức sai rất nặng:

• Bình phương: $\frac{\partial}{\partial z}(p - 1)^2 = 2(p - 1)\,p(1 - p) \approx -0.0196$.
• Cross-entropy: $\frac{\partial}{\partial z}\big(-\log p\big) = p - 1 = -0.99$.

Gradient của hàm bình phương nhỏ hơn 50 lần, đúng ở chỗ mô hình cần sửa nhiều nhất. Thừa số $p(1-p)$ đến từ đạo hàm của sigmoid và gần bằng 0 ở hai đầu, nơi đường cong phẳng. Cross-entropy có $\log$ triệt tiêu đúng thừa số đó. Thêm nữa, hàm bình phương ghép với sigmoid không còn lồi, còn cross-entropy thì lồi: không có cực tiểu địa phương nào để mắc kẹt.

Gradient và tự cài bằng NumPy

Đạo hàm của sigmoid có dạng đẹp: $\sigma'(z) = \sigma(z)\big(1 - \sigma(z)\big) = p(1 - p)$. Với một mẫu, loss là $\ell = -\big[y\log p + (1-y)\log(1-p)\big]$. Theo quy tắc chuỗi:

Mọi phân số triệt tiêu, chỉ còn lại “xác suất đoán trừ nhãn thật”. Vì $z = \mathbf{w}^\top\mathbf{x} + b$, nhân thêm $\mathbf{x}$ để có đạo hàm theo $\mathbf{w}$, rồi lấy trung bình trên cả tập:

So với linear regression ở bài 2.1, công thức giống hệt, chỉ thay $\hat{\mathbf{y}}$ bằng $\mathbf{p}$ và không có hệ số 2. Sự trùng hợp này không phải tình cờ: cả hai thuộc cùng một họ mô hình (generalized linear model), và ở đó gradient luôn có dạng “dự đoán trừ thực tế, nhân với đặc trưng”.

Thử với một mẫu $x = 2$, nhãn $y = 1$, mô hình $w = 1$, $b = -1$. Khi đó $z = 1 \cdot 2 - 1 = 1$, $p = \sigma(1) = 0.731$, loss $= -\log 0.731 = 0.313$. Gradient theo $w$ là $(p - y)\,x = (0.731 - 1)\cdot 2 = -0.538$. Gradient âm nghĩa là tăng $w$ sẽ giảm loss: một bước với learning rate $0.5$ cho $w = 1 + 0.5 \cdot 0.538 = 1.269$, và mô hình tự tin hơn vào nhãn đúng.

Bảng shape cho 300 email train với 2 đặc trưng:

Cài đặt theo đúng cách của bài 2.1, gộp $(\mathbf{w}, b)$ vào một vector theta:

def sigmoid(z):
    # sigmoid(z) = exp(-log(1 + exp(-z))), tính ổn định
    return np.exp(-np.logaddexp(0., -z))

def loss(theta, X, y):
    logits = X @ theta[:-1] + theta[-1]
    # cross-entropy tính thẳng từ logits: không tràn số, không cần kẹp
    return np.mean(np.logaddexp(0., logits) - y * logits)

def grad(theta, X, y):
    r = sigmoid(X @ theta[:-1] + theta[-1]) - y       # p − y, shape (n,)
    return np.append(X.T @ r / len(y), r.mean())

Loss được tính thẳng từ logits bằng logaddexp, nên không tràn số và không cần kẹp xác suất. Nếu kẹp xác suất ngay trong loss dùng để học, gradient $p - y$ sẽ không còn khớp ở vùng bị kẹp. Trước khi huấn luyện, kiểm gradient bằng sai phân trung tâm như bài 2.1, bước rẻ nhất để bắt lỗi dấu hoặc lỗi chia $n$:

def numerical_grad(f, theta, h=1e-5):
    g = np.zeros_like(theta)
    for j in range(len(theta)):
        e = np.zeros_like(theta)
        e[j] = h
        g[j] = (f(theta + e) - f(theta - e)) / (2 * h)
    return g

def rel_error(a, b):
    return np.linalg.norm(a - b) / (np.linalg.norm(a) + np.linalg.norm(b))

theta0 = np.random.default_rng(1).normal(size=3)
num = numerical_grad(lambda t: loss(t, X_tr, y_tr), theta0)
print(f"sai số tương đối: {rel_error(grad(theta0, X_tr, y_tr), num):.1e}")

Kết quảsai số tương đối: 5.8e-12

Sai số cỡ $10^{-12}$: gradient đúng. Giờ chạy gradient descent. Hai đặc trưng đều là số đếm nhỏ, cùng thang đo, nên ở đây không cần chuẩn hóa.

theta = np.zeros(3)
history = []
for epoch in range(5000):
    history.append(loss(theta, X_tr, y_tr))
    theta -= 0.5 * grad(theta, X_tr, y_tr)

print("w =", theta[:2].round(3), "  b =", theta[2].round(3))
print("loss ban đầu:", round(history[0], 4), "  sau 5000 vòng:", round(history[-1], 4))

Kết quảw = [1.124 0.947]   b = -4.73
loss ban đầu: 0.6931   sau 5000 vòng: 0.3995

Loss ban đầu là $0.6931 = \log 2$, không phải ngẫu nhiên: với theta bằng 0, mọi email có $p = 0.5$ và mỗi email mất $-\log 0.5$. Đây là một mốc nên nhớ để kiểm code: bài hai lớp khởi tạo bằng 0 thì loss ban đầu phải là $\log 2$ (dùng class weight thì mốc này đổi).

Tham số học được nằm gần quy luật thật $(1.1,\ 0.9,\ -4.5)$; phần lệch là do chỉ có 300 email. Đối chiếu với scikit-learn:

model = LogisticRegression(C=np.inf).fit(X_tr, y_tr)
print("scikit-learn: w =", model.coef_[0].round(3), "  b =", model.intercept_.round(3))
print("trùng gradient descent:", np.allclose(theta, np.append(model.coef_[0], model.intercept_), atol=1e-3))

Kết quảscikit-learn: w = [1.124 0.947]   b = [-4.73]
trùng gradient descent: True

Hai cách cho cùng một nghiệm. scikit-learn không dùng gradient descent mà dùng L-BFGS, một phương pháp dùng thêm thông tin độ cong nên hội tụ trong vài chục bước thay vì vài nghìn. Khác với linear regression, ở đây không có nghiệm đóng: đặt gradient bằng 0 cho một hệ phương trình chứa sigmoid, không giải ra được bằng biến đổi đại số.

Đọc hệ số qua odds

Hệ số của logistic regression không đọc được như linear regression, kiểu “thêm một link thì xác suất tăng bao nhiêu”. Cách đọc đúng là qua odds, như mục trước đã nói.

w = model.coef_[0]
print("thêm 1 link: odds nhân", np.exp(w[0]).round(2), "  thêm 1 từ quảng cáo: odds nhân", np.exp(w[1]).round(2))

emails = np.array([[1, 1], [2, 1], [7, 1], [8, 1]])     # (số link, số từ quảng cáo)
print("P(spam):", model.predict_proba(emails)[:, 1].round(3))

Kết quảthêm 1 link: odds nhân 3.08   thêm 1 từ quảng cáo: odds nhân 2.58
P(spam): [0.065 0.177 0.983 0.995]

Mỗi link thêm vào nhân odds spam lên khoảng 3 lần, bất kể email đang ở đâu. Nhưng xác suất thì không tăng đều. Đi từ 1 lên 2 link, xác suất tăng khoảng 0.11; đi từ 7 lên 8 link, khi email đã gần như chắc là spam, xác suất chỉ nhích thêm khoảng 0.01 vì không thể vượt quá 1. Odds nhân đều, xác suất bão hòa. Muốn so độ quan trọng giữa các đặc trưng có đơn vị khác nhau thì chuẩn hóa trước, giống bài 2.2.

Ngưỡng quyết định

Ngưỡng $0.5$ hợp lý khi hai loại sai có giá như nhau. Với bộ lọc thư rác thì không: để lọt một email spam chỉ hơi phiền, còn chặn nhầm một email thật (thư mời nhập học, kết quả thi) có thể rất đắt. Xem ngưỡng thay đổi điều gì trên 100 email test:

p_te = model.predict_proba(X_te)[:, 1]
print("predict trùng p > 0.5:", np.array_equal(model.predict(X_te), (p_te > 0.5).astype(float)))
for t in [0.3, 0.5, 0.9]:
    block = p_te >= t
    print(f"ngưỡng {t}: chặn đúng {np.sum(block & (y_te == 1)):>2} spam, "
          f"chặn nhầm {np.sum(block & (y_te == 0)):>2} thư thật, lọt {np.sum(~block & (y_te == 1)):>2} spam")
print("accuracy:", model.score(X_te, y_te), "  luôn đoán 'không spam':", np.mean(y_te == 0))

Kết quảpredict trùng p > 0.5: True
ngưỡng 0.3: chặn đúng 30 spam, chặn nhầm 21 thư thật, lọt  3 spam
ngưỡng 0.5: chặn đúng 25 spam, chặn nhầm  7 thư thật, lọt  8 spam
ngưỡng 0.9: chặn đúng  4 spam, chặn nhầm  0 thư thật, lọt 29 spam
accuracy: 0.85   luôn đoán 'không spam': 0.67

Dòng đầu xác nhận predict chính là cắt $p > 0.5$ (đúng bằng $0.5$ thì scikit-learn chọn lớp 0). Hạ ngưỡng thì chặn được nhiều spam hơn nhưng chặn nhầm nhiều thư thật hơn; nâng ngưỡng thì ngược lại. Không có ngưỡng nào tốt nhất cho mọi bài: ngưỡng là quyết định nghiệp vụ, chọn theo cái giá của từng loại sai. Mô hình chỉ cung cấp xác suất. Bài 1.5 có các thước đo cho đúng sự đánh đổi này (precision, recall, đường ROC).

Dòng cuối là một lời nhắc khác. Một “mô hình” luôn đoán “không spam” đã được accuracy khoảng $0.67$, vì hai phần ba số email là thư thường. Accuracy của mô hình thật phải được so với mốc đó, không phải với $0$. Dữ liệu càng lệch thì mốc này càng cao: nếu chỉ 1% email là spam, đoán bừa “không spam” đã có accuracy $0.99$.

Khi đề bài chấm bằng log loss, cái cần nộp là xác suất. Mốc tương ứng là đoán cho mọi email cùng một xác suất bằng tỉ lệ spam của tập train:

from sklearn.metrics import log_loss

base = np.full(len(y_te), y_tr.mean())
print("log loss mốc:", round(log_loss(y_te, base), 3), "  mô hình:", round(log_loss(y_te, p_te), 3))

Kết quảlog loss mốc: 0.635   mô hình: 0.371

Nhiều lớp: softmax regression

Nhận dạng chữ số viết tay có 10 lớp, từ 0 đến 9. Mở rộng tự nhiên: mỗi lớp $k$ có vector trọng số $\mathbf{w}_k$ và bias $b_k$ riêng, cho một điểm $z_k = \mathbf{w}_k^\top\mathbf{x} + b_k$ (gọi chung là logits). Hàm softmax biến $K$ điểm thành một phân phối xác suất:

Mọi $p_k$ dương và cộng lại bằng 1. Lớp có điểm cao nhất có xác suất cao nhất, nhưng các lớp khác không bị đẩy về đúng 0, nên “max” mềm hơn, đúng như tên gọi. Với $K = 2$, $p_1 = \frac{1}{1 + e^{-(z_1 - z_2)}} = \sigma(z_1 - z_2)$: softmax hai lớp chính là logistic regression trên hiệu hai điểm. Softmax luôn chia hết xác suất cho các lớp đã biết: đưa ảnh một chiếc ô tô vào mô hình chó, mèo, chim thì nó vẫn chọn một trong ba, có khi rất chắc.

Hàm mất mát vẫn là cross-entropy: $\ell = -\log p_{y}$, trừ log xác suất của lớp đúng. Gradient theo logits cũng giữ dạng quen thuộc:

trong đó $\mathbf{e}_y$ là vector one-hot của nhãn thật. Mô hình đẩy xác suất của lớp đúng lên và của các lớp khác xuống, đúng bằng lượng đang chênh. Mỗi thành phần của $\mathbf{p} - \mathbf{e}_y$ nằm trong $[-1, 1]$: âm ở lớp đúng, dương ở các lớp khác.

Cài softmax có một cái bẫy. $e^{1000}$ vượt quá số lớn nhất mà kiểu float64 biểu diễn được, nên thành inf, và inf / inf là nan. Cách chữa dựa trên một nhận xét: cộng cùng một hằng số $c$ vào mọi $z_k$ không đổi softmax, vì $e^{c}$ xuất hiện ở cả tử lẫn mẫu và triệt tiêu. Chọn $c = -\max_k z_k$ thì số mũ lớn nhất là $0$, không bao giờ tràn. Cùng lý do, nhân mọi logit với một số dương giữ nguyên thứ tự nên giữ nguyên lớp dự đoán, chỉ làm phân phối nhọn hơn hay bẹt hơn.

def softmax_naive(z):
    e = np.exp(z)
    return e / e.sum()

def softmax(Z):
    Z = Z - Z.max(axis=-1, keepdims=True)             # trừ max từng hàng, kết quả không đổi
    E = np.exp(Z)
    return E / E.sum(axis=-1, keepdims=True)

z = np.array([2.0, 1.0, 0.0])
print(softmax(z).round(3))
print(softmax_naive(z + 1000), softmax(z + 1000).round(3))

Kết quả[0.665 0.245 0.09 ]
[nan nan nan] [0.665 0.245 0.09 ]

Dòng đầu tính tay được: trừ max được $(0, -1, -2)$, lấy mũ được $(1,\ 0.368,\ 0.135)$, tổng là $1.503$, chia ra được $(0.665,\ 0.245,\ 0.090)$. Lớp đầu hơn lớp thứ hai 1 đơn vị logit, và xác suất gấp $e \approx 2.7$ lần. Nếu nhãn đúng là lớp thứ hai thì loss là $-\log 0.245 = 1.41$, và gradient theo logits là $\mathbf{p} - \mathbf{e}_2 = (0.665,\ -0.755,\ 0.090)$: kéo lớp đầu xuống, đẩy lớp thứ hai lên.

Khi cần $\log p_k$ (để tính loss) thì đừng tính softmax rồi mới lấy log, vì $p_k$ rất nhỏ có thể làm tròn thành 0. Dùng thẳng log-sum-exp với cùng mẹo trừ max:

Thử trên bộ chữ số viết tay của scikit-learn: 1797 ảnh $8 \times 8$, mỗi điểm ảnh có giá trị từ 0 đến 16.

from sklearn.datasets import load_digits

D, t = load_digits(return_X_y=True)
D = D / 16                                            # điểm ảnh về [0, 1]
idx = np.random.default_rng(0).permutation(len(t))
D, t = D[idx], t[idx]
D_tr, D_te, t_tr, t_te = D[:1300], D[1300:], t[:1300], t[1300:]
print(D_tr.shape, D_te.shape)

Kết quả(1300, 64) (497, 64)

Huấn luyện bằng gradient descent. Để so được với LogisticRegression() mặc định (C=1), ta thêm đúng khoản phạt L2 mà nó dùng: hàm mất mát của scikit-learn là $C\sum_i \ell_i + \tfrac12\lVert W\rVert^2$, chia cho $Cn$ thì thành loss trung bình cộng $\tfrac{1}{2Cn}\lVert W\rVert^2$.

n, K = len(t_tr), 10
Y = np.eye(K)[t_tr]                                   # one-hot, (1300, 10)
lam = 1 / (1.0 * n)                                   # khớp C = 1
W, b = np.zeros((D_tr.shape[1], K)), np.zeros(K)
for epoch in range(5000):
    G = (softmax(D_tr @ W + b) - Y) / n               # (1300, 10)
    W -= 2.0 * (D_tr.T @ G + lam * W)
    b -= 2.0 * G.sum(axis=0)

pred = np.argmax(D_te @ W + b, axis=1)
print("tự cài:       accuracy test =", round(np.mean(pred == t_te), 3))

sk = LogisticRegression(C=1.0, max_iter=1000).fit(D_tr, t_tr)
print("scikit-learn: accuracy test =", round(sk.score(D_te, t_te), 3))
print("nhãn trùng nhau:", np.mean(sk.predict(D_te) == pred),
      "  xác suất lệch lớn nhất:", np.abs(sk.predict_proba(D_te) - softmax(D_te @ W + b)).max().round(3))

Kết quảtự cài:       accuracy test = 0.978
scikit-learn: accuracy test = 0.978
nhãn trùng nhau: 1.0   xác suất lệch lớn nhất: 0.032

Một mô hình tuyến tính đơn giản đã nhận đúng khoảng 98% chữ số. Hai cài đặt cho cùng nhãn trên mọi ảnh test; xác suất còn lệch nhau một chút vì gradient descent sau 5000 vòng vẫn chưa hội tụ hẳn, trong khi L-BFGS của scikit-learn đã tới nơi.

Mỗi cột của W có 64 số, xếp lại thành ảnh $8 \times 8$ thì đọc được mô hình đang “nhìn” gì. Điểm ảnh có trọng số dương là nơi nét mực làm tăng điểm của lớp đó, trọng số âm là nơi nét mực làm giảm điểm. Hình dưới không giống những chữ số mẫu: mô hình không học “chữ 0 trông thế nào” mà học “chỗ nào có mực thì phân biệt được 0 với chín lớp còn lại”.