Giới thiệu dự án

Trong kỷ nguyên bùng nổ của các nền tảng truyền thông số và dịch vụ phát video trực tuyến (Over-The-Top - OTT), số lượng nội dung giải trí được phát hành trên toàn cầu gia tăng theo cấp số nhân. Thống kê từ ngành công nghiệp điện ảnh cho thấy mỗi năm có khoảng 2.500 đến 3.000 bộ phim điện ảnh cùng hàng nghìn tập phim truyền hình (TV Series) được sản xuất và phân phối trên toàn thế giới. Sự phong phú này dẫn đến hiện tượng quá tải thông tin (information overload), khiến người dùng mất trung bình từ 15 đến 20 phút mỗi phiên duyệt tìm để lựa chọn được nội dung ưng ý, làm suy giảm đáng kể chỉ số trải nghiệm người dùng (User Experience - UX) và tỷ lệ giữ chân khách hàng (Customer Retention Rate).

+-------------------------------------------------------------------------------+
|                           KIẾN TRÚC TỔNG THỂ MOONFLIX                         |
+-------------------------------------------------------------------------------+
|  CLIENT TIER (React Native 0.71.8 / React.js Web Client)                      |
|    - User Authentication (JWT)    - Interactive Rating & Review Engine        |
|    - Dynamic Browse & Search      - Personalized Watchlist & Realtime Rails   |
+-------------------------------------------------------------------------------+
                                      | HTTP/REST & JSON API
                                      v
+-------------------------------------------------------------------------------+
|  SERVER & ML TIER (Node.js 18.16.0 LTS / Python 3.9.16 Fast Engine)          |
|    - RESTful Controller           - Demographic Filtering Engine (IMDB WR)    |
|    - User/Session Service         - Content-Based Engine (TF-IDF/Cosine Sim)  |
|    - Watchlist & Log Controller   - Collaborative Filtering Engine (Pearson)  |
+-------------------------------------------------------------------------------+
                                      | Database Drivers & In-Memory Bus
                                      v
+-------------------------------------------------------------------------------+
|  DATA & PERSISTENCE TIER                                                      |
|    - MongoDB 6.0.5 (NoSQL Store: Users, Movies Metadata, User Logs, Reviews)  |
|    - In-Memory Matrix Cache (Pre-computed Cosine & Similarity Sparse Matrices)|
+-------------------------------------------------------------------------------+

Trước thách thức đó, đồ án tốt nghiệp đại học "Áp dụng thuật toán gợi ý vào xây dựng ứng dụng đề xuất phim" được thực hiện bởi sinh viên Phạm Việt Hoàng (Lớp Điện tử 02 – K63, Trường Điện – Điện tử, Đại học Bách Khoa Hà Nội), dưới sự hướng dẫn khoa học của TS. Nguyễn Xuân Dũng và PGS. Trần Quang Vinh tại phòng nghiên cứu SANSLAB (Smart Applications and Network System Laboratory). Đề tài tập trung giải quyết bài toán cốt lõi: tự động hóa quá trình cá nhân hóa trải nghiệm giải trí thông qua các giải thuật đề xuất thông minh và triển khai vào một nền tảng thực tế mang tên Moonflix.

Mục tiêu nghiên cứu cụ thể

  1. Nghiên cứu lý thuyết nền tảng: Phân tích chuyên sâu các mô hình Hệ thống Gợi ý (Recommender System - RS), bao gồm Lọc cộng tác (Collaborative Filtering - CF), Lọc dựa trên nội dung (Content-Based Filtering - CBF), và Lọc nhân khẩu học (Demographic Filtering - DF).
  2. Khai phá và chuẩn hóa dữ liệu: Xây dựng quy trình thu thập dữ liệu tự động (data scraping) qua TMDB API v3, kết hợp tiền xử lý và trích xuất thuộc tính trên các tập dữ liệu chuẩn mực (MovieLens 100k, EachMovie).
  3. Mô hình hóa và tối ưu giải thuật: Triển khai các thuật toán đo lường độ tương đồng (Pearson Correlation Coefficient, Cosine Similarity, TF-IDF Vectorization) kết hợp công thức xếp hạng trọng số (IMDB Weighted Rating), tối ưu hóa các hàm mất mát để hạ thấp sai số dự đoán.
  4. Xây dựng ứng dụng hoàn chỉnh: Thiết kế và phát triển nền tảng web/app trực tuyến "Moonflix" với kiến trúc phân tầng, tích hợp trọn vẹn engine gợi ý vào hệ thống người dùng thực.

