Giới thiệu dự án

Bối cảnh và thực trạng ngành

Trong kỷ nguyên bùng nổ thông tin và trí tuệ nhân tạo (AI), khối lượng dữ liệu đa chiều sinh ra từ các hệ thống thị giác máy tính, cảm biến IoT và mô hình ngôn ngữ lớn (LLMs) tăng trưởng theo cấp số nhân (dự báo đạt 175 Zettabytes theo IDC). Sự gia tăng đột biến về số chiều (Curse of Dimensionality) dẫn đến nghẽn băng thông truyền tải, quá tải bộ nhớ đệm (RAM/VRAM), và làm suy giảm hiệu năng tính toán của các mô hình học máy. Các kỹ thuật đại số tuyến tính kinh điển, đặc biệt là Phân rã giá trị kỳ dị (Singular Value Decomposition - SVD) và Phân tích thành phần chính (Principal Component Analysis - PCA), đóng vai trò cốt lõi trong việc tối ưu hóa cấu trúc ma trận, trích xuất đặc trưng và nén dữ liệu mà vẫn bảo toàn tối đa lượng thông tin cốt lõi.

                  +-------------------------------------------------+
                  |      Dữ liệu ma trận đa chiều (m x n)          |
                  +-------------------------------------------------+
                                           |
                                           v
       +-----------------------------------+-----------------------------------+
       |                                                                       |
       v                                                                       v
+-----------------------------+                                 +-----------------------------+
|    SVD (A = U * Σ * V^T)    |                                 |   PCA (Tối đa hóa Var/Cov)  |
| - Xấp xỉ hạng thấp          |                                 | - Khử tương quan đa chiều   |
| - Nén ma trận ảnh số        |                                 | - Trích xuất đặc trưng mặt  |
| - Nén tham số Transformer   |                                 | - Chiếu không gian (d -> k) |
+-----------------------------+                                 +-----------------------------+

Vấn đề nghiên cứu và các điểm nghẽn kỹ thuật

Dự án tập trung giải quyết 3 điểm nghẽn trọng yếu trong xử lý dữ liệu ma trận lớn:

  • Gia tăng kích thước lưu trữ và chi phí truyền dẫn ảnh số: Một ảnh màu kích thước $130 \times 130$ pixels yêu cầu $50{,}700$ giá trị biểu diễn trên 3 kênh RGB, gây tiêu hao băng thông đáng kể trong các thiết bị vệ tinh hoặc IoT năng lượng thấp.
  • Độ phức tạp tính toán cao trong nhận dạng khuôn mặt: Xử lý vector khuôn mặt thô kích thước $50 \times 37 = 1{,}850$ chiều làm bùng nổ không gian tham số phân loại, gây hiện tượng quá khớp (overfitting) và tăng độ trễ suy luận.
  • Thiếu cơ chế tối ưu hóa ma trận trọng số trong mô hình học sâu: Nhu cầu nén ma trận trọng số trong các tầng Attention của kiến trúc Transformer mà không làm suy giảm nghiêm trọng độ chính xác.

Mục tiêu dự án

  1. Hệ thống hóa cơ sở toán học: Xây dựng chứng minh toán học chặt chẽ cho Định lý phổ của ma trận đối xứng, Định lý phân tích SVD và Định lý Eckart-Young về xấp xỉ hạng thấp tối ưu.
  2. Thiết kế và cài đặt thuật toán: Xây dựng module tính toán SVD cắt cụt (Truncated SVD) và PCA thuần túy bằng Python/NumPy không phụ thuộc vào các hộp đen (black-box) phức tạp.
  3. Ứng dụng nén ảnh kỹ thuật số: Đánh giá hiệu suất nén ma trận ảnh số $130 \times 130$ qua các mức hạng $k \in {4, 16, 32, 64}$, lượng hóa tỷ lệ nén dung lượng và phần trăm năng lượng thông tin bảo toàn.
  4. Ứng dụng nhận dạng khuôn mặt (Eigenfaces): Xây dựng pipeline trích xuất đặc trưng khuôn mặt trên tập dữ liệu chuẩn LFW (Labeled Faces in the Wild), giảm số chiều từ $1{,}850$ xuống $150$ và tích hợp bộ phân loại Support Vector Machine (SVM).
  5. Nghiên cứu mở rộng: Khảo sát tiềm năng ứng dụng phân rã ma trận SVD trong việc nén ma trận trọng số của kiến trúc Transformer.

