Đạo hàm và gradient

Độ dốc tại một điểm

Ở bài 0.4, hàm bậc nhất có độ dốc không đổi: $x$ tăng 1 thì $y$ tăng $w$. Hàm $f(x) = x^2$ thì khác: gần $x = 0$ đồ thị gần như nằm ngang, càng xa thì càng dốc. Ta cần nói “độ dốc tại $x = 3$”.

Cách làm: lấy một điểm gần đó, $x = 3 + h$, và chia độ tăng của $f$ cho độ tăng của $x$:

Đây là độ dốc của đường thẳng nối hai điểm trên đồ thị. Cho $h$ nhỏ dần, đường ấy xoay dần về tiếp tuyến, đường thẳng chỉ chạm đồ thị tại đúng điểm $x = 3$. Độ dốc của tiếp tuyến là đạo hàm của $f$ tại 3, ký hiệu $f'(3)$.

import numpy as np

def f(x):
    return x ** 2

for h in [1, 0.1, 0.01, 0.001]:
    print(h, round((f(3 + h) - f(3)) / h, 6))

Kết quả1 7.0
0.1 6.1
0.01 6.01
0.001 6.001

Với $h$ nhỏ dần, tỉ số tiến về 6. Viết tay: $\frac{(3 + h)^2 - 9}{h} = \frac{6h + h^2}{h} = 6 + h$, và $h \to 0$ cho đúng 6.

Đọc đạo hàm như một lời hứa nhỏ: tăng $x$ thêm một lượng rất nhỏ $\Delta$ thì $f$ tăng thêm khoảng $f'(x) \cdot \Delta$. Đạo hàm dương thì hàm đang đi lên, âm thì đang đi xuống, bằng 0 thì đang nằm ngang, như ở đáy một cái bát.

Các quy tắc tính đạo hàm

Không ai tính giới hạn mỗi lần. Vài quy tắc đủ cho phần lớn học máy:

Hàng $x^n$ cho $(x^2)' = 2x$, khớp con số 6 tại $x = 3$. Hàng $e^x$ là lý do bài 0.4 chọn cơ số $e$: đạo hàm của nó là chính nó. Hai hàng cuối nói đạo hàm đi qua phép nhân với hằng số và phép cộng: $(3x^2 - 4x + 1)' = 6x - 4$.

Kiểm bằng số: so công thức với sai phân tại $x = 2$.

def numeric(g, x, h=1e-6):
    return (g(x + h) - g(x - h)) / (2 * h)

x = 2.0
tests = [("x^3", lambda t: t ** 3, 3 * x ** 2),
         ("e^x", np.exp, np.exp(x)),
         ("log x", np.log, 1 / x),
         ("3x^2 - 4x + 1", lambda t: 3 * t ** 2 - 4 * t + 1, 6 * x - 4)]
for name, g, exact in tests:
    print(f"{name:14s} công thức {exact:.6f}  sai phân {numeric(g, x):.6f}")

Kết quảx^3            công thức 12.000000  sai phân 12.000000
e^x            công thức 7.389056  sai phân 7.389056
log x          công thức 0.500000  sai phân 0.500000
3x^2 - 4x + 1  công thức 8.000000  sai phân 8.000000

Hàm numeric lấy hai điểm hai bên, $x + h$ và $x - h$, gọi là sai phân trung tâm; nó chính xác hơn cách lấy một bên ở mục trước. Mục cuối bài dùng lại hàm này để kiểm gradient.

Quy tắc chuỗi

Loss của model hiếm khi là một hàm đơn giản của trọng số. Nó là một chuỗi các bước: trọng số cho ra dự đoán, dự đoán cho ra sai số, sai số cho ra loss. Với hàm hợp $f(g(x))$, quy tắc chuỗi nói

Đọc bằng lời hứa ở trên: $x$ nhích $\Delta$ thì $g$ nhích khoảng $g'(x)\Delta$, và $g$ nhích chừng ấy thì $f$ nhích khoảng $f'(g)$ nhân lượng đó. Tốc độ đổi qua nhiều bước là tích các tốc độ đổi của từng bước.

Ví dụ $h(x) = (2x + 1)^2$. Bên trong là $g = 2x + 1$ với $g' = 2$; bên ngoài là $f = g^2$ với $f' = 2g$. Nên $h'(x) = 2(2x + 1) \cdot 2 = 4(2x + 1)$, tại $x = 1$ bằng 12.

