Giới thiệu dự án

Trong kỷ nguyên bùng nổ thông tin số, khối lượng nội dung và sản phẩm trực tuyến tăng trưởng theo cấp số nhân. Theo thống kê thực tế, mỗi phút có hơn 500 giờ video được tải lên YouTube, danh mục sản phẩm của Amazon vượt mốc 12.000 mặt hàng tiêu chuẩn, và hàng trăm triệu bài viết được đăng tải mỗi ngày trên các nền tảng mạng xã hội. Sự quá tải này dẫn đến nghịch lý lựa chọn (choice overload), khiến người dùng mất nhiều giờ để tìm kiếm nội dung ưng ý. Đối với doanh nghiệp số, 80% thời lượng xem trên Netflix và 60% lượt nhấp video trên trang chủ YouTube được thúc đẩy trực tiếp bởi các thuật toán gợi ý (Recommender Systems). Do đó, việc xây dựng một hệ thống gợi ý chuẩn xác, có khả năng cá nhân hóa trải nghiệm theo thời gian thực là bài toán sống còn.

Đồ án tốt nghiệp ngành Kỹ thuật Dữ liệu với đề tài "Ứng dụng học sâu cho bài toán gợi ý" (thực hiện bởi Võ Hà Nhật Tân và Phạm Đình Nhiên, dưới sự hướng dẫn của ThS. Quách Đình Hoàng tại Trường Đại học Sư phạm Kỹ thuật TP.HCM) tập trung giải quyết các điểm nghẽn cốt lõi của hệ thống gợi ý truyền thống.

+-------------------------------------------------------------------------+
|                           PROBLEM LANDSCAPE                             |
|                                                                         |
|  [Dữ liệu lớn / Quá tải thông tin] ---> [Ma trận tương tác cực thưa >99%] |
|                                                    |                    |
|                                                    v                    |
|  [Hạn chế của mô hình tuyến tính SVD/CF] <---+ [Mất mát phi tuyến]       |
|                     |                                                   |
|                     v                                                   |
|       [GIẢI PHÁP: DEEP AUTOENCODER PHI TUYẾN (SELU / ELU)]              |
+-------------------------------------------------------------------------+

Vấn đề nghiên cứu và Điểm nghẽn kỹ thuật (Pain Points)

Các giải pháp truyền thống như Lọc cộng tác dựa trên bộ nhớ (Memory-based Collaborative Filtering - User-based/Item-based CF) và Phân rã ma trận tuyến tính (Matrix Factorization - SVD) bộc lộ nhiều hạn chế nghiêm trọng:

  1. Độ thưa ma trận dữ liệu (Data Sparsity): Ma trận tương tác User-Item (Utility Matrix) trong thực tế thường có độ thưa vượt quá 99%, khiến việc tính toán độ tương đồng Cosine hoặc Pearson Correlation mất đi độ chính xác.
  2. Không mô hình hóa được tương tác phi tuyến tính: SVD hay Factorization Machines chỉ ánh xạ biểu diễn người dùng và vật phẩm thông qua tích vô hướng tuyến tính đơn giản, bỏ qua các quan hệ tương tác phi tuyến tính đa chiều tiềm ẩn giữa các đặc trưng.
  3. Hiện tượng suy giảm gradient (Dying ReLU) và Cold-start: Việc áp dụng mạng nơ-ron truyền thống dễ gặp lỗi tế bào thần kinh ngưng hoạt động khi gặp giá trị thưa (zero-values) và xử lý kém với các bản ghi mới.

Mục tiêu của đề tài

  1. Hệ thống hóa cơ sở lý thuyết toàn diện về các phương pháp gợi ý truyền thống (Content-Based, Collaborative Filtering, SVD) và nền tảng Deep Learning.
  2. Nghiên cứu và hiện thực hóa các kiến trúc mạng nơ-ron tự mã hóa sâu (Deep AutoEncoder - DAE) ứng dụng trên ma trận xếp hạng (rating matrix).
  3. Đánh giá và thực nghiệm tối ưu hàm kích hoạt tự chuẩn hóa (SELU, ELU) kết hợp với các chiến lược gán giá trị mặc định (Imputation Strategies) nhằm giảm thiểu hàm mất mát.
  4. Đạt chỉ số sai số chuẩn Root Mean Squared Error (RMSE) thấp hơn đáng kể so với các mô hình baseline trên tập dữ liệu chuẩn MovieLens.

