Giới thiệu dự án

Trong kỷ nguyên bùng nổ số lượng nội dung đa phương tiện, các nền tảng giải trí trực tuyến đang phải đối mặt với thách thức quá tải thông tin (Information Overload). Theo các báo cáo phân tích thị trường giải trí số, hơn 80% tổng thời lượng xem phim trên các nền tảng streaming danh tiếng như Netflix xuất phát trực tiếp từ các thuật toán gợi ý tự động. Người dùng thông thường chỉ dành trung bình từ 60 đến 90 giây để duyệt danh sách trước khi từ bỏ nếu không tìm thấy nội dung phù hợp với sở thích cá nhân. Tại các cụm rạp chiếu phim truyền thống và các ứng dụng phân phối phim, khách hàng thường gặp khó khăn khi phải tự tìm kiếm thủ công qua hàng ngàn tựa phim với poster dàn trải, thiếu tính cá nhân hóa, dẫn đến giảm sút trải nghiệm giải trí và làm lãng phí chi phí tiếp thị của nhà sản xuất.

Vấn đề cốt lõi đặt ra là làm thế nào để xây dựng một kiến trúc hệ thống đề xuất phim có khả năng khai phá chính xác thị hiếu tiềm ẩn của từng cá nhân, đồng thời giải quyết triệt để bài toán "khởi đầu lạnh" (Cold Start Problem) khi người dùng mới tham gia hệ thống chưa có lịch sử tương tác. Đồ án "Xây dựng ứng dụng đề xuất phim kết hợp hai phương pháp: Latent Factor Collaborative Filtering using Deep Learning (LFCF-DL) và Content-Based Filtering" do nhóm sinh viên Nguyễn Trọng Ninh và Trần Tuấn Vũ (Khoa Công nghệ Phần mềm, Trường Đại học Công nghệ Thông tin - ĐHQG-HCM) thực hiện dưới sự hướng dẫn của TS. Nguyễn Tấn Trần Minh Khang đã giải quyết trực tiếp bài toán này.

+-----------------------------------------------------------------------------------+
|                           HỆ THỐNG ĐỀ XUẤT PHIM HYBRID                            |
|                                                                                   |
|   +------------------------------------+   +----------------------------------+   |
|   |         LFCF-DL Subsystem          |   |   Content-Based & Weighting      |   |
|   | (User/Item Latent Factor Embeddings|   | (Cosine Similarity over Genres,  |   |
|   |       via Deep Neural Network)     |   |  Rating Volume Regularization)   |   |
|   +-----------------+------------------+   +-----------------+----------------+   |
|                     |                                        |                    |
|                     +-------------------+--------------------+                    |
|                                         |                                         |
|                                         v                                         |
|                      +-------------------------------------+                      |
|                      |  Hybrid Scoring & Ranking Engine    |                      |
|                      +------------------+------------------+                      |
|                                         |                                         |
|                                         v                                         |
|                      +-------------------------------------+                      |
|                      | Cross-Platform App (React Native)   |                      |
|                      +-------------------------------------+                      |
+-----------------------------------------------------------------------------------+

Mục tiêu cụ thể của dự án được xác định bao gồm:

  1. Nghiên cứu và triển khai mô hình học sâu Latent Factor Collaborative Filtering using Deep Learning (LFCF-DL) để ánh xạ người dùng và phim vào không gian vector tiềm ẩn đa chiều, từ đó dự đoán chính xác điểm đánh giá ($1 - 5$ sao).
  2. Xây dựng giải thuật Content-Based Filtering kết hợp độ đo tương đồng cosine và trọng số đánh giá cộng đồng nhằm tạo danh sách phim gợi ý chất lượng cao cho người dùng mới.
  3. Thiết kế và hiện thực hóa ứng dụng di động đa nền tảng hoàn chỉnh bằng React Native, kết nối hạ tầng dữ liệu qua Firebase với giao diện trực quan và trải nghiệm mượt mà.

