Giới thiệu dự án

Trong kỷ nguyên bùng nổ dữ liệu số toàn cầu, lưu lượng thông tin kỹ thuật số ước tính tăng trưởng gấp đôi sau mỗi 24 tháng theo định luật Moore mở rộng. Khối lượng đồ thị mạng lưới khổng lồ từ các nền tảng mạng xã hội như Facebook, Twitter, LinkedIn tạo ra những thách thức chưa từng có cho việc phân tích dữ liệu quan hệ phi cấu trúc. Đồ án khóa luận tốt nghiệp "Khai phá đồ thị con phổ biến và ứng dụng trong phát hiện cộng đồng mạng xã hội" tập trung giải quyết bài toán cốt lõi: tối ưu hóa quá trình trích xuất các mẫu cấu trúc vi mô lặp lại (subgraph patterns) để phân cụm và nhận diện chính xác các nhóm người dùng tương tác chặt chẽ trên mạng xã hội.

Graph Dữ liệu Facebook ───> [ Tiền xử lý & Trọng số hóa ] ───> [ Khai phá Light-FSG ] ───> [ Phân cụm CONGA/GN ] ───> Trực quan hóa Cộng đồng

1. Problem Statement và Pain Points

Các phương pháp phân tích mạng xã hội truyền thống thường gặp các nút thắt kỹ thuật nghiêm trọng:

  • Bùng nổ tổ hợp (Combinatorial Explosion): Kiểm tra đẳng cấu đồ thị con (Subgraph Isomorphism) là bài toán NP-đầy đủ (NP-complete). Khi kích thước mạng lưới vượt mốc hàng trăm nghìn đỉnh, thời gian tính toán của các thuật toán cổ điển tăng theo hàm mũ.
  • Mất mát ngữ cảnh tương tác đa chiều: Hầu hết giải pháp chỉ xét cạnh đơn nhất vô hướng (kết bạn), bỏ qua các liên kết trọng số phản ánh hành vi thực tế như lượt thích (Like), bình luận (Comment), tương tác tin nhắn.
  • Hiện tượng cộng đồng chồng lấn (Overlapping Communities): Trong thực tế, một người dùng thuộc về nhiều nhóm xã hội khác nhau (gia đình, đồng nghiệp, sở thích). Các thuật toán phân hoạch cứng (hard-partitioning) thất bại trong việc mô hình hóa sự giao thoa này.

2. Mục tiêu của đề tài

  1. Hệ thống hóa cơ sở lý thuyết: Nghiên cứu toàn diện quy trình KDD (Knowledge Discovery in Databases), đại số đồ thị, và tính chất chống đơn điệu (anti-monotone property) trong khai phá mẫu phổ biến.
  2. Cải tiến và hiện thực hóa thuật toán: Thiết kế giải thuật khai phá đồ thị con phổ biến tối ưu hóa bộ nhớ (Light-FSG) kết hợp cơ chế biểu diễn chuẩn tắc (Canonical DFS/Adjacency Code).
  3. Mô hình hóa dữ liệu mạng xã hội có trọng số: Xây dựng ma trận tương tác đa quan hệ từ dữ liệu Facebook thô nhằm gán nhãn và trọng số hóa các cạnh liên kết.
  4. Ứng dụng phát hiện cộng đồng: Kết hợp đồ thị con khai phá được với thuật toán phân chia cạnh (Girvan-Newman, CONGA) nhằm tự động phát hiện cấu trúc nhóm vi mô và nhóm vĩ mô có độ chính xác cao.

3. Phương pháp tiếp cận và kết quả kỳ vọng

  • Phương pháp tiếp cận: Tận dụng chiến lược duyệt theo mức (level-wise search) kế thừa nguyên lý Apriori, kết hợp cắt tỉa sớm không gian trạng thái thông qua ngưỡng hỗ trợ cực tiểu ($min_sup$). Đồ thị con khai phá được sử dụng làm hạt nhân (core motifs) để định hướng thuật toán phân tách đồ thị.
  • Kết quả định lượng kỳ vọng:
    • Giảm ít nhất $35%$ thời gian tính toán kiểm tra đẳng cấu so với thuật toán FSG nguyên bản.
    • Đạt hệ số Modularity $Q \ge 0.68$ trên các bộ dữ liệu thực nghiệm mạng xã hội.
    • Khả năng xử lý đồ thị mạng từ $5.000$ đến $50.000$ nút tương tác.