Phương pháp tiếp cận và phạm vi nghiên cứu

Đồ án áp dụng giải pháp lai ghép (Hybrid Recommendation Approach) kết hợp giữa Lọc nhân khẩu học (để giải quyết vấn đề bài toán người dùng mới / vật phẩm mới - Cold-Start Problem) và Lọc dựa trên nội dung sử dụng độ đo tương đồng Cosine trên không gian vector hóa đa chiều (Metadata Soup gồm dàn diễn viên, đạo diễn, từ khóa và tóm tắt kịch bản). Hệ thống được kiểm thử định lượng trên bộ dữ liệu chuẩn MovieLens 100k và dữ liệu thực tế thu thập từ The Movie Database (TMDB).

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

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

Hệ thống gợi ý hiện đại được phân thành ba nhánh tiếp cận chính: Lọc cộng tác, Lọc theo nội dung, và Lọc dựa trên cơ sở tri thức (Knowledge-Based). Bảng so sánh dưới đây làm rõ ưu và nhược điểm của từng phương pháp:

Tiêu chí Lọc cộng tác (Collaborative Filtering) Lọc theo nội dung (Content-Based Filtering) Lọc trên cơ sở tri thức (Knowledge-Based)
Bản chất hoạt động Tương quan Người - Người (People-to-People) Tương quan Vật phẩm - Vật phẩm (Item-to-Item) Ánh xạ suy diễn yêu cầu tường minh
Phụ thuộc tri thức miền Không cần mô tả thuộc tính chi tiết Yêu cầu trích xuất đặc trưng thuộc tính Cần xây dựng luật/ontology miền phức tạp
Vấn đề Cold Start Nghiêm trọng khi User/Item chưa có rating Tốt với Item mới, vẫn hạn chế với User mới Không bị ảnh hưởng bởi dữ liệu lịch sử
Độ đa dạng (Serendipity) Rất cao (khám phá sở thích tiềm ẩn) Thấp (bị giới hạn trong vòng lặp nội dung cũ) Phụ thuộc hoàn toàn vào cấu hình luật
Độ phức tạp tính toán $\mathcal{O}(m \cdot n)$ đến $\mathcal{O}(m^2)$ $\mathcal{O}(n \cdot d)$ ($d$: số chiều vector đặc trưng) $\mathcal{O}(k)$ ($k$: số lượng luật suy diễn)

Ma trận ưu tiên yêu cầu chức năng (Phương pháp MoSCoW)

  • Must have (Bắt buộc có): Xác thực tài khoản (JWT); Khám phá phim thịnh hành (Demographic Filtering); Gợi ý phim liên quan theo thời gian thực (Cosine Similarity trên Metadata Soup); Xem chi tiết phim, danh sách diễn viên, đạo diễn; Tìm kiếm theo tiêu đề.
  • Should have (Nên có): Hệ thống đánh giá/bình luận điểm sao; Danh sách phim yêu thích cá nhân (Favorite Watchlist); Lọc phim theo thể loại kết hợp điểm đánh giá trung bình.
  • Could have (Có thể có): Lọc cộng tác đa tầng dựa trên phân rã ma trận (Matrix Factorization - SVD); Tự động điều chỉnh trọng số gợi ý theo lịch sử duyệt.
  • Won't have (Chưa triển khai trong giai đoạn này): Tính năng Streaming video trực tiếp P2P; Hệ thống gợi ý ngữ cảnh theo thời gian thực dựa trên sóng não/thiết bị IoT.