Phạm vi nghiên cứu tập trung trên bộ dữ liệu tiêu chuẩn công nghiệp MovieLens 100K, xử lý 100.000 lượt đánh giá từ 943 người dùng trên 1.682 bộ phim với cấu trúc phân chia huấn luyện/kiểm thử theo tỷ lệ chuẩn $80:20$.

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

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

Khảo sát thực trạng cho thấy các hệ thống bán vé rạp chiếu phim và website truyền thống chủ yếu hiển thị danh sách phim theo thứ tự thời gian phát hành hoặc doanh thu phòng vé. Cách tiếp cận này bộc lộ những khiếm khuyết lớn:

Tiêu chí so sánh Lọc cộng tác ma trận truyền thống (SVD/PMF) Lọc dựa trên nội dung thuần túy (Content-Based) Giải pháp Hybrid (LFCF-DL + Content-Based của Đồ án)
Học quan hệ phi tuyến Hạn chế (chỉ dùng phép nhân ma trận tuyến tính) Không hỗ trợ Rất cao (thông qua các lớp Embedding và hàm phi tuyến)
Xử lý Cold Start User Kém (không thể gợi ý nếu chưa có rating) Khá (dựa trên thể loại khai báo ban đầu) Xuất sắc (chuyển đổi linh hoạt giữa Content-Based và LFCF-DL)
Tận dụng đặc trưng tiềm ẩn Khá Kém (chỉ dùng metadata thô) Rất cao (học tự động qua Gradient Descent)
Độ trễ suy luận (Inference) Trung bình Thấp Rất thấp ($\le 120\text{ms}$ khi tối ưu hóa vector nhúng)

Yêu cầu người dùng được phân loại theo mô hình MoSCoW:

  • Must have: Đăng ký/đăng nhập an toàn, hiển thị danh mục phim, tìm kiếm từ khóa, tính toán danh sách đề xuất cá nhân hóa, xem chi tiết và chấm điểm phim.
  • Should have: Lọc phim theo thể loại, lưu danh sách phim yêu thích, lưu lịch sử phim đã xem.
  • Could have: Đánh giá theo trọng số tương quan thời gian thực.
  • Won't have: Phát video trực tuyến chất lượng cao 4K trên ứng dụng client (tập trung thuần túy vào bài toán đề xuất).

Thiết kế hệ thống

Kiến trúc giải pháp được thiết kế theo mô hình phân tầng hướng dịch vụ (Service-Oriented Architecture), bao gồm 3 phân tầng chính:

  • Tầng giao diện (Presentation Layer): Ứng dụng di động xây dựng trên framework React Native (v0.72+), hỗ trợ cả hệ điều hành Android và iOS.
  • Tầng xử lý dữ liệu và logic (Business & BaaS Layer): Sử dụng Firebase Authentication để quản lý phiên người dùng, Firebase Realtime Database/Firestore để đồng bộ trạng thái đánh giá, danh sách yêu thích và lịch sử xem.
  • Tầng học máy và tính toán đề xuất (AI/ML Engine): Mô hình Deep Learning trích xuất biểu diễn embedding của User/Item, phục vụ tính toán trực tiếp thông qua tích vô hướng vector.
       +-------------------------------------------------------+
       |                  React Native Client                  |
       |  (UI Screens: Home, Detail, Genres, Favorites, User)  |
       +---------------------------+---------------------------+
                                   |
                +------------------+------------------+
                |                                     |
                v                                     v
   +-------------------------+           +-------------------------+
   |   Firebase Auth & DB    |           |    LFCF-DL Engine       |
   | (Users, Ratings, Lists) |           | (User/Movie Embeddings) |
   +-------------------------+           +-------------------------+

Hệ thống cơ sở dữ liệu quan hệ/phi quan hệ được mô hình hóa chặt chẽ với các thực thể cốt lõi:

