Bài 2: Đại số Tuyến tính & Đạo hàm qua dòng lệnh

Chào mừng bạn quay trở lại với lộ trình Kỹ Sư AI Thực Chiến. Ở Bài 1, chúng ta đã bắt nhịp thành công sang môi trường lập trình Python. Tuy nhiên, trước khi có thể huấn luyện những mô hình học sâu phức tạp như Multi-Layer Perceptron (MLP), CNN hay Transformer, chúng ta bắt buộc phải hiểu được ngôn ngữ giao tiếp chung của thế giới AI: Đại số Tuyến tính (Linear Algebra) và Giải tích (Calculus).

Đối với lập trình viên Web chưa có chuyên môn về toán cao cấp, các công thức toán học học thuật trên trường lớp thường rất khô khan và khó hình dung. Bài học này được thiết kế để thay đổi hoàn toàn điều đó: chúng ta sẽ đi từ bản chất hình học trực quan nhất, sau đó tự tay hiện thực hóa các phép nhân ma trận và vòng lặp tính đạo hàm bằng mã nguồn Python thô để hiểu cặn kẽ cách máy tính "học" dữ liệu.

2.1 Bản chất hình học của Vector & Ma trận

Hãy bắt đầu bằng cách số hóa thế giới thực. Trong khoa học máy tính, mọi loại dữ liệu đầu vào (một bức ảnh, một file âm thanh, một bài viết) đều được biểu diễn dưới dạng mảng số. Trong toán học, ta gọi các mảng số đó là Vector và Ma trận (Matrix).

• Vector: Là một mảng số một chiều. Dưới lăng kính lập trình, một vector 3 chiều chỉ đơn giản là một list có 3 phần tử: v = [x_1, x_2, x_3]. Về mặt hình học, một vector đại diện cho một mũi tên chỉ từ gốc tọa độ $O(0, 0, 0)$ đến điểm có tọa độ tương ứng trong không gian.
• Ma trận: Là một mảng số hai chiều (dạng bảng gồm dòng và cột). Ví dụ, một ma trận kích thước $2 \times 3$ (2 dòng, 3 cột) được biểu diễn trong code Python là một danh sách chứa các danh sách con: A = [[1, 2, 3], [4, 5, 6]].

Bản chất hình học cốt lõi của một ma trận là gì? Đừng chỉ coi ma trận là những ô lưu trữ số tĩnh giống như bảng Excel. Trong học máy, ma trận đại diện cho một phép biến đổi không gian tuyến tính (Linear Transformation). Khi ta nhân một ma trận $A$ với một vector đầu vào $x$, ta đang thực hiện xoay, kéo dãn, hoặc nén vector đó trong không gian để tạo ra một vector đầu ra mới $y = Ax$:

Đây chính là nguyên lý cốt lõi của một tầng nơ-ron nhân tạo: nhận tín hiệu đầu vào $x$, "uốn nắn" không mảng số đó là Vector và Ma trận (Matrix).

Về mặt hình học, một vector $X = [x_1, x_2]$ đại diện cho một điểm hoặc một mũi tên chỉ hướng xuất phát từ gốc tọa độ đến điểm đó trong không gian hai chiều. Số lượng phần tử trong vector quyết định số chiều (Dimensionality) của không gian.

Một ma trận $W$ không đơn thuần là một bảng số tĩnh. Trong học sâu, ma trận đại diện cho một Phép biến đổi tuyến tính (Linear Transformation). Khi ta nhân một ma trận $W$ với một vector $X$, chúng ta đang biến đổi không gian (quay, co giãn hoặc chiếu) để đưa vector $X$ từ không gian ban đầu sang một không gian biểu diễn mới: $$Y = W \cdot X$$ Các trọng số (weights) của mạng nơ-ron chính là các tham số của phép biến đổi không gian này, giúp bóc tách và uốn cong dữ liệu để dễ dàng phân loại.

2.2 Giải mã phép nhân ma trận (Matrix Multiplication)

Để nhân hai ma trận $A$ và $B$, chúng ta thực hiện nhân từng dòng của ma trận bên trái với từng cột của ma trận bên phải. Điều này đặt ra một điều kiện ghép chiều nghiêm ngặt: Số cột của ma trận bên trái bắt buộc phải bằng số dòng của ma trận bên phải.

Nếu ma trận $A$ có kích thước $m \times n$ và ma trận $B$ có kích thước $n \times p$, ma trận kết quả $C = A \cdot B$ sẽ có kích thước $m \times p$. Mỗi phần tử $C_{ij}$ được tính bằng công thức: $$C_{ij} = \sum_{k=1}^n A_{ik} B_{kj}$$