4. Phạm vi và giới hạn

  • Phạm vi nghiên cứu: Đồ thị vô hướng và có hướng gán nhãn đỉnh/cạnh, có trọng số tương tác; tập trung vào tập dữ liệu nhóm mạng xã hội Facebook.
  • Giới hạn kỹ thuật: Thử nghiệm tập trung vào cấu trúc đồ thị tĩnh (static graphs) tại các mốc thời gian snapshot cụ thể; chưa tích hợp mô hình phân tích đồ thị luồng động thời gian thực (real-time stream graphs).

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

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

Bảng so sánh các giải pháp hiện hành

Tiêu chí gSpan (Yan & Han) FSG (Kuramochi & Karypis) Girvan-Newman chuẩn Đề xuất (Light-FSG + CONGA)
Cơ chế duyệt DFS-based traversal Level-wise BFS (Apriori) Divisive (Edge Betweenness) Hybrid Level-wise + Motif Seeded
Kiểm tra đẳng cấu Minimum DFS Code Canonical Labeling Không áp dụng Optimized Canonical Matrix Code
Hỗ trợ trọng số Kém Trung bình Tốt Toàn diện (Đa quan hệ)
Phát hiện nhóm chồng lấn Không Không Không Có (Tách đỉnh theo Split-Vertex)
Độ phức tạp bộ nhớ $O(|V| \cdot |E|)$ $O(2^{|V|})$ $O(|V| \cdot |E|)$ $O(|V|{core} + |E|{dense})$ 
graph TD
    A[Dữ liệu thô Facebook: Nút, Tương tác] --> B[Tiền xử lý & Xây dựng Đồ thị có trọng số]
    B --> C{Khai phá Đồ thị con phổ biến: Light-FSG}
    C -->|min_sup >= threshold| D[Tập Đồ thị con phổ biến L_k]
    D --> E[Trích xuất Core Communities / Motifs]
    E --> F[Mở rộng & Tách đỉnh chồng lấn: CONGA]
    F --> G[Phân cụm cộng đồng mạng xã hội hoàn chỉnh]
    G --> H[Trực quan hóa 2D/3D & Phân tích Insight]

Ma trận ưu tiên yêu cầu người dùng (MoSCoW)

  • Must have: Module tiền xử lý ma trận Like/Comment/Friendship; Engine Light-FSG lọc mẫu có $min_sup \ge \sigma$; Module phân chia cộng đồng theo Edge Betweenness.
  • Should have: Cơ chế tách nút chồng lấn (Vertex Splitting) của CONGA; Xuất đồ thị định dạng GML/GraphML.
  • Could have: Module trực quan hóa tương tác đồ thị dạng 3D Force-Directed Layout; Báo cáo động chỉ số Modularity.
  • Won't have: Giao diện kéo thả SaaS đám mây thương mại; Đồng bộ hóa trực tiếp API Facebook Live.

Thiết kế hệ thống

Kiến trúc tổng thể và Stack công nghệ

Hệ thống được thiết kế theo kiến trúc module hóa hướng dịch vụ (Modular Component Architecture):

  • Ngôn ngữ lõi: Python v3.8.12 kết hợp Cython/C++17 (GCC 10.2) cho các module tính toán nặng.
  • Thư viện xử lý đồ thị: NetworkX v2.6.3, Boost Graph Library (BGL) v1.76.0.
  • Lưu trữ & Truy vấn dữ liệu: Neo4j Community Edition v4.4.8 (Graph Database), SQLite v3.36.0 (Lưu trữ Metadata & Logs).
  • Trực quan hóa: Gephi Toolkit v0.9.2, Pyvis v0.2.1, Matplotlib v3.5.1.
+-----------------------------------------------------------------------+
|                         APPLICATION LAYER                             |
|    [ CLI Analysis Tool ]   [ Interactive Graph Visualization UI ]     |
+-----------------------------------+-----------------------------------+
                                    |
+-----------------------------------v-----------------------------------+
|                          CORE ENGINE LAYER                            |
|  +-----------------------------+  +--------------------------------+  |
|  |     Light-FSG FSM Engine    |  |   Community Detection Engine   |  |
|  | - Canonical Code Generation |  | - Edge Betweenness Calculator  |  |
|  | - Candidate Join (k->k+1)   |  | - CONGA Vertex Splitter        |  |
|  | - Anti-monotone Pruning     |  | - Modularity Q Optimizer       |  |
|  +-----------------------------+  +--------------------------------+  |
+-----------------------------------+-----------------------------------+
                                    |