Phương pháp tiếp cận và Giới hạn phạm vi

  • Phương pháp tiếp cận: Mô hình hóa bài toán dự đoán đánh giá (Rating Prediction) dưới dạng bài toán tái tạo ma trận thưa thông qua AutoEncoder, trích xuất biểu diễn ẩn (latent representation) nhiều tầng.
  • Phạm vi và giới hạn: Tập trung vào dữ liệu phản hồi tường minh (explicit feedback - điểm đánh giá 1 đến 5 sao) từ bộ dữ liệu chuẩn MovieLens (tập 100K/1M ratings); phạm vi nghiên cứu tập trung vào mô hình hóa dữ liệu dạng bảng/ma trận, chưa đi sâu vào đồ thị tri thức (Knowledge Graph) phân tán quy mô Petabyte.

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

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

Bảng so sánh chi tiết giữa các giải pháp gợi ý phổ biến hiện nay:

Tiêu chí Content-Based Filtering Memory-based CF (User/Item-based) Matrix Factorization (SVD) Deep AutoEncoder (Đề tài đề xuất)
Bản chất thuật toán Phân tích đặc trưng vật phẩm (TF-IDF, meta-tags) Tính độ tương đồng k-NN (Cosine / Pearson) Phân rã ma trận đại số tuyến tính ($R \approx U \cdot V^T$) Mạng nơ-ron phi tuyến tái tạo vector đánh giá
Khả năng học quan hệ phi tuyến Kém (chỉ so khớp đặc trưng) Không (tính khoảng cách tuyến tính) Rất hạn chế (phép nhân vector tuyến tính) Rất cao (nhờ các tầng ẩn và hàm kích hoạt phi tuyến)
Độ nhạy với Data Sparsity Thấp (chỉ cần metadata) Rất cao (thất bại nếu ít tương tác chung) Trung bình (cần kỹ thuật điều chuẩn $L_2$) Tối ưu tốt (nhờ cơ chế Bottleneck Latent Representation)
Chi phí tính toán Inference $O(N)$ theo số item $O(M \cdot N)$ rất chậm khi dữ liệu lớn $O(K)$ nhanh ($K$ là latent factors) $O(1)$ phép nhân ma trận Feedforward (<15ms)
Khả năng khái quát hóa Hạn chế (hiệu ứng Filter Bubble) Khá Tốt Vượt trội trên dữ liệu phức tạp

Thiết kế hệ thống

Hệ thống được thiết kế theo mô hình luồng dữ liệu 4 tầng độc lập:

[User-Item Raw Data] 
       │
       ▼
[Tầng 1: Preprocessing & Sparse Matrix Encoding] 
       │  (Chuyển đổi DataFrame -> User/Item Vector, Train/Val/Test Split: 80/10/10)
       ▼
[Tầng 2: Deep AutoEncoder Neural Core]
       │  - Encoder: Dense(512, SELU) -> Dense(256, SELU) -> Latent Bottleneck(128)
       │  - Regularization: Dropout(0.2), L2 Weight Decay
       │  - Decoder: Dense(256, SELU) -> Dense(512, SELU) -> Output Layer(Dense N-items)
       ▼
[Tầng 3: Loss Function Optimization]
       │  - Masked Mean Squared Error (Chỉ tối ưu trên các rating đã quan sát)
       ▼
[Tầng 4: Recommendation & Ranking Engine]
       │  (Dự đoán Rating chưa đánh giá -> Top-K Item Selection)

Cấu hình Technology Stack

  • Ngôn ngữ lập trình: Python 3.8.12.
  • Deep Learning Frameworks: TensorFlow 2.8.0 / Keras 2.8.0, PyTorch 1.11.0.
  • Data Engineering & Computing: Pandas 1.3.5, NumPy 1.21.6, SciPy 1.7.3.
  • Machine Learning & Metrics: Scikit-learn 1.0.2.
  • Môi trường thực nghiệm: Google Colaboratory Pro (NVIDIA Tesla T4/V100 GPU, 16GB VRAM, Intel Xeon CPU @ 2.20GHz).

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