-- Cấu trúc bảng người dùng (users)
CREATE TABLE users (
    userId INT PRIMARY KEY,
    userName VARCHAR(255) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password VARCHAR(255) NOT NULL
);

-- Cấu trúc bảng danh mục phim (movies)
CREATE TABLE movies (
    movieId INT PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    genres VARCHAR(255) NOT NULL,
    image VARCHAR(500) NOT NULL
);

-- Cấu trúc bảng chi tiết tương tác (Chitiet)
CREATE TABLE Chitiet (
    userId INT,
    movieId INT,
    rating FLOAT NOT NULL,
    isFavorite BOOLEAN DEFAULT FALSE,
    isWatched BOOLEAN DEFAULT FALSE,
    PRIMARY KEY (userId, movieId),
    FOREIGN KEY (userId) REFERENCES users(userId),
    FOREIGN KEY (movieId) REFERENCES movies(movieId)
);

Methodology

Quy trình nghiên cứu và phát triển phần mềm tuân thủ nghiêm ngặt mô hình Scrum/Agile với chu kỳ lặp (sprint) kéo dài 2 tuần:

  • Sprint 1 (Khởi tạo & Tiền xử lý dữ liệu): Khảo sát hiện trạng, thu thập bộ dữ liệu MovieLens 100K, chuẩn hóa ma trận User-Item, phân chia tập dữ liệu theo tỷ lệ $80%$ Train ($80.000$ mẫu) và $20%$ Test ($20.000$ mẫu).
  • Sprint 2 (Xây dựng mô hình LFCF-DL): Thiết kế kiến trúc lớp nhúng (Embedding Layers), định nghĩa hàm mất mát MSE và huấn luyện mô hình qua thuật toán tối ưu Adam.
  • Sprint 3 (Xây dựng giải thuật Content-Based & Backend): Xây dựng vector đặc trưng cho thể loại phim, lập trình giải thuật Cosine Similarity và tích hợp cơ sở dữ liệu Firebase.
  • Sprint 4 (Phát triển ứng dụng React Native): Xây dựng toàn bộ 8 màn hình chức năng, tích hợp React Navigation, quản lý state bằng Redux và gọi API qua Axios.
  • Sprint 5 (Kiểm thử, đánh giá & Tối ưu hóa): Đo lường sai số MSE/RMSE trên tập test, kiểm thử giao diện người dùng và tinh chỉnh hiệu năng phản hồi của ứng dụng.

Implementation và kết quả

Development process

1. Mô hình Latent Factor Collaborative Filtering using Deep Learning (LFCF-DL)

Mô hình khởi tạo hai không gian vector nhúng tiềm ẩn (latent factor embedding spaces): một ma trận nhúng người dùng $U \in \mathbb{R}^{m \times k}$ cho $m$ người dùng ($m = 943$) và một ma trận nhúng phim $V \in \mathbb{R}^{n \times k}$ cho $n$ bộ phim ($n = 1682$), trong đó $k$ là số chiều thuộc tính ẩn (latent dimension, $k = 32$ hoặc $64$).

Mỗi người dùng $i$ được ánh xạ thành vector $u_i \in \mathbb{R}^k$, mỗi bộ phim $j$ được ánh xạ thành vector $v_j \in \mathbb{R}^k$. Điểm dự đoán $\hat{r}_{ij}$ được tính toán dựa trên tích vô hướng của hai vector nhúng kết hợp độ lệch (bias):

$$\hat{r}_{ij} = u_i^T v_j + b_u^{(i)} + b_v^{(j)} + \mu$$

Trong đó:

  • $b_u^{(i)}$ là độ lệch cá nhân của người dùng $i$.
  • $b_v^{(j)}$ là độ lệch nội tại của bộ phim $j$.
  • $\mu$ là điểm đánh giá trung bình toàn bộ hệ thống.

Hàm mất mát Mean Squared Error (MSE) có bổ sung chuẩn hóa $L_2$ để kiểm soát hiện tượng quá khớp (Overfitting):