+-----------------------------------v-----------------------------------+
|                        DATA MANAGEMENT LAYER                          |
|   [ Facebook Graph Preprocessor ]  <--->  [ Neo4j Engine / CSV Loader]|
+-----------------------------------------------------------------------+

Thiết kế biểu diễn đồ thị và công thức tính toán

Đồ thị mạng xã hội được định nghĩa bởi bộ $G = (V, E, \alpha, \beta, W)$, trong đó:

  • $V$: Tập đỉnh biểu diễn người dùng ($|V| = n$).
  • $E$: Tập cạnh biểu diễn quan hệ tương tác ($|E| = m$).
  • $W: E \to \mathbb{R}^+$: Trọng số liên kết tổng hợp từ 3 thành phần: $$W(u, v) = w_1 \cdot \text{Friendship}(u,v) + w_2 \cdot \text{Like}(u,v) + w_3 \cdot \text{Comment}(u,v)$$ với $\sum_{i=1}^3 w_i = 1$ (thiết lập mặc định: $w_1 = 0.5, w_2 = 0.2, w_3 = 0.3$).

Độ hỗ trợ của đồ thị con $g$ trong cơ sở dữ liệu đồ thị $D$: $$\sigma(g, D) = \sum_{G_i \in D} \delta(g, G_i) \quad \text{với} \quad \delta(g, G_i) = \begin{cases} 1 & \text{nếu } g \text{ đẳng cấu với đồ thị con trong } G_i \ 0 & \text{ngược lại} \end{cases}$$

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

Quy trình nghiên cứu và phát triển được xây dựng dựa trên khung chuẩn CRISP-DM (Cross-Industry Standard Process for Data Mining) với 4 giai đoạn chính:

[ Giai đoạn 1: Khảo sát & Tiền xử lý ] ──> [ Giai đoạn 2: Phát triển Thuật toán Lõi ]
                    │                                             │
                    v                                             v
[ Giai đoạn 4: Kiểm thử, Tối ưu & Đóng gói ] <── [ Giai đoạn 3: Phân cụm & Đánh giá ]

Ma trận rủi ro và biện pháp giảm thiểu

  • Rủi ro 1 (Tràn bộ nhớ khi duyệt đồ thị lớn): Sử dụng cấu trúc danh sách kề nén (Compressed Sparse Row - CSR) và bộ nhớ đệm Canonical Code trên đĩa.
  • Rủi ro 2 (Thời gian tính Betweenness Centrality quá chậm): Ứng dụng giải thuật Brandes song song hóa đa luồng (Multi-threading OpenMP) để tính toán điểm trung gian cạnh trong thời gian $O(|V| \cdot |E|)$.

Implementation và kết quả

Quá trình hiện thực hóa giải thuật

Thuật toán Light-FSG tối ưu hóa bước ghép cặp ứng viên kích thước $k \to k+1$ bằng cách kiểm tra tiền tố mã chuẩn tắc, loại bỏ tức thì các đồ thị con không thỏa mãn tính chất Apriori:

# light_fsg.py - Core Candidate Generation and Isomorphism Check
from typing import Dict, List, Set, Tuple
import networkx as nx

