Vector và ma trận

Vector: một dãy số có thứ tự

Một vector là một dãy số có thứ tự. Học sinh A tự học 6 giờ, điểm học kỳ 1 là 7.5, vắng 1 buổi, nên được mô tả bằng vector $\mathbf{a} = (6, 7.5, 1)$. Thứ tự quan trọng: $(7.5, 6, 1)$ là một học sinh khác. Số phần tử của vector gọi là số chiều. Mỗi con số mô tả một mẫu dữ liệu, như giờ tự học hay số buổi vắng, gọi là một đặc trưng (feature); mỗi đặc trưng là một chiều.

Vector hai chiều vẽ được thành một mũi tên từ gốc tọa độ tới điểm $(x, y)$. Hai phép tính cơ bản đều làm từng phần tử:

Cộng hai vector là nối mũi tên này vào đầu mũi tên kia. Nhân với số $c$ là kéo dài mũi tên $c$ lần, hoặc đảo chiều khi $c < 0$.

import numpy as np

a = np.array([3.0, 1.0])
b = np.array([1.0, 2.0])
print(a + b, 2 * a, a - b)

Kết quả[4. 3.] [6. 2.] [ 2. -1.]

Phép trừ $\mathbf{a} - \mathbf{b}$ cho mũi tên đi từ đầu $\mathbf{b}$ tới đầu $\mathbf{a}$. Mục sau dùng nó để đo khoảng cách.

Độ dài và khoảng cách

Độ dài của vector $(3, 4)$ là cạnh huyền của tam giác vuông có hai cạnh 3 và 4, bằng 5 theo định lý Pythagoras. Tổng quát cho $d$ chiều, độ dài, hay chuẩn L2 (L2 norm), là

Khoảng cách giữa hai điểm là độ dài của hiệu: $\lVert \mathbf{a} - \mathbf{b} \rVert$. Đây là khoảng cách Euclid, cách đo mà kNN ở bài 2.4 dùng để tìm hàng xóm gần nhất.

Còn một cách đo khác: cộng trị tuyệt đối từng thành phần, $|a_1| + |a_2| + \dots$, gọi là chuẩn L1. Trên bàn cờ, xe đi theo hàng và cột, nên quãng đường của nó là khoảng cách L1, còn quãng đường chim bay là khoảng cách L2.

p = np.array([1.0, 2.0])
q = np.array([4.0, 6.0])
d = q - p
print(d, np.linalg.norm(d), np.sqrt((d ** 2).sum()), np.abs(d).sum())

Kết quả[3. 4.] 5.0 5.0 7.0

Từ $p$ tới $q$ phải đi 3 theo trục ngang và 4 theo trục dọc. Đường thẳng dài 5, đường đi theo ô dài 7. np.linalg.norm mặc định tính chuẩn L2, đúng bằng công thức viết tay.

Tích vô hướng

Tích vô hướng (dot product) của hai vector cùng số chiều là tổng các tích từng cặp:

Kết quả là một số, không phải vector. Ý nghĩa đầu tiên là tổng có trọng số. Ở bài 0.4, hàm bậc nhất $y = wx + b$ chỉ có một đầu vào. Với ba đặc trưng, model tuyến tính tính

Mỗi trọng số $w_j$ nói đặc trưng thứ $j$ đóng góp bao nhiêu. Trọng số âm cho số buổi vắng nghĩa là vắng càng nhiều thì điểm dự đoán càng thấp.

Ý nghĩa thứ hai là hình học. Gọi $\theta$ là góc giữa hai mũi tên, khi đó

Không cần nhớ lượng giác để đọc công thức này. $\cos\theta$ bằng 1 khi hai mũi tên cùng hướng, bằng 0 khi chúng vuông góc, bằng $-1$ khi ngược hướng. Vì vậy dấu của tích vô hướng cho biết hai vector “cùng phía” hay “ngược phía”.

Chia tích vô hướng cho hai độ dài, ta còn lại đúng $\cos\theta$, gọi là cosine similarity. Nó chỉ đo hướng, không đo độ dài, nên nằm trong khoảng từ $-1$ đến 1. Các chương sau biểu diễn một từ hay một ảnh bằng vector, gọi là embedding, rồi dùng cosine similarity để tìm từ hay ảnh giống nhau.

w = np.array([0.1, 0.8, -0.3])          # giờ tự học, điểm HK1, số buổi vắng
x = np.array([6.0, 7.5, 1.0])           # học sinh A
print(w @ x, (w * x).sum(), w @ x + 1.0)

def cosine(u, v):
    return u @ v / (np.linalg.norm(u) * np.linalg.norm(v))

meo = np.array([0.9, 0.8, 0.1])
cho = np.array([0.8, 0.9, 0.2])
oto = np.array([0.1, 0.2, 0.9])
print(round(cosine(meo, cho), 3), round(cosine(meo, oto), 3))

Kết quả6.3 6.3 7.3
0.99 0.303

Dòng đầu: tích vô hướng bằng tổng các tích từng cặp, $0.6 + 6.0 - 0.3 = 6.3$; cộng thêm $b = 1$ được điểm dự đoán 7.3. Dòng hai dùng ba vector đồ chơi cho ba từ: “mèo” và “chó” gần cùng hướng nên cosine gần 1, “mèo” và “ô tô” lệch hướng nhiều nên cosine chỉ 0.3.

Ma trận: một bảng số