Nếu viết bằng ngôn ngữ lập trình cơ bản sử dụng các vòng lặp for lồng nhau, chúng ta sẽ cần tới 3 vòng lặp để thực hiện phép toán này:

def naive_matrix_multiply(A, B):
    # Lấy số lượng dòng và cột
    m, n = len(A), len(A[0])
    n_B, p = len(B), len(B[0])
    
    # Kiểm tra tính tương thích kích thước
    if n != n_B:
        raise ValueError("Kích thước ma trận không tương thích để nhân!")
        
    # Khởi tạo ma trận kết quả toàn số 0
    C = [[0.0 for _ in range(p)] for _ in range(m)]
    
    # 3 vòng lặp for lồng nhau (Độ phức tạp O(N^3))
    for i in range(m):
        for j in range(p):
            for k in range(n):
                C[i][j] += A[i][k] * B[k][j]
    return C

# Chạy thử nghiệm
A = [[1, 2], [3, 4]] # 2x2
B = [[5, 6], [7, 8]] # 2x2
print("Kết quả nhân ma trận thô:", naive_matrix_multiply(A, B))
# Đầu ra: [[19, 22], [43, 50]]

Trên thực tế, lỗi ghép chiều sai (mục đã nói ở trên) là lỗi phổ biến bậc nhất khi mới viết code AI — NumPy sẽ ném ra một thông báo lỗi cụ thể, và biết cách ĐỌC đúng thông báo đó quan trọng hơn nhiều so với việc học thuộc quy tắc:

import numpy as np

A = np.array([[1, 2, 3], [4, 5, 6]])   # shape (2, 3)
B = np.array([[1, 2, 3], [4, 5, 6]])   # shape (2, 3) — CÙNG shape với A, không ghép được

try:
    C = A @ B
except ValueError as e:
    print("Lỗi:", e)
    # Lỗi: matmul: Input operand 1 has a mismatch in its core dimension 0
    #      (size 2 is different from 3)
    # Đọc lỗi: "operand 1" = B, "core dimension 0" = chiều dòng của B (2) không
    # khớp với chiều CỘT của A (3) — đúng quy tắc "cột A = dòng B" đã học ở trên.

# ✅ Cách sửa phổ biến nhất: dùng .T để chuyển vị B, biến (2,3) thành (3,2)
C = A @ B.T   # (2,3) @ (3,2) -> (2,2), hợp lệ
print("Kết quả sau khi chuyển vị B:\n", C)

Mẹo debug thực chiến: mỗi khi gặp ValueError về matmul, hãy in ra .shape của cả hai mảng TRƯỚC dòng gây lỗi (print(A.shape, B.shape)) — 90% trường hợp bạn sẽ thấy ngay chiều nào đang lệch mà không cần đọc kỹ thông báo lỗi dài dòng của NumPy.

2.3 Đạo hàm (Derivatives) — La bàn chỉ hướng giảm sai số

Nếu như Đại số Tuyến tính giúp ta biểu diễn cấu trúc mạng nơ-ron, thì Giải tích (đạo hàm) lại là cơ chế giúp mạng nơ-ron có khả năng "học hỏi" từ sai số.

Về mặt hình học, đạo hàm của hàm số $f(x)$ tại một điểm đại diện cho độ dốc (hệ số góc) của đường tiếp tuyến của đồ thị hàm số đó tại điểm đó. Đạo hàm cho ta biết hàm số đang tăng hay giảm nhanh như thế nào nếu ta dịch chuyển biến đầu vào $x$ đi một lượng cực kỳ nhỏ.

Công thức giới hạn vi phân lý thuyết của đạo hàm:

Trong thế giới lập trình, máy tính không thể tính giới hạn toán học trực tiếp. Tuy nhiên, ta có thể tính xấp xỉ đạo hàm thông qua phương pháp Sai phân hữu hạn (Finite Difference) bằng cách chọn một bước dịch chuyển $h$ đủ nhỏ (thường là $10^{-5}$):

def f(x):
    return x**2  # Ví dụ hàm f(x) = x^2

def numerical_derivative(func, x, h=1e-5):
    # Tính xấp xỉ độ dốc
    return (func(x + h) - func(x)) / h

# Tính đạo hàm số học tại x = 3
slope = numerical_derivative(f, 3)
print(f"Đạo hàm xấp xỉ tại x=3: {slope:.5f}") # Kết quả xấp xỉ: 6.00001 (đạo hàm giải tích lý thuyết là 2x = 6)