Phương pháp tiếp cận giải pháp

Đồ án áp dụng phương pháp nghiên cứu định lượng kết hợp thực nghiệm:

  • Tiếp cận từ đại số tuyến tính: Biểu diễn ma trận dữ liệu $A \in \mathbb{R}^{m \times n}$ dưới dạng tích của các ma trận trực giao và ma trận đường chéo $A = U \Sigma V^T = \sum_{i=1}^r \sigma_i u_i v_i^T$.
  • Tiếp cận từ thống kê đa biến: Khử tương quan giữa các biến quan sát thông qua việc chéo hóa ma trận hiệp phương sai $C = \frac{1}{N} \hat{X} \hat{X}^T$, tìm các hướng chiếu có phương sai lớn nhất.

Kết quả đầu ra kỳ vọng và chỉ số đo lường

  • Tỷ lệ nén ảnh: Giảm tối thiểu $50%$ đến $75.3%$ dung lượng lưu trữ ma trận điểm ảnh với $k=32$ và $k=16$, giữ lại trên $90%$ tổng phương sai năng lượng.
  • Độ chính xác nhận dạng: Đạt độ chính xác $\ge 80%$ trên tập kiểm thử LFW ($322$ mẫu) sau khi giảm $91.89%$ số chiều không gian (từ $1{,}850$ xuống $150$ chiều).
  • Thời gian tính toán: Tối ưu hóa thuật toán SVD/PCA đạt thời gian phản hồi dưới $50\text{ ms}$ cho việc chiếu giảm chiều vector kiểm thử.

Phạm vi và giới hạn của đề tài

  • Phạm vi: Nghiên cứu ma trận thực $\mathbb{R}^{m \times n}$, triển khai trên ma trận ảnh xám/ảnh màu 2D tĩnh và tập dữ liệu nhận dạng khuôn mặt LFW.
  • Giới hạn: Chưa thực hiện phân rã ma trận trực tuyến (Online/Incremental SVD) cho luồng dữ liệu thời gian thực (streaming data) có số chiều thay đổi động.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

So sánh các giải pháp giảm chiều và nén dữ liệu ma trận

Tiêu chí Truncated SVD / PCA (Đề tài) Autoencoder (Deep Learning) Discrete Cosine Transform (DCT / JPEG) Linear Discriminant Analysis (LDA)
Cơ sở toán học Đại số tuyến tính, giải tích phổ, ma trận trực giao Tối ưu hóa phi tuyến qua hàm mất mát (Loss function) Biến đổi tần số lượng giác rời rạc Tối đa hóa khoảng cách giữa các lớp (Supervised)
Bảo toàn thông tin Nghiệm tối ưu toàn cục (Global Optimum) theo Eckart-Young Dễ mắc kẹt tại cực tiểu cục bộ (Local Minima) Tối ưu cho tín hiệu hình ảnh/âm thanh tự nhiên Tối ưu cho phân lớp, không tối ưu cho tái tạo
Chi phí huấn luyện Thấp, tính toán đại số tất định $O(\min(m^2n, mn^2))$ Rất cao, đòi hỏi GPU và nhiều epochs huấn luyện Rất thấp, độ phức tạp $O(N \log N)$ theo khối Thấp, phụ thuộc vào số lớp phân loại
Khả năng diễn giải Cao (các trục trực giao, giá trị kỳ dị rõ ràng) Thấp (Mô hình hộp đen Black-box) Trung bình (phân bổ tần số không gian) Cao (các vector phân biệt giữa các lớp)
Yêu cầu dữ liệu Không cần gán nhãn (Unsupervised), dữ liệu nhỏ vẫn tốt Cần tập dữ liệu lớn để tránh hiện tượng quá khớp Không cần dữ liệu huấn luyện Bắt buộc phải có nhãn lớp (Supervised)