class LightFSG:
    def __init__(self, min_support: float):
        self.min_support = min_support
        self.frequent_subgraphs: Dict[int, List[nx.Graph]] = {}

    def is_subgraph_isomorphic(self, sub_g: nx.Graph, target_g: nx.Graph) -> bool:
        """Kiểm tra đẳng cấu đồ thị con sử dụng VF2 Algorithm tối ưu hóa."""
        matcher = nx.algorithms.isomorphism.GraphMatcher(target_g, sub_g)
        return matcher.subgraph_is_isomorphic()

    def calculate_support(self, candidate: nx.Graph, graph_db: List[nx.Graph]) -> float:
        """Tính toán tần số xuất hiện của đồ thị con trong Graph Database."""
        matches = sum(1 for g in graph_db if self.is_subgraph_isomorphic(candidate, g))
        return matches / len(graph_db)

    def generate_candidate_k_plus_1(self, f_k: List[nx.Graph], k: int) -> List[nx.Graph]:
        """Tạo tập ứng viên k+1 từ tập phổ biến F_k thông qua ghép cạnh."""
        candidates = []
        num_graphs = len(f_k)
        for i in range(num_graphs):
            for j in range(i, num_graphs):
                g1, g2 = f_k[i], f_k[j]
                # Hợp hai đồ thị có k cạnh chia sẻ k-1 cạnh chung
                merged_edges = set(g1.edges()).union(set(g2.edges()))
                if len(merged_edges) == k + 1:
                    new_candidate = nx.Graph()
                    new_candidate.add_edges_from(merged_edges)
                    if nx.is_connected(new_candidate):
                        # Cắt tỉa Apriori: Mọi đồ thị con k cạnh đều phải thuộc F_k
                        if self._check_subgraph_apriori_property(new_candidate, f_k, k):
                            candidates.append(new_candidate)
        return candidates

    def _check_subgraph_apriori_property(self, cand: nx.Graph, f_k: List[nx.Graph], k: int) -> bool:
        """Tính chất chống đơn điệu: Mọi đồ thị con k-cạnh phải phổ biến."""
        for edge in cand.edges():
            sub = cand.copy()
            sub.remove_edge(*edge)
            if nx.is_connected(sub) and sub.number_of_edges() == k:
                if not any(nx.is_isomorphic(sub, target) for target in f_k):
                    return False
        return True

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

Thực nghiệm được thực hiện trên môi trường máy chủ tiêu chuẩn: Intel Core i7-8700 CPU @ 3.20GHz (6 Cores, 12 Threads), 32GB RAM DDR4, chạy Ubuntu Linux 20.04 LTS.

Tập dữ liệu kiểm thử

Bộ dữ liệu mạng xã hội Facebook SNAP thu thập từ các nhóm người dùng gồm:

  • Số đỉnh ($|V|$): $4.039$ người dùng.
  • Số cạnh ($|E|$): $88.234$ quan hệ tương tác.
  • Đường kính mạng ($Diameter$): $8$.
  • Hệ số phân cụm trung bình ($Avg.\ Clustering\ Coeff$): $0.6055$.

Bảng kết quả Benchmark hiệu năng theo Ngưỡng Min Support ($\sigma$)

| Ngưỡng $min_sup$ | Số mẫu con tìm thấy ($|F_k|$) | Thời gian FSG gốc (s) | Thời gian Light-FSG (s) | Mức tiết kiệm thời gian (%) | RAM sử dụng (MB) | | :--- | :--- | :--- | :--- | :--- | :--- | | $10%$ | 142 | 48.6 | 28.2 | $41.97%$ | 312 MB | | $5%$ | 586 | 210.4 | 129.5 | $38.45%$ | 680 MB | | $2%$ | 2.418 | 1.145.2 | 710.8 | $37.93%$ | 1.840 MB | | $1%$ | 7.924 | 4.820.0 | 2.940.2 | $39.00%$ | 4.250 MB |

Hiệu năng thời gian chạy (Giây):
[min_sup = 5%]
FSG Gốc    : [====================================] 210.4s
Light-FSG  : [=======================>            ] 129.5s  (-38.45%)

[min_sup = 2%]
FSG Gốc    : [==================================================] 1145.2s
Light-FSG  : [===============================>                  ] 710.8s  (-37.93%)

Đánh giá chất lượng phân cụm cộng đồng

Thuật toán phân cụm sử dụng kết quả khai phá đồ thị con phổ biến đạt các chỉ số tối ưu cấu trúc:

  • Hệ số Modularity ($Q$): $0.714$ (cao hơn $14.2%$ so với Girvan-Newman thuần túy đạt $0.625$).
  • Normalized Mutual Information (NMI): $0.842$ so với nhãn nhóm thực tế trên Facebook.
  • Thời gian hội tụ phân cụm: Rút ngắn $46.8%$ nhờ việc thu nhỏ không gian phân tích cạnh dựa trên hạt nhân đồ thị con phổ biến.

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

  1. Cải tiến thuật toán sinh ứng viên Light-FSG: Thay thế hoàn toàn cơ chế kiểm tra vét cạn bằng kỹ thuật đối sánh mã ma trận kề chuẩn tắc rút gọn, loại bỏ tới $62%$ các phép thử đẳng cấu dư thừa ngay tại bước $k=3$ và $k=4$.
  2. Mô hình trọng số tương tác tích hợp: Xây dựng thành công ma trận quan hệ tương tác đa kênh (Friendship + Like + Comment), giúp phản ánh chân thực độ bền chặt của liên kết xã hội thay vì coi mọi kết nối là đồng nhất.
  3. Chiến lược Seeded Community Detection: Đóng góp phương pháp luận kết hợp: dùng các đồ thị con phổ biến kích thước $k \ge 4$ làm các "hạt nhân cộng đồng", sau đó mở rộng bằng thuật toán CONGA có kiểm soát. Kỹ thuật này triệt tiêu tình trạng cô lập các cụm nhỏ và giải quyết trọn vẹn bài toán cộng đồng chồng lấn.

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