Nghiên cứu áp dụng quy trình phát triển lặp CRISP-DM kết hợp mô hình phân pha linh hoạt:

  • Phase 1 (Tuần 1 - 3): Khảo sát tài liệu, phân tích toán học của hàm kích hoạt (Sigmoid, Tanh, ReLU, Leaky ReLU, SELU) và thuật toán lan truyền ngược (Backpropagation).
  • Phase 2 (Tuần 4 - 6): Xây dựng các mô hình cơ sở (Content-based, User-based CF, Item-based CF, SVD Baseline).
  • Phase 3 (Tuần 7 - 12): Thiết kế, lập trình kiến trúc AutoEncoder chuẩn và nâng cấp lên Deep AutoEncoder nhiều tầng trên Keras/TensorFlow.
  • Phase 4 (Tuần 13 - 16): Tinh chỉnh siêu tham số (Hyperparameter Tuning), kiểm thử các hàm kích hoạt và chiến lược xử lý dữ liệu khuyết.
  • Phase 5 (Tuần 17 - 19): Đánh giá hiệu năng bằng kiểm thử chéo (Cross-Validation), phân tích thống kê lỗi và hoàn thiện báo cáo khóa luận.

Implementation và kết quả

Chi tiết giải thuật và Cấu trúc mã nguồn

Trọng tâm kỹ thuật của đề tài là việc xây dựng mô hình Deep AutoEncoder với hàm mất mát tùy biến Masked Loss, chỉ tính toán sai số tại các vị trí người dùng đã chấm điểm, tránh việc phạt mô hình khi dự đoán các vị trí chưa được đánh giá.

import tensorflow as tf
from tensorflow.keras import layers, Model, regularizers

class DeepAutoEncoderRec(Model):
    def __init__(self, num_items, hidden_dims=[512, 256, 128], dropout_rate=0.2, l2_reg=1e-4):
        super(DeepAutoEncoderRec, self).__init__()
        self.encoder_layers = []
        # Tầng Encoder nén ma trận đầu vào
        for dim in hidden_dims:
            self.encoder_layers.append(
                layers.Dense(
                    dim, 
                    activation='selu', 
                    kernel_initializer='lecun_normal',
                    kernel_regularizer=regularizers.l2(l2_reg)
                )
            )
            self.encoder_layers.append(layers.Dropout(dropout_rate))
            
        # Tầng Decoder giải mã tái tạo vector đánh giá
        self.decoder_layers = []
        for dim in reversed(hidden_dims[:-1]):
            self.decoder_layers.append(
                layers.Dense(
                    dim, 
                    activation='selu',
                    kernel_initializer='lecun_normal',
                    kernel_regularizer=regularizers.l2(l2_reg)
                )
            )
            self.decoder_layers.append(layers.Dropout(dropout_rate))
            
        # Lớp đầu ra tái tạo lại toàn bộ item ratings
        self.output_layer = layers.Dense(
            num_items, 
            activation='linear',
            kernel_regularizer=regularizers.l2(l2_reg)
        )

    def call(self, inputs, training=False):
        x = inputs
        for layer in self.encoder_layers:
            x = layer(x, training=training)
        for layer in self.decoder_layers:
            x = layer(x, training=training)
        return self.output_layer(x)

def masked_rmse_loss(y_true, y_pred):
    """
    Hàm mất mát Masked RMSE: Chỉ tính sai số trên các rating > 0 (đã tương tác)
    """
    mask = tf.cast(tf.math.greater(y_true, 0.0), dtype=tf.float32)
    squared_error = tf.math.square(y_true - y_pred) * mask
    loss = tf.math.sqrt(tf.math.reduce_sum(squared_error) / (tf.math.reduce_sum(mask) + 1e-8))
    return loss

Kết quả đo lường và Đánh giá hiệu năng

Các thử nghiệm được thực hiện trên tập dữ liệu MovieLens với các kịch bản cấu hình siêu tham số: Batch Size = 128, Optimizer = Adam (Learning Rate = 0.001, $\beta_1 = 0.9, \beta_2 = 0.999$), Epochs = 100 kết hợp Early Stopping.

                  SO SÁNH SAI SỐ RMSE GIỮA CÁC MÔ HÌNH
         (Càng thấp càng chính xác, đo lường trên MovieLens Test Split)

  User-based CF (k-NN)    | ============================== (1.025)
  Item-based CF (k-NN)    | ============================ (0.985)
  Matrix Factorization SVD| ======================= (0.934)
  Standard AutoEncoder    | =================== (0.892)
  Deep AutoEncoder (ReLU) | ================= (0.865)
  Deep AutoEncoder (SELU) | =============== (0.821)  <-- TỐI ƯU NHẤT
                          +--------+--------+--------+--------+
                         0.0      0.3      0.6      0.9      1.2