Xếp vector của bốn học sinh thành bốn hàng, ta được một ma trận 4 hàng, 3 cột, viết là ma trận $4 \times 3$ hay shape (4, 3). Quy ước của học máy: mỗi hàng là một mẫu, mỗi cột là một đặc trưng. Ma trận dữ liệu thường ký hiệu $X$, shape $(n, d)$ với $n$ mẫu và $d$ đặc trưng.

Nhân ma trận $X$ với vector trọng số $\mathbf{w}$ là làm tích vô hướng của từng hàng với $\mathbf{w}$:

Một phép nhân cho dự đoán của cả $n$ học sinh. Mỗi hàng có 3 số và $\mathbf{w}$ có 3 số, nên số cột của $X$ phải bằng độ dài của $\mathbf{w}$. Kết quả có $n$ số, một số cho mỗi hàng.

X = np.array([[6.0, 7.5, 1.0],
              [2.0, 6.0, 4.0],
              [10.0, 8.5, 0.0],
              [4.0, 5.5, 2.0]])
b = 1.0
print(X.shape, w.shape, (X @ w).shape)
print(X @ w + b)
print([round(float(row @ w + b), 1) for row in X])

Kết quả(4, 3) (3,) (4,)
[7.3 4.8 8.8 5.2]
[7.3, 4.8, 8.8, 5.2]

Dòng cuối tính lại bằng vòng lặp qua từng hàng và ra đúng bốn số. Phép X @ w làm cùng việc ấy, chỉ nhanh hơn nhiều khi bảng có hàng triệu dòng. Số b được cộng vào cả bốn dự đoán nhờ broadcasting của bài 0.2.

Nhân hai ma trận

Giờ muốn hai dự đoán cho mỗi học sinh, chẳng hạn điểm Toán và điểm Văn. Mỗi môn có một vector trọng số riêng. Xếp hai vector ấy thành hai cột của ma trận $W$ shape $(3, 2)$. Khi đó $XW$ có shape $(4, 2)$: ô ở hàng $i$, cột $j$ là tích vô hướng của hàng $i$ của $X$ với cột $j$ của $W$.

Quy tắc shape:

Hai số $k$ ở giữa phải bằng nhau, vì đó là độ dài của hai vector đem nhân vô hướng. Hai số ở ngoài cho shape kết quả. Một lớp của mạng neural làm đúng phép này: $X$ là $(n, d)$, $W$ là $(d, h)$, kết quả $(n, h)$ là $h$ đặc trưng mới cho mỗi mẫu. Mỗi cột của $W$ là một nơ-ron.

Chuyển vị $X^\top$ (trong NumPy là X.T) đổi hàng thành cột, nên shape $(m, n)$ thành $(n, m)$. Thứ tự nhân quan trọng: $AB$ và $BA$ nói chung khác nhau, và nhiều khi một trong hai còn không nhân được vì shape không khớp. Ma trận đơn vị $I$ có 1 trên đường chéo, 0 ở mọi ô khác; nhân với $I$ không đổi gì, như nhân một số với 1.

W = np.array([[0.1, -0.2],
              [0.8, 0.5],
              [-0.3, 0.4]])
H = X @ W
print(H.shape)
print(np.round(H, 2))
print(X.T.shape, W.T.shape)
try:
    W @ X
except ValueError as e:
    print("W @ X lỗi:", e)
I = np.eye(3)
print(np.allclose(X @ I, X))

Kết quả(4, 2)
[[6.3  2.95]
 [3.8  4.2 ]
 [7.8  2.25]
 [4.2  2.75]]
(3, 4) (2, 3)
W @ X lỗi: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 4 is different from 2)
True

Cột đầu của H là X @ w ở mục trước, chưa cộng $b$, vì cột đầu của W chính là w. W @ X là $(3, 2) @ (4, 3)$: số 2 và số 4 ở giữa không bằng nhau, nên NumPy báo lỗi. Thông báo lỗi dài nhưng đọc được ý chính ở cuối: kích thước 4 khác 2.

Ma trận như một phép biến đổi

Một ma trận $2 \times 2$ nhân với mọi điểm của mặt phẳng là một cách biến đổi mặt phẳng. $\begin{pmatrix} 2 & 0 \\ 0 & 1 \end{pmatrix}$ kéo giãn trục ngang gấp đôi. $\begin{pmatrix} 0 & -1 \\ 1 & 0 \end{pmatrix}$ xoay mọi điểm 90 độ ngược chiều kim đồng hồ. Cột đầu của ma trận là nơi điểm $(1, 0)$ đi tới, cột sau là nơi điểm $(0, 1)$ đi tới.

Một lớp của mạng neural cũng làm việc này: nó biến đổi dữ liệu sang một hệ tọa độ mới, nơi các lớp dễ tách nhau hơn.

Trong toán, điểm được viết thành cột và nhân bên phải ma trận: $M\mathbf{v}$. Trong code, mỗi điểm là một hàng của bảng $X$, nên cùng phép biến đổi ấy viết là X @ M.T.

square = np.array([[0, 0], [1, 0], [1, 1], [0, 1]], dtype=float)   # mỗi hàng một đỉnh
M = np.array([[2.0, 1.0],
              [0.0, 1.0]])
print(square @ M.T)

Kết quả[[0. 0.]
 [2. 0.]
 [3. 1.]
 [1. 1.]]

Đỉnh $(1, 0)$ đi tới $(2, 0)$, đúng cột đầu của $M$; đỉnh $(0, 1)$ đi tới $(1, 1)$, đúng cột sau. Hình vuông thành hình bình hành.