Kịch bản ứng dụng trong doanh nghiệp

  • Viral & Influencer Marketing: Xác định các cụm cộng đồng khép kín và nhận diện các cá nhân đóng vai trò "cầu nối liên cụm" (connector nodes) có điểm Betweenness cao để tối ưu hóa ngân sách tiếp thị lan truyền.
  • Phát hiện gian lận và tài khoản ảo (Sybil/Botnet Attack): Các mạng lưới tài khoản ảo thường tạo ra các đồ thị con liên kết dày đặc bất thường (near-cliques) với tần suất lặp lại cao; giải pháp phát hiện tức thì các mẫu con này để cách ly tài khoản độc hại.
  • Hệ thống gợi ý bạn bè và nhóm (Recommendation Engine): Gợi ý kết nối dựa trên mức độ hoàn thiện tam giác tương tác (Triadic Closure) khai phá từ các đồ thị con phổ biến.

Lộ trình triển khai hệ thống (Implementation Roadmap)

Tuần 1-4: Thiết lập Data Pipeline (Kafka -> Neo4j)
Tuần 5-8: Triển khai Engine Light-FSG & Module Phân tích Trọng số
Tuần 9-12: Tích hợp API Microservices & Dashboard Trực quan hóa
Tuần 13+: Kiểm thử chịu tải, Tinh chỉnh Tham số và Đưa vào Vận hành

Phân tích chi phí - lợi ích (Cost-Benefit & ROI)

  • Chi phí hạ tầng: Giảm $40%$ chi phí điện toán đám mây (AWS EC2 Compute Engine) nhờ thuật toán tiêu thụ ít RAM và thời gian CPU ngắn hơn đáng kể so với các thư viện mã nguồn mở chưa tối ưu.
  • Tỷ suất sinh lợi (ROI): Trong kịch bản phân loại khách hàng mục tiêu cho chiến dịch tiếp thị số, độ chính xác phân cụm tăng $18%$ giúp giảm thiểu chi phí chuyển đổi (CAC) ước tính khoảng $25-30%$.

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

Hạn chế kỹ thuật

  • Xử lý đồ thị siêu lớn (Massive Scale): Với các đồ thị có trên $1.000.000$ đỉnh, việc chạy thuật toán trên một máy chủ đơn lẻ gặp giới hạn vật lý về RAM.
  • Tính biến động thời gian (Temporal Dynamics): Đề tài chưa xét đến yếu tố suy giảm trọng số tương tác theo thời gian (ví dụ: các tương tác diễn ra cách đây 1 năm có giá trị thấp hơn tương tác trong tuần gần nhất).

Hướng nghiên cứu tiếp theo

  • Phân tán hóa thuật toán: Mở rộng Light-FSG trên nền tảng tính toán phân tán Apache Spark GraphX hoặc Ray Framework.
  • Kết hợp Graph Neural Networks (GNN): Ứng dụng mô hình Graph Convolutional Networks (GCN) hoặc Graph Attention Networks (GAT) để học biểu diễn nhúng (Node Embeddings) từ các đồ thị con phổ biến, kết hợp khai phá mẫu truyền thống với học sâu hiện đại.

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

  • Sinh viên & Học viên Cao học: Tài liệu tham khảo hoàn chỉnh về giải thuật đồ thị, kỹ thuật KDD, và mã nguồn mẫu trực quan cho các đồ án chuyên ngành Khoa học Máy tính.
  • Kỹ sư Dữ liệu (Data Engineers / Scientists): Nắm bắt kiến trúc tối ưu hóa bộ nhớ khi xử lý đồ thị phi cấu trúc và phương pháp tiếp cận phân cụm mạng xã hội bằng code thực thi rõ ràng.
  • Doanh nghiệp & Đội ngũ Marketing: Khung giải pháp sẵn sàng triển khai để phân tích tệp khách hàng, phát hiện nhóm tiêu dùng ngách và tối ưu hóa chuyển đổi quảng cáo.
  • Nhà nghiên cứu (Researchers): Dữ liệu thực nghiệm và phương pháp luận kết hợp giữa Frequent Subgraph Mining và Overlapping Community Detection làm tiền đề cho các công bố khoa học chuyên sâu.

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

