Giới thiệu dự án

Thương mại điện tử (E-Commerce) đã trở thành trụ cột trọng yếu của nền kinh tế số toàn cầu. Theo báo cáo e-Conomy SEA, thị trường thương mại điện tử Đông Nam Á duy trì tốc độ tăng trưởng kép hàng năm (CAGR) trên 20%, tạo ra khối lượng giao dịch khổng lồ. Tuy nhiên, sự bùng nổ về số lượng sản phẩm dẫn đến hiện tượng quá tải thông tin (Information Overload), khiến tỷ lệ bỏ dở giỏ hàng trung bình của các nền tảng bán lẻ chạm mức 69.57%. Người tiêu dùng mất nhiều thời gian tìm kiếm, trong khi các doanh nghiệp vừa và nhỏ (SMEs) gặp khó khăn trong việc cá nhân hóa trải nghiệm khách lẻ.

Khóa luận tốt nghiệp kỹ sư ngành Kỹ thuật Phần mềm tại Trường Đại học Công nghệ Thông tin - ĐHQG-HCM (UIT) của nhóm tác giả Lê Quốc Khanh và Nguyễn Văn Đạt, dưới sự hướng dẫn của ThS. Thái Thụy Hàn Uyển, đã nghiên cứu và phát triển thành công đề tài: "Xây dựng Website thương mại điện tử kết hợp khuyến nghị sản phẩm" (Building an E-Commerce Website Integrated Recommendation System - RES).

flowchart LR
    A[Khách hàng] -->|Duyệt & Tìm kiếm| B[Frontend ReactJS]
    B -->|REST API & WebSocket| C[Backend Golang API Gateway]
    C -->|ACID Transactions| D[(Cơ sở dữ liệu MySQL 8.0)]
    C -->|RPC / Data Pipeline| E[Python Recommendation Engine]
    E -->|Gợi ý cá nhân hóa| B
    C -->|Thanh toán trực tuyến| F[PayPal Payment Gateway]

Vấn đề thực tiễn và mục tiêu dự án

Các sàn thương mại điện tử truyền thống dành cho doanh nghiệp nhỏ thường gặp phải ba điểm nghẽn chính:

  1. Thiếu tính năng gợi ý thông minh: Các website nhỏ lẻ chỉ hiển thị sản phẩm theo thứ tự thêm mới hoặc bán chạy, thiếu năng lực phân tích sở thích tương đồng giữa các nhóm người dùng.
  2. Trải nghiệm giỏ hàng kém linh hoạt: Buộc người dùng thanh toán toàn bộ giỏ hàng cùng lúc, không hỗ trợ lựa chọn từng món đồ cụ thể để thanh toán phân đoạn.
  3. Hiệu năng suy giảm khi dữ liệu tăng trưởng: Thiếu cơ chế phân trang (Pagination) và tải lười (Lazy Loading), dẫn đến thời gian phản hồi trang (TTFB) tăng tuyến tính theo số lượng sản phẩm.

Dự án RES đặt ra 5 mục tiêu cụ thể:

  1. Xây dựng nền tảng E-Commerce kiến trúc phân tầng (Clean Architecture), hỗ trợ đa cửa hàng (Multi-store/Multi-vendor).
  2. Phát triển hệ thống gợi ý sản phẩm tích hợp thuật toán lọc cộng tác (User-based Collaborative Filtering - CF).
  3. Tối ưu hiệu năng tải trang với Lazy Loading và Server-side Pagination, giữ độ trễ API dưới 150ms.
  4. Tích hợp thanh toán quốc tế qua cổng PayPal REST SDK, hỗ trợ định dạng địa chỉ hành chính chi tiết và bộ lọc ngôn từ cấm (Profanity Filter) cho bình luận.
  5. Cung cấp kênh giao tiếp thời gian thực qua Live Chat giữa người mua - người bán và Chatbot hỗ trợ kịch bản tự động.

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

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

Nhóm nghiên cứu đã khảo sát và đối sánh hệ thống RES với các mô hình thương mại điện tử hiện nay trên thị trường.

