Hạng và không gian null

Bài toán

Tinh chỉnh một ma trận trọng số 4096×4096 nghĩa là cập nhật 16 777 216 tham số. LoRA chỉ học hai ma trận nhỏ, $B$ cỡ 4096×16 và $A$ cỡ 16×4096, tổng cộng 131 072 tham số (khoảng 0.78%), rồi cộng tích $BA$ vào ma trận gốc. Cách làm này đặt cược vào một giả định: thay đổi cần cho một tác vụ chỉ sống trong một không gian ít chiều. Muốn hiểu giả định đó nói gì, cần ba khái niệm: span, hạng và không gian null.

Kéo thử trước

Đầu vào x

Bật JavaScript để kéo x và hai cột của M.

Đầu ra M·x

M

[[1, 2], [2, 4]]

hạng

1

không gian cột

đường qua gốc, hướng (1, 2)

không gian null

span{(2, −1)}

hạng + số chiều null

1 + 1 = 2 = số cột

x

(1, 1)

M·x

(3, 6)

Mọi điểm x + t·(2, −1) đều đáp xuống (3, 6): nhiều đầu vào, một đầu ra, nên không đi ngược lại được.

A = [[1, 2], [2, 4]]B = [[1, 2], [3, 4]]P = [[1, 0], [0, 0]]Ma trận 0

Nên thử: bấm B để thấy cả mặt phẳng đầu ra được phủ kín; bấm P và tự đoán không gian null trước khi nhìn.

Thử bằng số trước

Hai ma trận trông giống nhau, $A = [[1, 2], [2, 4]]$ và $B = [[1, 2], [3, 4]]$:

đầu vào	A·v	B·v
(1, 1)	(3, 6)	(3, 7)
(3, 0)	(3, 6)	(3, 9)
(2, −1)	(0, 0)	(0, 2)

$A$ làm hai chuyện mà $B$ không làm. Nó biến hai đầu vào khác nhau, $(1, 1)$ và $(3, 0)$, thành cùng một đầu ra $(3, 6)$, giống một hàm băm bị đụng độ; đã đụng độ thì không đi ngược lại được. Và nó biến một vector khác 0, $(2, -1)$, thành đúng gốc toạ độ: cả một hướng bị xoá. Khác biệt đó gói trong một con số, gọi là hạng.

Span: tập mọi thứ tạo được

Trong đại số tuyến tính chỉ có hai phép: cộng vector và nhân vector với một số. Ghép chúng lại được tổ hợp tuyến tính $a\,v_1 + b\,v_2 + \dots$ với các hệ số tuỳ ý. Span của một bộ vector là tập tất cả các tổ hợp tuyến tính của chúng, tức mọi điểm tạo ra được từ bộ đó.

bộ vector	span	số chiều
chỉ (0, 0)	một điểm: gốc toạ độ	0
một vector khác 0, ví dụ (1, 2)	một đường thẳng qua gốc	1
(1, 3) và (2, 4), không cùng phương	cả mặt phẳng	2
(1, 2) và (2, 4), cùng phương	vẫn chỉ một đường thẳng	1

Dòng cuối là chỗ cần nhớ: hai vector không bảo đảm hai chiều. Với $(1, 2)$ và $(2, 4)$:

$$a\,(1, 2) + b\,(2, 4) = (a + 2b,\ 2a + 4b) = (t,\ 2t), \quad t = a + 2b$$

Mọi kết quả nằm trên đường $y = 2x$. Điểm $(5, 6)$ nằm ngoài đường đó nên không tạo ra được. Điểm $(6, 12)$ thì tạo ra được, và bằng nhiều cách: $(a, b) = (6, 0), (0, 3), (2, 2), (4, 1), (-2, 4)$.

Độc lập và phụ thuộc tuyến tính

Một bộ vector phụ thuộc tuyến tính khi có ít nhất một vector biểu diễn được từ các vector còn lại; nói cách khác, có một tổ hợp bằng 0 mà các hệ số không đều bằng 0. Không có vector nào như vậy thì bộ đó độc lập tuyến tính. Vector phụ thuộc là vector thừa: thêm nó vào không mở thêm chiều nào, giống một bảng có cột gia_ban và cột gia_ban_x2.

