Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và sự bùng nổ của ngành công nghiệp giải trí đa phương tiện, các cụm rạp chiếu phim hiện đại đang đối mặt với thách thức lớn về bài toán tối ưu hóa trải nghiệm khách hàng. Thống kê từ ngành công nghiệp điện ảnh cho thấy có tới hơn 68% khán giả mất từ 10 đến 15 phút để lựa chọn một bộ phim phù hợp khi truy cập các nền tảng bán vé trực tuyến. Tình trạng quá tải thông tin (Information Overload) dẫn đến hiện tượng suy giảm tỷ lệ chuyển đổi đặt vé (Booking Conversion Rate) và làm giảm mức độ hài lòng của người dùng.

Hầu hết các hệ thống bán vé rạp chiếu phim truyền thống hiện nay chỉ cung cấp danh sách phim tĩnh dựa trên bảng xếp hạng doanh thu phòng vé hoặc thời gian phát hành. Cách tiếp cận này hoàn toàn thiếu tính cá nhân hóa (Personalization), không tận dụng được dữ liệu hành vi, lịch sử đánh giá và sở thích riêng biệt của từng khách hàng. Điều này tạo ra rào cản lớn trong việc gia tăng tỷ lệ lấp đầy ghế trống (Seat Occupancy Rate), đặc biệt là vào các khung giờ thấp điểm và đối với các tựa phim độc lập hoặc phim mới phát hành.

Đồ án chuyên ngành "Xây dựng hệ thống khuyến nghị cho rạp chiếu phim" do sinh viên Nguyễn Cao Triều thực hiện dưới sự hướng dẫn của thầy Lê Văn Hạnh tại Khoa Công nghệ - Kỹ thuật, Trường Đại học Quốc tế Hồng Bàng (10/2024), được triển khai nhằm giải quyết triệt để bài toán trên.

Mục tiêu cụ thể của dự án được xác định rõ ràng:

  1. Nghiên cứu và triển khai thuật toán học máy chuyên sâu: Hiện thực hóa mô hình Lọc cộng tác dựa trên người dùng (User-based Collaborative Filtering - UCF) sử dụng Hệ số tương quan Pearson (Pearson Correlation - PC) kết hợp Trọng số đánh giá (Weighted Rating - WR).
  2. Xây dựng mô hình Lọc dựa trên nội dung (Content-Based Filtering - CBF): Khai thác vector hóa đặc trưng thể loại và mô tả phim thông qua kỹ thuật Term Frequency-Inverse Document Frequency (TF-IDF) và tính toán khoảng cách vector bằng Độ tương đồng Cosine (Cosine Similarity - CS).
  3. Phát triển mô hình khuyến nghị kết hợp (Hybrid Collaborative Filtering - HCF): Tích hợp linh hoạt kết quả từ UCF và CBF theo cơ chế trọng số $\alpha$, triệt tiêu nhược điểm khởi đầu lạnh (Cold-Start Problem) và ma trận thưa (Data Sparsity).
  4. Kiến trúc hệ thống Microservices phân tán: Tách biệt module nghiệp vụ backend điều phối (Java Spring Boot), module tính toán trí tuệ nhân tạo (Python Flask), cơ sở dữ liệu quan hệ (MySQL 8.0) và giao diện người dùng tương tác động (React.js).
  5. Đo lường và đánh giá hiệu năng: Đảm bảo độ trễ phản hồi API gợi ý dưới 200ms và cung cấp danh sách Top-N gợi ý phim chính xác theo thời gian thực.

Phạm vi của đề tài tập trung vào việc mô hình hóa dữ liệu người dùng, phim ảnh, lịch chiếu và giao dịch đặt vé tại rạp; thử nghiệm đánh giá thuật toán trên tập dữ liệu đa chiều; và hoàn thiện ứng dụng web full-stack có khả năng tích hợp trực tiếp vào hạ tầng bán vé của các cụm rạp. Giới hạn của phiên bản hiện tại là chưa tích hợp xử lý luồng dữ liệu thời gian thực quy mô lớn (Stream Processing) và chưa khai thác dữ liệu phi cấu trúc phức tạp như phân tích cảm xúc từ bình luận văn bản (Sentiment Analysis).

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

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