Bảng tổng hợp số liệu thực nghiệm chi tiết:

Mô hình kiểm thử Hàm kích hoạt (Hidden Layers) Chiến lược Rating mặc định RMSE Train RMSE Validation RMSE Test
User-based CF N/A Mean Rating 0.912 1.015 1.025
Item-based CF N/A Mean Rating 0.884 0.972 0.985
Matrix Factorization (SVD) Linear 0 0.795 0.928 0.934
AutoEncoder (1 Hidden Layer) ReLU 0 0.812 0.887 0.892
Deep AutoEncoder [256, 512, 256] ReLU Zero Imputation 0.782 0.859 0.865
Deep AutoEncoder [256, 512, 256] ELU Mean Imputation 0.741 0.835 0.839
Deep AutoEncoder [512, 256, 128] SELU Masked / Zero 0.712 0.818 0.821

Phân tích chuyên sâu kết quả thực nghiệm

  1. Ưu thế của hàm kích hoạt SELU: SELU đạt RMSE 0.821 (cải thiện hơn 12.1% so với SVD và 19.9% so với User-based CF). Bản chất tự chuẩn hóa (Self-Normalizing) của SELU giúp giá trị kích hoạt luôn hội tụ về giá trị trung bình 0 và phương sai 1, triệt tiêu hoàn toàn hiện tượng bão hòa gradient (Vanishing/Exploding Gradient) mà không cần thêm tầng Batch Normalization.
  2. Khắc phục lỗi Dying ReLU: Hàm ReLU thông thường khi nhận đầu vào thưa (nhiều giá trị 0) khiến hơn 35% tế bào nơ-ron rơi vào trạng thái "chết" (zero gradient). Ngược lại, Leaky ReLU và SELU duy trì gradient âm nhỏ khác 0, cho phép toàn bộ mạng tiếp tục học biểu diễn.

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

  1. Ứng dụng kiến trúc Deep AutoEncoder đa tầng đối xứng: Thay vì sử dụng AutoEncoder đơn tầng truyền thống, đồ án thiết kế cấu trúc mạng sâu đối xứng [512 -> 256 -> 128 -> 256 -> 512] với cơ chế nén Bottleneck chặt chẽ, buộc mạng nơ-ron phải chắt lọc các đặc trưng tiềm ẩn (Latent Factor representations) quan trọng nhất của người dùng.
  2. Loại bỏ hiện tượng Dying ReLU bằng hàm kích hoạt tự chuẩn hóa: Đề xuất và chứng minh bằng thực nghiệm việc thay thế các hàm kích hoạt cổ điển (Sigmoid, ReLU) bằng SELU/ELU, giúp mô hình hóa mượt mà các ma trận cực thưa mà không làm triệt tiêu gradient.
  3. Cơ chế Masked Loss Function tối ưu hóa tài nguyên: Tối ưu hóa hàm chi phí chỉ trên các phần tử có tương tác thực tế, giảm thiểu 85% nhiễu do việc gán nhãn 0 nhân tạo gây ra, nâng cao độ tin cậy của Top-K gợi ý.
  4. Đóng góp kỹ thuật cho lĩnh vực Data Engineering: Cung cấp bộ khung thực nghiệm chuẩn hóa (benchmarking framework) hoàn chỉnh từ khâu trích xuất, xử lý ma trận thưa đến triển khai mô hình học sâu, đóng vai trò là tài liệu tham khảo chất lượng cao cho cộng đồng kỹ sư dữ liệu.

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

Kịch bản ứng dụng công nghiệp

  • Hệ thống Streaming Media (Phim ảnh / Âm nhạc): Tích hợp vào backend của các nền tảng xem phim trực tuyến để gợi ý danh sách "Phim bạn có thể thích" theo thời gian thực khi người dùng vừa chấm điểm một bộ phim.
  • Thương mại điện tử (E-Commerce): Tái tạo giỏ hàng và danh mục gợi ý chéo (Cross-selling/Up-selling) bằng cách biến đổi hành vi xem/mua hàng thành ma trận tương tác.

Kiến trúc triển khai sản phẩm (Deployment Architecture)

[Web / Mobile Clients] 
       │ (RESTful API Call: /api/v1/recommend/{user_id})
       ▼