Áp vào model $\hat{y} = wx$ với loss $L = (\hat{y} - y)^2$. Coi $w$ là biến, $x$ và $y$ là số đã biết. Chuỗi gồm hai bước: $w \to \hat{y}$ có đạo hàm $x$, và $\hat{y} \to L$ có đạo hàm $2(\hat{y} - y)$. Nhân lại:

Mạng neural chỉ là một chuỗi dài hơn. Thuật toán backpropagation ở chương 3 là quy tắc chuỗi áp dụng có hệ thống, từ loss đi ngược về từng trọng số.

Một ví dụ quan trọng là sigmoid $\sigma(z) = (1 + e^{-z})^{-1}$. Áp quy tắc chuỗi hai lần rồi rút gọn, ta được một công thức rất gọn:

Tại $z = 0$, $\sigma = 0.5$ nên $\sigma' = 0.25$, lớn nhất có thể. Ở hai đầu chữ S, $\sigma'$ gần 0. Một mạng nhiều lớp sigmoid nhân nhiều thừa số không quá 0.25 với nhau, nên gradient ở các lớp đầu nhỏ dần. Chương 3 gọi đây là vanishing gradient.

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

for z in [0.0, 2.0, 5.0]:
    s = sigmoid(z)
    print(z, round(s * (1 - s), 4), round(numeric(sigmoid, z), 4))

w, x, y = 1.0, 2.0, 6.0
loss = lambda w: (w * x - y) ** 2
print(2 * (w * x - y) * x, round(numeric(loss, w), 4))

Kết quả0.0 0.25 0.25
2.0 0.105 0.105
5.0 0.0066 0.0066
-16.0 -16.0

Công thức và sai phân khớp nhau ở cả ba điểm của sigmoid. Dòng cuối: với $w = 1$, model đoán $2$ trong khi đáp án là $6$; đạo hàm $-16$ âm, nghĩa là tăng $w$ thì loss giảm. Đúng như mong đợi, vì model đang đoán thấp.

Đạo hàm riêng và gradient

Loss thường phụ thuộc nhiều tham số cùng lúc. Với hàm hai biến $f(x, y)$, đạo hàm riêng theo $x$, viết $\partial f / \partial x$, là đạo hàm khi coi $y$ như hằng số. Ví dụ $f(x, y) = x^2 y + 3x$:

Xếp mọi đạo hàm riêng thành một vector, ta được gradient:

Gradient chỉ hướng làm $f$ tăng nhanh nhất, và độ dài của nó cho biết dốc cỡ nào. Hướng ngược lại, $-\nabla f$, làm $f$ giảm nhanh nhất. Hình dưới là bản đồ đường đồng mức của cái bát $f(x, y) = x^2 + y^2$; mỗi vòng là một mức cao. Gradient tại mỗi điểm vuông góc với đường đồng mức và chỉ ra ngoài.

def bowl(v):
    return v[0] ** 2 + v[1] ** 2

def grad_numeric(g, v, h=1e-6):
    out = np.zeros_like(v)
    for i in range(len(v)):
        e = np.zeros_like(v)
        e[i] = h
        out[i] = (g(v + e) - g(v - e)) / (2 * h)
    return out

v = np.array([1.0, 2.0])
print(2 * v, np.round(grad_numeric(bowl, v), 6))

Kết quả[2. 4.] [2. 4.]

grad_numeric làm sai phân trung tâm theo từng tọa độ, giữ các tọa độ khác cố định: đúng định nghĩa đạo hàm riêng. Tại $(1, 2)$, gradient là $(2, 4)$, chỉ ra xa gốc.

Gradient descent

Đã biết hướng làm loss giảm nhanh nhất là $-\nabla L$. Gradient descent đi một bước nhỏ theo hướng ấy, rồi tính lại gradient, rồi đi tiếp:

$\eta$ là learning rate, quyết định mỗi bước dài bao nhiêu. Hình ảnh quen thuộc: đi xuống núi trong sương mù, chỉ thấy độ dốc dưới chân, nên mỗi lần bước một bước theo hướng dốc xuống nhất.

Thử với model một trọng số ở trên, $x = 2$, $y = 6$, đáp án tốt nhất là $w = 3$. Bắt đầu từ $w = 0$, so hai learning rate.

def descend(eta, steps, w=0.0):
    path = []
    for _ in range(steps):
        grad = 2 * (w * x - y) * x
        w = w - eta * grad
        path.append(round(w, 4))
    return path

