Backpropagation từ đầu: Động cơ trước, rồi đến mạng

Trước khi xây cỗ máy, cần chốt một câu hỏi, vì nếu câu trả lời đi theo hướng ngược lại thì sẽ chẳng có gì để xây.

Perceptron thất bại với XOR vì một đường thẳng không thể tách bốn điểm. Cách sửa hiển nhiên là xếp chồng: đưa đầu vào qua một lớp tuyến tính, rồi một lớp nữa. Cách đó có giúp gì không?

Không, và chứng minh chỉ mất hai dòng. Một lớp tuyến tính là $\mathbf{h} = W_1\mathbf{x} + \mathbf{b}_1$. Đưa nó vào một lớp khác, $\mathbf{y} = W_2\mathbf{h} + \mathbf{b}_2$, rồi thay vào:

Hợp thành là $W\mathbf{x} + \mathbf{b}$ với $W = W_2W_1$ và $\mathbf{b} = W_2\mathbf{b}_1 + \mathbf{b}_2$. Một chồng các lớp tuyến tính chỉ là một lớp tuyến tính duy nhất. Mười lớp, một nghìn lớp: vẫn là một đường thẳng, vẫn không làm được XOR.

Đáng để nhìn tận mắt điều đó xảy ra thay vì chỉ tin nó:

import numpy as np
rng = np.random.default_rng(0)
W1, b1 = rng.normal(size=(3, 2)), rng.normal(size=3)
W2, b2 = rng.normal(size=(1, 3)), rng.normal(size=1)
x = rng.normal(size=2)

two_layers = W2 @ (W1 @ x + b1) + b2
one_layer  = (W2 @ W1) @ x + (W2 @ b1 + b2)
print(two_layers[0], one_layer[0], abs(two_layers[0] - one_layer[0]))

-4.612963371048  -4.612963371048  0.00e+00

Không phải xấp xỉ bằng nhau. Giống hệt từng bit, vì đó là cùng một phép tính được sắp xếp lại.

Vì vậy độ sâu tự nó không mua được gì. Thứ có ích là đặt một hàm phi tuyến giữa các lớp — và đó là toàn bộ lý do các hàm kích hoạt tồn tại. Chúng không phải một nét trang trí sinh học hay một mẹo chuẩn hóa. Không có chúng, lớp thứ hai chỉ là đồ trang trí.

Giờ đến phần toán học, và đó là một quy tắc bạn đã biết được áp dụng ở một nơi hơi lạ.

Quy tắc dây chuyền một biến nói rằng nếu $L$ phụ thuộc vào $c$ và $c$ phụ thuộc vào $x$, thì $\frac{dL}{dx} = \frac{dL}{dc} \cdot \frac{dc}{dx}$. Các đạo hàm nhân với nhau dọc theo một chuỗi.

Phần quan trọng ở đây là điều xảy ra khi một biến cấp dữ liệu cho nhiều hơn một đường downstream. Nếu $x$ ảnh hưởng đến $L$ thông qua $a$ và cũng thông qua $b$, các phần đóng góp sẽ cộng lại:

Nhân dọc theo một đường, cộng qua các đường. Đó là toàn bộ backpropagation, và mọi chi tiết triển khai trong phần còn lại của chương này — bao gồm += trong code và lệnh gọi zero_grad() làm vấp ngã mọi người khi viết training loop đầu tiên — đều là hệ quả trực tiếp của từ thứ hai đó.

Lấy một mạch cụ thể gồm năm phép toán, với $x = 0.5$ và $y = 1.4$:

Lưu ý rằng $x$ xuất hiện ba lần: trong $a$, trong $b$, và trực tiếp trong $L$. Hãy làm backward pass trên giấy, từ phải sang trái, bắt đầu từ $\frac{dL}{dL} = 1$:

Hãy giữ con số đó. Vài trang nữa, một chương trình sẽ tạo ra nó mà không được cho biết bất kỳ điều nào ở trên.

Trực giác khiến việc này lập trình được là: mỗi bước trong số đó đều cục bộ. Để đẩy gradient qua nút phép nhân, bạn cần gradient đi vào và hai giá trị đầu vào đã lưu — không cần biết gì về phần còn lại của mạch. Mỗi phép toán biết cách tự lấy đạo hàm của chính nó.

Vì vậy hãy tạo một con số nhớ được điều gì đã tạo ra nó.

class Value:
    """A number that remembers where it came from."""

    def __init__(self, data, _children=(), _op=""):
        self.data = data
        self.grad = 0.0
        self._backward = lambda: None
        self._prev = set(_children)      
        self._op = _op