$$\mathcal{L} = \frac{1}{|R|} \sum_{(i,j) \in R} \left(r_{ij} - \hat{r}_{ij}\right)^2 + \lambda \left(|u_i|_2^2 + |v_j|_2^2 + (b_u^{(i)})^2 + (b_v^{(j)})^2\right)$$

Đoạn mã hiện thực kiến trúc mô hình LFCF-DL trên nền tảng PyTorch:

import torch
import torch.nn as nn

class LFCFDeepLearning(nn.Module):
    def __init__(self, num_users: int, num_items: int, embedding_dim: int = 32):
        super(LFCFDeepLearning, self).__init__()
        self.user_embedding = nn.Embedding(num_users, embedding_dim)
        self.item_embedding = nn.Embedding(num_items, embedding_dim)
        self.user_bias = nn.Embedding(num_users, 1)
        self.item_bias = nn.Embedding(num_items, 1)
        self.global_bias = nn.Parameter(torch.zeros(1))
        
        # Khởi tạo trọng số ngẫu nhiên theo phân phối chuẩn
        nn.init.normal_(self.user_embedding.weight, std=0.01)
        nn.init.normal_(self.item_embedding.weight, std=0.01)
        nn.init.zeros_(self.user_bias.weight)
        nn.init.zeros_(self.item_bias.weight)

    def forward(self, user_idx: torch.Tensor, item_idx: torch.Tensor) -> torch.Tensor:
        u_emb = self.user_embedding(user_idx)
        v_emb = self.item_embedding(item_idx)
        
        # Tính tích vô hướng giữa 2 vector nhúng
        dot_product = (u_emb * v_emb).sum(dim=1, keepdim=True)
        u_b = self.user_bias(user_idx)
        i_b = self.item_bias(item_idx)
        
        prediction = dot_product + u_b + i_b + self.global_bias
        return prediction.squeeze()

2. Giải thuật Content-Based Filtering cho người dùng mới (Cold Start)

Đối với người dùng mới chưa có lịch sử đánh giá, hệ thống thu thập sở thích thể loại qua bước đăng ký hoặc màn hình chọn danh mục ban đầu. Mỗi bộ phim $j$ được mã hóa thành vector nhị phân $g_j \in {0, 1}^C$ đại diện cho $C$ thể loại phim (Action, Comedy, Drama, Sci-Fi,...). Độ tương đồng giữa hồ sơ thể loại người dùng $p_u$ và phim $g_j$ được tính bằng Cosine Similarity:

$$\text{Cosine Similarity}(p_u, g_j) = \frac{p_u \cdot g_j}{|p_u|_2 |g_j|_2}$$

Để đảm bảo độ tin cậy, hệ thống kết hợp trọng số đánh giá cộng đồng $W_j$:

$$\text{Final Score}(j) = \alpha \cdot \text{Cosine Similarity}(p_u, g_j) + (1 - \alpha) \cdot \left(\frac{\bar{r}j}{5.0} \times \log{10}(1 + N_j)\right)$$

Trong đó $\bar{r}_j$ là điểm đánh giá trung bình của phim $j$, $N_j$ là tổng số lượt đánh giá, và $\alpha = 0.7$ là tham số điều phối.

3. Xây dựng giao diện ứng dụng di động bằng React Native

Client sử dụng cấu trúc component phân cấp, kết hợp Axios để truy vấn các API đề xuất và Firebase Realtime Database để ghi nhận tức thời hành động của người dùng.

// Service tính toán và tải dữ liệu phim đề xuất trên React Native
import axios from 'axios';

export const fetchRecommendedMovies = async (userId, userGenres) => {
  try {
    const response = await axios.post('https://api-recsys.uit.edu.vn/v1/recommend', {
      user_id: userId,
      selected_genres: userGenres,
      limit: 10
    });
    return response.data.movies;
  } catch (error) {
    console.error('Lỗi khi tải danh sách phim đề xuất:', error);
    throw error;
  }
};