Hai cột của $A$ là $(1, 2)$ và $(2, 4)$: $2\,(1, 2) - 1\,(2, 4) = (0, 0)$ với hệ số $(2, -1)$ khác 0, nên phụ thuộc. Hai cột của $B$ là $(1, 3)$ và $(2, 4)$: giải $a + 2b = 0$, $3a + 4b = 0$ chỉ ra $a = b = 0$, nên độc lập.

Một bộ vector vừa độc lập vừa span được cả không gian gọi là cơ sở: không dư, không thiếu. Hai cột của $B$ là một cơ sở của mặt phẳng; viết $(3, 5)$ theo cơ sở đó được hệ số $(-1, 2)$, vì $-1\,(1, 3) + 2\,(2, 4) = (3, 5)$. Số vector trong một cơ sở là số chiều của không gian.

Hạng: số chiều giữ lại được

Hạng của ma trận là số chiều của tập mọi đầu ra, cũng bằng số cột độc lập tuyến tính.

xét	$A$	$B$
hai cột	(1, 2), (2, 4): cùng phương	(1, 3), (2, 4): khác phương
mọi đầu ra	đường $y = 2x$	cả mặt phẳng
hạng	1	2
đi ngược lại được không	không	có

Vài trường hợp để chốt khái niệm:

ma trận	hạng	làm gì với mặt phẳng
[[0, 0], [0, 0]]	0	bóp mọi thứ về gốc
[[1, 0], [0, 0]]	1	chiếu vuông góc xuống trục ngang: (3, 5) thành (3, 0)
[[1, 2], [2, 4]]	1	bóp xuống đường $y = 2x$
[[1, 2], [3, 4]]	2	méo đi nhưng không mất chiều nào
[[1, 0], [0, 1]]	2	không làm gì

Hai bẫy: hạng 1 không có nghĩa chỉ có một hàng khác 0, vì $[[1, 2], [2, 4]]$ có đủ bốn số khác 0 mà hạng vẫn là 1. Và hạng không vượt quá số hàng lẫn số cột: ma trận 768×4 có hạng tối đa là 4.

Khi nào M·x = t có nghiệm

Tập mọi đầu ra của $M$ gọi là không gian cột: nó là span của các cột, vì $Mx$ là tổ hợp các cột với hệ số là toạ độ của $x$ (bài 2). Từ đó:

Hệ $Mx = t$ có nghiệm khi và chỉ khi $t$ nằm trong không gian cột của $M$.

Không gian cột của $A$ là đường $y = 2x$. Với $t = (5, 6)$ thì $y - 2x = -4 \ne 0$: điểm nằm ngoài đường, hệ vô nghiệm. Với $t = (3, 6)$ thì $y - 2x = 0$: có nghiệm, ví dụ $(1, 1)$ hoặc $(3, 0)$.

Cẩn thận khi kiểm bằng numpy: np.linalg.solve(A, t) báo lỗi Singular matrix với mọi $t$, kể cả $t = (3, 6)$ vốn có nghiệm. Lỗi đó nói ”$A$ không khả nghịch”, không nói ”$t$ nằm ngoài không gian cột”.

Không gian null: phần bị bóp về 0

Không gian null của $M$ là tập mọi $x$ mà $Mx = 0$. Với $A$:

$$A\,(x, y) = (x + 2y,\ 2x + 4y) = (0, 0)$$

Phương trình thứ hai chỉ là phương trình thứ nhất nhân 2, nên còn đúng một ràng buộc $x = -2y$. Chọn $y = -1$ được $x = 2$: không gian null của $A$ là span của $(2, -1)$, một đường thẳng. Hàm scipy.linalg.null_space(A) trả về $(-0.8944,\ 0.4472)$: cùng đường đó, chỉ đổi dấu và chuẩn hoá về độ dài 1. Với $B$, hàm này trả về ma trận không có cột nào: chỉ vector 0 bị bóp về 0, nên $B$ đi ngược lại được.

Không gian null giải thích vì sao $A\,x = (6, 12)$ có nhiều nghiệm. Các nghiệm $(6, 0), (0, 3), (2, 2), (4, 1), (-2, 4)$ lệch nhau đúng một bội của $(2, -1)$, vì nếu $Ax_0 = t$ và $An = 0$ thì $A(x_0 + n) = t$:

Tập nghiệm của $Mx = t$ là một nghiệm bất kỳ cộng với cả không gian null.

