Chương trình học Bài 107 trên tổng số 250 · Trực giác về mạng nơ-ron, LLM và dự án cuối về AI
Trực giác về mạng nơ-ron, LLM và dự án cuối về AI

Self-attention từ con số không

Bạn đã xây một nơ-ron và một lượt truyền xuôi. Giờ bạn sẽ xây ý tưởng duy nhất đã biến các mạng nơ-ron trơn thành transformer và, từ đó, thành các LLM đằng sau mọi trợ lý trò chuyện: self-attention. Nó là một nhúm phép nhân ma trận, và bạn làm được toàn bộ bằng numpy.

Trực giác

Hãy hình dung mỗi từ trong một câu muốn thu thập thông tin từ các từ khác. Self-attention cho mỗi vị trí ba vector:

  • Một query (Q): thứ vị trí này đang tìm.
  • Một key (K): thứ mỗi vị trí cung cấp, dùng để so khớp.
  • Một value (V): thông tin thật mà mỗi vị trí mang.

Một vị trí so sánh query của nó với mọi key để quyết định nên lắng nghe mỗi vị trí khác bao nhiêu, rồi lấy một hỗn hợp có trọng số của các value theo những mức đó. Khớp mạnh -> trọng số lớn -> value đó đóng góp nhiều hơn. Đó là toàn bộ cơ chế: query chú ý tới key, và câu trả lời là một hỗn hợp có trọng số của các value.

Phần toán: attention tích vô hướng có co giãn

Điểm khớp giữa một query và một key là tích vô hướng của chúng (lớn hơn khi chúng chỉ cùng hướng). Xếp mọi query vào một ma trận Q và mọi key vào K, và mọi điểm số cùng lúc là Q @ K.T. Ta chia cho sqrt(d_k) (số chiều của key) để điểm số không bùng nổ khi vector dài ra:

scores = Q @ K.T / np.sqrt(d_k)

Vì sao phải chia? Một tích vô hướng tăng theo số chiều. Nếu d_k là 64 và các phần tử khoảng 1, điểm thô rơi vào khoảng 64, và những số lớn như vậy đẩy softmax dồn hết vào một key và làm phẳng gradient. Chia cho sqrt(d_k), ở đây sqrt(64) = 8, kéo điểm số về một khoảng hợp lý để attention luôn mượt và huấn luyện được. Trong ví dụ tí hon d_k = 1 bạn chạy bên dưới, số chia chỉ là 1, nên bạn sẽ không thấy nó phát huy, nhưng ở kích thước mô hình thật nó là thiết yếu.

Mỗi hàng của scores giữ điểm số của một query với mọi key. Ta biến mỗi hàng thành các trọng số dương có tổng bằng 1 bằng một softmax trên trục cuối:

weights = softmax(scores, axis=-1)   # each row sums to 1

Softmax lấy mũ rồi chuẩn hóa. Làm một cách ngây thơ, np.exp của một điểm lớn tràn thành inf và các trọng số ra nan. Cách sửa là mẹo ổn định số học chuẩn: trừ giá trị lớn nhất của mỗi hàng trước khi lấy mũ. Về mặt toán nó không đổi kết quả (cùng một hằng số triệt tiêu ở tử và mẫu), nhưng nó giữ mọi số mũ <= 0:

def softmax(x):
    x = x - x.max(axis=-1, keepdims=True)   # stability: largest exponent is now 0
    e = np.exp(x)
    return e / e.sum(axis=-1, keepdims=True)

Cuối cùng, đầu ra của mỗi query là các trọng số của nó áp lên các value, thêm một phép nhân ma trận nữa:

output = weights @ V

Ghép lại, công thức nổi tiếng chỉ là softmax(Q @ K.T / sqrt(d_k)) @ V. Nếu Q là (n, d_k), K là (m, d_k), và V là (m, d_v), thì weights là (n, m) và output là (n, d_v): một vector đầu ra cho mỗi query, mỗi cái là một hỗn hợp các hàng value.

Đây là toàn bộ mẹo của transformer

Một transformer thật không dừng ở một phép tính attention. Multi-head attention chạy song song vài phép như vậy (mỗi head học phép chiếu Q, K, V riêng, nên các head khác nhau chú ý tới những thứ khác nhau) và nối các kết quả lại. Một khối transformer rồi xếp attention với một mạng truyền xuôi nhỏ và một kết nối tắt (residual), và một mô hình xếp hàng chục khối như vậy. Nhưng trái tim đang đập của mỗi khối chính xác là hàm bạn sắp viết: điểm số, softmax ổn định, tổng có trọng số của các value. Xây được cái này là bạn hiểu phép toán cốt lõi mà một LLM lặp lại khi nó "chú ý" tới prompt.

Một lưu ý trung thực: ở đây Q, K và V được trao cho bạn như các mảng cố định. Trong một mô hình thật chúng không được cho sẵn, chúng được tạo ra bằng cách nhân embedding của mỗi token với ba ma trận trọng số đã học, W_q, W_k và W_v. Những ma trận đó, và các ma trận trong mọi khối, chính là thứ việc huấn luyện điều chỉnh bằng gradient descent từ bài trước. Nên thứ bạn xây ở đây là lõi cố định của attention, giống hệt trong mọi transformer; việc học nằm trong các phép chiếu đưa dữ liệu vào nó.

Nhấn Chạy để xem attention biến một Q/K/V tí hon thành một đầu ra và in ma trận trọng số để bạn đọc ra ai đã chú ý tới ai.

Đến lượt bạn

Cài đặt attention tích vô hướng có co giãn bằng numpy. Viết attention(Q, K, V) trả về một tuple (output, weights). Tính scores = Q @ K.T / np.sqrt(d_k) trong đó d_k là chiều cuối của Q; áp dụng một softmax ổn định số học trên trục cuối (trừ giá trị lớn nhất của mỗi hàng trước np.exp) để có weights mà mỗi hàng có tổng bằng 1; rồi output = weights @ V. Trả về output trước, rồi ma trận weights. Rồi đặt out, w = attention(Q, K, V) cho các mảng được cung cấp.

Bạn thấy vấn đề gì trong bài học này? Hãy báo cáo nó · Hỏi về bài học này

Bài tập này sẽ sớm mở.

Hoàn thành bài học trước đó để mở khóa bài này. Toàn bộ khóa học là miễn phí, không cần tài khoản, và bạn có thể đọc bài học này ngay bây giờ.