Tiêu chí so sánh Nền tảng Monolithic truyền thống (WooCommerce/OpenCart) Sàn TMĐT quy mô lớn (Shopee/Lazada) Hệ thống Đề tài RES
Kiến trúc Monolith, PHP/MySQL Microservices phân tán cao Clean Architecture Decoupled (Go + React + Python)
Cơ chế gợi ý Content-based đơn giản hoặc mua plugin ngoài Deep Learning & Collaborative Filtering phức tạp User-based Collaborative Filtering qua ma trận Cosine
Linh hoạt giỏ hàng Mua tất cả trong giỏ Chọn từng mục hoặc từng shop Chọn tùy ý từng sản phẩm để thanh toán, lưu phần còn lại
Hiệu năng tải Dễ nghẽn khi catalog > 10.000 sản phẩm Rất cao, phân tán CDN Tối ưu bằng Paging + Lazy Loading + Go Concurrency
Chi phí vận hành Thấp nhưng khó mở rộng Cực kỳ tốn kém Tối ưu tài nguyên, sẵn sàng container hóa trên Kubernetes

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 JWT, quản lý đa cửa hàng, quản lý danh mục và thông số sản phẩm, giỏ hàng tùy chọn, thanh toán PayPal, gợi ý Collaborative Filtering.
  • Should-have: Nhắn tin trực gian thực (WebSocket Chat), bộ lọc bình luận độc hại, kiểm tra tính hợp lệ của mật khẩu và số điện thoại, chọn địa chỉ hành chính qua combobox phân cấp.
  • Could-have: Chatbot kịch bản FAQ, hỗ trợ đa ngôn ngữ (Anh - Việt), đánh giá kèm hình ảnh/video sau khi đơn hàng giao thành công.
  • Won't-have (giai đoạn 1): Ứng dụng di động chuyên biệt cho đơn vị vận chuyển (Shipper App).

Thiết kế hệ thống

graph TD
    subgraph Client Layer
        UI[ReactJS 18.2 SPA Client]
    end

    subgraph API Gateway & Core Backend
        GW[Go Gin Web Framework v1.9]
        AUTH[JWT Middleware & Security Filter]
        SVC_PROD[Product & Store Service]
        SVC_ORDER[Order & Cart Service]
        SVC_CHAT[WebSocket Chat Service]
    end

    subgraph Data & Analytics Layer
        DB[(MySQL 8.0 Database)]
        PY_CF[Python 3.10 CF Engine / NumPy / Pandas]
    end

    subgraph Third-Party Integrations
        PP[PayPal REST API]
        GCP[GCP / Kubernetes Cluster]
    end

    UI -->|HTTP/REST & WSS| GW
    GW --> AUTH
    AUTH --> SVC_PROD
    AUTH --> SVC_ORDER
    AUTH --> SVC_CHAT
    SVC_PROD --> DB
    SVC_ORDER --> DB
    SVC_ORDER --> PP
    SVC_CHAT --> DB
    DB -->|Rating Matrix Export| PY_CF
    PY_CF -->|Top-K Recommendation| SVC_PROD

Bảng công nghệ và phiên bản sử dụng

Tầng hệ thống Công nghệ / Thư viện Phiên bản Vai trò kỹ thuật
Frontend ReactJS, React Router 18.2.0 Xây dựng giao diện Single Page Application (SPA), Virtual DOM rendering
Backend Core Golang, Gin Framework 1.20 / 1.9.1 Xử lý business logic, RESTful API hiệu năng cao với Goroutines
ORM / Data Access GORM 1.25.0 Ánh xạ đối tượng quan hệ, quản lý transaction an toàn trong Go
Data Science / CF Python, NumPy, Pandas 3.10 / 1.24 / 2.0 Tính toán ma trận độ tương đồng Cosine và dự đoán Rating
Database MySQL Server 8.0.33 Quản lý dữ liệu quan hệ với chuẩn ACID, indexing tối ưu
Container & Cloud Docker, Kubernetes (k8s) 24.0 / 1.26 Đóng gói microservices và điều phối tự động trên Google Cloud Platform

Thiết kế Cơ sở dữ liệu và API

Cơ sở dữ liệu được chuẩn hóa ở dạng chuẩn 3NF với các bảng cốt lõi: users, providers (cửa hàng), products, product_specifications, cart_items, orders, order_items, comments, ratings, chat_rooms, messages.

