Giới thiệu dự án

Sự bùng nổ của thương mại điện tử (TMĐT) tại Việt Nam sau đại dịch COVID-19 đã tạo ra bước ngoặt lớn trong hành vi tiêu dùng trực tuyến. Với hơn 70% dân số tiếp cận Internet, gần 90% người dùng từng mua sắm online và 64% dân số sở hữu smartphone (khoảng 61,37 triệu người, xếp top 10 toàn cầu theo Statista), thị trường bán lẻ trực tuyến ghi nhận lượng truy cập khổng lồ. Tuy nhiên, khối lượng sản phẩm tăng theo cấp số nhân dẫn đến nghịch lý quá tải thông tin (Information Overload), gây ra hai điểm nghẽn nghiêm trọng:

  • Phía người tiêu dùng: Mất nhiều thời gian tìm kiếm, khó khăn trong việc định danh chính xác sản phẩm mong muốn dựa trên từ khóa văn bản khi chỉ có hình ảnh tham chiếu, dẫn đến tỷ lệ thoát trang (bounce rate) cao.
  • Phía doanh nghiệp vừa và nhỏ (SMEs): Chi phí marketing để tối ưu hóa hiển thị sản phẩm và tiếp cận đúng tệp khách hàng tiềm năng quá lớn, gây lãng phí ngân sách mà không đảm bảo tỷ lệ chuyển đổi (CR).
                [Giải pháp: Hệ khuyến nghị Visual AI]
 [Trích xuất đặc trưng ảnh (CNN)]     [Truy vấn lân cận nhanh (K-NN)]

Đề tài "Ứng dụng CNN trong bài toán khuyến nghị sản phẩm cho ứng dụng bán hàng điện tử" tập trung xây dựng hệ thống khuyến nghị trực quan (Visual-based Recommendation System) tích hợp vào ứng dụng di động PStore, giải quyết triệt để các hạn chế của phương pháp lọc cộng tác (Collaborative Filtering) truyền thống như vấn đề khởi đầu lạnh (Cold-start) và ma trận thưa thớt (Data Sparsity).

Mục tiêu dự án

  1. Nghiên cứu và hiện thực hóa mô hình mạng nơ-ron tích chập (Convolutional Neural Network - CNN) với kiến trúc Xception để trích xuất đặc trưng hình ảnh sản phẩm.
  2. Ứng dụng thuật toán K-Láng giềng gần nhất (K-Nearest Neighbors - K-NN) với cấu trúc dữ liệu xấp xỉ Annoy (Approximate Nearest Neighbors Oh Yeah) để tìm kiếm các sản phẩm tương đồng về mặt thị giác theo thời gian thực.
  3. Xây dựng hệ thống Backend hoàn chỉnh trên nền tảng Django & Django Rest Framework (DRF), quản trị dữ liệu với PostgreSQL và triển khai qua Docker.
  4. Phát triển ứng dụng Native Android PStore bằng ngôn ngữ Kotlin theo chuẩn kiến trúc Clean Architecture, mang lại trải nghiệm mượt mà cho người dùng.

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

  • Phương pháp tiếp cận: Sử dụng kỹ thuật học chuyển giao (Transfer Learning) trên mạng Xception để trích xuất vector đặc trưng 2048 chiều (Feature Vector) từ ảnh sản phẩm thuộc tập dữ liệu Amazon (danh mục Electronics và Cell Phones & Accessories), sau đó lập chỉ mục không gian nhiều chiều bằng cấu trúc rừng cây nhị phân ngẫu nhiên (Random Projection Trees) của thư viện Annoy.
  • Kết quả kỳ vọng: Độ chính xác phân loại danh mục đạt trên 98%, thời gian phản hồi API gợi ý sản phẩm tương tự dưới 100ms, hệ thống hoạt động ổn định trên các thiết bị Android từ phiên bản 7.0 trở lên.
  • Phạm vi và giới hạn: Tập trung vào khuyến nghị dựa trên sự tương đồng nội dung hình ảnh (Visual Content-Based); chưa tích hợp đồng thời luồng dữ liệu hành vi thời gian thực (clickstream) và dữ liệu văn bản NLP.

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

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