Phân tích yêu cầu người dùng theo mô hình MoSCoW

  • Must have (Bắt buộc phải có):
    • Thuật toán SVD phân rã đầy đủ và SVD cắt cụt cho ma trận thực bất kỳ.
    • Thuật toán PCA xây dựng trên cơ sở phân tích ma trận hiệp phương sai và SVD.
    • Bộ kiểm thử xấp xỉ hạng thấp trên ảnh thực tế và trực quan hóa năng lượng thông tin.
    • Module Eigenfaces giảm chiều vector khuôn mặt và đánh giá qua mô hình phân loại SVM.
  • Should have (Nên có):
    • Tự động chọn ngưỡng giá trị kỳ dị $k$ dựa trên tỷ lệ năng lượng tích lũy $\alpha \ge 90%$.
    • Phân tích sai số xấp xỉ theo cả hai chuẩn ma trận: Chuẩn Frobenius $|\cdot|_F$ và Chuẩn Spectral $|\cdot|_2$.
  • Could have (Có thể có):
    • Pipeline thử nghiệm ứng dụng phân rã ma trận trọng số trong các khối Multi-Head Attention.
  • Won't have (Chưa thực hiện đợt này):
    • Xây dựng giao diện Web UI thời gian thực cho người dùng cuối.

Thiết kế hệ thống

graph TD
    A["Dữ liệu thô (Ảnh / Ma trận đa chiều)"] --> B["Tiền xử lý: Chuẩn hóa tâm E[x]=0 & Căn chỉnh kích thước"]
    B --> C{"Lựa chọn Pipeline"}
    
    C -->|"Nén ma trận ảnh"| D["Phân rã SVD: A = U * Σ * V^T"]
    D --> E["Cắt cụt hạng k: A_k = U_k * Σ_k * V_k^T"]
    E --> F["Tái cấu trúc ảnh nén & Đo lường sai số Frobenius"]
    
    C -->|"Nhận dạng khuôn mặt"| G["Tính ma trận hiệp phương sai C = (1/N) * X_hat * X_hat^T"]
    G --> H["Trích xuất Không gian Eigenfaces (A_k = U_k)"]
    H --> I["Chiếu dữ liệu: w = A_k^T * (v - x_bar) (1850d -> 150d)"]
    I --> J["Bộ phân loại SVM (RBF/Linear Kernel)"]
    J --> K["Kết quả nhận dạng & Báo cáo Precision/Recall"]

Ngăn xếp công nghệ (Technology Stack)

  • Ngôn ngữ lập trình: Python 3.10+
  • Thư viện tính toán đại số: NumPy 1.24.3 (xử lý mảng đa chiều và đại số tuyến tính cơ bản), SciPy 1.10.1 (tối ưu hóa phân rã phổ và ma trận thưa)
  • Thư viện học máy & Thị giác: Scikit-Learn 1.2.2 (triển khai SVM, phân tách train/test, đánh giá metrics), OpenCV-Python 4.7.0 (tiền xử lý ảnh)
  • Trực quan hóa dữ liệu: Matplotlib 3.7.1, Seaborn 0.12.2

Thiết kế cấu trúc dữ liệu và giao diện hàm cốt lõi

  • Lưu trữ vector đặc trưng: Mảng NumPy 2D float64 kích thước $(N, k)$, trong đó $N$ là số mẫu, $k$ là số thành phần chính ($k = 150$).
  • Giao diện lập trình (API Interface):
import numpy as np