Testing và validation

Quá trình kiểm thử mô hình LFCF-DL được thực hiện với các siêu tham số: kích thước batch $128$, thuật toán Adam với tốc độ học (Learning Rate) $\eta = 0.001$, số chiều vector nhúng $k = 32$, hệ số suy giảm trọng số (weight decay) $\lambda = 1e-4$.

Chỉ số đánh giá Baseline Matrix Factorization (SVD) Neural Matrix Factorization LFCF-DL (Triển khai trong đồ án) Mức độ cải thiện so với Baseline
Train MSE 0.7821 0.6954 0.6712 Giảm $14.18%$
Test MSE 0.8945 0.8230 0.8015 Giảm $10.40%$
Test RMSE 0.9457 0.9072 0.8952 Cải thiện $5.34%$
Inference Latency 4.2 ms 8.7 ms 5.1 ms Tối ưu hóa cho di động

Các kịch bản kiểm thử chức năng giao diện người dùng (Black-box testing) đạt tỷ lệ kiểm thử thành công $100%$ trên 8 màn hình chức năng chính:

  • Màn hình Đăng nhập / Đăng ký (Xác thực tài khoản qua Firebase Auth).
  • Màn hình Trang chủ (Hiển thị Top Pick cho User theo LFCF-DL).
  • Màn hình Thông tin chi tiết phim (Xem mô tả, poster, điểm trung bình, xếp hạng sao $1 - 5$).
  • Màn hình Phim theo thể loại (Lọc dữ liệu đa tiêu chí).
  • Màn hình Phim yêu thích & Phim đã xem (Quản lý trạng thái tức thì).
  • Màn hình Thông tin người dùng (Cập nhật profile cá nhân).

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

  1. Kiến trúc tích hợp thông minh (Hybrid Synergy): Không dừng lại ở mô hình Collaborative Filtering truyền thống vốn bị tê liệt khi đối mặt với dữ liệu thưa thớt (Matrix Sparsity $> 93%$), đồ án kết hợp nhuần nhuyễn mạng học sâu biểu diễn embedding với thuật toán Content-Based có trọng số đánh giá cộng đồng.
  2. Cơ chế nhúng linh hoạt trên biên (Edge-Ready Embedding Computation): Mô hình LFCF-DL cho phép trích xuất trực tiếp các vector nhúng $u_i, v_j$ sau khi huấn luyện, giúp việc tính toán tích vô hướng để xếp hạng phim trên ứng dụng di động diễn ra tức thì mà không đòi hỏi tài nguyên server đắt đỏ.
  3. Ứng dụng công nghệ hoàn chỉnh từ nghiên cứu đến thực tế: Đồ án tạo ra một sản phẩm hoàn chỉnh với quy trình kỹ thuật phần mềm chuẩn mực (đầy đủ biểu đồ Use-case, biểu đồ tuần tự, biểu đồ hoạt động và thiết kế cơ sở dữ liệu quan hệ), sẵn sàng đóng gói thành ứng dụng di động thực tế trên cả hai nền tảng Android và iOS.

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

Kịch bản triển khai thực tế

  • Cụm rạp chiếu phim (CGV, Lotte Cinema, Galaxy Cinema): Tích hợp module đề xuất vào ứng dụng mua vé nhằm gợi ý các suất chiếu và bộ phim tương tự với lịch sử xem của hội viên, gia tăng tỷ lệ chuyển đổi mua vé thêm $15 - 25%$.
  • Nền tảng xem phim trực tuyến (OTT Streaming Services): Cung cấp trải nghiệm trang chủ được cá nhân hóa hoàn toàn cho từng tài khoản người dùng, tự động làm mới danh sách đề xuất mỗi khi người dùng hoàn thành một bộ phim hoặc để lại đánh giá mới.