Thiết kế hệ thống

Hệ thống Moonflix được thiết kế theo mô hình kiến trúc ba tầng (3-Tier Architecture), đảm bảo tính module hóa và khả năng mở rộng độc lập:

  1. Client Tier (Giao diện người dùng): Ứng dụng xây dựng trên nền tảng React Native / React.js, tối ưu hóa hiển thị đa thiết bị (Web & Mobile), quản lý trạng thái tập trung với Redux Toolkit.
  2. Application & Engine Tier (Xử lý nghiệp vụ & Gợi ý): Backend RESTful API xây dựng bằng Node.js (Express) kết hợp module tính toán ma trận khoa học viết bằng Python 3.9 (Scipy, Scikit-learn, Pandas).
  3. Data Tier (Lưu trữ và Truy vấn): Cơ sở dữ liệu NoSQL MongoDB 6.0 lưu trữ thông tin người dùng, lịch sử đánh giá, siêu dữ liệu phim và hệ thống lưu trữ đệm in-memory cho các ma trận tương đồng đã tiền tính toán.
+-----------------------------------------------------------------------------------+
|                           METADATA SOUP VECTORIZATION PIPELINE                    |
+-----------------------------------------------------------------------------------+
|  Raw Movie Features (TMDB Data Source):                                           |
|    - Cast (Top 3 Actors)       - Director (Key Person)                            |
|    - Genres (Action, Sci-Fi)   - Overview (Plot Text Summary)                     |
+-----------------------------------------------------------------------------------+
                                         |
                                         v
|  Text Preprocessing & Normalization:                                              |
|    - Lowercase conversion      - Remove spaces ("Christopher Nolan" -> "cnolan")  |
|    - Stopwords filtering       - Token concatenation into a single document       |
+-----------------------------------------------------------------------------------+
                                         |
                                         v
|  Feature Extraction Engine:                                                       |
|    - CountVectorizer / TF-IDF Vectorizer (ngram_range=(1, 2), max_features=5000)  |
|    - Generates Sparse Feature Matrix: Size (N_movies x 5000)                      |
+-----------------------------------------------------------------------------------+
                                         |
                                         v
|  Cosine Similarity Computation:                                                   |
|    - CosineSim(A, B) = (A . B) / (||A|| * ||B||)                                  |
|    - Yields Dense/Sparse Similarity Matrix (N_movies x N_movies)                  |
+-----------------------------------------------------------------------------------+

Technology Stack và phiên bản chi tiết

  • Python: 3.9.16 (Numpy 1.24.2, Pandas 1.5.3, Scikit-learn 1.2.2, Scipy 1.10.1)
  • Database: MongoDB Community Server 6.0.5, Mongoose ODM 7.0.3
  • Web Frontend: React Native 0.71.8 / React 18.2.0, TailwindCSS 3.3.0, Axios 1.3.4
  • Runtime & Tooling: Node.js 18.16.0 LTS, PyCharm Professional 2022.3, Git 2.39.2

Thiết kế cấu trúc dữ liệu chính (MongoDB Schema)

// User Schema Interface
interface IUser {
  _id: ObjectId;
  username: string;
  email: string;
  passwordHash: string;
  favoriteList: Array<number>; // Mảng chứa TMDB Movie IDs
  createdAt: Date;
}

// Movie Interaction Schema Interface
interface IRating {
  _id: ObjectId;
  userId: ObjectId;
  movieId: number; // TMDB Movie ID
  rating: number;  // Thang điểm từ 1.0 đến 5.0 (hoặc 1.0 đến 10.0)
  reviewText?: string;
  timestamp: Date;
}

Đặc tả API Endpoints chính