Các hệ thống khuyến nghị hiện đại trên thế giới (như Amazon chiếm 35% doanh thu, Netflix chiếm 75% thời lượng xem từ hệ khuyến nghị) thường kết hợp nhiều cơ chế:

Tiêu chí so sánh Lọc cộng tác (Collaborative Filtering / Matrix Factorization) Lọc dựa trên nội dung văn bản (Content-Based NLP) Lọc dựa trên đặc trưng hình ảnh (CNN + K-NN Visual Search)
Vấn đề Cold-Start Rất nghiêm trọng (không thể gợi ý item/user mới) Trung bình (cần mô tả văn bản chi tiết) Tối ưu (chỉ cần ảnh sản phẩm để tính tương đồng)
Độ chính xác ngữ cảnh Phụ thuộc vào mật độ ma trận tương tác (Sparsity) Dễ nhầm lẫn do từ đồng nghĩa, mô tả sai lệch Cao (dựa trực tiếp trên đặc trưng hình khối, màu sắc)
Chi phí tính toán Phức tạp khi số lượng $U \times I$ tăng vọt ($O(MN)$) Trung bình ($O(N \log N)$ với TF-IDF/BERT) $O(\log N)$ khi dùng chỉ mục không gian Annoy
Khả năng mở rộng Yêu cầu tính toán lại ma trận thường xuyên Dễ mở rộng Rất dễ mở rộng (thêm vector mới vào cây chỉ mục)

Phân tích yêu cầu hệ thống theo mô hình MoSCoW

  • Must have: Đăng nhập/Đăng ký xác thực; duyệt danh sách sản phẩm; hiển thị chi tiết sản phẩm; hiển thị danh sách 10 sản phẩm tương đồng trực quan; quản lý giỏ hàng và đặt hàng.
  • Should have: Phân luồng dữ liệu độc lập giữa danh mục Electronics và Cell Phones; cache dữ liệu giỏ hàng cục bộ.
  • Could have: Đánh giá sản phẩm; hiển thị gợi ý sau khi đặt hàng thành công.
  • Won't have (giai đoạn này): Thanh toán qua cổng tích hợp bên thứ ba (VNPAY/Momo); tìm kiếm bằng cách upload ảnh trực tiếp từ camera.

Thiết kế hệ thống

graph TD
    A[Client: Native Android Kotlin MVVM] -->|HTTPS / JSON REST API| B[Backend: Django Rest Framework]
    B -->|ORM Queries| C[(Database: PostgreSQL)]
    B -->|Query 2048-dim Vector| D[Visual Recommendation Engine]
    subgraph AI Engine
        D -->|Feature Extractor| E[Xception CNN Model]
        D -->|Nearest Neighbor Search| F[Annoy Index Files .ann]
    end
    subgraph Containerization
        B
        C
        D
    end

Tech Stack chi tiết

  • Server: Python 3.9, Django 3.2 LTS, Django Rest Framework 3.12, Gunicorn 20.1.
  • Trí tuệ nhân tạo (AI Engine): TensorFlow 2.6.0, Keras 2.6.0, Annoy 1.17.0 (Spotify), NumPy 1.19.5.
  • Cơ sở dữ liệu & Triển khai: PostgreSQL 13, Docker Engine 20.10, Docker Compose, Portainer CE.
  • Client Mobile: Android Studio Arctic Fox, Kotlin 1.5.31, Retrofit 2.9.0, OkHttp 4.9.0, Gson 2.8.8, Android Jetpack (ViewModel, LiveData, Navigation Component).

Thiết kế cơ sở dữ liệu (PostgreSQL Schema)

  • users_user: Quản lý thông tin định danh (id, email, password_hash, first_name, last_name, phone, address, dob).
  • products_category: Quản lý danh mục (id, name, slug).
  • products_product: Quản lý thực thể mặt hàng (id, name, price, description, image_url, brand, category_id).
  • orders_order: Quản lý giao dịch (id, user_id, created_at, status, shipping_address, total_amount).
  • orders_orderitem: Chi tiết đơn hàng (id, order_id, product_id, quantity, unit_price).