+-------------------------------------------------------------------------------+
|                      MÔ HÌNH TRIỂN KHAI HỆ THỐNG MỞ RỘNG                      |
|                                                                               |
|  [React Native Clients] <---> [Cloud Load Balancer / Nginx]                  |
|                                         |                                     |
|                                         v                                     |
|                           [FastAPI Python Backend Cluster]                    |
|                                         |                                     |
|                 +-----------------------+-----------------------+             |
|                 |                                               |             |
|                 v                                               v             |
|   [Redis Cache: Top-K & Embeddings]             [PostgreSQL / Firebase DB]    |
|                 ^                                                             |
|                 |                                                             |
|   [Periodic Offline Training: PyTorch LFCF-DL Pipeline via Airflow]           |
+-------------------------------------------------------------------------------+

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

  • Hạ tầng máy chủ (Server-side):
    • CPU: Tối thiểu 4 vCPU, 8GB RAM (cho giai đoạn phục vụ suy luận API).
    • GPU: NVIDIA T4 / RTX 3060 (phục vụ tái huấn luyện định kỳ hàng tuần trên tập dữ liệu mở rộng).
    • Môi trường: Docker container, Python 3.10+, FastAPI framework, PyTorch 2.0+.
  • Hạ tầng thiết bị đầu cuối (Client-side):
    • Thiết bị di động chạy Android 8.0+ hoặc iOS 13.0+.
    • Dung lượng bộ nhớ trống: Tối thiểu 50MB.

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

Mặc dù đã đạt được những kết quả đáng khích lệ, đề tài vẫn ghi nhận một số điểm hạn chế kỹ thuật:

  • Tập dữ liệu tĩnh: Mô hình hiện tại mới được huấn luyện và đánh giá trên bộ dữ liệu tĩnh MovieLens 100K; chưa tích hợp cơ chế lắng nghe phản hồi ngầm định thời gian thực (Implicit Feedback) như thời gian dừng xem poster (dwell time) hay hành vi bỏ qua phim.
  • Tần suất cập nhật trọng số: Ma trận nhúng người dùng mới vẫn cần chu kỳ tái huấn luyện định kỳ (batch re-training) để hòa nhập hoàn toàn vào không gian tiềm ẩn của LFCF-DL.

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

  1. Ứng dụng mô hình Neural Collaborative Filtering (NCF) kết hợp nhiều lớp Perceptron đa tầng (Multi-Layer Perceptron - MLP) để học sâu hơn các tương tác phi tuyến phức tạp giữa User và Movie.
  2. Ứng dụng mạng nơ-ron đồ thị Graph Neural Networks (GNN / LightGCN) nhằm tận dụng cấu trúc đồ thị liên kết giữa người dùng, diễn viên, đạo diễn và thể loại phim.
  3. Xây dựng pipeline dữ liệu streaming thời gian thực bằng Apache Kafka và Redis để cập nhật vector nhúng người dùng tức thời theo từng lượt bấm của họ.

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

  • Sinh viên & Học viên chuyên ngành Công nghệ Thông tin / Kỹ thuật Phần mềm: Cung cấp tài liệu tham khảo hoàn chỉnh từ lý thuyết thuật toán đề xuất (Collaborative Filtering, Content-Based) đến phương pháp phân tích thiết kế hệ thống phần mềm bằng UML.
  • Kỹ sư phát triển phần mềm di động (Mobile Developers): Tham khảo kiến trúc tích hợp hệ thống học máy vào ứng dụng React Native và quản lý cơ sở dữ liệu thời gian thực với Firebase.
  • Các doanh nghiệp truyền thông & Giải trí số: Có được bản thiết kế kiến trúc hệ thống đề xuất chi phí thấp, hiệu quả cao, dễ dàng tùy biến theo mô hình kinh doanh cụ thể.
  • Nhà nghiên cứu hệ thống khuyến nghị (RecSys Researchers): Nắm bắt phương pháp benchmark định lượng giữa các mô hình Deep Learning Embedding và giải thuật truyền thống trên tập dữ liệu MovieLens.

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