Phương thức Endpoint Chức năng Tham số / Payload Mã phản hồi
POST /api/v1/auth/login Xác thực đăng nhập người dùng { email, password } 200 OK, 401 Unauthorized
GET /api/v1/movies/trending Lấy danh sách phim thịnh hành (DF) ?page=1&limit=20 200 OK
GET /api/v1/movies/:id/similar Đề xuất top $N$ phim tương đồng id (Movie ID), ?top=10 200 OK, 404 Not Found
POST /api/v1/movies/:id/rate Gửi đánh giá sao của người dùng { rating, reviewText } 201 Created, 400 Bad Request
GET /api/v1/user/favorites Truy vấn danh sách yêu thích Header: Bearer <JWT_TOKEN> 200 OK, 403 Forbidden

Methodology

Đồ án được triển khai theo mô hình linh hoạt Agile/Scrum rút gọn kéo dài trong 16 tuần, chia thành 4 Sprint chính:

  • Sprint 1 (Tuần 1 - 4): Nghiên cứu tổng quan lý thuyết, khảo sát các bộ dữ liệu MovieLens 100k, EachMovie; thiết lập môi trường lập trình Python, PyCharm, MongoDB.
  • Sprint 2 (Tuần 5 - 8): Xây dựng module tự động hóa Data Scraper trên TMDB API v3; thực hiện tiền xử lý, làm sạch và chuẩn hóa dữ liệu Text/Ratings.
  • Sprint 3 (Tuần 9 - 12): Lập trình và thử nghiệm các mô hình toán học (Demographic Filtering, Cosine Similarity trên TF-IDF, User/Item-based Pearson CF); đánh giá sai số MAE/RMSE.
  • Sprint 4 (Tuần 13 - 16): Xây dựng ứng dụng web/app Moonflix bằng React Native & Node.js; tích hợp API gợi ý; tiến hành kiểm thử UAT và hoàn thiện tài liệu.
+-----------------------------------------------------------------------------------+
|                        PROJECT SPRINT TIMELINE & MILESTONES                       |
+-----------------------------------------------------------------------------------+
| Sprint 1 [W1-W4]   : Literature Review & Benchmark Environment Setup              |
|                      Deliverable: Theoretical spec + Baseline datasets            |
|                                                                                   |
| Sprint 2 [W5-W8]   : TMDB Data Scraping & Pipeline Cleaning                       |
|                      Deliverable: Normalized Movie Database & Metadata            |
|                                                                                   |
| Sprint 3 [W9-W12]  : Recommender Algorithms Modeling & Offline Evaluation         |
|                      Deliverable: Trained Engines (RMSE/MAE Evaluation)           |
|                                                                                   |
| Sprint 4 [W13-W16] : Moonflix Fullstack Integration & UAT Deployment              |
|                      Deliverable: Working Application + Production Thesis         |
+-----------------------------------------------------------------------------------+

Implementation và kết quả

Development process & Core Algorithms

1. Demographic Filtering (Lọc nhân khẩu học / Xếp hạng trọng số)

Để giải quyết bài toán gợi ý phim đại chúng cho người dùng mới mà không bị sai lệch bởi các bộ phim có quá ít lượt đánh giá nhưng điểm số tuyệt đối, đồ án áp dụng công thức xếp hạng trọng số của IMDB (Weighted Rating - WR):

$$WR = \left( \frac{v}{v + m} \right) \cdot R + \left( \frac{m}{v + m} \right) \cdot C$$

Trong đó:

  • $v$: Số lượng bình chọn (vote count) của bộ phim hiện tại.
  • $m$: Ngưỡng số bình chọn tối thiểu để được xếp hạng (chọn tại phân vị 90% - 90th percentile của tập dữ liệu, tương đương $m \approx 400$).
  • $R$: Điểm đánh giá trung bình (vote average) của bộ phim hiện tại.
  • $C$: Điểm bình chọn trung bình của toàn bộ các bộ phim trong cơ sở dữ liệu.
import pandas as pd
import numpy as np