Bốn trường. data là giá trị. grad tích lũy $\frac{\partial L}{\partial \text{self}}$. _prev là tập các Value mà giá trị này được tính từ đó — các cạnh của đồ thị. Và _backward là một closure mà mỗi phép toán cài vào: nó biết cách đẩy gradient của nút này lùi một bước về các đầu vào.

Mọi toán tử đều theo cùng một hình dạng: tính đầu ra, ghi lại cha mẹ, cài quy tắc cục bộ.

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other), "+")

        def _backward():
            self.grad += out.grad       
            other.grad += out.grad      

        out._backward = _backward
        return out

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data * other.data, (self, other), "*")

        def _backward():
            self.grad += other.data * out.grad   
            other.grad += self.data * out.grad   

        out._backward = _backward
        return out

    def tanh(self):
        t = math.tanh(self.data)
        out = Value(t, (self,), "tanh")

        def _backward():
            self.grad += (1 - t * t) * out.grad

        out._backward = _backward
        return out

    def relu(self):
        out = Value(self.data if self.data > 0 else 0.0, (self,), "relu")

        def _backward():
            self.grad += (1.0 if out.data > 0 else 0.0) * out.grad

        out._backward = _backward
        return out

Đọc bốn thân _backward như một bảng, bạn sẽ thấy các mẫu dòng chảy từ phần suy diễn trên giấy nằm ngay đó:

Từng dòng đều dùng += và không bao giờ dùng =. Đó là quy tắc “cộng qua các đường”, được mã hóa. Một nút cấp dữ liệu cho hai consumer sẽ được gọi hai lần, và hai phần đóng góp tự cộng lại.

Rồi đến driver, phần duy nhất có hiểu biết toàn cục:

    def backward(self):
        order, seen = [], set()

        def build(v):
            if v in seen:
                return
            seen.add(v)
            for child in v._prev:
                build(child)
            order.append(v)

        build(self)
        self.grad = 1.0
        for v in reversed(order):       
            v._backward()               

build tạo ra một thứ tự tô-pô của đồ thị: mọi nút xuất hiện sau toàn bộ đầu vào của nó. Đi qua danh sách đó theo chiều ngược lại đảm bảo rằng khi bạn gọi _backward của một nút, gradient của chính nút đó đã hoàn chỉnh — mọi consumer downstream của nó đã đóng góp xong. Sai thứ tự là bạn đẩy một gradient mới hoàn thành một nửa ngược về sau, tạo ra đáp án sai mà không có thông báo lỗi.

x = Value(0.5)
y = Value(1.4)
a = x * y
b = x + y
c = a * b
d = c.tanh()
L = d + x
L.backward()
print(x.grad, y.grad)

forward:  a=0.7000  b=1.9000  c=1.3300  d=0.8692  L=1.3692
backward: dL/dd=1.0000  dL/dc=0.2444  dL/da=0.4644  dL/db=0.1711
          dL/dx=1.8212   dL/dy=0.4033

1.8212. Cùng một con số, từ một chương trình chỉ được cho biết quy tắc của +, quy tắc của *, quy tắc của tanh, và không biết gì về mạch này.

Hai kiểm tra độc lập, vì “nó khớp với thứ tôi tự suy ra” là một bài kiểm tra yếu khi cùng một người làm cả hai.

Lấy đạo hàm số. Nhích đầu vào và đo. Sai phân trung tâm $\frac{L(x+h) - L(x-h)}{2h}$ ước lượng đạo hàm mà không cần giải tích nào cả:

dL/dx:  analytic=1.821202805  numeric=1.821202805  |diff|=1.80e-10
dL/dy:  analytic=0.403269235  numeric=0.403269235  |diff|=7.64e-12

So với PyTorch, có một autodiff engine công nghiệp do những người làm việc này để kiếm sống viết ra:

torch dL/dx=1.821202805316   ours=1.821202805316   |diff|=2.22e-16
torch dL/dy=0.403269234753   ours=0.403269234753   |diff|=1.11e-16

Khớp ở mức $2 \times 10^{-16}$, tức machine epsilon của số thực 64-bit: hai engine đang thực hiện cùng một phép tính số học. Hãy giữ phép kiểm tra số trong túi — đó là công cụ để gỡ lỗi backward pass của một lớp mới, và là lý do một gradient sai có thể được tìm thấy.

Cùng một mạch, đầu vào khác. Đặt $x = 2$ và $y = -3$, khiến $c = 6$:

x=0.5, y=1.4:  dL/dc = 0.244400     three paths into x:  0.6501 + 0.1711 + 1.0000 = 1.8212
x=2.0, y=-3.0: dL/dc = 0.000025     three paths into x:  0.0001 + -0.0001 + 1.0000 = 0.9999

Gradient đi qua nút $\tanh$ giảm đi 9.945 lần. Mọi thứ upstream của nó — trong một mạng thật, mọi lớp trước nó — gần như không nhận được gì. Hai đường qua mạch đã im lặng; chỉ kết nối trực tiếp bỏ qua $\tanh$ vẫn còn mang tín hiệu.

Đó là vấn đề vanishing gradient, trong một nút. Xếp bốn mươi lớp $\tanh$ và nhân bốn mươi hệ số như vậy với nhau, các lớp đầu sẽ ngừng học hoàn toàn. Nhân tiện, đây cũng là một lập luận ủng hộ skip connections mà bạn có thể thấy ở dạng thu nhỏ: đường đi vòng qua phi tuyến là đường duy nhất sống sót.

Mọi _backward đều dùng +=. Điều đó đúng — đó là cách các đường cộng lại. Nhưng nó có một hệ quả bắt tất cả mọi người: gradient cũng tích lũy qua các lần gọi backward(). Engine không hề biết lần gọi thứ hai của bạn là một bước huấn luyện mới chứ không phải một đường khác trong cùng đồ thị.

Vì vậy training loop phải xóa chúng:

for step in range(steps):
    ys = [model(x) for x, _ in DATA]
    loss = sum((yp - yt) ** 2 for yp, (_, yt) in zip(ys, DATA))

    for p in model.parameters():   
        p.grad = 0.0

    loss.backward()
    for p in model.parameters():
        p.data -= lr * p.grad

Đây là optimizer.zero_grad() trong PyTorch, và lời khuyên thường gặp là quên nó sẽ làm hỏng huấn luyện. Vậy hãy xóa hai dòng đó và xem nó hỏng đến mức nào. Cùng seed, cùng mọi thứ, 200 bước XOR:

Ở các learning rate nhỏ, phiên bản có lỗi thắng từng hàng một. Nó hội tụ khi phiên bản đúng bị kẹt.

Đó không phải là may mắn ngẫu nhiên, và rất đáng hiểu, vì nó giải thích vì sao lỗi này khó bắt đến vậy. Nếu bạn không bao giờ xóa gradient, thì ở bước $k$ tham số được cập nhật bằng tổng của mọi gradient đã tính từ trước đến nay. Trên một hàm mất mát liên tục chỉ về gần cùng một hướng, tổng đó tăng đều, và hiệu ứng là learning rate tự tăng lên. Ở $\eta = 0.05$, nơi thuật toán đúng đang bò, step size runaway trông đúng như một bản sửa lỗi.

Rồi nhìn ba hàng cuối. Ở $\eta = 0.3$, cùng cơ chế đó làm mô hình vỡ tung — loss 8.0 là điểm số của một mô hình sụp về hằng số $\pm 1$ — bằng một nửa của 16 mà bốn câu trả lời sai tối đa sẽ gây ra — — trong khi phiên bản đúng lúc này hội tụ sạch sẽ.

Vì vậy phát biểu trung thực không phải là “luôn gọi zero_grad nếu không mô hình của bạn sẽ không huấn luyện”. Mà là: không có nó, bạn không còn chạy gradient descent nữa. Bạn đang chạy một thứ có step size trôi dần lên với tốc độ không ai chọn, và nó sẽ có vẻ hoạt động, đôi khi còn tốt hơn thứ thật, cho đến khi không còn như vậy — khi đó bạn sẽ đổ lỗi cho learning rate, khởi tạo, hoặc dữ liệu. Đây là hình dạng của những lỗi tệ nhất trong machine learning: chúng không crash, chúng biến thuật toán thành một thuật toán khác đôi khi đạt điểm tốt hơn.

Khi engine đã xong, một mạng nơ-ron hầu như không cần nhiều code. Một nơ-ron là một dot product, một bias và một activation; một lớp là danh sách các nơ-ron; một mạng là danh sách các lớp.

class Neuron:
    def __init__(self, nin):
        self.w = [Value(random.uniform(-1, 1)) for _ in range(nin)]
        self.b = Value(0.0)

    def __call__(self, x):
        act = sum((wi * xi for wi, xi in zip(self.w, x)), self.b)
        return act.tanh()

    def parameters(self):
        return self.w + [self.b]