Hạng cộng số chiều null bằng số cột

Mỗi chiều của đầu vào hoặc được giữ lại, hoặc bị bóp về 0; không chiều nào biến mất khỏi sổ sách. Với $n$ là số cột của $M$:

$$\operatorname{rank}(M) + \dim \operatorname{null}(M) = n$$

ma trận	số cột	hạng	số chiều null
A = [[1, 2], [2, 4]]	2	1	1
B = [[1, 2], [3, 4]]	2	2	0
[[0, 0], [0, 0]]	2	0	2
[[1, 0], [0, 1]]	2	2	0

Không gian cột nằm ở phía đầu ra, không gian null nằm ở phía đầu vào. Với ma trận vuông hai phía trùng nhau nên dễ lẫn; với ma trận 3×2 thì không gian null ở trong mặt phẳng còn không gian cột ở trong không gian 3 chiều.

Hạng là cổ chai, và hạng thấp thì nén được

Ghép hai phép biến đổi thì hạng không bao giờ tăng:

$$\operatorname{rank}(AB) \le \min(\operatorname{rank} A,\ \operatorname{rank} B)$$

Với $A$ hạng 1 và $B$ hạng 2: $AB = [[7, 10], [14, 20]]$ và $BA = [[5, 10], [11, 22]]$ đều hạng 1, và nhân thêm $B$ bao nhiêu lần cũng vẫn hạng 1. Chiều đã mất thì mất hẳn.

Mặt kia: ma trận hạng thấp lưu được gọn. Ma trận hạng 1 là tích của một cột với một hàng, ví dụ $A = (1, 2)^\top (1, 2)$. Ma trận $m \times n$ hạng $r$ viết được thành tích hai ma trận $m \times r$ và $r \times n$, tức $r(m + n)$ số thay vì $mn$ số. Với $m = 1000$, $n = 768$, $r = 50$: 88 400 số thay vì 768 000, bằng 11.5%.

Quay lại LoRA: phần cập nhật $BA$ có hạng không quá $r$. Với ma trận 4096×4096, $r = 16$ cần 131 072 tham số (0.78%), $r = 8$ cần 65 536 (0.39%, ít hơn 256 lần so với cập nhật cả ma trận).

Hiểu nhầm hay gặp

Các ý dưới đây là lỗi thật đã gặp khi học bài này.

• “Phụ thuộc tuyến tính là các vector nằm trên cùng một đường thẳng.” Chỉ đúng khi có hai vector. Ba vector $(1, 0)$, $(0, 1)$, $(1, 1)$ phụ thuộc, vì $(1, 1) = (1, 0) + (0, 1)$, dù không nằm trên một đường.
• “Độc lập là không có ít nhất một vector biểu diễn được từ các vector khác.” Phủ định đúng của “có ít nhất một” là “không có vector nào”: độc lập nghĩa là không vector nào biểu diễn được từ các vector còn lại.
• “Hạng là số hàng” hoặc “số cột”. $[[1, 3], [2, 6]]$ có 2 hàng mà hạng 1; $[[1, 0, 1], [0, 1, 1]]$ có 3 cột mà hạng 2, vì cột $(1, 1)$ bằng tổng hai cột đầu. Số hàng và số cột chỉ là giới hạn trên.
• “Không gian null của $P = [[1, 0], [0, 0]]$ là gốc toạ độ.” $P(x, y) = (x, 0)$ bằng 0 chỉ cần $x = 0$, còn $y$ tuỳ ý: không gian null là cả trục dọc. Một ẩn tự do cho một đường thẳng, không phải một điểm.
• Lẫn không gian null với không gian cột. Với $P$, không gian null là trục dọc (các đầu vào bị xoá), không gian cột là trục ngang (mọi đầu ra có thể có).
• Viết hệ $Mx = 0$ theo cột. Với $B = [[1, 2], [3, 4]]$, hệ đúng là $x + 2y = 0$ và $3x + 4y = 0$: phương trình thứ $i$ lấy hàng thứ $i$. Kiểm nhanh: $B\,(1, 0)$ phải ra cột 1.
• Lẫn đầu ra với nghiệm. Với $M = [[1, 3], [2, 6]]$ và $t = (2, 4)$, các nghiệm là $(2, 0), (-1, 1), (-4, 2), \dots$, lệch nhau đúng $(3, -1)$. Điểm $(4, 8)$ nằm trong không gian cột nhưng không phải nghiệm: $M\,(4, 8) = (28, 56)$.