1. Yêu cầu kỹ thuật tối thiểu để triển khai hệ thống là gì?

Hệ thống backend yêu cầu môi trường Python 3.9+ hỗ trợ PyTorch/TensorFlow, RAM tối thiểu 4GB và cơ sở dữ liệu Firebase/PostgreSQL. Phía ứng dụng di động yêu cầu môi trường Node.js 18+ cùng React Native CLI để build ứng dụng cho Android SDK 33+ và iOS 13+.

2. Mô hình xử lý bài toán Cold Start cho người dùng mới như thế nào?

Khi người dùng mới đăng ký chưa có lịch sử đánh giá, hệ thống sẽ tự động chuyển sang giải thuật Content-Based Filtering. Thuật toán sử dụng các thể loại phim mà người dùng chọn ban đầu để tính độ tương đồng Cosine với các bộ phim trong kho dữ liệu, đồng thời kết hợp với trọng số đánh giá từ cộng đồng để đưa ra gợi ý chất lượng cao ngay lập tức.

3. Hệ thống có thể mở rộng lên các bộ dữ liệu lớn hơn (như MovieLens 1M hoặc 20M) không?

Hoàn toàn khả thi. Do kiến trúc LFCF-DL sử dụng các lớp Embedding có kích thước ma trận cố định $O(m \times k + n \times k)$, khi mở rộng lên hàng triệu bản ghi, hệ thống chỉ cần tăng dung lượng bộ nhớ RAM/VRAM của máy chủ huấn luyện và sử dụng các thư viện tìm kiếm vector lân cận xấp xỉ tốc độ cao như FAISS hoặc ScaNN để duy trì độ trễ suy luận dưới 50ms.

4. Chi phí vận hành và bảo trì hệ thống ước tính như thế nào?

Nhờ tận dụng kiến trúc BaaS từ Firebase (gói miễn phí Spark hoặc gói trả phí theo lưu lượng Blaze) kết hợp với máy chủ API suy luận cấu hình vừa phải, chi phí vận hành ban đầu cho một ứng dụng có khoảng 10.000 người dùng hoạt động hàng tháng (MAU) chỉ dao động từ $15 - $30 USD/tháng.

5. Tại sao đồ án chọn MSE làm hàm mất mát thay vì Cross-Entropy?

Bởi vì bài toán đề xuất phim trong đồ án được mô hình hóa dưới dạng bài toán hồi quy (Regression Task) để dự đoán điểm đánh giá chính xác trên thang điểm liên tục từ 1.0 đến 5.0 sao. Mean Squared Error (MSE) phạt nặng các sai số dự đoán lớn, giúp mô hình bám sát chính xác mức độ hài lòng thực tế của người dùng.

Kết luận

Đồ án "Xây dựng ứng dụng đề xuất phim kết hợp hai phương pháp: Latent Factor Collaborative Filtering using Deep Learning (LFCF-DL) và Content-Based Filtering" của nhóm sinh viên Trường Đại học Công nghệ Thông tin - ĐHQG-HCM đã giải quyết thành công bài toán cá nhân hóa trải nghiệm giải trí số. Bằng việc kết hợp sức mạnh biểu diễn đặc trưng tiềm ẩn phi tuyến của Deep Learning với khả năng khắc phục khởi đầu lạnh của Content-Based Filtering, hệ thống đạt được độ chính xác cao với chỉ số Test RMSE đạt mức ấn tượng $0.8952$ trên bộ dữ liệu MovieLens 100K.

Sản phẩm ứng dụng di động React Native hoàn thiện với đầy đủ quy trình phân tích thiết kế hệ thống chuẩn mực đã chứng minh tính khả thi, độ ổn định và tiềm năng ứng dụng thương mại rộng rãi trong ngành công nghiệp giải trí số và hệ thống rạp chiếu phim hiện đại.