class Layer:
    def __init__(self, nin, nout):
        self.neurons = [Neuron(nin) for _ in range(nout)]

    def __call__(self, x):
        out = [n(x) for n in self.neurons]
        return out[0] if len(out) == 1 else out

    def parameters(self):
        return [p for n in self.neurons for p in n.parameters()]


class MLP:
    def __init__(self, nin, nouts):
        sizes = [nin] + nouts
        self.layers = [Layer(sizes[i], sizes[i + 1]) for i in range(len(nouts))]

    def __call__(self, x):
        for layer in self.layers:
            x = layer(x)
        return x

    def parameters(self):
        return [p for layer in self.layers for p in layer.parameters()]

Không có backward pass nào trong tất cả những thứ đó. Không một dòng. Lớp Value đã biết cách lấy đạo hàm của bất cứ thứ gì các lớp này tình cờ xây ra, và đó là mục đích của việc viết nó trước: một autodiff engine không biết nó đang được dùng cho mạng nơ-ron.

Giờ đến bài toán từ Chương 1. Hai đầu vào, hai đơn vị ẩn, một đầu ra, chín tham số:

step   1: loss 4.156690
step  10: loss 4.005572
step  50: loss 3.996708
step 100: loss 3.510700
step 200: loss 0.038597

[0, 0] -> -0.9081  (target -1)  ok
[0, 1] -> +0.8934  (target +1)  ok
[1, 0] -> +0.8906  (target +1)  ok
[1, 1] -> -0.9207  (target -1)  ok

Bốn trên bốn. Hàm mà không perceptron nào tính được — đã được chứng minh ở Chương 1 bằng bốn bất đẳng thức đòi $b$ vừa dương vừa âm — được tính bởi chín con số tìm được tự động.

Phần thỏa mãn không phải là nó hoạt động. Mà là có thể nhìn thấy cách nó hoạt động, vì với hai đơn vị ẩn, biểu diễn trung gian là một điểm trong mặt phẳng và bạn có thể chỉ việc in ra.

Sau khi huấn luyện đến loss 0.001241, đây là nơi mỗi đầu vào hạ cánh sau lớp ẩn, và điều nơ-ron đầu ra làm với nó:

Nhìn vào hàng đầu và hàng thứ tư. Các đầu vào $(0,0)$ và $(1,1)$ là hai góc đối diện theo đường chéo của hình vuông — xa nhau nhất có thể trong bài toán này — và lớp ẩn ánh xạ chúng tới $(0.82, -0.85)$ và $(0.84, -0.86)$. Gần như cùng một điểm. Lớp này đã gấp mặt phẳng để hai góc bị loại đặt chồng lên nhau, và khi chúng ở cùng một chỗ, một đường thẳng có thể tách chúng khỏi hai điểm còn lại.

Và nơ-ron đầu ra chính xác là đường thẳng đó. Các tham số đã học của nó là $\mathbf{w} = (-3.1153,\ +3.0893)$, $b = +2.7697$, nên ranh giới quyết định của nó là

đó là một đường thẳng — một perceptron, cùng đối tượng từ Chương 1, không thay đổi. Khi đó nó không giải được XOR và bây giờ cũng không. Điều thay đổi là nó không còn nhìn vào đầu vào nữa; nó đang nhìn vào một không gian mà lớp đầu tiên xây cho nó, trong đó bài toán có thể tách tuyến tính.

Đó là một biểu diễn đã học, và đáng để nói chính xác vì cụm từ này sẽ được dùng khá lỏng trong phần còn lại của khóa học, và trong phần còn lại của lĩnh vực. Nó không phải là nén, tóm tắt, hay embedding theo nghĩa huyền bí nào. Nó là một phép đổi tọa độ, được học thay vì được thiết kế, với nhiệm vụ duy nhất là làm cho công việc của lớp tiếp theo trở nên dễ dàng.

Có một định lý ở đây, và nó thường bị trích dẫn rất tệ.

Cybenko năm 1989 và Hornik năm 1991 đã chứng minh rằng một mạng feedforward với một lớp ẩn duy nhất và một hàm kích hoạt phù hợp có thể xấp xỉ bất kỳ hàm liên tục nào trên một tập compact, tới bất kỳ độ chính xác nào bạn muốn, miễn là có đủ đơn vị ẩn.³⁴ Đây là một kết quả thật sự quan trọng: nó nói kiến trúc không phải là giới hạn.