Code: tự viết rồi đối chiếu

Tự viết hàm tính hạng bằng khử Gauss rồi so với numpy và scipy. Mỗi assert là một con số trong trang này, kể cả hạng 64 của bảng điểm attention ở mục dưới.

# Span, hạng, không gian cột, không gian null: tự tính bằng Python thuần rồi đối chiếu numpy và scipy.
# Mọi assert dưới đây là số được nhắc trong bài.
import numpy as np
from scipy.linalg import null_space


def mat_vec(M, v):
    return [sum(M[i][t] * v[t] for t in range(len(v))) for i in range(len(M))]


def rank(M, eps=1e-9):
    """Hạng = số hàng khác 0 còn lại sau khử Gauss (có đổi hàng để lấy trụ lớn nhất)."""
    M = [[float(x) for x in hang] for hang in M]
    so_hang, so_cot, r = len(M), len(M[0]), 0
    for c in range(so_cot):
        if r == so_hang:
            break
        tru = max(range(r, so_hang), key=lambda i: abs(M[i][c]))
        if abs(M[tru][c]) < eps:
            continue
        M[r], M[tru] = M[tru], M[r]
        for i in range(r + 1, so_hang):
            k = M[i][c] / M[r][c]
            M[i] = [x - k * y for x, y in zip(M[i], M[r])]
        r += 1
    return r


A = [[1, 2], [2, 4]]
B = [[1, 2], [3, 4]]

# Thử trước: A làm đụng độ và xoá một hướng, B thì không
for v, ra_A, ra_B in [((1, 1), [3, 6], [3, 7]), ((3, 0), [3, 6], [3, 9]), ((2, -1), [0, 0], [0, 2])]:
    assert mat_vec(A, v) == ra_A and mat_vec(B, v) == ra_B
assert rank(A) == 1 == np.linalg.matrix_rank(A) and rank(B) == 2 == np.linalg.matrix_rank(B)

# Span của (1, 2) và (2, 4) là đường y = 2x: (6, 12) tạo được bằng nhiều cách, (5, 6) thì không
nghiem = [(6, 0), (0, 3), (2, 2), (4, 1), (-2, 4)]
assert all(mat_vec(A, x) == [6, 12] for x in nghiem)
# các nghiệm lệch nhau đúng một bội của (2, -1)
for x in nghiem:
    dx, dy = x[0] - 6, x[1] - 0
    assert dx * (-1) - dy * 2 == 0  # (dx, dy) cùng phương với (2, -1)
for t in [(5, 6), (1, 1)]:
    assert t[1] - 2 * t[0] != 0  # nằm ngoài đường y = 2x nên A·x = t vô nghiệm
assert mat_vec(A, (1, 1)) == mat_vec(A, (3, 0)) == [3, 6]  # t = (3, 6) có nghiệm
print("y - 2x của (5, 6) và (1, 1):", 6 - 2 * 5, 1 - 2 * 1)
# np.linalg.solve báo lỗi với MỌI t, kể cả t có nghiệm, vì A suy biến
for t in [(3, 6), (5, 6)]:
    try:
        np.linalg.solve(np.array(A, float), t)
        raise AssertionError("solve lẽ ra phải báo lỗi")
    except np.linalg.LinAlgError:
        pass

# Không gian null
nA = null_space(np.array(A, float))
print("null_space(A) =", nA.ravel().round(4), "  null_space(B) có", null_space(np.array(B, float)).shape[1], "cột")
assert nA.shape == (2, 1) and np.allclose(np.abs(nA.ravel()), np.array([2, 1]) / np.sqrt(5))
assert np.allclose(np.abs(nA.ravel()), [0.8944, 0.4472], atol=1e-4)
assert null_space(np.array(B, float)).shape == (2, 0)

# Cột của B là một cơ sở: (3, 5) = -1·(1, 3) + 2·(2, 4)
assert mat_vec(B, (-1, 2)) == [3, 5]
# Hai cột của A phụ thuộc: tổ hợp với hệ số (2, -1) ra vector 0
assert (2 * np.array([1, 2]) - 1 * np.array([2, 4])).tolist() == [0, 0]