[FastAPI Gateway / Load Balancer]
       │
       ├───> [Redis Cache: Cache Top-50 Recommendations (TTL: 2 hours)]
       │            │ (Cache Hit: Latency < 2ms)
       │            ▼
       └───> [Triton Inference Server / ONNX Runtime (DAE Model)]
                    │ (Cache Miss: Latency < 15ms)
                    ▼
             [PostgreSQL / Feature Store]

Yêu cầu hệ thống và Triển khai

  1. Cấu hình phần cứng tối thiểu (Inference):
    • CPU: 4 Cores (Intel Xeon hoặc AMD EPYC).
    • RAM: 8 GB.
    • GPU: Tùy chọn (NVIDIA T4 16GB nếu throughput > 1.000 requests/giây).
  2. Cấu hình phần cứng huấn luyện (Training):
    • GPU: NVIDIA RTX 3090 (24GB) hoặc Tesla V100.
    • RAM: 32 GB.
  3. Môi trường phần mềm: Docker Engine >= 20.10, Docker Compose >= 2.0, CUDA Toolkit 11.2+.

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

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

  • Vấn đề Cold-Start tuyệt đối: Mô hình Deep AutoEncoder dựa hoàn toàn trên ma trận tương tác nên không thể đưa ra gợi ý chuẩn xác cho người dùng mới đăng ký (hoàn toàn chưa có lượt rating nào) hoặc phim mới thêm vào hệ thống.
  • Dữ liệu đơn phương thức (Single-modality): Hệ thống chỉ khai thác dữ liệu đánh giá dạng số, chưa kết hợp các dữ liệu phi cấu trúc phong phú như tóm tắt nội dung phim (văn bản), poster phim (hình ảnh) hay trailer (video).

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

  1. Xây dựng mô hình Hybrid Deep Learning: Tích hợp mô hình Transformer (BERT/RoBERTa) để nhúng văn bản mô tả phim kết hợp cùng Deep AutoEncoder qua kiến trúc Wide & Deep hoặc DeepFM.
  2. Ứng dụng Graph Neural Networks (GNN): Chuyển đổi ma trận tương tác thành đồ thị hai phía (Bipartite Graph User-Item) và áp dụng thuật toán LightGCN / PinSage để khai thác cấu trúc đồ thị đa bậc.
  3. Mở rộng sang Phản hồi ẩn (Implicit Feedback): Nâng cấp kiến trúc sang Variational AutoEncoders (VAE) hoặc AutoRec tối ưu hóa cho dữ liệu clickstream, thời gian dừng xem (dwell time).

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

+-------------------------------------------------------------------------+
|                         ĐỐI TƯỢNG HƯỞNG LỢI                             |
+--------------------+----------------------------------------------------+
| Sinh viên CNTT /   | - Nắm vững toán học hàm kích hoạt & Backprop       |
| Data Engineering   | - Khung code mẫu chuẩn TensorFlow / PyTorch        |
+--------------------+----------------------------------------------------+
| Kỹ sư AI /         | - Kỹ thuật xử lý ma trận thưa và Masked Loss       |
| Backend Developers | - Kiến trúc triển khai Deep AutoEncoder độ trễ thấp |
+--------------------+----------------------------------------------------+
| Doanh nghiệp số /  | - Cải thiện CTR và thời gian tương tác lên 15-20%  |
| Startups           | - Tiết kiệm chi phí phần cứng với mô hình gọn nhẹ  |
+--------------------+----------------------------------------------------+
| Nhà nghiên cứu     | - Cơ sở thực nghiệm chi tiết cho biến thể AutoRec  |
| (Researchers)      | - Bộ dữ liệu benchmark có tính tái lập cao         |
+--------------------+----------------------------------------------------+
  • Sinh viên & Học viên: Tiếp cận tài liệu nghiên cứu ứng dụng có cơ sở toán học rõ ràng, cấu trúc mã nguồn thực tế thay vì lý thuyết thuần túy.
  • Kỹ sư phần mềm & AI: Sở hữu giải pháp kiến trúc tối ưu có khả năng áp dụng trực tiếp vào các hệ thống gợi ý quy mô thực tế với chi phí tính toán thấp.
  • Doanh nghiệp số: Tận dụng giải pháp để tăng tỷ lệ giữ chân khách hàng (retention rate), thúc đẩy chỉ số chuyển đổi thương mại mà không cần đầu tư hạ tầng phần cứng đắt đỏ.

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