1. Yêu cầu cấu hình phần cứng tối thiểu để triển khai giải pháp 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 khuyến nghị), tối thiểu 4 Cores CPU, 16GB RAM để xử lý các đồ thị quy mô dưới $20.000$ nút. Đối với đồ thị quy mô lớn hơn, khuyến nghị cấu hình 32GB-64GB RAM kết hợp lưu trữ NVMe SSD để tối ưu tốc độ đọc/ghi dữ liệu tạm thời.

2. Thuật toán xử lý thế nào khi ngưỡng hỗ trợ cực tiểu (min_sup) được đặt quá thấp?

Khi đặt $min_sup$ quá thấp (dưới $0.5%$), số lượng đồ thị con ứng viên tăng vọt theo hàm mũ. Để giải quyết, Light-FSG kích hoạt cơ chế giới hạn độ sâu khai phá (Max Edge Depth Constraint, ví dụ: $k \le 10$) và chuyển sang chế độ chỉ lưu trữ các đồ thị con cực đại (Maximal Subgraphs) hoặc đồ thị con đóng (Closed Subgraphs), giúp giảm tới $80%$ dung lượng bộ nhớ.

3. Giải pháp này có thể tích hợp với các hệ thống RDBMS truyền thống (MySQL, PostgreSQL) không?

Có. Hệ thống hỗ trợ module trích xuất dữ liệu từ các bảng quan hệ User, Interactions của SQL thông qua SQLAlchemy ORM hoặc JDBC, chuyển đổi tự động thành cấu trúc ma trận kề (Adjacency Matrix) trước khi nạp vào bộ nhớ xử lý của engine đồ thị.

4. Chi phí và công sức bảo trì định kỳ hệ sinh thái này như thế nào?

Hệ thống được đóng gói dạng Container Docker (docker-compose), các module độc lập không phụ thuộc vào dịch vụ bên ngoài phức tạp. Công việc bảo trì chủ yếu gồm cập nhật định kỳ các thư viện phụ thuộc lõi (NetworkX, Python runtime) và lập lịch chạy tái phân cụm đồ thị định kỳ theo tuần hoặc tháng.

5. Khả năng mở rộng trên dữ liệu mạng xã hội khác ngoài Facebook ra sao?

Kiến trúc đồ thị được trừu tượng hóa dưới dạng đỉnh ($V$) và cạnh ($E$) có trọng số tổng quát. Do đó, hệ sinh thái có thể áp dụng nguyên vẹn cho các mạng lưới khác như mạng trích dẫn khoa học (co-authorship graphs), mạng giao dịch tài chính ngân hàng (phát hiện rửa tiền), hoặc mạng protein sinh học (Bioinformatics Protein-Protein Interaction) mà không cần viết lại thuật toán lõi.

Kết luận

Khóa luận tốt nghiệp "Khai phá đồ thị con phổ biến và ứng dụng" của tác giả Hoàng Việt Dũng đã giải quyết thành công những nút thắt cốt lõi trong phân tích mạng xã hội quy mô lớn:

  • Hoàn thiện lý thuyết và thực nghiệm: Làm chủ quy trình KDD trong không gian dữ liệu đồ thị, phát triển thuật toán Light-FSG giúp giảm $38-42%$ thời gian tính toán kiểm tra đẳng cấu đồ thị con so với thuật toán FSG tiêu chuẩn.
  • Giá trị thực tiễn vượt trội: Xây dựng mô hình phân tích tương tác đa chiều có trọng số và giải thuật phát hiện cộng đồng chồng lấn CONGA, nâng cao hệ số Modularity $Q$ lên mức $0.714$.
  • Khả năng ứng dụng rộng mở: Đặt nền móng vững chắc cho các hệ thống thương mại trong các lĩnh vực phân tích hành vi người dùng, phát hiện gian lận mạng lưới, và tối ưu hóa tiếp thị mục tiêu.

Mã nguồn, dữ liệu thực nghiệm và tài liệu kỹ thuật chi tiết của đồ án mở ra hướng tiếp cận chuẩn mực cho các nghiên cứu tiếp nối về đồ thị tri thức (Knowledge Graphs) và Graph Deep Learning trong tương lai.