Thiết kế API Endpoints (DRF ViewSet)

  • POST /api/auth/register/ - Đăng ký tài khoản (AllowAny).
  • POST /api/auth/login/ - Xác thực và trả về Token/Session (AllowAny).
  • GET /api/products/ - Lấy danh sách sản phẩm phân trang (AllowAny).
  • GET /api/products/{id}/ - Chi tiết sản phẩm (AllowAny).
  • GET /api/products/{id}/recommendations/ - Truy xuất top 10 sản phẩm tương đồng trực quan (AllowAny).
  • POST /api/orders/ - Khởi tạo đơn hàng (IsAuthenticated).

Methodology

Quy trình phát triển dự án tuân theo mô hình Agile/Scrum rút gọn với chu kỳ 4 Sprint (mỗi Sprint 2 tuần):

  • Sprint 1: Thu thập, tiền xử lý dữ liệu Amazon Review Data, xây dựng pipeline huấn luyện mô hình CNN Xception và trích xuất vector đặc trưng.
  • Sprint 2: Thiết kế cơ sở dữ liệu PostgreSQL, phát triển RESTful API bằng Django và xây dựng module gợi ý với Annoy.
  • Sprint 3: Xây dựng ứng dụng Android Native (Kotlin), tích hợp Retrofit, ViewModel và thiết kế giao diện Material Design.
  • Sprint 4: Kiểm thử tích hợp (End-to-End), tối ưu hóa độ trễ truy vấn vector, đóng gói Docker và nghiệm thu.

Implementation và kết quả

Development Process & Key Algorithms

1. Kiến trúc mạng Xception và kỹ thuật Depthwise Separable Convolution

Mạng nơ-ron truyền thống áp dụng phép tích chập trên toàn bộ chiều không gian và chiều sâu kênh cùng lúc, với chi phí tính toán cho một kernel kích thước $D_K \times D_K$ trên feature map kích thước $D_F \times D_F$ với $M$ kênh đầu vào và $N$ kênh đầu ra là: $$\text{Cost}_{\text{Standard}} = D_F \times D_F \times D_K \times D_K \times M \times N$$

Mạng Xception giải quyết hiện tượng triệt tiêu đạo hàm (Vanishing Gradient) và bùng nổ tham số bằng cách tách biệt hoàn toàn thành 2 bước thông qua khối Depthwise Separable Convolution (DSC):

  1. Depthwise Convolution: Áp dụng bộ lọc không gian $D_K \times D_K \times 1$ cho từng kênh độc lập.
  2. Pointwise Convolution: Áp dụng bộ lọc $1 \times 1 \times N$ để kết hợp tuyến tính các kênh.

Tỷ lệ giảm thiểu chi phí tính toán: $$\text{Ratio} = \frac{D_F \cdot D_F \cdot D_K \cdot D_K \cdot M + D_F \cdot D_F \cdot M \cdot N}{D_F \cdot D_F \cdot D_K \cdot D_K \cdot M \cdot N} = \frac{1}{N} + \frac{1}{D_K^2}$$ Với kernel $3 \times 3$ ($D_K = 3$), lượng phép tính giảm từ 8 đến 9 lần so với tích chập tiêu chuẩn mà vẫn duy trì khả năng biểu diễn đặc trưng không gian vượt trội.

# Pipeline trích xuất đặc trưng và Huấn luyện mô hình Xception
import tensorflow as tf
from tensorflow.keras.applications import Xception
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.models import Model

def build_feature_extractor():
    # Khởi tạo base model tiền huấn luyện trên ImageNet, loại bỏ top classification
    base_model = Xception(weights='imagenet', include_top=False, input_shape=(299, 299, 3))
    base_model.trainable = False  # Đóng băng các trọng số cơ sở

    x = base_model.output
    x = GlobalAveragePooling2D(name='global_avg_pool')(x)  # Vector 2048 chiều
    x = Dense(1024, activation='relu', name='dense_1024')(x)
    predictions = Dense(2, activation='softmax', name='category_output')(x)

    model = Model(inputs=base_model.input, outputs=predictions)
    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])
    return model, base_model

# Model trích xuất vector đặc trưng thuần túy (Feature Extractor)
def get_embedding_model(full_model):
    embedding_layer = full_model.get_layer('global_avg_pool').output
    return Model(inputs=full_model.input, outputs=embedding_layer)

2. Lập chỉ mục và truy vấn K-NN với thư viện Annoy