1. Yêu cầu kỹ thuật tối thiểu để triển khai mô hình Deep AutoEncoder lên môi trường Production là gì?

Hệ thống yêu cầu máy chủ Linux (Ubuntu 20.04 LTS trở lên) trang bị tối thiểu 4 Core CPU, 8GB RAM và Docker runtime. Để đạt độ trễ phản hồi <15ms cho 500 người dùng đồng thời (concurrency), khuyến nghị chuyển đổi mô hình Keras/TensorFlow sang định dạng ONNX hoặc TensorRT và chạy trên máy chủ có GPU chuyên dụng như NVIDIA Tesla T4.

2. Mô hình xử lý bài toán thưa dữ liệu (Data Sparsity) như thế nào khi ma trận có hơn 99% phần tử rỗng?

Mô hình áp dụng hai kỹ thuật phối hợp:

  1. Sử dụng Masked Loss Function, cho phép phép toán lan truyền ngược chỉ cập nhật trọng số tại các vị trí có dữ liệu thực, ngăn chặn việc ép mô hình dự đoán tất cả các ô trống về giá trị 0.
  2. Không gian ẩn (Bottleneck Latent Space) kích thước 128 chiều đóng vai trò như một bộ nén thông tin, bắt buộc mô hình phải học các quy luật khái quát hóa thay vì ghi nhớ dữ liệu thưa.

3. Làm thế nào để tích hợp hệ thống gợi ý này vào nền tảng Web/App đang chạy?

Hệ thống được đóng gói dưới dạng RESTful API microservice sử dụng FastAPI. Backend hiện tại chỉ cần gửi yêu cầu HTTP GET /recommend/{user_id} kèm danh sách lịch sử đánh giá gần nhất; microservice sẽ trả về định dạng JSON chứa danh sách movie_id được xếp hạng cao nhất cùng điểm số dự đoán trong thời gian dưới 20ms.

4. Chi phí bảo trì và chu kỳ cập nhật (Retraining) mô hình được khuyến nghị ra sao?

  • Inference hàng ngày: Chi phí phần cứng máy chủ đám mây (AWS EC2 g4dn.xlarge hoặc GCP n1-standard-4 gắn T4) ước tính khoảng $150 - $250/tháng.
  • Chiến lược Retraining: Huấn luyện lại toàn bộ mô hình (Full Retrain) theo chu kỳ tuần hoặc tháng (mất khoảng 15-30 phút trên GPU). Với dữ liệu phát sinh hàng ngày, có thể áp dụng Fine-tuning tầng Decoder trên tập dữ liệu tương tác mới.

5. Tại sao mô hình chọn Deep AutoEncoder thay vì các kiến trúc phức tạp hơn như Transformer hay RNN?

Deep AutoEncoder mang lại tỷ lệ hiệu quả/chi phí (ROI) tối ưu cho bài toán gợi ý tĩnh (Collaborative Rating Prediction). Kiến trúc này có thời gian huấn luyện nhanh hơn 5-8 lần so với Transformer-based Recommenders, kích thước file trọng số nhỏ (<50MB), dễ bảo trì và độ trễ phản hồi cực thấp, phù hợp với hầu hết các hệ sinh thái ứng dụng vừa và lớn.

Kết luận

Khóa luận tốt nghiệp "Ứng dụng học sâu cho bài toán gợi ý" của nhóm sinh viên Võ Hà Nhật Tân và Phạm Đình Nhiên đã chứng minh sự vượt trội của phương pháp tiếp cận Deep Learning đối với bài toán cá nhân hóa thông tin. Bằng việc kết hợp kiến trúc Deep AutoEncoder đa tầng với hàm kích hoạt tự chuẩn hóa SELU và hàm mất mát Masked Loss tùy biến, đề tài đã hạ thấp sai số dự đoán RMSE xuống mức 0.821, vượt xa các phương pháp lọc cộng tác truyền thống và phân rã ma trận tuyến tính.

Nghiên cứu không chỉ dừng lại ở lý thuyết toán học mà còn mang tính ứng dụng thực tiễn cao, cung cấp một kiến trúc hệ thống rõ ràng, khả thi trong triển khai công nghiệp. Đây là nền tảng vững chắc để tiếp tục mở rộng sang các hệ thống gợi ý đa phương thức (Multimodal RecSys) và đồ thị nơ-ron (Graph Neural Networks) trong tương lai.