Khảo sát các giải pháp đề xuất nội dung và bán vé hiện có trên thị trường cho thấy sự phân hóa rõ rệt giữa các nền tảng streaming trực tuyến (như Netflix, HBO Max) và các hệ thống rạp chiếu phim truyền thống (CGV, Lotte Cinema, BHD Star).

Tiêu chí so sánh Hệ thống Rạp truyền thống (Rule-based) Nền tảng Streaming (Pure Collaborative Filtering) Giải pháp Đề xuất trong Đồ án (Hybrid Recommendation Engine)
Cơ chế gợi ý Thủ công theo doanh thu / Phim Hot Dựa trên ma trận tương đồng người dùng / mục Kết hợp lọc cộng tác (UCF) và lọc nội dung (CBF)
Xử lý Cold-Start Không hỗ trợ Rất kém khi thiếu dữ liệu tương tác Tốt nhờ phân tích metadata thể loại qua TF-IDF
Độ cá nhân hóa 0% (Hiển thị giống nhau cho mọi user) Cao nhưng dễ rơi vào hiện tượng bong bóng lọc Rất cao, cân bằng giữa sở thích cá nhân và cộng đồng
Khả năng tích hợp Gắn liền trong monolith CRM/ERP Độc lập, phức tạp Module Microservice Flask REST API linh hoạt
Chi phí tính toán Thấp Rất cao khi ma trận người dùng bùng nổ Tối ưu hóa phân tán giữa Spring Boot và Python Engine

Yêu cầu người dùng và hệ thống được chuẩn hóa theo mô hình MoSCoW:

  • Must have: Hệ thống xác thực người dùng JWT; module quản lý phim, rạp, suất chiếu; module tính toán tương quan Pearson; vector hóa TF-IDF và Cosine Similarity; luồng đặt vé và lưu vết lịch sử tương tác (user_history).
  • Should have: Khả năng tinh chỉnh tham số trọng số kết hợp $\alpha$; giao diện quản trị Admin trực quan; hệ thống đánh giá xếp hạng 1-5 sao.
  • Could have: Module bình luận phim đa cấp; banner quảng cáo động theo sở thích người dùng.
  • Won't have (trong giai đoạn này): Cổng thanh toán quốc tế đa kênh thời gian thực; khuyến nghị đa rạp dựa trên vị trí GPS thời gian thực.

Thiết kế hệ thống

Kiến trúc giải pháp được thiết kế theo mô hình Microservices phân lớp, tách biệt hoàn toàn giữa tầng hiển thị giao diện, tầng xử lý nghiệp vụ trung gian và tầng tính toán AI chuyên sâu.

+-----------------------------------------------------------------------+
|                    CLIENT LAYER (React.js / Axios)                    |
|           Single Page Application - Component-Based UI/UX             |
+-----------------------------------------------------------------------+
+-----------------------------------------------------------------------+
|                 API GATEWAY & BACKEND (Java Spring Boot)              |
|   - Controllers: User, Movie, Showtime, Order, Feedback               |
|   - Services: Business Logic, Security (JWT), Data Orchestrator       |
|   - Repositories: Spring Data JPA / Hibernate Connection Pool         |
+-----------------------------------------------------------------------+
   SQL Queries (JDBC)                           HTTP Request (JSON)
+-------------------------+             +-------------------------------+
|  DATABASE (MySQL 8.0)   |             |  AI RECOMMENDATION ENGINE     |
| - users, movies, orders |             |  (Python Flask Microservice)  |
| - user_history, comment |  Data Sync  |  - Content-based (TF-IDF)     |
| - banner_phim, tbnews   |             |  - Hybrid Scorer (Alpha Blend)|
+-------------------------+             +-------------------------------+

Technology Stack chi tiết:

  • Frontend: React.js 18.2, React Router DOM, Axios, HTML5/CSS3/Bootstrap.
  • Backend Service: Java OpenJDK 17, Spring Boot 3.x, Spring Data JPA, Spring Security, Hibernate ORM.
  • AI Recommendation Engine: Python 3.10, Flask 3.0, Pandas, NumPy, Scikit-learn.
  • Database Engine: MySQL Server 8.0 Community Edition, MySQL Workbench.
  • Development Tools: IntelliJ IDEA Ultimate, Visual Studio Code, Postman API Platform.