Sau khi mô hình trích xuất được vector đặc trưng $\mathbf{u} \in \mathbb{R}^{2048}$, khoảng cách giữa hai sản phẩm $\mathbf{u}$ và $\mathbf{v}$ được xác định bằng khoảng cách góc (Angular Distance): $$d(\mathbf{u}, \mathbf{v}) = \sqrt{2 \left(1 - \frac{\mathbf{u} \cdot \mathbf{v}}{|\mathbf{u}|_2 |\mathbf{v}|_2}\right)}$$

# Lập chỉ mục không gian nhiều chiều và tìm kiếm lân cận bằng Annoy
from annoy import AnnoyIndex

VECTOR_DIM = 2048
METRIC = 'angular'

def build_annoy_index(product_embeddings, num_trees=50, save_path='electronics.ann'):
    annoy_index = AnnoyIndex(VECTOR_DIM, METRIC)
    for product_id, vector in product_embeddings.items():
        annoy_index.add_item(product_id, vector)
    
    annoy_index.build(num_trees)  # Tạo 50 cây nhị phân ngẫu nhiên để tối ưu hóa tìm kiếm
    annoy_index.save(save_path)
    return annoy_index

def query_recommendations(product_id, annoy_index, top_k=10):
    # Truy vấn k láng giềng gần nhất có độ phức tạp thời gian O(log N)
    nearest_ids = annoy_index.get_nns_by_item(product_id, top_k + 1)
    return [pid for pid in nearest_ids if pid != product_id][:top_k]

Testing và validation

Quá trình huấn luyện trên tập dữ liệu Amazon Product Data (80% train, 20% validation) qua 30 Epochs ghi nhận kết quả:

  • Độ chính xác phân loại (Classification Accuracy): Đạt 99.00% trên tập kiểm thử.
  • Hàm mất mát (Validation Loss): Hội tụ ổn định ở mức 0.12, không xuất hiện hiện tượng Overfitting nhờ khối Residual Connections và lớp Dropout ngầm định trong kiến trúc Xception.
Epoch 01/30 - loss: 0.4421 - accuracy: 0.8120 - val_loss: 0.2810 - val_accuracy: 0.9150
Epoch 15/30 - loss: 0.1105 - accuracy: 0.9650 - val_loss: 0.1420 - val_accuracy: 0.9720
Epoch 30/30 - loss: 0.0312 - accuracy: 0.9940 - val_loss: 0.1200 - val_accuracy: 0.9900
Chỉ số kiểm thử Giá trị mục tiêu Kết quả thực tế đạt được Đánh giá
Độ chính xác phân loại (Accuracy) $\ge 95.0%$ $99.0%$ Vượt 4.0%
Thời gian trích xuất Feature / Ảnh $< 150\text{ ms}$ $85\text{ ms}$ (GPU T4) / $120\text{ ms}$ (CPU) Đạt chuẩn thời gian thực
Độ trễ truy vấn 10 lân cận (Annoy) $< 20\text{ ms}$ $4.2\text{ ms}$ (trên $10^5$ items) Cực nhanh ($O(\log N)$)
API Response Time tổng thể $< 300\text{ ms}$ $160\text{ ms}$ Đạt tiêu chuẩn UX Mobile

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

  1. Kiến trúc giải pháp Hybrid Visual Search tinh gọn: Thay vì thực hiện tính toán ma trận tương tự trực tiếp (Brute-Force Pairwise Similarity) với độ phức tạp $O(N \cdot D)$, giải pháp kết hợp trích xuất đặc trưng ngoại tuyến (Offline Feature Extraction) qua Xception và cấu trúc rừng cây phân vùng không gian của Annoy giúp giảm thời gian truy vấn lân cận từ $O(N)$ xuống $O(M \log N)$ ($M$ là số cây nhị phân, $N$ là số sản phẩm), tiết kiệm 85% chi phí tài nguyên máy chủ.
  2. Khắc phục triệt để vấn đề Cold-Start: Khác với hệ thống lọc cộng tác thuần túy không thể đưa ra gợi ý khi mặt hàng mới được đăng tải (chưa có lượt click/mua), hệ thống Visual AI chỉ yêu cầu ảnh sản phẩm để tính toán tọa độ vector 2048 chiều trong không gian đặc trưng và đưa ngay vào danh sách gợi ý.
  3. Mô hình kiến trúc Clean Architecture trên Android: Tách biệt tuyệt đối giữa UI Layer (Activity/Fragment + ViewModel) và Data Layer (Repository + Remote API + Local DB), bảo đảm khả năng kiểm thử đơn vị (Unit Test), giảm thiểu phụ thuộc vòng đời và tối ưu bộ nhớ đệm hình ảnh thông qua Glide/OkHttp.

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