Khi chúng ta làm việc với hàm nhiều biến đầu vào (ví dụ hàm Loss phụ thuộc vào hàng triệu trọng số $W$), đạo hàm của hàm số theo từng biến số riêng lẻ được gọi là Đạo hàm riêng (Partial Derivative), ký hiệu là $\frac{\partial f}{\partial w_i}$.

Tập hợp tất cả các đạo hàm riêng này thành một vector được gọi là Gradient Vector, ký hiệu là $\nabla f$ (đọc là nabla f): $$\nabla f = \left[ \frac{\partial f}{\partial w_1}, \frac{\partial f}{\partial w_2}, \dots, \frac{\partial f}{\partial w_n} \right]$$

Về mặt hình học, Gradient luôn chỉ hướng dốc lên nhanh nhất của hàm số tại điểm đó. Do đó, để tìm cực tiểu của hàm sai số (đáy thung lũng), chúng ta phải đi theo hướng ngược lại với chiều của vector Gradient, tức là hướng $-\nabla f$. Đây chính là triết lý cốt lõi của thuật toán tối ưu hóa huyền thoại Gradient Descent (Cực tiểu hóa độ dốc).

2.4 Dự án thực hành bài 2: Tự viết thuật toán Gradient Descent

Dự án thực hành của bài học này là tự viết thuật toán Gradient Descent hoàn chỉnh để tìm cực tiểu của hàm số sai số lồi: $$f(x) = x^2 - 4x + 4$$ Bằng công thức toán học, ta dễ dàng biết được hàm số này có thể viết lại thành $f(x) = (x-2)^2$, đạt cực tiểu bằng 0 tại điểm $x = 2$.

Chúng ta sẽ phỏng đoán ngẫu nhiên điểm xuất phát cực kỳ xa, ví dụ $x_{\text{init}} = 10.0$, và bắt CPU chạy vòng lặp cập nhật để tự "bò" về điểm tối ưu $x=2$ theo công thức: $$x_{\text{new}} = x_{\text{old}} - \eta \cdot f'(x_{\text{old}})$$ Trong đó $\eta$ (đọc là eta) là hệ số học (learning rate), điều khiển độ lớn của mỗi bước chân xuống dốc.

# Định nghĩa hàm số lỗi và đạo hàm xấp xỉ
def f(x):
    return x**2 - 4*x + 4

def get_gradient(x, h=1e-5):
    return (f(x + h) - f(x)) / h

# Siêu tham số tối ưu hóa
x = 10.0             # Điểm xuất phát ngẫu nhiên
learning_rate = 0.1  # Hệ số học (eta)
epochs = 50          # Số lần lặp tối đa
tolerance = 1e-6     # Ngưỡng dừng sớm

for epoch in range(1, epochs + 1):
    grad = get_gradient(x)
    
    # Bước đi ngược chiều đạo hàm để giảm sai số
    x_new = x - learning_rate * grad
    
    # Kiểm tra điều kiện dừng nếu x thay đổi cực nhỏ
    if abs(x_new - x) < tolerance:
        print(f"Hội tụ sớm tại vòng lặp {epoch}! x = {x_new:.6f}")
        x = x_new
        break
        
    x = x_new
    print(f"Vòng lặp {epoch:02d}: x = {x:.6f} | Loss = {f(x):.6f}")

print(f"\nKết quả tối ưu tìm được: x = {x:.6f} | Giá trị cực tiểu: f(x) = {f(x):.6f}")

Để thấy rõ MỐI QUAN HỆ giữa dấu của đạo hàm và hướng cập nhật $x$ (điều dễ gây nhầm lẫn nhất khi mới học), hãy lần theo tay 3 vòng lặp đầu tiên với $x_{\text{init}} = 10$, $\eta = 0.1$:

Quy tắc bất biến xuyên suốt: đạo hàm dương → $x$ phải GIẢM để đi xuống dốc (vì trừ đi 1 số dương); ngược lại nếu đạo hàm ÂM (đang ở phía bên trái điểm cực tiểu $x=2$), phép trừ số âm sẽ làm $x$ TĂNG lên — thuật toán luôn tự động "bò" đúng hướng về điểm cực tiểu $x=2$ mà không cần biết trước đáp án, chỉ dựa vào dấu của đạo hàm tại từng bước.

Tóm tắt bài học & Cầu nối kiến thức

Cầu nối bài tiếp theo: Để tăng hiệu năng tính toán ma trận lên hàng triệu phép tính mỗi giây mà không bị nghẽn CPU, chúng ta cần học cách song song hóa dữ liệu với hai thư viện cốt lõi NumPy và Pandas ở Bài số 3.