class MatrixDecompositionEngine:
    @staticmethod
    def compute_truncated_svd(A: np.ndarray, k: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
        """
        Thực hiện phân rã SVD cắt cụt bậc k cho ma trận thực A (m x n).
        Output: U_k (m x k), Sigma_k (k,), Vt_k (k x n)
        """
        pass

    @staticmethod
    def compute_pca_projection(X: np.ndarray, n_components: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
        """
        Chuẩn hóa ma trận dữ liệu X, tính ma trận tải và ma trận thành phần chính.
        Output: X_projected (N x k), Eigenfaces (m x k), Mean_vector (m,)
        """
        pass

Phương pháp luận (Methodology)

Dự án áp dụng quy trình phát triển nghiên cứu CRISP-DM (Cross-Industry Standard Process for Data Mining) gồm 5 giai đoạn:

  1. Nghiên cứu lý thuyết (Tuần 1 - 3): Chứng minh tính chất trực giao, định lý phổ, định lý Eckart-Young.
  2. Thiết kế thuật toán cơ sở (Tuần 4 - 6): Hiện thực hóa SVD và PCA thuần túy trên ma trận mô phỏng nhỏ.
  3. Thực nghiệm nén ảnh (Tuần 7 - 8): Đánh giá trên ảnh số $130 \times 130$ với các tham số $k$ khác nhau.
  4. Thực nghiệm nhận dạng khuôn mặt (Tuần 9 - 11): Khai phá tập dữ liệu LFW, huấn luyện SVM trên không gian Eigenfaces.
  5. Đánh giá và tối ưu hóa (Tuần 12): Tổng hợp báo cáo, kiểm thử độ chịu lỗi và viết tài liệu khoa học.

Implementation và kết quả

Quá trình phát triển và thuật toán cốt lõi

1. Cơ sở toán học của Định lý Eckart-Young

Cho ma trận $A \in \mathbb{R}^{m \times n}$ có hạng $r$, phân rã SVD đầy đủ là $A = \sum_{i=1}^r \sigma_i u_i v_i^T$. Với mỗi $k < r$, ma trận xấp xỉ hạng $k$ được định nghĩa: $$A_k = \sum_{i=1}^k \sigma_i u_i v_i^T$$ Định lý Eckart-Young khẳng định rằng với mọi ma trận $B$ có $\text{rank}(B) \le k$: $$|A - A_k|F = \sqrt{\sum{i=k+1}^r \sigma_i^2} \le |A - B|_F$$ $$|A - A_k|2 = \sigma{k+1} \le |A - B|_2$$

2. Mã nguồn triển khai thuật toán SVD và PCA

import numpy as np

def manual_svd(A: np.ndarray):
    """
    Tính toán SVD của ma trận A (m x n) dựa trên phân rã trị riêng của A^T * A.
    """
    m, n = A.shape
    # Bước 1: Tính ma trận Gram A^T * A
    AtA = np.dot(A.T, A)
    
    # Bước 2: Tính giá trị riêng và vector riêng của A^T * A
    eigenvalues, V = np.linalg.eigh(AtA)
    
    # Sắp xếp giá trị riêng giảm dần
    sorted_indices = np.argsort(eigenvalues)[::-1]
    eigenvalues = np.maximum(eigenvalues[sorted_indices], 0)
    V = V[:, sorted_indices]
    
    # Bước 3: Tính các giá trị kỳ dị (singular values)
    singular_values = np.sqrt(eigenvalues)
    non_zero_mask = singular_values > 1e-10
    r = np.sum(non_zero_mask)
    
    # Bước 4: Tính ma trận trực giao U
    U = np.zeros((m, m))
    for i in range(r):
        U[:, i] = np.dot(A, V[:, i]) / singular_values[i]
        
    return U, singular_values, V.T

def run_eigenface_pca(X_train: np.ndarray, k_components: int = 150):
    """
    Trích xuất không gian Eigenface từ tập dữ liệu huấn luyện X_train (m_features x N_samples).
    """
    # 1. Tính khuôn mặt trung bình
    mean_face = np.mean(X_train, axis=1, keepdims=True)
    X_centered = X_train - mean_face
    
    # 2. Phân rã SVD trên ma trận đã chuẩn hóa tâm
    U, S, Vt = np.linalg.svd(X_centered, full_matrices=False)
    
    # 3. Chọn k thành phần chính đầu tiên
    eigenfaces = U[:, :k_components]
    
    # 4. Chiếu dữ liệu vào không gian đặc trưng mới
    weights_train = np.dot(eigenfaces.T, X_centered)
    
    return eigenfaces, weights_train, mean_face

Kiểm thử và đánh giá thực nghiệm

1. Đánh giá hiệu năng nén ảnh số ($130 \times 130 \times 3$)

Dữ liệu ảnh gốc có kích thước $130 \times 130$, gồm 3 kênh màu RGB tương đương $50{,}700$ phần tử lưu trữ. Khi áp dụng SVD cắt cụt với các mức hạng $k$:

Mức hạng ($k$) Số phần tử lưu trữ ($3 \times [k + 2 \times 130k]$) Dung lượng giảm (%) Năng lượng thông tin bảo toàn ($\sum_{i=1}^k \sigma_i^2 / \sum \sigma^2$) Đánh giá chất lượng thị giác
$k = 4$ $3{,}132$ 93.82% $71.45%$ Ảnh mờ, chỉ giữ lại các mảng khối sáng tối chính
$k = 16$ $12{,}528$ 75.29% $86.30%$ Cấu trúc ảnh nhận diện rõ, chi tiết cạnh bắt đầu xuất hiện
$k = 32$ $25{,}056$ 50.58% 94.85% Chất lượng gần như nguyên bản, mắt người khó phân biệt
$k = 64$ $50{,}112$ 1.16% $99.12%$ Tái tạo hoàn hảo, không tối ưu về mặt lưu trữ

Nhận xét: Với $k = 32$, mô hình đạt điểm cân bằng Pareto tối ưu: tiết kiệm 50.58% bộ nhớ trong khi bảo toàn 94.85% hàm lượng thông tin ma trận gốc.

Năng lượng thông tin tích lũy (%)
100% |                                      *---* (k=64: 99.1%)
 90% |                           *----------* (k=32: 94.8%)
 80% |                *----------* (k=16: 86.3%)
 70% |  *-------------* (k=4: 71.5%)
  0% +------------------------------------------------------------
        k=4          k=16        k=32       k=64   (Số thành phần)

2. Đánh giá bài toán nhận dạng khuôn mặt trên tập dữ liệu LFW

  • Tổng số mẫu ảnh: $1{,}288$ ảnh khuôn mặt của 7 nhân vật nổi tiếng.
  • Kích thước ảnh: $50 \times 37 = 1{,}850$ pixels.
  • Phân chia dữ liệu: 75% tập huấn luyện ($966$ mẫu), 25% tập kiểm thử ($322$ mẫu).
  • Giảm chiều: Từ $1{,}850$ chiều xuống $k = 150$ chiều bằng Eigenfaces.
  • Mô hình phân lớp: Support Vector Machine (SVM) với Kernel RBF ($C=1000.0, \gamma=0.005$).
                      BÁO CÁO PHÂN LOẠI CHI TIẾT (LFW TEST SET)
===================================================================================
Đối tượng (Classes)      | Precision | Recall | F1-Score | Số mẫu thực tế (Support)
-------------------------+-----------+--------+----------+-------------------------
Ariel Sharon             |   0.67    |  0.62  |   0.64   |           13
Colin Powell             |   0.75    |  0.88  |   0.81   |           60
Donald Rumsfeld          |   0.71    |  0.81  |   0.76   |           27
George W Bush            |   0.89    |  0.88  |   0.88   |          146
Gerhard Schroeder        |   0.78    |  0.74  |   0.76   |           27
Hugo Chavez              |   0.88    |  0.47  |   0.61   |           15
Tony Blair               |   0.81    |  0.74  |   0.78   |           34
-------------------------+-----------+--------+----------+-------------------------
Accuracy (Toàn cục)      |           |        |   0.80   |          322
Macro Average            |   0.78    |  0.73  |   0.75   |          322
Weighted Average         |   0.81    |  0.80  |   0.80   |          322
===================================================================================

Kết quả đạt được so với mục tiêu ban đầu

  • Độ chính xác toàn cục (Accuracy): Đạt 80.0% trên tập kiểm thử độc lập gồm 322 khuôn mặt chưa từng thấy trong quá trình huấn luyện.
  • Mức độ nén không gian đặc trưng: Giảm từ $1{,}850$ chiều xuống $150$ chiều (giảm 91.89% số chiều dữ liệu), giúp thời gian huấn luyện và suy luận của SVM tăng tốc hơn 12.4 lần so với việc huấn luyện trực tiếp trên toàn bộ pixel ảnh thô.

Đổi mới và đóng góp

Các đóng góp kỹ thuật nổi bật

  1. Ứng dụng toán học giải tích phổ vào nén ma trận: Không chỉ dừng lại ở mặt lý thuyết thuần túy, đề tài đã chứng minh chi tiết và ứng dụng Định lý Eckart-Young để xây dựng tiêu chuẩn chọn số thành phần $k$ tối ưu tự động thông qua ngưỡng phương sai tích lũy: $$\text{Threshold}(k) = \frac{\sum_{i=1}^k \sigma_i^2}{\sum_{i=1}^r \sigma_i^2} \ge \alpha \quad (\text{với } \alpha = 0.90 \text{ hoặc } 0.95)$$
  2. Chứng minh tính không duy nhất của nghiệm PCA: Làm rõ vai trò của phép quay trực giao $Q$ ($Q Q^T = I_r$) trong việc biến đổi ma trận tải $(A Q, B Q)$, giúp đơn giản hóa cấu trúc diễn giải nhân tố trong không gian dữ liệu nhiều chiều.
  3. Mở rộng nghiên cứu sang kiến trúc Transformer: Đề xuất hướng tiếp cận sử dụng SVD để phân rã các ma trận trọng số $W_Q, W_K, W_V \in \mathbb{R}^{d_{model} \times d_k}$ trong khối Multi-Head Attention thành tích hai ma trận hạng thấp $W \approx U_k V_k^T$, làm tiền đề cho các giải pháp Low-Rank Adaptation (LoRA) hiện đại.
      +-----------------------------+
      |  Trọng số gốc W (d x d)     | ===> Chi phí lưu trữ: d^2 tham số
      +-----------------------------+
                     ||  (Phân rã SVD cắt cụt hạng k << d)
                     \/
      +---------------+   +---------------+
      |  U_k (d x k)  | * |  V_k^T (k x d)| ===> Chi phí mới: 2 * d * k tham số
      +---------------+   +---------------+

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng trong đời sống và công nghiệp

  • Hệ thống truyền ảnh vệ tinh và viễn thám: Truyền dữ liệu ảnh qua kênh truyền có băng thông giới hạn bằng cách chỉ truyền $k$ giá trị kỳ dị và các vector riêng tương ứng, sau đó khôi phục lại tại trạm mặt đất.
  • Xác thực sinh trắc học trên thiết bị biên (Edge IoT): Nhúng các vector Eigenface vào chip vi điều khiển có dung lượng RAM dưới $64\text{ KB}$ để nhận diện người dùng tại các cửa kiểm soát thông minh.
  • Nén mô hình ngôn ngữ lớn (LLM Model Compression): Nén các tầng Feed-Forward Network (FFN) và Attention Weights để chạy suy luận (Inference) trên các GPU tiêu dùng có VRAM hạn chế.

Hướng dẫn triển khai và yêu cầu hệ thống

1. Yêu cầu phần cứng & phần mềm

  • Hệ điều hành: Linux (Ubuntu 20.04/22.04 LTS), macOS, hoặc Windows 10/11
  • Phần cứng tối thiểu: CPU 2 Cores 2.0 GHz, 4 GB RAM, 500 MB dung lượng đĩa trống
  • Môi trường: Python 3.10 trở lên

2. Cài đặt các gói phụ thuộc

pip install numpy>=1.24.3 scipy>=1.10.1 scikit-learn>=1.2.2 matplotlib>=3.7.1 opencv-python>=4.7.0

3. Quy trình thực thi pipeline chuẩn

# Bước 1: Huấn luyện và xuất không gian Eigenfaces
python train_eigenfaces.py --dataset lfw --n_components 150 --output_dir ./models/

# Bước 2: Nén ảnh đơn lẻ bằng SVD
python compress_image.py --input sample.jpg --k 32 --output compressed.png

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Giả định tuyến tính của PCA/SVD: Cả hai phương pháp đều dựa trên các phép biến đổi tuyến tính trực giao, do đó không nắm bắt được các cấu trúc phi tuyến phức tạp (Non-linear manifold) như Kernel PCA, Autoencoder hoặc t-SNE.
  • Chi phí tính toán ma trận lớn: Phân rã SVD đầy đủ trên ma trận kích thước cực lớn $m, n > 10^5$ đòi hỏi bộ nhớ $O(mn)$ và thời gian $O(\min(m^2n, mn^2))$, dễ dẫn đến lỗi tràn bộ nhớ (Out-Of-Memory).
  • Độ nhạy cảm với ngoại lai (Outliers): Do tối ưu hóa hàm khoảng cách bình phương Euclidean, SVD và PCA truyền thống rất nhạy cảm với các điểm dữ liệu nhiễu đột biến.

Hướng phát triển trong tương lai

  • Triển khai Randomized SVD: Áp dụng các thuật toán chiếu ngẫu nhiên (Randomized Linear Algebra) để tăng tốc độ tính toán SVD lên gấp $5-10$ lần trên các tập dữ liệu ma trận khổng lồ.
  • Nghiên cứu Robust PCA (RPCA): Tách ma trận dữ liệu thành phần hạng thấp và ma trận thưa $X = L + S$ nhằm loại bỏ nhiễu và ngoại lai trong bài toán tách nền video.
  • Tích hợp sâu vào LoRA/PEFT: Hiện thực hóa module nén tự động các trọng số mạng nơ-ron Transformer phục vụ tinh chỉnh mô hình ngôn ngữ lớn hiệu quả.

Đối tượng hưởng lợi

1. Sinh viên và Giảng viên ngành Toán - Tin, Khoa học dữ liệu

  • Cung cấp tài liệu tham khảo hoàn chỉnh, liên kết chặt chẽ giữa lý thuyết đại số tuyến tính trừu tượng (Định lý phổ, Gram-Schmidt) với ứng dụng thực tế trên dữ liệu máy tính.
  • Bộ mã nguồn mẫu trực quan, dễ dàng tích hợp vào các bài giảng học phần Giải tích số và Máy học cơ bản.

2. Kỹ sư Trí tuệ nhân tạo và Phát triển phần mềm (AI/Software Engineers)

  • Nắm vững cơ chế toán học đằng sau các hàm thư viện có sẵn (np.linalg.svd, sklearn.decomposition.PCA).
  • Nắm bắt kỹ thuật tối ưu hóa bộ nhớ và giảm số chiều dữ liệu trước khi đưa vào các mô hình học máy phức tạp.

3. Doanh nghiệp và Đơn vị phát triển hệ thống nhúng/IoT

  • Cung cấp giải pháp nén dữ liệu nhẹ, không phụ thuộc vào phần cứng đắt tiền, giúp tiết kiệm từ 30% đến 50% chi phí lưu trữ đám mây và băng thông truyền tải dữ liệu.

Câu hỏi thường gặp

1. Yêu cầu kỹ thuật tối thiểu để triển khai giải pháp này là gì?

Giải pháp được thiết kế tối ưu, hoàn toàn có thể chạy mượt mà trên môi trường CPU thông thường (không bắt buộc GPU). Hệ thống chỉ cần Python 3.10+ cùng các thư viện chuẩn NumPy, SciPy và Scikit-Learn.

2. Sự khác biệt cốt lõi giữa SVD và PCA là gì?

SVD là kỹ thuật phân tích đại số thuần túy áp dụng cho mọi ma trận thực $A \in \mathbb{R}^{m \times n}$ bất kỳ. PCA là kỹ thuật thống kê đa biến nhằm tối đa hóa phương sai dữ liệu; về mặt thuật toán, PCA chính là phân tích SVD trên ma trận dữ liệu đã được trừ đi vector kỳ vọng (chuẩn hóa tâm $E[X] = 0$).

3. Tại sao chọn $k = 150$ trong bài toán nhận dạng khuôn mặt LFW?

Số chiều $k = 150$ được lựa chọn dựa trên thực nghiệm cân bằng giữa độ chính xác và chi phí tính toán. Tại $k = 150$, không gian Eigenface giữ lại trên $92%$ tổng phương sai của tập dữ liệu LFW, đồng thời giảm hơn $91.89%$ số chiều so với ảnh gốc $1{,}850$ chiều, giúp bộ phân loại SVM đạt độ chính xác tối ưu $80.0%$.

4. Chi phí bảo trì và tích hợp vào hệ thống hiện có như thế nào?

Mã nguồn được đóng gói theo dạng module độc lập, không có phụ thuộc ẩn. Chi phí bảo trì gần như bằng 0 do các thuật toán đại số ma trận có tính tất định cao, không gặp hiện tượng trôi dạt mô hình (model drift) bất thường như các mạng nơ-ron sâu.

5. Làm thế nào để giải quyết vấn đề khi kích thước ma trận quá lớn không thể nạp vào RAM?

Có thể chuyển sang sử dụng thuật toán Incremental PCA (IPCA) hoặc Randomized SVD (được tích hợp sẵn trong module sklearn.decomposition.IncrementalPCA), cho phép xử lý dữ liệu theo từng mini-batch mà không cần nạp toàn bộ ma trận vào bộ nhớ cùng một lúc.

Kết luận

Khóa luận tốt nghiệp "Một số phương pháp phân tích ma trận và ứng dụng" của tác giả Nguyễn Nhật Nam (chuyên ngành Khoa học dữ liệu, Trường Đại học Quy Nhơn) đã hệ thống hóa và chứng minh chặt chẽ nền tảng toán học của Phân rã giá trị kỳ dị (SVD) và Phân tích thành phần chính (PCA). Thông qua các thực nghiệm cụ thể trên bài toán nén ảnh số và nhận dạng khuôn mặt Eigenfaces trên tập dữ liệu LFW, nghiên cứu đã minh chứng tính hiệu quả vượt trội của các phương pháp phân rã ma trận trong việc giảm chiều dữ liệu (giảm $91.89%$ số chiều, đạt độ chính xác phân loại $80%$) và tiết kiệm không gian lưu trữ (giảm hơn $50%$ dung lượng với $k=32$).

Nghiên cứu không chỉ khẳng định giá trị bền vững của đại số tuyến tính cổ điển trong kỷ nguyên khoa học dữ liệu mà còn mở ra những tiềm năng ứng dụng sâu rộng trong việc nén và tối ưu hóa các mô hình trí tuệ nhân tạo hiện đại. Bạn đọc và các nhà nghiên cứu quan tâm có thể khai thác các công thức và mã nguồn mẫu được chuẩn hóa trong đồ án để ứng dụng vào các bài toán xử lý tín hiệu, thị giác máy tính và nén mạng nơ-ron sâu.