Giờ hãy đọc những gì nó bỏ qua. Nó không nói cần bao nhiêu đơn vị — cận có thể lớn đến mức thiên văn. Nó không nói các trọng số có thể được tìm thấy; nó khẳng định sự tồn tại, và gradient descent từ một khởi đầu ngẫu nhiên không phải là oracle. Và nó không nói gì về hành vi trên dữ liệu bạn chưa thấy, vốn là nửa sau của Chương 6.

Khoảng cách giữa “tồn tại” và “có thể tìm được” không phải chuyện hàn lâm. Đây là cùng bài toán XOR, 50 lần khởi tạo ngẫu nhiên mỗi cấu hình, 1000 bước, chỉ thay đổi kích thước lớp ẩn:

Với kiến trúc tối thiểu có thể dùng được, cứ bốn lần chạy thì một lần không bao giờ tới đích — nó ổn định trong một cấu hình không thể đi xuống thoát ra, chính là cực tiểu cục bộ mà Chương 3 đã cho thấy trên một bề mặt một chiều. Thêm một đơn vị và các thất bại gần như biến mất, không phải vì mạng trở nên biểu đạt hơn (hai đơn vị đã đủ — 38 lần chạy chứng minh điều đó) mà vì các chiều bổ sung cho phép quá trình đi xuống có nhiều hướng hơn để thoát.

Và rồi tám đơn vị lại tệ hơn bốn một chút. Với learning rate và ngân sách bước cố định, nhiều capacity hơn không tốt hơn một cách đơn điệu. Bất kỳ ai nói với bạn rằng cách sửa một mạng bị kẹt luôn là mạng lớn hơn thì đang ngoại suy từ phần giữa của bảng đó.

Đây cũng là bài học của định lý hội tụ trong Chương 1, và sẽ là cùng bài học trong Chương 10 về scaling laws, dưới dạng mà chương đó đưa ra: dự đoán loss không phải là dự đoán capability bạn đang trả tiền để có, và khoảng cách giữa hai thứ đó là nơi công việc engineering diễn ra.

Giờ bạn đã có một mạng có thể huấn luyện. Thành tựu đó nhỏ hơn cảm giác của nó, vì mạng của bạn huấn luyện trên bốn ví dụ và cũng được đo trên chính bốn ví dụ đó.

Chạy cùng code trên một tập dữ liệu thật, một loạt vấn đề mới sẽ xuất hiện, không vấn đề nào nói về gradient. Loss giảm một lúc rồi dừng. Hoặc nó giảm trên dữ liệu huấn luyện và tăng trên mọi thứ khác. Hoặc nó không nhúc nhích ngay từ bước đầu tiên, và nguyên nhân hóa ra là phạm vi của các trọng số ngẫu nhiên ban đầu. Hoặc đầu vào của một đơn vị trôi sang âm trên mọi ví dụ ở epoch thứ ba và nó đã chết kể từ đó, âm thầm, mang theo một mảnh capacity của mô hình.

Đây không phải các lỗi kỳ lạ; chúng là trạng thái bình thường của một mạng vừa được viết ra, và không lỗi nào tự thông báo. Gradient đúng — bạn đã kiểm tra nó với PyTorch tới mười sáu chữ số thập phân — và mô hình vẫn không học.

Chương 6 nói về điều đó: khởi tạo, chuẩn hóa, overfitting và regularization, cùng thói quen chẩn đoán là hỏi điều nào đang xảy ra trước khi thay đổi bất cứ thứ gì. Đó là khác biệt giữa một mạng chạy được và một mạng hoạt động được.

Lớp Value trong chương này xuất phát trực tiếp từ micrograd của Andrej Karpathy, và video của anh The spelled-out intro to neural networks and backpropagation: building micrograd là ba giờ đáng giá nhất bạn có thể dành cho tài liệu này nếu muốn nghe một người khác giải thích theo cách thứ hai. Bài viết năm 2016 của anh Yes you should understand backprop lập luận cho việc tự viết một bản, và là bài đọc được giao trong Stanford CS224n. Ghi chú CS231n về backpropagation (cs231n.github.io/optimization-2) là cách trình bày kinh điển về các mẫu dòng chảy được lập bảng phía trên. Với phần toán học như giải tích trên đồ thị thay vì giai thoại mạng nơ-ron, chương 5.6 của Mathematics for Machine Learning của Deisenroth, Faisal và Ong rõ ràng một cách hiếm có; còn khảo sát Automatic Differentiation in Machine Learning: a Survey của Baydin, Pearlmutter, Radul và Siskind (arXiv:1502.05767) là tài liệu tham chiếu cho toàn bộ lĩnh vực, bao gồm trade-off forward/reverse đã thảo luận ở trên.