Nhân ma trận, ma trận "biến hình", vector riêng & trị riêng bằng NumPy
Trong bài này
Series · Bài 9/12 Toán AI thực chiến: học Toán cho AI bằng code Python
- Ký hiệu Toán → NumPy & công thức 1 nơ-ron
- Ảnh là ma trận & Web App chấm điểm CV
- Hàm số & Sigmoid
- Khoảng cách, chuẩn hóa & KNN
- Mini-App định giá laptop cũ
- Vector, tích vô hướng & cosine
- Chữ thành vector bằng đếm từ
- Embedding, tìm kiếm ngữ nghĩa & RAG
- Nhân ma trận, vector riêng & trị riêng
- PCA: bản đồ sinh viên 2D & nén ảnh
- Đạo hàm, đạo hàm riêng & chain rule
- Lan truyền ngược: nơ-ron tự sửa sai
Bạn đã quen với vector: một hàng số như giỏ hàng, hồ sơ, điểm thi. Nhưng dữ liệu thật hiếm khi chỉ có một hàng — một bảng đơn gọi món của cả nhóm, một bảng giá của nhiều quán, một bức ảnh hàng trăm nghìn điểm sáng. Bảng số đó gọi là ma trận, và gần như mọi mô hình AI đều chạy bằng phép nhân ma trận.
Trong bài này, bạn sẽ đọc và cắt lát ma trận bằng NumPy, hiểu vì sao nhân ma trận chỉ là "làm nhiều tích vô hướng cùng lúc", nhìn thấy ma trận như một phép "biến hình", rồi tự tay đi tìm vector riêng và trị riêng — viên gạch nền cho kỹ thuật nén dữ liệu PCA ở bài sau.
Chuẩn bị
Bạn chỉ cần trình duyệt và một tài khoản Google:
- Mở notebook của bài: Notebook Colab — Ma trận, trị riêng & PCA.
- Chọn File › Save a copy in Drive để có bản sao của riêng bạn (bản gốc chỉ xem được).
- Bấm Connect ở góc phải trên. Thấy dấu ✓ xanh là sẵn sàng.
Không muốn dùng notebook có sẵn? Tạo một notebook Colab mới rồi dán lần lượt từng ô code trong bài này. Nhấn Shift + Enter để chạy một ô và nhảy xuống ô dưới.
💡 Notebook đã có sẵn ô đáp án (thu gọn). Hãy tự gõ khung code và điền chỗ trống trước, chỉ mở đáp án để đối chiếu — đó là cách duy nhất để Toán "ngấm". Chỗ trống được đánh dấu bằng
____; nếu chạy khi còn chỗ trống, Colab báoNameError: name '____' is not defined— đó chỉ là lời nhắc bạn chưa điền xong.
Ma trận là bảng số m hàng × n cột
Ba bạn An, Bình, Chi gọi món ở quán. Ghi vào một bảng: mỗi hàng là một bạn, mỗi cột là một món [cà phê, trà sữa, bánh mì]:
| A | Cà phê | Trà sữa | Bánh mì |
|---|---|---|---|
| An | 2 | 1 | 0 |
| Bình | 1 | 1 | 2 |
| Chi | 0 | 2 | 1 |
Bảng đó là ma trận (matrix — "mây-trích") A cỡ 3 × 3. Bảng giá P có 3 món × 2 quán (X, Y) là ma trận 3 × 2. Lật bảng giá để mỗi hàng là một quán thì được chuyển vị Pᵀ cỡ 2 × 3.
Ba ký hiệu cần nhớ:
- A: m × n (đọc: "A cỡ m nhân n") — m hàng, n cột.
- A[i, j] (đọc: "A i j") — phần tử ở hàng i, cột j. Python đếm từ 0, nên hàng đầu tiên là hàng 0.
- Aᵀ (đọc: "A chuyển vị") — lật hàng thành cột.
# [A1]: Ma trận = bảng số m hàng × n cột
import numpy as np
import matplotlib.pyplot as plt
# Mỗi HÀNG là một bạn, mỗi CỘT là một món: [cà phê, trà sữa, bánh mì]
A = np.array([[2, 1, 0], # An
[1, 1, 2], # Bình
[0, 2, 1]]) # Chi
print("A =\n", A)
print("A.shape :", A.shape) # (số hàng, số cột)
print("Hàng của Bình A[1] :", A[1])
print("Cột trà sữa A[:, 1] :", A[:, 1])
print("Chi gọi mấy trà sữa? A[2, 1] =", A[2, 1])
# Bảng giá: mỗi HÀNG là một món, mỗi CỘT là một quán [quán X, quán Y]
P = np.array([[25, 20], # cà phê
[30, 35], # trà sữa
[20, 15]]) # bánh mì
print("\nP.shape:", P.shape, " → chuyển vị P.T.shape:", P.T.shape)
print("P.T (lật hàng thành cột) =\n", P.T)
Kết quả:
A =
[[2 1 0]
[1 1 2]
[0 2 1]]
A.shape : (3, 3)
Hàng của Bình A[1] : [1 1 2]
Cột trà sữa A[:, 1] : [1 1 2]
Chi gọi mấy trà sữa? A[2, 1] = 2
P.shape: (3, 2) → chuyển vị P.T.shape: (2, 3)
P.T (lật hàng thành cột) =
[[25 30 20]
[20 35 15]]
Để ý: A[1] lấy cả hàng, còn A[:, 1] lấy cả cột — dấu : nghĩa là "tất cả các hàng". Một ma trận thực chất là một danh sách các vector xếp chồng lên nhau.
Tự kiểm tra: Dũng gọi 3 bánh mì, không gọi gì khác. Hàng của Dũng là gì?
[0, 0, 3] — theo đúng thứ tự cột [cà phê, trà sữa, bánh mì].
Nhân ma trận = làm nhiều tích vô hướng cùng lúc
Ở quán X, giá là [25, 30, 20] nghìn. Hóa đơn của An = [2, 1, 0] · [25, 30, 20] = 50 + 30 + 0 = 80 nghìn — chính là tích vô hướng bạn đã gặp ở Bài 6 trong series. Tính cho cả 3 bạn ở cả 2 quán là 6 tích vô hướng. Phép nhân ma trận A @ P làm hết 6 phép đó trong một dòng.
Ô (i, j) của A @ P = hàng i của A · cột j của P (đọc: "A nhân P" — mỗi ô kết quả là tích vô hướng giữa một hàng của A và một cột của P).
| A @ P | Quán X | Quán Y | Tính tay ô quán Y |
|---|---|---|---|
| An | 80 | 75 | 2×20 + 1×35 + 0×15 = 75 |
| Bình | 95 | 85 | 1×20 + 1×35 + 2×15 = 85 |
| Chi | 80 | 85 | 0×20 + 2×35 + 1×15 = 85 |
Luật kích thước: (3 × 3) @ (3 × 2) → (3 × 2). Tổng quát: (m × n) @ (n × p) → (m × p). Hai số ở giữa phải bằng nhau; kết quả lấy số hàng bên trái và số cột bên phải. Vì thế P @ A — tức (3 × 2) @ (3 × 3) — sẽ báo lỗi.
# [A2]: Nhân ma trận = làm NHIỀU tích vô hướng cùng lúc
gia_X = P[:, 0] # giá ở quán X: [25 30 20]
print("Hóa đơn từng bạn ở quán X A @ gia_X =", A @ gia_X)
# Cách 1: vòng lặp — mỗi ô kết quả = (hàng i của A) · (cột j của P)
KQ = np.zeros((3, 2), dtype=int)
for i in range(3): # từng bạn
for j in range(2): # từng quán
KQ[i, j] = np.dot(A[i], P[:, j])
print("\nVòng lặp:\n", KQ)
# Cách 2: toán tử @ của NumPy
print("A @ P:\n", A @ P)
print("Kích thước:", A.shape, "@", P.shape, "→", (A @ P).shape)
# Số cột của ma trận trái PHẢI bằng số hàng của ma trận phải
try:
P @ A
except ValueError as e:
print("\nP @ A báo lỗi:", str(e)[:60], "…")
Kết quả:
Hóa đơn từng bạn ở quán X A @ gia_X = [80 95 80]
Vòng lặp:
[[80 75]
[95 85]
[80 85]]
A @ P:
[[80 75]
[95 85]
[80 85]]
Kích thước: (3, 3) @ (3, 2) → (3, 2)
P @ A báo lỗi: matmul: Input operand 1 has a mismatch in its core dimension …
Vòng lặp hai tầng và toán tử @ cho cùng một bảng hóa đơn — nhưng @ ngắn hơn và nhanh hơn rất nhiều khi bảng có hàng triệu dòng. Dòng đầu tiên còn cho thấy ma trận nhân vector (A𝐠, đọc "A nhân g"): ra hóa đơn của cả 3 bạn ở quán X cùng lúc.
💡 Nhớ lại công thức một nơ-ron ở Bài 1 trong series: z = 𝐰·𝐱 + b tính cho một hồ sơ. Với cả bảng hồ sơ X (mỗi hàng một người), chỉ cần viết gọn
X @ w + b— mỗi hàng ra một kết quả. Đó là lý do GPU được thiết kế để nhân ma trận thật nhanh.
Ma trận là một phép "biến hình"
Kéo giãn một bức ảnh trên điện thoại, xoay nhân vật trong game 2D, bộ lọc làm méo khuôn mặt — bên trong đều là: lấy từng điểm (x, y), nhân với một ma trận 2 × 2. Với M = [[2, 1], [1, 2]], điểm (1, 0) đi tới (2, 1), điểm (1, 1) đi tới (3, 3): hình vuông bị kéo xiên thành hình bình hành.
| 𝐯 | M @ 𝐯 | Hướng |
|---|---|---|
| [1, 0] | [2, 1] | Bị xoay lệch |
| [1, 1] | [3, 3] = 3 × [1, 1] | Giữ hướng, dài gấp 3 |
| [1, −1] | [1, −1] = 1 × [1, −1] | Giữ hướng, giữ độ dài |
# [A3]: Ma trận là một phép "biến hình": nhân với M làm mọi điểm di chuyển
M = np.array([[2, 1],
[1, 2]])
vuong = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]) # hình vuông (mỗi hàng là 1 điểm)
moi = vuong @ M.T # nhân M với từng điểm
for v in [np.array([1, 0]), np.array([1, 1]), np.array([1, -1])]:
print(f"M @ {v} = {M @ v}")
plt.figure(figsize=(5, 5))
plt.fill(vuong[:, 0], vuong[:, 1], alpha=0.4, label="trước: hình vuông")
plt.fill(moi[:, 0], moi[:, 1], alpha=0.3, label="sau khi nhân M")
for v, mau in [([1, 0], "red"), ([1, 1], "green")]:
Mv = M @ np.array(v)
plt.quiver(0, 0, *v, angles="xy", scale_units="xy", scale=1, color=mau, width=0.012)
plt.quiver(0, 0, *Mv, angles="xy", scale_units="xy", scale=1, color=mau, width=0.006, alpha=0.6)
plt.xlim(-0.5, 3.5); plt.ylim(-0.5, 3.5); plt.grid(alpha=0.3); plt.gca().set_aspect("equal")
plt.title("Đỏ [1,0] bị đổi hướng · Xanh [1,1] giữ nguyên hướng"); plt.legend(loc="upper left")
plt.show()
Kết quả:
M @ [1 0] = [2 1]
M @ [1 1] = [3 3]
M @ [ 1 -1] = [ 1 -1]
Kèm theo là một hình: hình vuông xanh bị kéo xiên thành hình bình hành màu cam.
Phép vuong @ M.T nhân M với cả 5 điểm của hình vuông trong một lần (mỗi hàng là một điểm, nên ta dùng M.T để luật kích thước khớp). Câu hỏi đáng giá nhất ở đây: có những hướng nào bị M kéo dài mà không bị bẻ lệch?
Vector riêng & trị riêng: những hướng "cứng đầu"
Kéo một miếng bột bánh theo đường chéo: các sợi nằm dọc đường chéo chỉ dài ra mà không lệch đi; mọi sợi khác vừa dài ra vừa bị xoay. Những hướng "cứng đầu" đó là vector riêng (eigenvector — "ai-gần véc-tơ"); số lần chúng dài ra là trị riêng (eigenvalue).
M𝐯 = λ𝐯 (đọc: "M nhân v bằng lam-đa nhân v") — 𝐯 là vector riêng, λ (lam-đa) là trị riêng.
Tính tay với M = [[2, 1], [1, 2]]:
- M·[1, 1] = [2 + 1, 1 + 2] = [3, 3] = 3·[1, 1] → λ = 3.
- M·[1, −1] = [2 − 1, 1 − 2] = [1, −1] → λ = 1.
- Mọi vector cùng hướng như [2, 2], [5, 5] cũng là vector riêng (cùng λ = 3).
NumPy tìm giúp bằng np.linalg.eigh. Hàm này dành cho ma trận đối xứng (lật qua đường chéo vẫn y nguyên, như M ở đây). Nó trả λ từ nhỏ đến lớn, và mỗi cột của V là một vector riêng dài đúng 1 (0.707 = 1/√2).
# [A4]: Vector riêng & trị riêng: M v = λ v (nhân M xong vẫn cùng hướng, chỉ dài ra λ lần)
# eigh: dành cho ma trận ĐỐI XỨNG (lật qua đường chéo vẫn y nguyên) — trả λ từ nhỏ đến lớn
lam, V = np.linalg.eigh(M)
print("Trị riêng λ :", lam)
print("Vector riêng (cột) :\n", V.round(3))
for i in range(2):
v = V[:, i]
print(f"\nλ = {lam[i]:.0f}, v = {v.round(3)}")
print(" M @ v =", (M @ v).round(3))
print(" λ * v =", (lam[i] * v).round(3), "→ bằng nhau:", np.allclose(M @ v, lam[i] * v))
Kết quả:
Trị riêng λ : [1. 3.]
Vector riêng (cột) :
[[-0.707 0.707]
[ 0.707 0.707]]
λ = 1, v = [-0.707 0.707]
M @ v = [-0.707 0.707]
λ * v = [-0.707 0.707] → bằng nhau: True
λ = 3, v = [0.707 0.707]
M @ v = [2.121 2.121]
λ * v = [2.121 2.121] → bằng nhau: True
Hai trị riêng 1 và 3 khớp với tính tay. Vector [−0.707, 0.707] chỉ là [1, −1] bị lật dấu và thu về độ dài 1 — vẫn cùng một đường thẳng, nên vẫn là vector riêng. Hàm np.allclose so hai mảng số thực "gần bằng nhau" (tránh lỗi làm tròn), xác nhận M @ v đúng bằng λ * v.
💡 Vì sao AI cần thứ này? Ở bài sau, ta sẽ tìm vector riêng của một ma trận đặc biệt tính từ dữ liệu. Vector riêng có λ lớn nhất chính là hướng mà dữ liệu "trải rộng" nhất — hướng giữ nhiều thông tin nhất. Đó là toàn bộ bí mật của PCA.
Thực hành: hóa đơn & calo cả nhóm, đi tìm vector riêng
a) 4 bạn gọi [cà phê, trà sữa, bánh mì]. Bảng T cho mỗi món [giá (nghìn), calo]. Dùng một phép nhân ma trận để ra cùng lúc tiền và calo của từng bạn.
| goi | Cà phê | Trà sữa | Bánh mì |
|---|---|---|---|
| An | 2 | 1 | 1 |
| Bình | 0 | 2 | 1 |
| Chi | 3 | 0 | 2 |
| Dũng | 1 | 1 | 0 |
| T | Giá (nghìn) | Calo |
|---|---|---|
| Cà phê sữa | 25 | 90 |
| Trà sữa | 30 | 350 |
| Bánh mì | 20 | 300 |
b) Với M = [[5, 2], [2, 2]], kiểm tra 4 vector [2, 1], [1, −2], [1, 1], [4, 2]: vector nào là vector riêng của M? Trị riêng bằng bao nhiêu?
Các bước:
- Phần a):
kq = goi @ T, kích thước (4 × 3) @ (3 × 2) → (4 × 2). Tính tay hàng An để đối chiếu: tiền 2×25 + 1×30 + 1×20 = 100; calo 2×90 + 350 + 300 = 830. - Phần b): tính
Mv = M @ v. Nếu Mv = λv thì λ = Mv[0] / v[0]. - Kiểm tra Mv có đúng bằng λ nhân v không:
np.allclose(Mv, lam * v), rồi đối chiếu vớinp.linalg.eigh(M).
# BÀI TẬP 1 — KHUNG CODE: điền vào chỗ ____
import numpy as np
# a) Mỗi hàng là 1 bạn: số [cà phê, trà sữa, bánh mì]
goi = np.array([[2, 1, 1], # An
[0, 2, 1], # Bình
[3, 0, 2], # Chi
[1, 1, 0]]) # Dũng
# Mỗi hàng là 1 món: [giá (nghìn), calo]
T = np.array([[25, 90], # cà phê sữa
[30, 350], # trà sữa
[20, 300]]) # bánh mì
kq = ____ @ ____ # (4 × 3) @ (3 × 2) → (4 × 2)
print("a) Kích thước kết quả:", kq.shape)
for ten, (tien, calo) in zip(["An", "Bình", "Chi", "Dũng"], kq):
print(f" {ten:5s}: {tien:4d} nghìn · {calo:5d} calo")
# b) Vector riêng của M
M = np.array([[5, 2],
[2, 2]])
print("\nb)")
for v in [np.array([2, 1]), np.array([1, -2]), np.array([1, 1]), np.array([4, 2])]:
Mv = ____ @ v
lam = Mv[0] / v[0] # nếu Mv = λv thì λ = Mv[0] / v[0]
la_rieng = np.allclose(Mv, ____ * v) # Mv có đúng bằng λ nhân v không?
print(f" v = {str(v):8s} → M @ v = {str(Mv):9s}", f"✅ vector riêng, λ = {lam:g}" if la_rieng else "❌ bị đổi hướng")
print("\nKiểm tra bằng np.linalg.eigh: λ =", np.linalg.eigh(M)[0])
Xem đáp án
Ba chỗ trống cần điền:
kq = goi @ T
...
Mv = M @ v
...
la_rieng = np.allclose(Mv, lam * v)
Kết quả:
a) Kích thước kết quả: (4, 2)
An : 100 nghìn · 830 calo
Bình : 80 nghìn · 1000 calo
Chi : 115 nghìn · 870 calo
Dũng : 55 nghìn · 440 calo
b)
v = [2 1] → M @ v = [12 6] ✅ vector riêng, λ = 6
v = [ 1 -2] → M @ v = [ 1 -2] ✅ vector riêng, λ = 1
v = [1 1] → M @ v = [7 4] ❌ bị đổi hướng
v = [4 2] → M @ v = [24 12] ✅ vector riêng, λ = 6
Kiểm tra bằng np.linalg.eigh: λ = [1. 6.]
Đọc kết quả: [2, 1] và [4, 2] cùng hướng nên cùng λ = 6; [1, −2] có λ = 1; còn [1, 1] bị M bẻ lệch thành [7, 4] (7/1 ≠ 4/1). Ma trận 2 × 2 này có đúng hai "hướng cứng đầu" — khớp với hai trị riêng mà eigh tìm ra.
Lỗi thường gặp
| Thông báo lỗi | Nguyên nhân | Cách xử lý |
|---|---|---|
NameError: name '____' is not defined |
Còn chỗ trống chưa điền | Tìm ____ trong ô và điền đủ |
ValueError: matmul: … mismatch in its core dimension |
Sai luật kích thước: số cột bên trái khác số hàng bên phải | In .shape hai ma trận; đổi thứ tự hoặc dùng .T |
| λ ra theo thứ tự "ngược" mong đợi | np.linalg.eigh luôn trả λ từ nhỏ đến lớn |
Không sai. Muốn từ lớn đến nhỏ thì sắp lại bằng np.argsort(lam)[::-1] (dùng ở bài sau) |
| Vector riêng bị ngược dấu so với tính tay | [1, −1] và [−1, 1] cùng một đường thẳng | Không sai — cả hai đều là vector riêng |
Tự luyện thêm
- Thêm cột thứ ba "thời gian chờ (phút)" vào T: cà phê 3, trà sữa 7, bánh mì 2.
kqcó kích thước bao nhiêu? Ai phải chờ lâu nhất? - Tìm tay vector riêng của [[3, 0], [0, 1]]. Gợi ý: thử [1, 0] và [0, 1]. Sau đó kiểm tra lại bằng
np.linalg.eigh. - Thử đổi M ở phần "biến hình" thành [[1, 0], [0, −1]] rồi chạy lại ô vẽ hình. Hình vuông bị biến thành gì? Hướng nào giữ nguyên?
Tóm tắt
Ma trận là bảng số; nhân ma trận là làm nhiều tích vô hướng cùng lúc theo luật (m × n) @ (n × p) → (m × p); mỗi ma trận vuông là một phép "biến hình", và vector riêng là những hướng chỉ bị kéo dài λ lần chứ không bị bẻ lệch.
| Ký hiệu Toán | Cách đọc | Lệnh NumPy |
|---|---|---|
| A: m × n | "A cỡ m nhân n" | A.shape |
| A[i, j] | "A i j" | A[i, j], cả hàng A[i], cả cột A[:, j] |
| Aᵀ | "A chuyển vị" | A.T |
| A𝐠 | "A nhân g" | A @ g |
| AP | "A nhân P" | A @ P |
| M𝐯 = λ𝐯 | "M nhân v bằng lam-đa nhân v" | lam, V = np.linalg.eigh(M) |
| Kiểm tra M𝐯 = λ𝐯 | — | np.allclose(M @ v, lam * v) |
Bài tiếp theo trong series: PCA — dùng chính vector riêng và trị riêng để ép dữ liệu nhiều chiều xuống 2 chiều. Bạn sẽ tính PCA bằng tay, tự viết bằng NumPy, rồi làm Web App vẽ bản đồ sinh viên 2D và nén ảnh.