def compute_demographic_ranking(df: pd.DataFrame, percentile: float = 0.90) -> pd.DataFrame:
    """
    Tính toán bảng xếp hạng phim thịnh hành dựa trên công thức IMDB Weighted Rating.
    """
    C = df['vote_average'].mean()
    m = df['vote_count'].quantile(percentile)
    
    # Lọc các bộ phim thỏa mãn điều kiện số lượt đánh giá tối thiểu
    qualified_movies = df.copy().loc[df['vote_count'] >= m]
    
    def weighted_rating(x, m=m, C=C):
        v = x['vote_count']
        R = x['vote_average']
        return (v / (v + m) * R) + (m / (m + v) * C)
    
    qualified_movies['score'] = qualified_movies.apply(weighted_rating, axis=1)
    qualified_movies = qualified_movies.sort_values('score', ascending=False)
    return qualified_movies[['id', 'title', 'vote_count', 'vote_average', 'score']]

2. Content-Based Filtering với Cosine Similarity và Metadata Soup

Giải thuật trích xuất thông tin đa chiều từ tập dữ liệu bao gồm: 3 diễn viên chính (cast), đạo diễn (director), các thể loại (genres), và từ khóa tóm tắt (keywords). Sau khi làm sạch chuỗi (chuyển chữ thường, xóa khoảng trắng giữa các danh từ riêng như "Christopher Nolan" thành "christophernolan" để tránh nhầm lẫn), các trường được ghép thành một chuỗi đại diện duy nhất gọi là metadata_soup.

Độ tương đồng góc Cosine giữa hai vector đặc trưng $\mathbf{A}$ và $\mathbf{B}$ được xác định bởi:

$$\text{CosineSim}(\mathbf{A}, \mathbf{B}) = \frac{\mathbf{A} \cdot \mathbf{B}}{|\mathbf{A}|2 |\mathbf{B}|2} = \frac{\sum{i=1}^{n} A_i B_i}{\sqrt{\sum{i=1}^{n} A_i^2} \sqrt{\sum_{i=1}^{n} B_i^2}}$$

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity

def build_content_based_matrix(df: pd.DataFrame):
    """
    Xây dựng ma trận tương đồng Cosine từ Metadata Soup của các bộ phim.
    """
    # Khởi tạo CountVectorizer loại bỏ stop words tiếng Anh
    count_vec = CountVectorizer(stop_words='english')
    count_matrix = count_vec.fit_transform(df['metadata_soup'])
    
    # Tính ma trận tương đồng kích thước (N_movies x N_movies)
    cosine_sim = cosine_similarity(count_matrix, count_matrix)
    indices = pd.Series(df.index, index=df['title']).drop_duplicates()
    return cosine_sim, indices

def get_content_recommendations(title: str, cosine_sim, indices, df: pd.DataFrame, top_n: int = 10):
    """
    Truy xuất Top N bộ phim có độ tương đồng nội dung cao nhất với phim đầu vào.
    """
    if title not in indices:
        return []
    idx = indices[title]
    sim_scores = list(enumerate(cosine_sim[idx]))
    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
    sim_scores = sim_scores[1:top_n + 1] # Loại bỏ chính phim đang xét (ở vị trí index 0)
    movie_indices = [i[0] for i in sim_scores]
    return df['title'].iloc[movie_indices].tolist()

3. Collaborative Filtering qua Hệ số tương quan Pearson

Để dự đoán mức độ đánh giá $\hat{r}_{uj}$ của người dùng $u$ cho phim $j$, hệ thống áp dụng kỹ thuật chuẩn hóa trừ đi điểm trung bình $\mu_u$ của người dùng đó nhằm loại bỏ thiên kiến khó tính/dễ tính:

$$\text{Sim}(u, v) = \frac{\sum_{k \in I_u \cap I_v} (r_{uk} - \mu_u)(r_{vk} - \mu_v)}{\sqrt{\sum_{k \in I_u \cap I_v} (r_{uk} - \mu_u)^2} \sqrt{\sum_{k \in I_u \cap I_v} (r_{vk} - \mu_v)^2}}$$

Dự đoán điểm số được ngoại suy dựa trên $K$ láng giềng gần nhất ($P_u(j)$):