# Hạng + số chiều không gian null = số cột
for M, hang, nullity in [(A, 1, 1), (B, 2, 0), ([[0, 0], [0, 0]], 0, 2), ([[1, 0], [0, 1]], 2, 0), ([[1, 0], [0, 0]], 1, 1)]:
    assert rank(M) == hang == np.linalg.matrix_rank(np.array(M))
    assert null_space(np.array(M, float)).shape[1] == nullity and hang + nullity == 2

# Các chỗ hay nhầm
assert rank([[1, 3], [2, 6]]) == 1 and rank([[1, 0, 1], [0, 1, 1]]) == 2
assert mat_vec([[1, 3], [2, 6]], (4, 8)) == [28, 56]  # (4, 8) nằm trên đường nhưng không phải nghiệm
M = [[1, 3], [2, 6]]
assert all(mat_vec(M, x) == [2, 4] for x in [(2, 0), (-1, 1), (-4, 2)]) and mat_vec(M, (3, -1)) == [0, 0]
assert np.allclose(np.abs(null_space(np.array([[1.0, 0], [0, 0]])).ravel()), [0, 1])  # null của P là cả trục y
assert rank([[1, 0], [0, 1], [1, 1]]) == 2  # ba vector (1,0), (0,1), (1,1) phụ thuộc

# Hạng là cổ chai: ghép thêm bao nhiêu phép biến đổi cũng không tăng
AB, BA = np.array(A) @ np.array(B), np.array(B) @ np.array(A)
assert AB.tolist() == [[7, 10], [14, 20]] and BA.tolist() == [[5, 10], [11, 22]]
assert np.linalg.matrix_rank(AB) == np.linalg.matrix_rank(BA) == 1
assert all(np.linalg.matrix_rank(np.linalg.matrix_power(np.array(B), k) @ np.array(A)) == 1 for k in range(1, 6))

# Hạng thấp thì nén được
assert np.array_equal(np.outer([1, 2], [1, 2]), A)
m, n, r = 1000, 768, 50
print(f"lưu đầy đủ {m * n:,} số, lưu dạng hạng {r}: {r * (m + n):,} số = {r * (m + n) / (m * n):.1%}")
assert (m * n, r * (m + n), round(100 * r * (m + n) / (m * n), 1)) == (768_000, 88_400, 11.5)

# LoRA trên ma trận 4096×4096
d = 4096
assert d * d == 16_777_216
for r, so, phan_tram, giam in [(16, 131_072, 0.78, 128), (8, 65_536, 0.39, 256)]:
    assert 2 * d * r == so and round(100 * so / d**2, 2) == phan_tram and d * d // so == giam

# Attention: bảng điểm Q·Kᵀ cỡ 100×100 nhưng hạng chỉ 64 khi mỗi đầu có 64 chiều
rng = np.random.default_rng(0)
X = rng.standard_normal((100, 512))
WQ, WK = rng.standard_normal((2, 512, 64))
diem = (X @ WQ) @ (X @ WK).T
assert diem.shape == (100, 100) and np.linalg.matrix_rank(diem) == 64
print("đúng hết")

Nằm ở đâu trong AI

Khái niệm	Chỗ dùng
Hạng thấp thì nén được	LoRA: học phần cập nhật $BA$ hạng $r$ thay cho cả ma trận trọng số
Hạng không vượt chiều nhỏ nhất	Attention: với 100 token, mỗi token 512 chiều và $W^Q$, $W^K$ cỡ 512×64, bảng điểm $QK^\top$ cỡ 100×100 nhưng hạng chỉ 64
$\operatorname{rank}(AB) \le \min$	Lớp cổ chai trong autoencoder; Multi-head Latent Attention của DeepSeek nén KV cache qua một không gian ít chiều để giảm bộ nhớ
Không gian null khác {0}	Lớp nén không khôi phục được nguyên bản: phần rơi vào không gian null bị xoá thật
Cột phụ thuộc	Đặc trưng trùng lặp (đa cộng tuyến) làm ma trận hiệp phương sai suy biến, mô hình hồi quy mất ổn định
Không gian cột	Hồi quy tuyến tính: khi $Mx = t$ vô nghiệm, bình phương tối thiểu tìm điểm gần $t$ nhất trong không gian cột

Tự kiểm