print(descend(0.05, 6))
print(descend(0.05, 30)[-1])
print(descend(0.3, 6))

Kết quả[1.2, 1.92, 2.352, 2.6112, 2.7667, 2.86]
3.0
[7.2, -2.88, 11.232, -8.5248, 19.1347, -19.5886]

Với $\eta = 0.05$, $w$ tiến dần về 3, bước sau ngắn hơn bước trước vì càng gần đáy thì gradient càng nhỏ. Sau 30 bước đã bằng 3 tới bốn chữ số thập phân. Với $\eta = 0.3$, bước đầu nhảy lên 7.2, vượt qua đáy rất xa; mỗi bước sau lại vượt sang phía bên kia, xa hơn bước trước, và $w$ lớn dần không giới hạn. Ta nói gradient descent phân kỳ. Khi loss tăng vọt hay thành nan trong lúc huấn luyện, nghi phạm đầu tiên là learning rate quá lớn.

Với nhiều mẫu, loss là trung bình loss của từng mẫu, nên gradient cũng là trung bình gradient của từng mẫu. Lấy hai mẫu $(x, y) = (1, 2)$ và $(2, 5)$, bắt đầu từ $w = 0$ với $\eta = 0.1$. Hai dự đoán đều là 0, sai số $-2$ và $-5$, loss $(4 + 25)/2 = 14.5$. Gradient của từng mẫu là $2 \cdot \text{sai số} \cdot x$: $-4$ và $-20$, trung bình $-12$. Bước cập nhật cho $w = 0 - 0.1 \cdot (-12) = 1.2$. Sai số mới là $-0.8$ và $-2.6$, loss còn $(0.64 + 6.76)/2 = 3.7$.

xs = np.array([1.0, 2.0])
ys = np.array([2.0, 5.0])
w = 0.0
for step in range(3):
    err = w * xs - ys
    grad = np.mean(2 * err * xs)
    print(step, round(w, 4), round(np.mean(err ** 2), 4), round(grad, 4))
    w -= 0.1 * grad

Kết quả0 0.0 14.5 -12.0
1 1.2 3.7 -6.0
2 1.8 1.0 -3.0

Dòng 0 và dòng 1 khớp phép tính tay. Đáp án tốt nhất là $w = 12/5 = 2.4$, nơi gradient trung bình bằng 0; vài bước nữa $w$ sẽ tới đó.

Kiểm gradient bằng sai phân

Tự viết công thức gradient thì dễ sai một hệ số 2 hay một dấu trừ, mà code vẫn chạy. Cách kiểm: so gradient từ công thức với gradient tính bằng sai phân trên một ví dụ nhỏ. Nếu sai số tương đối cỡ $10^{-6}$ trở xuống thì công thức gần như chắc đúng.

Model tuyến tính ba trọng số, loss MSE trên năm mẫu: $L(\mathbf{w}) = \frac{1}{n}\lVert X\mathbf{w} - \mathbf{y} \rVert^2$. Quy tắc chuỗi cho gradient

Đọc bằng shape của bài 0.5: $X^\top$ là $(3, 5)$, phần dư $X\mathbf{w} - \mathbf{y}$ là $(5,)$, tích là $(3,)$, đúng một số cho mỗi trọng số.

rng = np.random.default_rng(0)
X = rng.normal(size=(5, 3))
y_vec = rng.normal(size=5)
w_vec = rng.normal(size=3)

def mse(w):
    return np.mean((X @ w - y_vec) ** 2)

exact = 2 / len(y_vec) * X.T @ (X @ w_vec - y_vec)
approx = grad_numeric(mse, w_vec)
wrong = 1 / len(y_vec) * X.T @ (X @ w_vec - y_vec)     # quên số 2
rel = lambda a, b: np.linalg.norm(a - b) / np.linalg.norm(a + b)
print(np.round(exact, 6))
print(np.round(approx, 6))
print(f"đúng: {rel(exact, approx):.1e}   quên số 2: {rel(wrong, approx):.1e}")

Kết quả[ 1.753666  1.112768 -0.48581 ]
[ 1.753666  1.112768 -0.48581 ]
đúng: 3.1e-11   quên số 2: 3.3e-01

Công thức đúng cho sai số tương đối rất nhỏ; bản quên số 2 cho sai số cỡ 0.3, lộ ngay. Đây cũng là cách PyTorch kiểm các phép tính tự viết (torch.autograd.gradcheck).