$$\hat{r}{uj} = \mu_u + \frac{\sum{v \in P_u(j)} \text{Sim}(u, v) \cdot (r_{vj} - \mu_v)}{\sum_{v \in P_u(j)} |\text{Sim}(u, v)|}$$

Testing và validation

Hiệu năng của các mô hình gợi ý được đo lường thông qua hai chỉ số độ lỗi quy chuẩn trong học máy: Sai số tuyệt đối trung bình (Mean Absolute Error - MAE) và Căn bậc hai của sai số bình phương trung bình (Root Mean Squared Error - RMSE):

$$\text{MAE} = \frac{1}{|D_{test}|} \sum_{(u, i) \in D_{test}} |r_{ui} - \hat{r}_{ui}|$$

$$\text{RMSE} = \sqrt{\frac{1}{|D_{test}|} \sum_{(u, i) \in D_{test}} (r_{ui} - \hat{r}_{ui})^2}$$

Bảng tổng hợp thực nghiệm sai số trên các tập dữ liệu

Bộ dữ liệu thử nghiệm Thuật toán triển khai Số lượng User / Item MAE RMSE Thời gian huấn luyện (s)
MovieLens 100k User-Based CF (Pearson) 943 Users / 1.682 Items 0.732 0.934 4.82s
MovieLens 100k Item-Based CF (Cosine) 943 Users / 1.682 Items 0.718 0.912 3.45s
EachMovie User-Based CF (Pearson) 2.811 Users / 1.628 Items 0.814 1.042 18.60s
EachMovie Matrix Factorization (ALS) 2.811 Users / 1.628 Items 0.695 0.887 12.15s
TMDB 5000 Scraped Content-Based (Soup+Cosine) 4.803 Items N/A (Top-10 Precision: 88.4%) N/A 1.85s (Inference < 15ms)

Kết quả đạt được

  1. Khả năng gợi ý chính xác: Kết quả thực nghiệm đối với các phim kinh điển như Dead Poets Society (ID: 2453) hay The Dark Knight Rises trả về danh sách các tác phẩm có tương quan cao nhất về mặt thể loại, phong cách đạo diễn và dàn diễn viên chính xác lên đến 88.4% theo đánh giá chủ quan của tập người dùng thử nghiệm.
  2. Hiệu năng hệ thống Moonflix:
    • Tốc độ phản hồi API trung bình: $118\text{ ms}$ trên các truy vấn danh sách đề xuất.
    • Điểm đánh giá mức độ hài lòng người dùng (System Usability Scale - SUS): $84.5 / 100$ điểm.
    • Giao diện người dùng trên nền tảng web phản hồi mượt mà, hỗ trợ đầy đủ các tính năng: đăng nhập, xem danh sách xu hướng, xem phim tương tự, đánh giá và lưu trữ mục yêu thích.

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

  1. Cải tiến vector hóa "Metadata Soup" thay vì chỉ dựa vào Overview: Các nghiên cứu truyền thống thường chỉ tính toán TF-IDF trên trường tóm tắt phim (overview), dẫn đến sai lệch khi hai phim có chung cốt truyện nhưng phong cách làm phim hoàn toàn khác nhau. Việc tổng hợp có trọng số giữa diễn viên (lấy top 3), đạo diễn (lặp lại trọng số 2 lần để tăng cường mức ảnh hưởng) và thể loại giúp độ chính xác của Content-Based Filtering tăng $31.2%$ so với chỉ sử dụng phân tích văn bản đơn thuần.
  2. Giải pháp khắc phục hiện tượng "Cold Start" hiệu quả: Kết hợp chuyển đổi mượt mà (seamless transition) giữa mô hình Lọc nhân khẩu học IMDB Weighted Rating cho người dùng mới và chuyển dần sang Content-Based/Collaborative Filtering khi người dùng bắt đầu có từ 3 tương tác đánh giá trở lên.
  3. Mô hình kiến trúc ứng dụng trọn gói (End-to-End Practical System): Không dừng lại ở việc mô phỏng thuật toán trong Jupyter Notebook, đồ án đã chuyển hóa hoàn toàn mô hình toán học thành các API RESTful chạy thực tế, lưu trữ trên MongoDB và phục vụ giao diện trực quan cho người dùng.

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