Mô hình Cơ sở Dữ liệu Thực thể (EER Schema): Hệ thống quản lý dữ liệu thông qua 11 bảng quan hệ chuẩn hóa cao:

  1. users: Quản lý thông tin định danh (id, name, email, password, role, remember_token).
  2. movies: Lưu trữ siêu dữ liệu phim (maPhim, tenPhim, theLoai, quocGia, gioiTinh, doTuoi, ngayKhoiChieu, danhGia, hot, dangChieu, sapChieu).
  3. user_history: Bảng dữ liệu tương tác phục vụ học máy (maHistory, maUser, maPhim, ratings, has_watched).
  4. showtime: Quản lý lịch chiếu (maLichChieu, ngayChieu, gioChieu, maPhim, maRap, giaVeThuong, giaVeVip).
  5. rapchieu & province: Quản lý cụm rạp và vị trí địa lý (maRap, tenRap, maTinh_id, diaChi).
  6. orderdetail: Lưu vết giao dịch vé (maOrder, userId, maPhim, maLichChieu, danhSachGhe, tongTien).
  7. tbnews, banner_phim, feedback, comment: Các thực thể mở rộng hỗ trợ truyền thông và tương tác.

Bảng đặc tả API Endpoints chính:

Phương thức Endpoint Chức năng Thành phần xử lý
POST /api/v1/auth/login Xác thực người dùng và cấp phát Token Spring Boot
GET /api/v1/movies/recommend/{userId} Lấy danh sách phim đề xuất Top-N Spring Boot $\rightarrow$ Flask API
POST /api/v1/ratings Ghi nhận lượt chấm điểm phim của User Spring Boot $\rightarrow$ MySQL
POST /recommend/hybrid Tính toán điểm số khuyến nghị lai ghép Python Flask Microservice
GET /api/v1/showtimes/movie/{id} Lấy lịch chiếu theo rạp và phim Spring Boot

Methodology

Dự án áp dụng quy trình phát triển phần mềm theo mô hình linh hoạt Agile/Scrum, phân chia lộ trình thực hiện thành 4 Sprint chính trong thời gian 12 tuần:

+--------------------+   +--------------------+   +--------------------+   +--------------------+
| SPRINT 1 (Tuần 1-3)|   | SPRINT 2 (Tuần 4-6)|   | SPRINT 3 (Tuần 7-9)|   |SPRINT 4 (Tuần 10-12|
| - Khảo sát bài toán|   | - Thiết kế MySQL DB|   | - Xây dựng React UI|   | - Tích hợp hệ thống|
| - Nghiên cứu UCF/  |-->| - Lập trình Spring |-->| - Xây dựng Flask ML|-->| - Kiểm thử E2E     |
|   CBF/Hybrid Math  |   |   Boot REST APIs   |   |   Model microservice|  | - Đánh giá độ chính|
| - Thu thập Dataset |   | - CRUD phim & vé   |   | - Pearson & TF-IDF |   |   xác & viết Báo cáo|
+--------------------+   +--------------------+   +--------------------+   +--------------------+

Chiến lược kiểm soát rủi ro tập trung vào việc xử lý rủi ro sai lệch dữ liệu (Data Inconsistency) giữa Spring Boot và Flask bằng cách chuẩn hóa định dạng JSON payload và áp dụng cơ chế Retry Pattern khi kết nối liên dịch vụ.

Implementation và kết quả

Development process

Cốt lõi của hệ thống khuyến nghị nằm ở sự kết hợp toán học giữa hai thuật toán UCF và CBF.

1. Lọc cộng tác dựa trên người dùng (User-based Collaborative Filtering)

Hệ số tương quan Pearson ($r$) giữa người dùng mục tiêu $u$ và người dùng láng giềng $v$ được xác định trên tập hợp các phim $I_{uv}$ mà cả hai cùng đánh giá:

$$r(u, v) = \frac{\sum_{i \in I_{uv}} (R_{u,i} - \bar{R}u)(R{v,i} - \bar{R}v)}{\sqrt{\sum{i \in I_{uv}} (R_{u,i} - \bar{R}u)^2} \cdot \sqrt{\sum{i \in I_{uv}} (R_{v,i} - \bar{R}_v)^2}}$$

Dự đoán điểm số cho bộ phim $i$ chưa xem của người dùng $u$ dựa trên Trọng số đánh giá (Weighted Average):

$$\text{Score}{CF}(u, i) = \frac{\sum{v \in N} r(u, v) \cdot R_{v,i}}{\sum_{v \in N} |r(u, v)|}$$

2. Lọc dựa trên nội dung (Content-Based Filtering)

Đặc trưng thể loại của từng bộ phim được mô hình hóa qua không gian vector $D$ chiều bằng TF-IDF:

$$\text{TF}(t, d) = \frac{f_{t,d}}{\sum_{t' \in d} f_{t',d}}, \quad \text{IDF}(t, D) = \log\left(\frac{|D|}{|{d \in D : t \in d}|}\right)$$

$$\text{TF-IDF}(t, d, D) = \text{TF}(t, d) \times \text{IDF}(t, D)$$

Độ tương đồng Cosine giữa vector đặc trưng phim $\vec{A}$ (phim đã thích) và $\vec{B}$ (phim ứng viên):

$$\text{Score}{CBF}(\vec{A}, \vec{B}) = \text{Cosine}(\vec{A}, \vec{B}) = \frac{\vec{A} \cdot \vec{B}}{|\vec{A}| |\vec{B}|} = \frac{\sum{k=1}^n A_k B_k}{\sqrt{\sum_{k=1}^n (A_k)^2} \sqrt{\sum_{k=1}^n (B_k)^2}}$$

3. Mô hình kết hợp lai (Hybrid Recommendation)

Điểm số tổng hợp cuối cùng để xếp hạng danh mục Top-N:

$$\text{FinalScore}(u, m) = \alpha \cdot \text{Score}{CF}(u, m) + (1 - \alpha) \cdot \text{Score}{CBF}(m)$$

Trong cấu hình thực nghiệm chuẩn của hệ thống, tham số $\alpha$ được thiết lập ở mức $0.8$.

# flask_app/recommendation_engine.py
import numpy as np
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.feature_extraction.text import TfidfVectorizer

def calculate_pearson_cf(user_id, ratings_df, target_movie_id):
    pivot_matrix = ratings_df.pivot(index='maUser', columns='maPhim', values='ratings')
    if user_id not in pivot_matrix.index:
        return 0.0
    
    target_user_ratings = pivot_matrix.loc[user_id]
    similarities = {}
    
    for other_user in pivot_matrix.index:
        if other_user != user_id:
            common_movies = target_user_ratings.dropna().index.intersection(
                pivot_matrix.loc[other_user].dropna().index
            )
            if len(common_movies) >= 2:
                u_vals = target_user_ratings[common_movies]
                v_vals = pivot_matrix.loc[other_user][common_movies]
                if np.std(u_vals) > 0 and np.std(v_vals) > 0:
                    corr = np.corrcoef(u_vals, v_vals)[0, 1]
                    if not np.isnan(corr):
                        similarities[other_user] = corr

    weighted_sum, sim_sum = 0.0, 0.0
    for other_user, sim in similarities.items():
        rating = pivot_matrix.loc[other_user, target_movie_id]
        if not np.isnan(rating) and sim > 0:
            weighted_sum += sim * rating
            sim_sum += sim

    return (weighted_sum / sim_sum) if sim_sum > 0 else 0.0

def calculate_cbf_similarity(target_movie_id, candidate_movie_id, movies_df):
    tfidf = TfidfVectorizer(token_pattern=r'(?u)\b[\w-]+\b')
    tfidf_matrix = tfidf.fit_transform(movies_df['theLoai'])
    
    idx_target = movies_df.index[movies_df['maPhim'] == target_movie_id].tolist()[0]
    idx_candidate = movies_df.index[movies_df['maPhim'] == candidate_movie_id].tolist()[0]
    
    sim = cosine_similarity(tfidf_matrix[idx_target], tfidf_matrix[idx_candidate])[0][0]
    return float(sim)

Tầng Spring Boot chịu trách nhiệm điều phối dữ liệu thông qua REST Client:

// backend/src/main/java/com/cinema/service/RecommendationService.java
package com.cinema.service;

import com.cinema.dto.RecommendationResponse;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.util.List;

@Service
public class RecommendationService {

    @Value("${flask.service.url}")
    private String flaskServiceUrl;

    private final RestTemplate restTemplate;

    public RecommendationService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public RecommendationResponse getHybridRecommendations(Long userId) {
        String targetUrl = flaskServiceUrl + "/api/recommend/hybrid?user_id=" + userId;
        return restTemplate.getForObject(targetUrl, RecommendationResponse.class);
    }
}

Testing và validation

Quá trình kiểm thử thuật toán được thực hiện thông qua tập Test Case dữ liệu mẫu chi tiết (UserId = 1, đánh giá Movie A = 5.0, Movie B = 3.0, Movie C = 2.5):

  1. Kiểm thử UCF (Pearson Correlation):

    • Tương quan giữa User 1 và User 2 (chung Movie A, B, C): $r_{1,2} \approx 0.143$.
    • Tương quan giữa User 1 và User 3 (chung Movie A, B): $r_{1,3} \approx 0.832$.
    • Tính toán dự báo điểm cho Movie D: $\text{Weighted Rating} = 4.50$.
    • Tính toán dự báo điểm cho Movie E: $\text{Weighted Rating} = 4.00$.

  2. Kiểm thử CBF (TF-IDF & Cosine Similarity):

    • Vector hóa thể loại phim (Drama, Sci-Fi, Comedy, Action...).
    • Độ tương đồng Cosine giữa Phim 1 và Phim 2 đạt $\approx 0.8502$.

  3. Kiểm thử Hybrid Integration:

    • Với trọng số kết hợp $\alpha = 0.8$: $$\text{FinalScore} = (0.8 \times 4.40) + (0.2 \times 2.60) = 3.52 + 0.52 = 4.04$$
    • Điểm số $4.04$ đưa bộ phim ứng viên vào nhóm vị trí hàng đầu của danh sách gợi ý.

Hiệu năng kỹ thuật đạt được:

  • Thời gian phản hồi trung bình của Flask Recommendation API: $118\text{ ms}$.
  • Thời gian phản hồi tổng thể End-to-End từ ReactJS qua Spring Boot đến DB: $185\text{ ms}$.
  • Tỷ lệ lỗi kết nối dịch vụ (Error Rate): $< 0.1%$ trên 500 yêu cầu đồng thời.

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

Module chức năng Trạng thái kế hoạch Kết quả hiện thực Đánh giá nghiệm thu
Xác thực & Người dùng Bắt buộc Hoàn thiện đăng ký, đăng nhập, bảo mật Session/Token Đạt 100%
Quản lý Phim & Lịch chiếu Bắt buộc Đầy đủ CRUD phim, phân loại thể loại, quản lý lịch theo rạp Đạt 100%
Engine Lọc cộng tác (UCF) Bắt buộc Hoàn thiện tính Pearson Correlation và Weighted Rating Đạt 100% (Khớp Test Case)
Engine Lọc nội dung (CBF) Bắt buộc Hoàn thiện TF-IDF vectorizer và Cosine Similarity Đạt 100%
Gợi ý tích hợp Hybrid Bắt buộc Kết hợp linh hoạt theo tham số $\alpha$, trả Top-N gợi ý Đạt 100%
Đặt vé & Lịch sử tương tác Bắt buộc Chọn ghế trực quan, lưu hóa đơn, cập nhật user_history Đạt 100%

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

  1. Cơ chế lai ghép động khắc phục Cold-Start: Khác với các hệ thống chỉ dùng thuần túy Collaborative Filtering (vốn bất khả thi khi người dùng mới chưa có lịch sử đánh giá), giải pháp trong đồ án tự động kích hoạt Content-Based Filtering qua vector TF-IDF thể loại để phục vụ người dùng mới, sau đó chuyển dần trọng số sang Lọc cộng tác khi dữ liệu tương tác tăng lên.
  2. Kiến trúc Hybrid đa ngôn ngữ hiệu năng cao: Phân tách rành mạch nhiệm vụ: Java Spring Boot xử lý I/O nặng và giao dịch cơ sở dữ liệu ACID an toàn; Python Flask đảm nhiệm tính toán ma trận và đại số tuyến tính chuyên sâu. Cách tiếp cận này giúp giảm tải hơn 40% chi phí tính toán cho máy chủ backend chính so với kiến trúc nguyên khối Monolith.
  3. Mô hình dữ liệu tương thích mở rộng: Bảng user_history được thiết kế tối giản nhưng giàu thông tin (ratings, has_watched), cho phép dễ dàng tích hợp thêm các giải pháp học máy nâng cao như Phân rã ma trận (Matrix Factorization - SVD) hoặc Mạng nơ-ron học sâu (Deep Neural Networks) trong tương lai.

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

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

Hệ thống được thiết kế để tích hợp trực tiếp vào quy trình bán vé số hóa của cụm rạp:

  • Kênh Web/Mobile App: Khi khách hàng đăng nhập, trang chủ lập tức hiển thị mục "Gợi ý dành riêng cho bạn" dựa trên kết quả tính toán của Hybrid Engine.
  • Kênh Kiosk tự phục vụ tại rạp: Đưa ra gợi ý các suất chiếu gần nhất của những bộ phim có nội dung tương đồng với phim người dùng từng xem thông qua số điện thoại hoặc mã thành viên.
                           [Python Flask Engine (TF-IDF + Pearson)]
                           [Hiển thị danh sách phim được cá nhân hóa]

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

  • Chi phí hạ tầng: Tối ưu hóa nhờ mã nguồn mở (Java, Python, React, MySQL), có thể triển khai trên cụm máy chủ ảo VPS hoặc Container Docker quy mô nhỏ với chi phí dưới $30/tháng.
  • Lợi ích kinh tế: Tăng tỷ lệ giữ chân khách hàng (Customer Retention), tăng doanh thu bán vé thêm ước tính từ $15 - 25%$ nhờ khai thác hiệu quả các tựa phim ít được quảng bá đại trà nhưng đúng "gu" của nhóm khách hàng ngách.

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

Hạn chế kỹ thuật

  • Ma trận đánh giá người dùng - phim trong môi trường thực tế sẽ ngày càng thưa (Sparsity cao), làm giảm hiệu năng của phương pháp lọc cộng tác truyền thống khi số lượng người dùng đạt mức hàng chục nghìn.
  • Thuật toán chưa đưa các biến số ngữ cảnh ngoại cảnh (Context-aware) vào mô hình tính điểm, chẳng hạn như: thời điểm trong ngày, thời tiết, đi xem một mình hay theo nhóm/gia đình.

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

  1. Nâng cấp thuật toán sang Deep Learning: Nghiên cứu ứng dụng mô hình Lọc cộng tác nơ-ron (Neural Collaborative Filtering - NCF) và Thuật toán phân rã ma trận nâng cao (SVD++ / TruncatedSVD).
  2. Xử lý ngôn ngữ tự nhiên (NLP) cho Bình luận: Tích hợp mô hình ngôn ngữ BERT để phân tích sắc thái cảm xúc từ cột comment của người dùng, tự động chuyển đổi đánh giá văn bản thành trọng số bổ trợ cho điểm Rating.
  3. Triển khai CI/CD & Container hóa: Đóng gói toàn bộ hệ thống bằng Docker Compose và điều phối tự động trên cụm Kubernetes nhằm đảm bảo khả năng mở rộng quy mô tự động (Auto-scaling).

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

  • Sinh viên & Học viên ngành CNTT/Khoa học dữ liệu: Tài liệu tham khảo toàn diện về cách kết hợp lý thuyết giải thuật học máy khuyến nghị (Pearson, TF-IDF, Cosine) vào một ứng dụng công nghệ full-stack hoàn chỉnh.
  • Lập trình viên Full-Stack & Kỹ sư AI: Mô hình kiến trúc mẫu về cách kết nối liên dịch vụ giữa Java Spring Boot và Python Flask Microservice thông qua RESTful API tiêu chuẩn.
  • Doanh nghiệp & Đơn vị vận hành rạp chiếu phim: Bản thiết kế giải pháp và cơ sở dữ liệu chuẩn hóa, sẵn sàng áp dụng để nâng cao năng lực cạnh tranh và tối ưu hóa doanh số phòng vé.
  • Khán giả xem phim: Tiết kiệm thời gian tra cứu, dễ dàng tiếp cận những tác phẩm điện ảnh chất lượng cao phù hợp chính xác với sở thích cá nhân.

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

1. Yêu cầu phần cứng và môi trường để triển khai hệ thống là gì?

Hệ thống yêu cầu máy chủ cài đặt hệ điều hành Linux (Ubuntu 20.04/22.04 LTS) hoặc Windows Server, tối thiểu 2 vCPU, 4GB RAM và 20GB dung lượng lưu trữ SSD. Môi trường phần mềm yêu cầu cài đặt sẵn OpenJDK 17+, Python 3.10+, Node.js 18+ và MySQL Server 8.0.

2. Hệ thống xử lý thế nào khi có người dùng hoàn toàn mới (Cold-Start Problem)?

Khi một người dùng mới đăng ký chưa có dữ liệu trong bảng user_history, thuật toán User-based Collaborative Filtering sẽ không thể tính tương quan Pearson. Hệ thống sẽ tự động điều chỉnh trọng số $\alpha = 0$, chuyển toàn bộ quyền tính điểm sang Content-Based Filtering dựa trên thể loại phim người dùng chọn lúc đăng ký hoặc đề xuất danh sách các bộ phim đang "Hot" có điểm đánh giá trung bình cao nhất từ bảng movies.

3. Việc giao tiếp giữa Spring Boot và Flask có gây nghẽn cổ chai (Bottleneck) không?

Không. Flask được thiết kế dưới dạng một Microservice phi trạng thái (Stateless API), chỉ tiếp nhận mảng dữ liệu tính toán gọn nhẹ qua giao thức HTTP JSON. Với cơ chế đa luồng của Spring Boot kết hợp WebClient hoặc Connection Pool, hệ thống hoàn toàn đảm bảo thời gian xử lý dưới 200ms cho mỗi yêu cầu.

4. Dữ liệu đánh giá có cần phải cập nhật liên tục vào mô hình AI không?

Dữ liệu đánh giá mới được lưu tức thì vào bảng user_history trong MySQL. Mỗi khi người dùng yêu cầu danh sách gợi ý, Flask microservice sẽ truy xuất dữ liệu tương tác mới nhất để tính toán theo thời gian thực. Đối với tập dữ liệu lớn hàng triệu bản ghi, hệ thống có thể cấu hình cơ chế tính toán định kỳ (Batch Job) và lưu kết quả vào Redis Cache.

5. Chi phí triển khai và thời gian hoàn vốn (ROI) ước tính như thế nào?

Chi phí triển khai ban đầu gần như bằng không về mặt bản quyền phần mềm nhờ sử dụng hoàn toàn mã nguồn mở. Với một cụm rạp quy mô vừa (3 - 5 rạp), việc tích hợp hệ thống khuyến nghị giúp tối ưu hóa công suất lấp đầy phòng chiếu, ước tính mang lại thời gian thu hồi vốn đầu tư phát triển trong vòng 3 đến 6 tháng hoạt động.

Kết luận

Đề tài "Xây dựng hệ thống khuyến nghị cho rạp chiếu phim" của tác giả Nguyễn Cao Triều đã hoàn thành xuất sắc toàn bộ các mục tiêu nghiên cứu và thực nghiệm đề ra. Dự án không chỉ giải quyết trọn vẹn bài toán lý thuyết về các thuật toán khuyến nghị kinh điển (User-based Collaborative Filtering, Pearson Correlation, TF-IDF, Cosine Similarity và Hybrid Filtering) mà còn hiện thực hóa thành công một sản phẩm phần mềm hoàn chỉnh, có tính ứng dụng thực tiễn cao.

Sự kết hợp kiến trúc chặt chẽ giữa React.js, Java Spring Boot, Python Flask và MySQL đã mang lại một giải pháp ổn định, phân tách trách nhiệm rõ ràng và sẵn sàng mở rộng. Đây là bước đệm vững chắc và là tài liệu tham khảo giá trị cho các kỹ sư phần mềm, các nhà nghiên cứu và doanh nghiệp trong nỗ lực ứng dụng trí tuệ nhân tạo nhằm nâng tầm trải nghiệm điện ảnh số.