-- Thiết kế bảng đánh giá phục vụ ma trận Collaborative Filtering
CREATE TABLE ratings (
    rating_id BIGINT AUTO_INCREMENT PRIMARY KEY,
    user_id BIGINT NOT NULL,
    product_id BIGINT NOT NULL,
    score TINYINT NOT NULL CHECK (score BETWEEN 1 AND 5),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    CONSTRAINT fk_rating_user FOREIGN KEY (user_id) REFERENCES users(user_id) ON DELETE CASCADE,
    CONSTRAINT fk_rating_product FOREIGN KEY (product_id) REFERENCES products(product_id) ON DELETE CASCADE,
    UNIQUE KEY uk_user_product_rating (user_id, product_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

Hệ thống cung cấp các API Endpoints tiêu chuẩn:

  • POST /api/v1/auth/login: Xác thực người dùng và cấp phát JWT token.
  • GET /api/v1/products?page=1&limit=20: Truy xuất danh sách sản phẩm phân trang kèm lazy loading.
  • POST /api/v1/cart/checkout: Đặt hàng cho các danh mục sản phẩm được tích chọn.
  • GET /api/v1/recommendations/user/{user_id}: Trả về danh sách gợi ý sản phẩm cá nhân hóa.

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

Dự án áp dụng mô hình phát triển Agile/Scrum trong vòng 16 tuần (25/02/2023 – 16/06/2023), chia thành 8 Sprints (mỗi Sprint kéo dài 2 tuần):

  • Sprint 1 - 2 (Tuần 1 - 4): Khảo sát thị trường, đặc tả 31 Use Cases, thiết kế ERD và Figma UI/UX.
  • Sprint 3 - 4 (Tuần 5 - 8): Xây dựng Backend Go Gin (Auth, Product, Category, Store) và giao diện ReactJS.
  • Sprint 5 - 6 (Tuần 9 - 12): Tích hợp WebSocket Chat, cổng PayPal, module tìm kiếm và xây dựng thuật toán User-based CF.
  • Sprint 7 - 8 (Tuần 13 - 16): Tích hợp Recommendation Engine vào luồng dữ liệu chính, kiểm thử tự động, tối ưu hóa container Docker/K8s và hoàn thiện tài liệu 135 trang.

Implementation và kết quả

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

Trọng tâm kỹ thuật của đề tài là thuật toán User-based Collaborative Filtering giải quyết bài toán gợi ý sản phẩm dựa trên độ tương đồng về hành vi tiêu dùng giữa các khách hàng.

1. Mô hình toán học của thuật toán

Quy trình tính toán trải qua 4 bước:

  • Bước 1: Khởi tạo Ma trận User-Item ($R$): Ma trận cấp $M \times N$ với $M$ người dùng và $N$ sản phẩm. Phần tử $r_{u,i}$ là điểm đánh giá của người dùng $u$ cho sản phẩm $i$ ($1 \le r_{u,i} \le 5$).

  • Bước 2: Chuẩn hóa ma trận (Mean-Centering): Để triệt tiêu thiên kiến cá nhân (người dùng khó tính chấm điểm thấp, người dùng dễ tính luôn chấm điểm cao), điểm đánh giá được trừ đi giá trị trung bình $\bar{r}u$ của chính người dùng đó: $$\bar{r}u = \frac{1}{|I_u|} \sum{i \in I_u} r{u,i}$$ $$s_{u,i} = r_{u,i} - \bar{r}_u$$

  • Bước 3: Tính toán độ tương đồng Cosine (Cosine Similarity): Độ tương đồng giữa hai người dùng $u$ và $v$ được xác định dựa trên vector đánh giá đã chuẩn hóa trên tập các sản phẩm $I_{uv}$ mà cả hai cùng đánh giá: $$sim(u, v) = \frac{\sum_{i \in I_{uv}} s_{u,i} \cdot s_{v,i}}{\sqrt{\sum_{i \in I_{uv}} s_{u,i}^2} \cdot \sqrt{\sum_{i \in I_{uv}} s_{v,i}^2}}$$

  • Bước 4: Dự đoán điểm đánh giá cho sản phẩm chưa mua: Với sản phẩm $i$ mà người dùng $u$ chưa tương tác, hệ thống chọn ra tập $N_k(u)$ gồm $k$ người dùng có độ tương đồng cao nhất đã đánh giá sản phẩm $i$: $$\hat{r}{u,i} = \bar{r}u + \frac{\sum{v \in N_k(u)} sim(u, v) \cdot (r{v,i} - \bar{r}v)}{\sum{v \in N_k(u)} |sim(u, v)|}$$

2. Mã nguồn triển khai thuật toán (Python Recommendation Service)

import numpy as np
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity

class UserBasedCollaborativeFiltering:
    def __init__(self, k_neighbors=2):
        self.k = k_neighbors
        self.user_item_matrix = None
        self.normalized_matrix = None
        self.similarity_matrix = None
        self.user_means = None

    def fit(self, df_ratings: pd.DataFrame):
        # Tạo pivot table từ dữ liệu đánh giá
        self.user_item_matrix = df_ratings.pivot(
            index='user_id', columns='product_id', values='rating'
        )
        # Tính trung bình đánh giá của từng user (bỏ qua NaN)
        self.user_means = self.user_item_matrix.mean(axis=1)
        # Chuẩn hóa ma trận bằng cách trừ giá trị trung bình
        self.normalized_matrix = self.user_item_matrix.sub(self.user_means, axis=0).fillna(0)
        
        # Tính toán ma trận tương đồng Cosine giữa các user
        sim = cosine_similarity(self.normalized_matrix)
        self.similarity_matrix = pd.DataFrame(
            sim, index=self.user_item_matrix.index, columns=self.user_item_matrix.index
        )

    def predict_rating(self, user_id: int, product_id: int) -> float:
        if user_id not in self.user_item_matrix.index:
            return 0.0
        if product_id not in self.user_item_matrix.columns:
            return float(self.user_means.get(user_id, 3.0))

        # Tìm k người dùng tương đồng nhất đã đánh giá sản phẩm này
        other_users = self.user_item_matrix[self.user_item_matrix[product_id].notnull()].index
        other_users = other_users.drop(user_id, errors='ignore')
        
        if other_users.empty:
            return float(self.user_means[user_id])

        sim_scores = self.similarity_matrix.loc[user_id, other_users]
        top_k_users = sim_scores.nlargest(self.k)
        
        if top_k_users.sum() == 0:
            return float(self.user_means[user_id])

        weighted_sum = 0.0
        sim_sum = 0.0
        for other_user, sim_score in top_k_users.items():
            normalized_rating = self.normalized_matrix.loc[other_user, product_id]
            weighted_sum += sim_score * normalized_rating
            sim_sum += abs(sim_score)

        predicted = self.user_means[user_id] + (weighted_sum / sim_sum if sim_sum != 0 else 0)
        return float(np.clip(predicted, 1.0, 5.0))

3. Xử lý bài toán Khởi động nguội (Cold Start Solution)

  • Trường hợp tài khoản mới chưa có đủ dữ liệu đánh giá ($N_{rating} < 3$), hệ thống tự động kích hoạt Fallback Mechanism: Truy vấn danh sách sản phẩm có điểm đánh giá trung bình cao nhất toàn sàn kết hợp số lượt mua thực tế.
  • Khi người dùng tích lũy đủ $\ge 3$ đánh giá hợp lệ, pipeline chuyển sang chế độ cá nhân hóa thời gian thực qua thuật toán User-based CF.

4. Mã nguồn xử lý nghiệp vụ Backend (Golang Clean Architecture)

package usecase

import (
	"context"
	"errors"
	"res-ecommerce/domain"
)

type CartUseCase struct {
	cartRepo  domain.CartRepository
	orderRepo domain.OrderRepository
}

func NewCartUseCase(c domain.CartRepository, o domain.OrderRepository) *CartUseCase {
	return &CartUseCase{cartRepo: c, orderRepo: o}
}

// CheckoutSelectedItems cho phép người dùng chỉ thanh toán các mặt hàng được chọn
func (uc *CartUseCase) CheckoutSelectedItems(ctx context.Context, userID int64, selectedItemIDs []int64) (*domain.Order, error) {
	if len(selectedItemIDs) == 0 {
		return nil, errors.New("không có sản phẩm nào được chọn để thanh toán")
	}

	cartItems, err := uc.cartRepo.GetItemsByIDs(ctx, userID, selectedItemIDs)
	if err != nil || len(cartItems) == 0 {
		return nil, errors.New("không thể lấy thông tin sản phẩm trong giỏ hàng")
	}

	// Khởi tạo Transaction Order và giữ lại các sản phẩm chưa được chọn trong giỏ
	order, err := uc.orderRepo.CreateOrderWithItems(ctx, userID, cartItems)
	if err != nil {
		return nil, err
	}

	// Xóa các sản phẩm đã thanh toán thành công khỏi giỏ hàng
	_ = uc.cartRepo.RemoveItems(ctx, userID, selectedItemIDs)

	return order, nil
}

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

Hệ thống đã trải qua 12 kịch bản kiểm thử tích hợp (Test Suites) từ Bảng 3.60 đến Bảng 3.71 trong báo cáo khóa luận, bao gồm xác thực tài khoản, xử lý giỏ hàng, nhắn tin WebSocket, thanh toán PayPal Sandbox và độ hội tụ thuật toán khuyến nghị.

+-----------------------------------------------------------------------+
|                       KẾT QUẢ KIỂM THỬ HỆ THỐNG                      |
+--------------------------+---------------+---------------+------------+
| Hạng mục kiểm thử        | Số Test Cases | Tỷ lệ Đạt (%) | Ghi chú    |
+--------------------------+---------------+---------------+------------+
| Xác thực & Phân quyền    | 24            | 100%          | JWT Valid  |
| Quản lý Giỏ & Đặt hàng   | 38            | 100%          | Multi-Shop |
| Cổng thanh toán PayPal   | 15            | 100%          | Sandbox OK |
| Thuật toán Gợi ý CF      | 20            | 95.0%         | Cosine OK  |
| WebSocket Live Chat      | 18            | 100%          | Realtime   |
+--------------------------+---------------+---------------+------------+
  • Độ trễ API Backend (Go Gin): Thời gian phản hồi trung bình cho các endpoint nghiệp vụ đạt $45\text{ms} - 110\text{ms}$ dưới tải 500 requests/second.
  • Tối ưu hiển thị Frontend: Việc triển khai Lazy Loading và Server-side Pagination giúp giảm $62%$ dung lượng payload ban đầu, đưa điểm số Google Lighthouse Performance đạt mức $92/100$.

Đánh giá của Hội đồng chuyên môn

Khóa luận đã bảo vệ thành công trước Hội đồng chấm tốt nghiệp Khoa Công nghệ Phần mềm - Trường Đại học Công nghệ Thông tin (ĐHQG-HCM) vào tháng 07/2023:

  • Cán bộ hướng dẫn (ThS. Thái Thụy Hàn Uyển): Đánh giá loại Xuất sắc (9.0/10), ghi nhận sản phẩm hoàn chỉnh, hỗ trợ tạo đa cửa hàng, áp dụng chuẩn xác thuật toán Collaborative Filtering và quản trị hệ thống chặt chẽ.
  • Cán bộ phản biện (ThS. Trần Thị Hồng Yến): Đánh giá loại Xuất sắc (9.0/10), biểu dương kiến trúc công nghệ mới (ReactJS, Golang, Python, MySQL, Docker/K8s) và tính thực tiễn cao của giải pháp.

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

  1. Cơ chế Selective Checkout trong quản lý giỏ hàng: Khắc phục nhược điểm "thanh toán tất cả hoặc không gì cả" của nhiều mã nguồn mở. Người dùng được tự do lựa chọn $m$ sản phẩm từ $n$ sản phẩm có trong giỏ hàng ($m \le n$) mà vẫn bảo toàn trạng thái giỏ hàng cho các phiên mua sắm sau.

  2. Mô hình kiến trúc lai Go - Python linh hoạt: Tận dụng tối đa thế mạnh xử lý đồng thời (Concurrency) và tốc độ biên dịch của Golang cho tầng API Gateway/Core Service, kết hợp với sức mạnh đại số tuyến tính của Python (NumPy, Pandas) cho tầng Recommendation, giảm thiểu chi phí tính toán trên máy chủ dữ liệu chính.

  3. Cơ chế kiểm soát bình luận và bảo vệ người bán: Quy định chặt chẽ điều kiện đánh giá sản phẩm: Chỉ những khách hàng có trạng thái đơn hàng COMPLETED mới được quyền bình luận và chấm điểm sao, kết hợp bộ lọc tự động kiểm duyệt ngôn từ vi phạm thuần phong mỹ tục.

+--------------------------------------------------------------------------+
|                  ĐỐI SOÁNH CÁC CHỈ SỐ CẢI TIẾN CỦA RES                   |
+-----------------------------+-------------------+------------------------+
| Chỉ số đo lường             | Hệ thống cơ sở    | Đề tài RES             |
+-----------------------------+-------------------+------------------------+
| Thời gian tải trang ban đầu | 2.8s (Tải toàn bộ)| 1.1s (Lazyload/Paging) |
| Tỷ lệ bỏ dở giỏ hàng        | ~68%              | Giảm ~28% (Selective)  |
| Độ phủ gợi ý cá nhân hóa    | 0% (Không có)     | 86.4% Active Users     |
| Khả năng mở rộng đa shop    | Đơn lẻ            | Đa cửa hàng động       |
+-----------------------------+-------------------+------------------------+

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

Kịch bản ứng dụng thực tế

  • Hệ thống thương mại điện tử cho chuỗi bán lẻ: Triển khai cho các chuỗi phân phối thời trang, công nghệ, bách hóa có nhu cầu vận hành nhiều chi nhánh bán hàng trên cùng một hạ tầng quản trị tập trung.
  • Sàn thương mại nội bộ doanh nghiệp/trường học: Cung cấp nền tảng trao đổi giáo trình, trang thiết bị học tập cho sinh viên với tính năng gợi ý tài liệu học tập theo sở thích cá nhân.
flowchart TD
    subgraph CI/CD & Production Deployment
        Git[GitHub Repository] -->|Push Code| GHA[GitHub Actions CI]
        GHA -->|Build & Test| Doc[Docker Container Image]
        Doc -->|Push| GCR[Google Artifact Registry]
        GCR -->|Deploy| GKE[Google Kubernetes Engine - GKE Cluster]
        GKE --> Pod1[Backend Pod - Golang Gin]
        GKE --> Pod2[Frontend Pod - ReactJS Nginx]
        GKE --> Pod3[Analytics Pod - Python CF]
    end

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

  • Chi phí hạ tầng tối ưu: Nhờ hiệu năng tiêu thụ RAM cực thấp của Golang (chỉ $\approx 30\text{MB} - 50\text{MB}$ RAM cho 1 instance API Gateway), chi phí thuê Cloud Cluster (GCP/AWS) giảm hơn $40%$ so với việc chạy nền tảng dựa trên Java Spring Boot hoặc PHP Monolith.
  • Thời gian hoàn vốn (ROI): Doanh nghiệp bán lẻ ứng dụng hệ thống ước tính đạt điểm hòa vốn sau 6 - 8 tháng vận hành nhờ tăng $18%$ giá trị đơn hàng trung bình (AOV) từ danh mục khuyến nghị thông minh.

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

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

  1. Quy mô ma trận thưa (Matrix Sparsity): Khi số lượng sản phẩm và người dùng tăng lên hàng chục nghìn, ma trận đánh giá trở nên cực kỳ thưa, ảnh hưởng đến độ chính xác của khoảng cách Cosine.
  2. Kịch bản Chatbot còn cơ bản: Chatbot hiện mới hỗ trợ 2 kịch bản điều hướng tự động dựa trên từ khóa, chưa tích hợp mô hình ngôn ngữ lớn (LLM).
  3. Thiếu Module phân phối vận chuyển: Hệ thống chưa có ứng dụng di động dành riêng cho tài xế giao hàng (Shipper) để cập nhật tọa độ GPS thời gian thực.

Hướng phát triển tiếp theo

  • Nâng cấp thuật toán gợi ý: Chuyển đổi từ User-based CF đơn thuần sang Mô hình Hybrid kết hợp Deep Learning (Neural Collaborative Filtering - NCF và Matrix Factorization).
  • Tích hợp Generative AI: Xây dựng trợ lý ảo tư vấn sản phẩm thông minh dựa trên RAG (Retrieval-Augmented Generation) và Gemini API.
  • Phát triển hệ sinh thái di động: Xây dựng ứng dụng di động cho Shipper và Buyer bằng React Native, đồng bộ qua giao thức gRPC tốc độ cao.

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

  • Sinh viên & Học viên CNTT: Nắm bắt trọn vẹn mô hình phát triển phần mềm chuẩn kỹ sư từ khâu phân tích 31 Use Cases, thiết kế CSDL chuẩn hóa, đến kỹ thuật lập trình Golang Clean Architecture và thuật toán Machine Learning thực chiến.
  • Lập trình viên Full-stack: Tham khảo kiến trúc tách biệt giữa ReactJS Frontend và Go Backend, cách quản lý concurrency với Goroutines và triển khai hệ thống microservices lên Docker/Kubernetes.
  • Doanh nghiệp vừa và nhỏ (SMEs): Sở hữu giải pháp thương mại điện tử trọn gói với chi phí bản quyền 0 đồng, linh hoạt mở rộng nhiều ngành hàng và gia tăng doanh số nhờ hệ thống gợi ý cá nhân hóa.
  • Nhà nghiên cứu khoa học dữ liệu: Có sẵn bộ khung thực nghiệm đánh giá thuật toán Collaborative Filtering và giải pháp khắc phục vấn đề Cold-Start trên dữ liệu giao dịch thực tế.

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

1. Cần chuẩn bị môi trường kỹ thuật gì để triển khai mã nguồn dự án RES?

Để triển khai hệ thống, máy chủ cần cài đặt:

  • Docker Engine $\ge 20.10$ và Docker Compose $\ge v2.0$.
  • Node.js $\ge 16.x$ (Frontend ReactJS build).
  • Go SDK $\ge 1.20$ và Python $\ge 3.10$ (cài đặt numpy, pandas, scikit-learn).
  • MySQL Server $\ge 8.0$ (hoặc sử dụng container MySQL dựng sẵn).

2. Thuật toán User-based Collaborative Filtering xử lý thế nào khi người dùng hoàn toàn chưa có đánh giá nào?

Hệ thống tự động kích hoạt cơ chế dự phòng (Fallback Mode). Thay vì tính toán khoảng cách Cosine trên ma trận rỗng, hệ thống sẽ truy vấn các sản phẩm có điểm đánh giá trung bình cao nhất ($\ge 4.5$ sao) và có số lượt mua nhiều nhất trong cùng danh mục để hiển thị cho người dùng mới.

3. Hệ thống có thể tích hợp thêm các cổng thanh toán nội địa như VNPay hay MoMo không?

Hoàn toàn có thể. Nhờ kiến trúc Clean Architecture, tầng thanh toán được trừu tượng hóa thông qua interface PaymentGateway. Để thêm VNPay hoặc MoMo, lập trình viên chỉ cần triển khai một struct mới thỏa mãn interface này mà không cần thay đổi logic xử lý đơn hàng cốt lõi.

4. Chi phí duy trì hệ thống trên Cloud hàng tháng khoảng bao nhiêu?

Với quy mô vừa và nhỏ (dưới 50.000 người dùng hàng tháng), hệ thống có thể chạy ổn định trên cụm Kubernetes gồm 2 Nodes (mỗi Node 2 vCPU, 4GB RAM) trên Google Cloud Platform (GKE) hoặc DigitalOcean với chi phí ước tính khoảng $40 - $60 USD/tháng.

5. Tại sao dự án chọn Golang làm Backend thay vì NodeJS hay Java Spring Boot?

Golang được chọn nhờ tốc độ thực thi tiệm cận C/C++, thời gian khởi động container gần như tức thì (< 100ms), cơ chế Goroutines xử lý hàng chục nghìn kết nối đồng thời với dung lượng bộ nhớ cực thấp, giúp tối ưu hóa chi phí vận hành đám mây vượt trội so với JVM của Java hay Event Loop đơn luồng của Node.js.

Kết luận

Khóa luận tốt nghiệp "Xây dựng Website thương mại điện tử kết hợp khuyến nghị sản phẩm" (RES) của hai kỹ sư Lê Quốc Khanh và Nguyễn Văn Đạt là một công trình nghiên cứu ứng dụng xuất sắc, kết hợp nhuần nhuyễn giữa kỹ thuật công nghệ phần mềm hiện đại và khoa học dữ liệu. Bằng việc làm chủ các công nghệ tiên tiến như ReactJS, Golang Clean Architecture, MySQL 8.0, Docker/Kubernetes cùng thuật toán lọc cộng tác User-based Collaborative Filtering, nhóm tác giả đã giải quyết trọn vẹn bài toán nâng cao trải nghiệm mua sắm và tối ưu hóa chuyển đổi kinh doanh.

Dự án không chỉ là tài liệu tham khảo kỹ thuật giá trị cao cho cộng đồng học thuật mà còn là giải pháp có tính ứng dụng thực tiễn to lớn, sẵn sàng thương mại hóa phục vụ cho làn sóng chuyển đổi số trong lĩnh vực bán lẻ trực tuyến.