Kịch bản ứng dụng trong thực tiễn

  • Tích hợp vào các nền tảng phát video trực tuyến (OTT): Cung cấp các hàng phim cá nhân hóa (Personalized Rails) như "Phim tương tự phim bạn vừa xem", "Top 10 phim thịnh hành hôm nay".
  • Hệ thống thương mại điện tử và bán lẻ: Áp dụng nguyên lý Metadata Soup và lọc cộng tác Pearson cho các bài toán gợi ý sản phẩm bán kèm (Cross-selling).

Hướng dẫn triển khai hệ thống (Deployment Guide)

# 1. Khởi tạo môi trường Backend và Database
git clone https://github.com/phamviethoang/moonflix-recommender.git
cd moonflix-recommender

# Cấu hình biến môi trường
echo "PORT=5000\nMONGO_URI=mongodb://localhost:27017/moonflix\nJWT_SECRET=secretKey123" > .env

# Cài đặt thư viện Python Engine
cd python_engine
pip install -r requirements.txt
python precompute_matrices.py  # Tạo ma trận cosine_sim.pkl và demographic_cache.json

# Cài đặt và khởi chạy Node.js Server
cd ../server
npm install
npm run start:prod

# Khởi chạy giao diện React Native / Web Client
cd ../client
npm install
npm run web

Phân tích chi phí và hiệu quả đầu tư (Cost-Benefit Analysis & ROI)

  • Chi phí hạ tầng tối thiểu: 01 máy chủ ảo Cloud VPS (2 vCPU, 4GB RAM, SSD 40GB) trị giá khoảng $$15 - $20/\text{tháng}$ đủ khả năng phục vụ $5.000$ người dùng hoạt động hàng ngày (Daily Active Users - DAU) nhờ cơ chế tiền tính toán (pre-computation) và lưu đệm ma trận tương đồng.
  • Hiệu quả kinh tế (ROI): Giảm thiểu $45%$ tỷ lệ người dùng thoát trang do không tìm thấy nội dung phù hợp, nâng cao thời gian lưu lại trên nền tảng (Time-on-Site) thêm trung bình $28%$.

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

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

  • Độ thưa của ma trận (Matrix Sparsity): Khi số lượng phim và người dùng tăng lên hàng chục nghìn, ma trận ratings có độ thưa trên $99%$, làm suy giảm hiệu năng của phương pháp lọc cộng tác User-Based truyền thống.
  • Tính toán tĩnh: Ma trận tương đồng Cosine hiện tại được tính toán ngoại tuyến (offline batch processing), chưa tự động cập nhật theo thời gian thực (real-time streaming update) ngay khi người dùng bấm thích một bộ phim mới.

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

  1. Ứng dụng Học sâu (Deep Learning): Tích hợp mạng nơ-ron lọc cộng tác (Neural Collaborative Filtering - NCF), Autoencoders và Graph Convolutional Networks (GCN) để học các biểu diễn nhúng tiềm ẩn (Latent Embeddings) phi tuyến tính.
  2. Mô hình Ngôn ngữ lớn (LLM-based Recommendation): Tận dụng các mô hình ngôn ngữ lớn (BERT/GPT) để trích xuất ngữ nghĩa sâu sắc hơn từ kịch bản và nhận xét chi tiết của người dùng.
  3. Mở rộng microservices: Đóng gói engine gợi ý thành các Docker container độc lập, triển khai điều phối trên Kubernetes để tự động co giãn theo tải lượng truy cập.

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

  • Sinh viên và Học viên nghiên cứu: Tiếp cận mã nguồn mẫu chuẩn mực, hiểu rõ cách thức chuyển đổi từ công thức toán học (Pearson, Cosine, Weighted Rating) sang mã nguồn Python/Node.js thực tế.
  • Kỹ sư phần mềm & Data Scientist: Cung cấp mô hình kiến trúc tham chiếu (Reference Architecture) kết hợp giữa React Native, Express API, MongoDB và Python Recommender Engine.
  • Doanh nghiệp vừa và nhỏ (SMEs) / Đơn vị truyền thông: Sở hữu giải pháp mã nguồn mở có chi phí triển khai thấp để tích hợp tính năng gợi ý thông minh vào sản phẩm số của mình mà không phụ thuộc vào các dịch vụ SaaS đắt đỏ.

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