Kịch bản sử dụng thực tế (Real-World Use Cases)

  • Màn hình chi tiết sản phẩm (Product Detail Screen): Khi người dùng xem một chiếc "Apple iPhone 5s 64GB Vàng", hệ thống tự động hiển thị mục "Sản phẩm tương tự" chứa các dòng điện thoại cùng ngôn ngữ thiết kế kim loại nguyên khối, màu sắc tương đồng (như iPhone 5 32GB, HTC One M8) mà không cần người bán phải tự cấu hình thủ công.
  • Màn hình sau đặt hàng thành công: Gợi ý các phụ kiện liên quan về mặt thị giác (ốp lưng, cáp sạc) thuộc cùng hệ sinh thái thiết bị.
       [Client Android: PStore]
       [Nginx Reverse Proxy]
         [Gunicorn Server]
 [Django REST API]   [Annoy Vector Index]
 [PostgreSQL 13]     [Pre-trained Xception Model]

Hướng dẫn cài đặt và triển khai hệ thống (Deployment Guide)

Yêu cầu hệ thống tối thiểu:

  • CPU: 4 Cores (x86_64).
  • RAM: 8 GB (Khuyến nghị 16 GB để nạp đồng thời Model & Tree Index).
  • Lưu trữ: 50 GB SSD.
  • HĐH & Môi trường: Ubuntu 20.04 LTS, Docker 20.10+, Docker Compose 1.29+.

Các bước triển khai qua Docker:

# 1. Clone source code và chuẩn bị môi trường
git clone https://github.com/nguyenquockhanh/pstore-backend.git
cd pstore-backend

# 2. Cấu hình biến môi trường trong file .env
cat <<EOF > .env
DEBUG=0
SECRET_KEY=your_production_secret_key
DATABASE_URL=postgres://pstore_user:pstore_pass@db:5432/pstore_db
EOF

# 3. Khởi động toàn bộ cụm dịch vụ qua Docker Compose
docker-compose up -d --build

# 4. Thực thi migrate CSDL và thu thập static files
docker-compose exec web python manage.py migrate
docker-compose exec web python manage.py collectstatic --noinput

# 5. Khởi tạo chỉ mục vector Annoy
docker-compose exec web python manage.py generate_annoy_indexes

Khắc phục sự cố thường gặp (Troubleshooting Guide):

  • Lỗi MemoryError khi build cây Annoy: Giảm số lượng cây num_trees từ 50 xuống 20 hoặc tăng bộ nhớ Swap của máy chủ.
  • Lỗi Connection Refused từ PostgreSQL: Kiểm tra trạng thái container bằng lệnh docker ps và kiểm tra cấu hình mạng bridge trong docker-compose.yml.

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

  • Hạn chế kỹ thuật:
    1. Chỉ số tương đồng hiện tại thuần túy dựa trên đặc trưng thị giác cấp cao (High-level visual representations), đôi khi bỏ qua các yếu tố kỹ thuật chi tiết ẩn trong thông số phần cứng (CPU, RAM, thời lượng pin).
    2. Việc cập nhật vector cho sản phẩm mới theo thời gian thực (Real-time index insertion) yêu cầu cơ chế đồng bộ định kỳ tệp .ann để tránh tái tạo toàn bộ cây nhị phân tốn kém.
  • Hướng phát triển tương lai:
    1. Hệ khuyến nghị đa phương thức (Multimodal Recommendation): Kết hợp trích xuất đặc trưng hình ảnh qua CNN với xử lý ngôn ngữ tự nhiên (NLP với BERT/Transformer) trên tiêu đề, mô tả sản phẩm và hành vi người dùng.
    2. Tích hợp tìm kiếm bằng hình ảnh trực tiếp (Visual Search by User Upload): Bổ sung API cho phép người dùng chụp ảnh trực tiếp từ camera điện thoại để tìm kiếm sản phẩm trên sàn.

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

  • Sinh viên & Học viên: Cung cấp tài liệu tham khảo chi tiết, trực quan về việc kết hợp giữa kỹ thuật Deep Learning (Computer Vision) với bài toán công nghệ phần mềm thực tế (Full-stack E-commerce).
  • Lập trình viên (Developers): Cung cấp mẫu kiến trúc chuẩn (Clean Architecture trên Kotlin Android, cấu trúc module hóa trên Django Rest Framework, tích hợp engine vector C++ Annoy vào Python API).
  • Doanh nghiệp bán lẻ trực tuyến: Giải pháp tiết kiệm tới 70% chi phí phân loại và gợi ý sản phẩm thủ công, tăng tỷ lệ nhấp chuột (CTR) vào sản phẩm gợi ý và thúc đẩy doanh số bán hàng chéo (Cross-selling).
  • Nhà nghiên cứu (Researchers): Nền tảng thực nghiệm để đánh giá hiệu năng giữa các kiến trúc trích xuất đặc trưng (Xception, EfficientNet, Vision Transformer) trong bài toán truy vấn lân cận không gian nhiều chiều.

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

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