1. Yêu cầu phần cứng tối thiểu để triển khai hệ thống Moonflix là gì?

Hệ thống yêu cầu máy chủ chạy hệ điều hành Linux (Ubuntu 20.04/22.04 LTS), cấu hình tối thiểu 2 vCPU, 4GB RAM và 20GB dung lượng ổ cứng khả dụng để vận hành trơn tru toàn bộ cụm dịch vụ MongoDB, Node.js API và in-memory vector matrices.

2. Hệ thống giải quyết 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ý và chưa có lịch sử tương tác, Moonflix kích hoạt cơ chế Demographic Filtering dựa trên công thức IMDB Weighted Rating để đề xuất danh sách các bộ phim thịnh hành có điểm đánh giá cao nhất toàn cầu. Khi người dùng bắt đầu xem hoặc đánh giá phim, hệ thống sẽ chuyển dần sang Lọc theo nội dung (Content-Based) và Lọc cộng tác (Collaborative Filtering).

3. Có thể tích hợp engine này vào các hệ thống quản trị nội dung (CMS) khác không?

Hoàn toàn có thể. Backend của Moonflix cung cấp chuẩn giao tiếp RESTful API tiêu chuẩn định dạng JSON, cho phép bất kỳ hệ thống CMS nào (như WordPress, Strapi) hoặc ứng dụng bên thứ ba dễ dàng gọi truy vấn để lấy dữ liệu gợi ý.

4. Chi phí vận hành và bảo trì hàng tháng ước tính là bao nhiêu?

Với quy mô thử nghiệm và doanh nghiệp nhỏ dưới 10.000 người dùng, chi phí duy trì chỉ bao gồm phí thuê máy chủ Cloud VPS khoảng $15 - $30 USD/tháng. Module pre-compute chạy định kỳ vào ban đêm tốn rất ít tài nguyên tính toán.

5. Cần bao lâu để hệ thống cập nhật danh sách phim mới?

Hệ thống tích hợp sẵn script tự động cào dữ liệu qua TMDB API v3. Script này có thể được cấu hình chạy định kỳ qua Cron Job (ví dụ: mỗi tuần một lần) để cập nhật các phim mới ra mắt vào cơ sở dữ liệu và tái tính toán ma trận tương đồng trong chưa đầy 5 phút.

Kết luận

Đồ án tốt nghiệp "Áp dụng thuật toán gợi ý vào xây dựng ứng dụng đề xuất phim" của sinh viên Phạm Việt Hoàng đã hoàn thành xuất sắc các mục tiêu nghiên cứu lý thuyết và thực nghiệm ứng dụng. Bằng việc kết hợp chặt chẽ giữa cơ sở toán học vững chắc (Hệ số tương quan Pearson, Độ đo tương đồng Cosine, Xếp hạng trọng số IMDB) và kỹ thuật lập trình hiện đại (React Native, Node.js, MongoDB, Python), đề tài đã xây dựng thành công nền tảng xem phim Moonflix có khả năng cá nhân hóa trải nghiệm người dùng với độ chính xác cao (RMSE đạt mức 0.912 trên MovieLens 100k) và thời gian đáp ứng nhanh chóng. Đây là tài liệu tham khảo có giá trị cao cả về mặt học thuật lẫn kỹ thuật triển khai thực tế cho cộng đồng nghiên cứu và phát triển phần mềm trong lĩnh vực Hệ thống Gợi ý.