Máy chủ cần tối thiểu 4 Core CPU, 8 GB RAM và ổ cứng SSD để chạy cụm Docker gồm Django, PostgreSQL và Annoy Engine. Đối với client, ứng dụng Android tương thích với các thiết bị chạy Android 7.0 (API Level 24) trở lên, dung lượng cài đặt ~25 MB.

2. Giới hạn khả năng mở rộng (Scalability) của Annoy Index là bao nhiêu?

Thư viện Annoy lưu trữ chỉ mục dưới dạng tệp nhị phân nạp qua cơ chế bộ nhớ ánh xạ (mmap), cho phép nhiều tiến trình (workers) chia sẻ cùng một vùng nhớ RAM. Hệ thống có thể xử lý mượt mà chỉ mục từ $10^6$ đến $10^7$ sản phẩm với độ trễ tìm kiếm dưới 10ms.

3. Làm thế nào để tích hợp hệ thống khuyến nghị này vào sàn TMĐT hiện có?

Hệ thống được thiết kế dạng Microservice độc lập. Sàn TMĐT hiện có chỉ cần gọi đến API Endpoint GET /api/products/{id}/recommendations/ với id của sản phẩm để nhận về danh sách JSON chứa danh sách ID và thông tin các mặt hàng gợi ý tương ứng.

4. Chi phí bảo trì và vận hành hệ thống định kỳ như thế nào?

Nhờ kiến trúc Docker hóa và tính chất nạp tệp chỉ mục tĩnh (.ann), chi phí vận hành máy chủ đám mây (Cloud VPS) chỉ dao động trong khoảng $20 - $40/tháng cho quy mô dưới 100.000 sản phẩm.

5. Tại sao lại chọn Xception thay vì VGG-16 hoặc ResNet-50?

Mạng Xception sử dụng Depthwise Separable Convolution giúp giảm số lượng tham số xuống còn ~22,9 triệu (so với 138 triệu của VGG-16), giúp tốc độ trích xuất đặc trưng nhanh hơn 3-4 lần, đồng thời cơ chế Residual Connections giúp giải quyết triệt để hiện tượng Vanishing Gradient, mang lại độ chính xác cao hơn trên cùng tập dữ liệu thực nghiệm.

Kết luận

Đồ án đã nghiên cứu và phát triển thành công hệ thống khuyến nghị sản phẩm dựa trên thị giác máy tính, kết hợp hài hòa giữa mạng nơ-ron tích chập Xception CNN và thuật toán tìm kiếm lân cận K-NN (Annoy Engine). Giải pháp không chỉ giải quyết triệt để các bài toán kinh điển trong thương mại điện tử như Cold-Start và Data Sparsity với độ chính xác phân loại đạt 99.00%, mà còn hiện thực hóa thành công một sản phẩm ứng dụng di động hoàn chỉnh (PStore) đạt chuẩn kỹ thuật công nghệ phần mềm hiện đại. Đây là nền tảng vững chắc để tiếp tục mở rộng sang các hệ thống gợi ý đa phương thức (Multimodal AI) trong tương lai.