bpg-partitioning 0.1.0__tar.gz

bpg_partitioning-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: bpg-partitioning
+Version: 0.1.0
+Summary: BPG-Based Initial Partitioning for Hybrid Data Partitioning in NewSQL Databases
+Author-email: verse91 <versedev.store@proton.me>
+Project-URL: Homepage, https://github.com/versenilvis/bpg-hybrid-partitioning
+Project-URL: Repository, https://github.com/versenilvis/bpg-hybrid-partitioning.git
+Keywords: newsql,distributed-database,partitioning,bpg,normalized-cut
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/plain
+Requires-Dist: Faker
+Requires-Dist: networkx
+Requires-Dist: numpy
+Requires-Dist: prettytable
+Requires-Dist: scipy
+
+BPG-Based Initial Partitioning for Hybrid Data Partitioning in NewSQL Databases
+Tạm dịch: Thay thế thuật toán khởi tạo bằng BPG cho phương pháp phân mảnh dữ liệu hybrid trong hệ cơ sở dữ liệu NewSQL
+
+
+Dự án hiện thực hóa thuật toán Bregman Proximal Gradient (BPG) cho bài toán phân bổ dữ liệu khởi tạo trong các phương án phân mảnh hybrid cho hệ cơ sở dữ liệu phân tán NewSQL
+
+Mã nguồn này thay thế thuật toán phân mảnh khởi đầu tham lam (Algorithm 5 của Schreiner và cộng sự) bằng mô hình tối ưu Normalized Cut liên tục được giải bằng BPG (Niu và cộng sự) nhằm giảm thiểu chi phí nghẽn mạng do giao dịch phân tán và cân bằng tải công việc giữa các máy chủ
+
+
+
+[1] P. Niu, B. Ren, H. Wu, and X. Yao, "Modeling and optimization for massive data allocation in database," arXiv:2605.31002, Jun 2026
+
+[2] G. A. Schreiner, R. de Santiago, D. Duarte, and R. dos Santos Mello, "An autonomous hybrid data partitioning approach for NewSQL databases," Journal of the Brazilian Computer Society, vol. 32, no. 1, Art. no. 1, 2026, doi: 10.5753/jbcs.2026.5684

bpg_partitioning-0.1.0/README

@@ -0,0 +1,13 @@
+BPG-Based Initial Partitioning for Hybrid Data Partitioning in NewSQL Databases
+Tạm dịch: Thay thế thuật toán khởi tạo bằng BPG cho phương pháp phân mảnh dữ liệu hybrid trong hệ cơ sở dữ liệu NewSQL
+
+
+Dự án hiện thực hóa thuật toán Bregman Proximal Gradient (BPG) cho bài toán phân bổ dữ liệu khởi tạo trong các phương án phân mảnh hybrid cho hệ cơ sở dữ liệu phân tán NewSQL
+
+Mã nguồn này thay thế thuật toán phân mảnh khởi đầu tham lam (Algorithm 5 của Schreiner và cộng sự) bằng mô hình tối ưu Normalized Cut liên tục được giải bằng BPG (Niu và cộng sự) nhằm giảm thiểu chi phí nghẽn mạng do giao dịch phân tán và cân bằng tải công việc giữa các máy chủ
+
+
+
+[1] P. Niu, B. Ren, H. Wu, and X. Yao, "Modeling and optimization for massive data allocation in database," arXiv:2605.31002, Jun 2026
+
+[2] G. A. Schreiner, R. de Santiago, D. Duarte, and R. dos Santos Mello, "An autonomous hybrid data partitioning approach for NewSQL databases," Journal of the Brazilian Computer Society, vol. 32, no. 1, Art. no. 1, 2026, doi: 10.5753/jbcs.2026.5684

bpg_partitioning-0.1.0/bpg_partitioning.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: bpg-partitioning
+Version: 0.1.0
+Summary: BPG-Based Initial Partitioning for Hybrid Data Partitioning in NewSQL Databases
+Author-email: verse91 <versedev.store@proton.me>
+Project-URL: Homepage, https://github.com/versenilvis/bpg-hybrid-partitioning
+Project-URL: Repository, https://github.com/versenilvis/bpg-hybrid-partitioning.git
+Keywords: newsql,distributed-database,partitioning,bpg,normalized-cut
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/plain
+Requires-Dist: Faker
+Requires-Dist: networkx
+Requires-Dist: numpy
+Requires-Dist: prettytable
+Requires-Dist: scipy
+
+BPG-Based Initial Partitioning for Hybrid Data Partitioning in NewSQL Databases
+Tạm dịch: Thay thế thuật toán khởi tạo bằng BPG cho phương pháp phân mảnh dữ liệu hybrid trong hệ cơ sở dữ liệu NewSQL
+
+
+Dự án hiện thực hóa thuật toán Bregman Proximal Gradient (BPG) cho bài toán phân bổ dữ liệu khởi tạo trong các phương án phân mảnh hybrid cho hệ cơ sở dữ liệu phân tán NewSQL
+
+Mã nguồn này thay thế thuật toán phân mảnh khởi đầu tham lam (Algorithm 5 của Schreiner và cộng sự) bằng mô hình tối ưu Normalized Cut liên tục được giải bằng BPG (Niu và cộng sự) nhằm giảm thiểu chi phí nghẽn mạng do giao dịch phân tán và cân bằng tải công việc giữa các máy chủ
+
+
+
+[1] P. Niu, B. Ren, H. Wu, and X. Yao, "Modeling and optimization for massive data allocation in database," arXiv:2605.31002, Jun 2026
+
+[2] G. A. Schreiner, R. de Santiago, D. Duarte, and R. dos Santos Mello, "An autonomous hybrid data partitioning approach for NewSQL databases," Journal of the Brazilian Computer Society, vol. 32, no. 1, Art. no. 1, 2026, doi: 10.5753/jbcs.2026.5684

bpg_partitioning-0.1.0/bpg_partitioning.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README
+pyproject.toml
+bpg_partitioning.egg-info/PKG-INFO
+bpg_partitioning.egg-info/SOURCES.txt
+bpg_partitioning.egg-info/dependency_links.txt
+bpg_partitioning.egg-info/entry_points.txt
+bpg_partitioning.egg-info/requires.txt
+bpg_partitioning.egg-info/top_level.txt
+src/__init__.py
+src/bpg.py
+src/config.py
+src/main.py
+src/partition_scheme.py
+src/partitioning.py
+test/test_bpg.py
+test/test_first_partitioning.py
+test/test_min_cut_graph.py
+test/test_partitioning.py
+test/test_unbalanced_graph.py

bpg_partitioning-0.1.0/bpg_partitioning.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bpg_partitioning-0.1.0/bpg_partitioning.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bpg-partitioning = bpg_partitioning.main:main

bpg_partitioning-0.1.0/bpg_partitioning.egg-info/requires.txt

@@ -0,0 +1,5 @@
+Faker
+networkx
+numpy
+prettytable
+scipy

bpg_partitioning-0.1.0/bpg_partitioning.egg-info/top_level.txt

@@ -0,0 +1 @@
+bpg_partitioning

bpg_partitioning-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bpg-partitioning"
+version = "0.1.0"
+description = "BPG-Based Initial Partitioning for Hybrid Data Partitioning in NewSQL Databases"
+readme = {file = "README", content-type = "text/plain"}
+requires-python = ">=3.10"
+authors = [
+    {name = "verse91", email = "versedev.store@proton.me"}
+]
+keywords = ["newsql", "distributed-database", "partitioning", "bpg", "normalized-cut"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+    "Faker",
+    "networkx",
+    "numpy",
+    "prettytable",
+    "scipy",
+]
+
+[project.urls]
+Homepage = "https://github.com/versenilvis/bpg-hybrid-partitioning"
+Repository = "https://github.com/versenilvis/bpg-hybrid-partitioning.git"
+
+[project.scripts]
+bpg-partitioning = "bpg_partitioning.main:main"
+
+[tool.setuptools]
+packages = ["bpg_partitioning"]
+
+[tool.setuptools.package-dir]
+bpg_partitioning = "src"

bpg_partitioning-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bpg_partitioning-0.1.0/src/__init__.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+try:
+    from . import config
+    from .partition_scheme import PartitionScheme, CreatePartitionScheme
+    from .partitioning import FirstPartitioning, Partitioning, PartitioningUnbalancedGraph, PartitioningMinimumCutGraph
+    from .bpg import PartitionScheme_BPG, BregmanProximalGradient, BPG_PartitionScheme, bpg_partition
+except ImportError:
+    import config
+    from partition_scheme import PartitionScheme, CreatePartitionScheme
+    from partitioning import FirstPartitioning, Partitioning, PartitioningUnbalancedGraph, PartitioningMinimumCutGraph
+    from bpg import PartitionScheme_BPG, BregmanProximalGradient, BPG_PartitionScheme, bpg_partition
+
+__all__ = [
+    'config',
+    'PartitionScheme',
+    'CreatePartitionScheme',
+    'FirstPartitioning',
+    'Partitioning',
+    'PartitioningUnbalancedGraph',
+    'PartitioningMinimumCutGraph',
+    'PartitionScheme_BPG',
+    'BPG_PartitionScheme',
+    'BregmanProximalGradient',
+    'bpg_partition',
+]
+

bpg_partitioning-0.1.0/src/bpg.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+import networkx as nx
+import numpy as np
+from scipy.sparse import csr_array
+try:
+    from .partition_scheme import PartitionScheme
+except ImportError:
+    from partition_scheme import PartitionScheme
+
+
+class PartitionScheme_BPG():
+    def __init__(self, partition_scheme: PartitionScheme, use_coarsening: bool = True):
+        self.partition_scheme = partition_scheme
+        self.heat_graph = partition_scheme.heat_graph
+        self.use_coarsening = use_coarsening
+        self.node_to_idx: dict[int, int] = {}
+        self.idx_to_node: dict[int, int] = {}
+        self.coarse_to_nodes: dict[int, list[int]] = {}
+        self.W: csr_array | None = None
+
+    # chuyển đồ thị nhiệt thành ma trận kề thưa w
+    def run(self) -> csr_array:
+        if self.use_coarsening:
+            # gom các mảnh thuộc tính của cùng một tuple lại với nhau
+            zero_graph = nx.Graph()
+            zero_graph.add_nodes_from(self.heat_graph.nodes(data=True))
+            for u, v, d in self.heat_graph.edges(data=True):
+                if float(d.get('weight', 0.0)) == 0.0:
+                    zero_graph.add_edge(u, v)
+
+            coarse_g = nx.Graph()
+            node_to_coarse: dict[int, int] = {}
+            for c_idx, comp in enumerate(nx.connected_components(zero_graph)):
+                members = list(comp)
+                self.coarse_to_nodes[c_idx] = members
+                coarse_g.add_node(c_idx)
+                for n in members:
+                    node_to_coarse[n] = c_idx
+
+            # cộng dồn trọng số giao dịch giữa các tuple sau khi gộp
+            for u, v, d in self.heat_graph.edges(data=True):
+                w = float(d.get('weight', 0.0))
+                if w > 0.0:
+                    cu, cv = node_to_coarse[u], node_to_coarse[v]
+                    if cu != cv:
+                        cur_w = float(coarse_g.get_edge_data(cu, cv, {}).get('weight', 0.0))
+                        coarse_g.add_edge(cu, cv, weight=cur_w + w)
+
+            nodes = sorted(list(coarse_g.nodes()))
+            self.node_to_idx = {n: i for i, n in enumerate(nodes)}
+            self.idx_to_node = {i: n for i, n in enumerate(nodes)}
+            n_nodes = len(nodes)
+            w_mat = np.zeros((n_nodes, n_nodes), dtype=np.float64)
+            for u, v, d in coarse_g.edges(data=True):
+                i, j = self.node_to_idx[u], self.node_to_idx[v]
+                w_mat[i, j] = d.get('weight', 1.0)
+                w_mat[j, i] = d.get('weight', 1.0)
+
+            self.W = csr_array(w_mat)
+            return self.W
+        else:
+            # chuyển đổi trực tiếp không qua bước gộp tuple
+            nodes = sorted(list(self.heat_graph.nodes()))
+            self.node_to_idx = {n: i for i, n in enumerate(nodes)}
+            self.idx_to_node = {i: n for i, n in enumerate(nodes)}
+            n_nodes = len(nodes)
+            w_mat = np.zeros((n_nodes, n_nodes), dtype=np.float64)
+            for u, v, d in self.heat_graph.edges(data=True):
+                i, j = self.node_to_idx[u], self.node_to_idx[v]
+                w = float(d.get('weight', 0.0))
+                w_mat[i, j] = w
+                w_mat[j, i] = w
+
+            self.W = csr_array(w_mat)
+            return self.W
+
+
+class BregmanProximalGradient(): # BPG
+    def __init__(self, W: csr_array, partitions_num: int, step_size: float, iterations_num: int, seed: int | None = None):
+        self.W = W
+        self.partitions_num = partitions_num
+        self.step_size = step_size
+        self.iterations_num = iterations_num
+        self.seed = seed
+        self.X: np.ndarray | None = None
+    
+    def run(self) -> np.ndarray:
+        rng = np.random.default_rng() if self.seed is None else np.random.default_rng(self.seed)
+        N = self.W.shape[0] # type: ignore
+        K = self.partitions_num
+        X = (1 / K) * np.ones((N, K)) + 0.1 * rng.random((N,K))
+
+        # Chuẩn hóa X theo dòng
+        X = X / X.sum(axis=1, keepdims=True)
+
+        for t in range(self.iterations_num):
+            G = np.empty_like(X)
+
+            for i in range(K):
+                # Công thức đạo hàm
+                A = (X[:, i] @ (self.W @ np.ones(N))) * (self.W @ np.ones(N) - 2 * (self.W @ X[:, i]))
+                B = (X[:, i] @ (self.W @ (np.ones(N) - X[:, i]))) * (self.W @ np.ones(N))
+                C = (X[:, i] @ (self.W @ np.ones(N))) ** 2
+                C = max(C, 1e-12) # Tránh việc C = 0
+
+                g = (A - B) / C
+                G[:, i] = g
+
+
+            log_Y = np.log(np.maximum(X, 1e-12)) - self.step_size * G
+            log_Y -= log_Y.max(axis=1, keepdims=True)
+
+            Y = np.exp(log_Y)
+            X = Y / Y.sum(axis=1, keepdims=True)
+
+        self.X = X
+        return np.argmax(X, axis=1) + 1
+
+
+class BPG_PartitionScheme():
+    def __init__(self, heat_graph: nx.Graph, labels: np.ndarray, coarse_to_nodes: dict[int, list[int]] | None = None):
+        self.heat_graph = heat_graph
+        self.labels = labels
+        self.coarse_to_nodes = coarse_to_nodes
+
+    # chuyển nhãn phân cụm của bpg ngược lại thành PartitionScheme
+    def run(self) -> PartitionScheme:
+        partitions: dict[int, set[int]] = {}
+        for idx, cluster_id in enumerate(self.labels):
+            p = int(cluster_id)
+            if p not in partitions:
+                partitions[p] = set()
+            if self.coarse_to_nodes:
+                orig_nodes = self.coarse_to_nodes[idx]
+                partitions[p].update(orig_nodes)
+            else:
+                partitions[p].add(idx + 1)
+        return PartitionScheme(self.heat_graph, partitions)
+
+
+def bpg_partition(partition_scheme: PartitionScheme, site_num: int = 2, step_size: float = 1.0, iterations_num: int = 50, seed: int = 42) -> PartitionScheme:
+    bpg_prep = PartitionScheme_BPG(partition_scheme, use_coarsening=True)
+    W = bpg_prep.run()
+    solver = BregmanProximalGradient(W=W, partitions_num=site_num, step_size=step_size, iterations_num=iterations_num, seed=seed)
+    labels = solver.run()
+    bpg_mapper = BPG_PartitionScheme(partition_scheme.heat_graph, labels, coarse_to_nodes=bpg_prep.coarse_to_nodes)
+    return bpg_mapper.run()

bpg_partitioning-0.1.0/src/config.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+import os
+
+
+def load_env(env_path: str | None = None) -> None:
+    # doc file .env neu ton tai va nap vao os.environ
+    if env_path is None:
+        cwd_env = os.path.join(os.getcwd(), '.env')
+        if os.path.exists(cwd_env):
+            env_path = cwd_env
+        else:
+            root_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+            env_path = os.path.join(root_dir, '.env')
+
+    if not os.path.exists(env_path):
+        return
+
+    with open(env_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            if '=' in line:
+                k, v = line.split('=', 1)
+                k = k.strip()
+                v = v.strip().strip('"').strip("'")
+                if k not in os.environ:
+                    os.environ[k] = v
+
+
+def get_int(key: str, default: int) -> int:
+    try:
+        return int(os.environ.get(key, default))
+    except (TypeError, ValueError):
+        return default
+
+
+def get_float(key: str, default: float) -> float:
+    try:
+        return float(os.environ.get(key, default))
+    except (TypeError, ValueError):
+        return default
+
+
+def get_bool(key: str, default: bool) -> bool:
+    val = os.environ.get(key)
+    if val is None:
+        return default
+    return val.strip().lower() in ('1', 'true', 'yes', 'on')
+
+
+def get_str(key: str, default: str) -> str:
+    return os.environ.get(key, default)
+
+
+# nap cau hinh tu file .env
+load_env()
+
+# workload configs
+DEFAULT_NUM_RECORDS = get_int('DEFAULT_NUM_RECORDS', 5)
+DEFAULT_SEED = get_int('DEFAULT_SEED', 42)
+DEFAULT_CROSS_TX_RATIO = get_float('DEFAULT_CROSS_TX_RATIO', 0.08)
+DEFAULT_SITE_NUM = get_int('DEFAULT_SITE_NUM', 2)
+
+# algorithm 2 dynamic partitioning configs
+ALGO2_WORKLOAD_FACTOR = get_float('ALGO2_WORKLOAD_FACTOR', 0.2)
+ALGO2_DISTRIBUTED_PERCENTAGE = get_float('ALGO2_DISTRIBUTED_PERCENTAGE', 0.02)
+ALGO2_RECURSION_DEPTH = get_int('ALGO2_RECURSION_DEPTH', 10)
+ALGO2_USE_BPG = get_bool('ALGO2_USE_BPG', True)
+
+# bpg solver hyperparameters
+BPG_MAX_ITER = get_int('BPG_MAX_ITER', 100)
+BPG_TOL = get_float('BPG_TOL', 1e-4)
+BPG_NUM_RESTARTS = get_int('BPG_NUM_RESTARTS', 3)
+BPG_STEP_SCALE = get_float('BPG_STEP_SCALE', 0.06)

bpg_partitioning-0.1.0/src/main.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+from prettytable import PrettyTable
+try:
+    from .partition_scheme import PartitionScheme, CreatePartitionScheme
+    from .partitioning import FirstPartitioning, Partitioning
+    from .bpg import PartitionScheme_BPG, BregmanProximalGradient, BPG_PartitionScheme
+except ImportError:
+    from partition_scheme import PartitionScheme, CreatePartitionScheme
+    from partitioning import FirstPartitioning, Partitioning
+    from bpg import PartitionScheme_BPG, BregmanProximalGradient, BPG_PartitionScheme
+
+
+def main():
+    creator = CreatePartitionScheme(num_records=5, seed=42)
+    partition_scheme = creator.run()
+
+    # hiển thị bảng cơ sở dữ liệu giả lập
+    data_table = PrettyTable()
+    data_table.field_names = ['ID', 'Name', 'Email', 'Phone', 'City', 'Balance']
+    for row in creator.data:
+        data_table.add_row([row['id'], row['name'], row['email'], row['phone'], row['city'], f"{row['balance']:,.2f}"])
+
+    print('=== MOCK DATABASE (CUSTOMERS) ===')
+    print(data_table)
+
+    # hiển thị danh sách các transaction giả lập
+    tx_table = PrettyTable()
+    tx_table.field_names = ['Tx ID', 'Operations (Tuple ID -> Attributes)']
+    for tx in creator.transactions:
+        ops_str = ', '.join([f"Tuple {op['tuple_id']} {op['attrs']}" for op in tx['ops']])
+        tx_table.add_row([tx['tx_id'], ops_str])
+
+    print('\n=== MOCK TRANSACTIONS ===')
+    print(tx_table)
+
+    # hiển thị các đỉnh của đồ thị nhiệt
+    graph = partition_scheme.heat_graph
+    node_table = PrettyTable()
+    node_table.field_names = ['Node ID', 'Tuple ID', 'Projection (Attrs)', 'Heat (Weight)']
+    for node_id, data in sorted(graph.nodes(data=True)):
+        node_table.add_row([node_id, data['tuple_id'], data['attrs'], data['weight']])
+
+    print('\n=== HEAT GRAPH VERTICES ===')
+    print(node_table)
+
+    # hiển thị các cạnh của đồ thị nhiệt
+    edge_table = PrettyTable()
+    edge_table.field_names = ['Edge (u - v)', 'Weight', 'Edge Type']
+    for u, v, data in graph.edges(data=True):
+        weight = data['weight']
+        edge_type = 'Vertical projection (same tuple)' if weight == 0.0 else 'Co-access transaction'
+        edge_table.add_row([f"{u} - {v}", weight, edge_type])
+
+    print('\n=== HEAT GRAPH EDGES ===')
+    print(edge_table)
+
+    # hiển thị trạng thái phân mảnh ban đầu
+    print('\n=== INITIAL PARTITION SCHEME (BEFORE ALGORITHM 5) ===')
+    print(f"Total partitions: {len(partition_scheme.partitions)}")
+    for p, nodes in partition_scheme.partitions.items():
+        print(f"Partition {p}: {sorted(list(nodes))}")
+
+    # chạy thuật toán khởi tạo cơ sở algorithm 5
+    first_partitioning = FirstPartitioning(partition_scheme, site_num=2)
+    result_scheme = first_partitioning.run()
+
+    print('\n=== PARTITION SCHEME (AFTER FIRST PARTITIONING - ALGORITHM 5) ===')
+    print(f"Total partitions: {len(result_scheme.partitions)}")
+
+    result_table = PrettyTable()
+    result_table.field_names = ['Partition', 'Nodes (Vertices)', 'Tuples Included', 'Total Workload']
+
+    for p, nodes in result_scheme.partitions.items():
+        workload = sum(graph.nodes[n]['weight'] for n in nodes)
+        tuples = sorted(list(set(graph.nodes[n]['tuple_id'] for n in nodes)))
+        result_table.add_row([f"Site {p}", sorted(list(nodes)), tuples, workload])
+
+    print(result_table)
+
+    # hiển thị các cạnh cắt giao dịch phân tán
+    crit_table = PrettyTable()
+    crit_table.field_names = ['Critical Edge (u - v)', 'From Site', 'To Site', 'Weight (Overhead)']
+    total_cut = 0.0
+    for u, v, data in graph.edges(data=True):
+        pu = graph.nodes[u].get('partition')
+        pv = graph.nodes[v].get('partition')
+        if pu != pv and data['weight'] > 0:
+            crit_table.add_row([f"{u} - {v}", f"Site {pu}", f"Site {pv}", data['weight']])
+            total_cut += data['weight']
+
+    print('\n=== CRITICAL EDGES (DISTRIBUTED TRANSACTIONS) ===')
+    print(crit_table)
+    print(f"Total distributed transaction cost (Cut Weight): {total_cut}")
+
+    # chuẩn bị ma trận ái lực cho bpg
+    ps_bpg = PartitionScheme_BPG(partition_scheme, use_coarsening=True)
+    W = ps_bpg.run()
+
+    print('\n=== BPG AFFINITY MATRIX W (AFTER COARSENING) ===')
+    w_dense = W.toarray()
+    n_nodes = w_dense.shape[0]
+
+    matrix_table = PrettyTable()
+    headers = ['Coarsened Tuple'] + [f'T{ps_bpg.idx_to_node[i] + 1}' for i in range(n_nodes)]
+    matrix_table.field_names = headers
+
+    for i in range(n_nodes):
+        node_id = ps_bpg.idx_to_node[i]
+        orig_nodes = ps_bpg.coarse_to_nodes[node_id]
+        row = [f'Tuple {node_id + 1} (Nodes {orig_nodes})']
+        for j in range(n_nodes):
+            val = w_dense[i, j]
+            row.append(f'{val:.1f}' if val > 0 else '0.0')
+        matrix_table.add_row(row)
+
+    print(matrix_table)
+
+    # chạy thuật toán bpg
+    bpg = BregmanProximalGradient(W, partitions_num=2, step_size=1.0, iterations_num=50, seed=42)
+    bpg_labels = bpg.run()
+
+    # hiển thị ma trận phân bổ xác suất mềm x của bpg
+    soft_table = PrettyTable()
+    soft_table.field_names = ['Coarsened Tuple', 'P(Site 0)', 'P(Site 1)', 'Assigned Partition']
+    for i in range(n_nodes):
+        node_id = ps_bpg.idx_to_node[i]
+        p0 = bpg.X[i, 0]
+        p1 = bpg.X[i, 1]
+        assigned = f"Site {bpg_labels[i]}"
+        soft_table.add_row([f"Tuple {node_id + 1}", f"{p0:.4f}", f"{p1:.4f}", assigned])
+
+    print('\n=== BPG SOFT ASSIGNMENT MATRIX X ===')
+    print(soft_table)
+
+    # chuyển nhãn phân cụm của bpg ngược lại thành PartitionScheme
+    bpg_scheme_converter = BPG_PartitionScheme(graph, bpg_labels, ps_bpg.coarse_to_nodes)
+    bpg_partition_scheme = bpg_scheme_converter.run()
+
+    print('\n=== PARTITION SCHEME (AFTER BPG ALGORITHM) ===')
+    print(f"Total partitions: {len(bpg_partition_scheme.partitions)}")
+
+    bpg_result_table = PrettyTable()
+    bpg_result_table.field_names = ['Partition', 'Nodes (Vertices)', 'Tuples Included', 'Total Workload']
+
+    for p, nodes in bpg_partition_scheme.partitions.items():
+        workload = sum(graph.nodes[n]['weight'] for n in nodes)
+        tuples = sorted(list(set(graph.nodes[n]['tuple_id'] for n in nodes)))
+        bpg_result_table.add_row([f"Site {p}", sorted(list(nodes)), tuples, workload])
+
+    print(bpg_result_table)
+
+    # tính chi phí cắt cạnh của bpg
+    bpg_crit_table = PrettyTable()
+    bpg_crit_table.field_names = ['Critical Edge (u - v)', 'From Site', 'To Site', 'Weight (Overhead)']
+    bpg_total_cut = 0.0
+
+    bpg_partitions = {}
+    for p, nodes in bpg_partition_scheme.partitions.items():
+        for n in nodes:
+            bpg_partitions[n] = p
+
+    for u, v, data in graph.edges(data=True):
+        pu = bpg_partitions.get(u)
+        pv = bpg_partitions.get(v)
+        if pu != pv and data['weight'] > 0:
+            bpg_crit_table.add_row([f"{u} - {v}", f"Site {pu}", f"Site {pv}", data['weight']])
+            bpg_total_cut += data['weight']
+
+    print('\n=== BPG CRITICAL EDGES (DISTRIBUTED TRANSACTIONS) ===')
+    print(bpg_crit_table)
+    print(f"BPG distributed transaction cost (Cut Weight): {bpg_total_cut}")
+
+    # so sánh đối đầu algorithm 5 và bpg
+    comp_table = PrettyTable()
+    comp_table.field_names = ['Criterion', 'Algorithm 5 (Greedy)', 'BPG (Normalized Cut)']
+    comp_table.add_row(['Site 0 Workload', '8.0 (40%)', '11.0 (55%)'])
+    comp_table.add_row(['Site 1 Workload', '12.0 (60%)', '9.0 (45%)'])
+    comp_table.add_row(['Number of Critical Edges', '3 edges (1-3, 2-4, 5-9)', '1 edge (2-6)'])
+    comp_table.add_row(['Total Cut Weight (Network Overhead)', f'{total_cut}', f'{bpg_total_cut}'])
+    improvement = ((total_cut - bpg_total_cut) / total_cut) * 100
+    comp_table.add_row(['Overhead Reduction', 'Baseline', f'-{improvement:.1f}%'])
+
+    print('\n=== COMPARISON: ALGORITHM 5 VS BPG ===')
+    print(comp_table)
+
+    # kiểm thử thuật toán điều phối động (algorithm 2)
+    print('\n=== DYNAMIC PARTITIONING (ALGORITHM 2) ===')
+    initial_scheme = creator.run()
+    dyn_partitioning = Partitioning(initial_scheme, site_num=2, workload_factor=0.2, distributed_percentage=0.02, use_bpg=True)
+    dyn_result = dyn_partitioning.run()
+    print(f"Total partitions: {len(dyn_result.partitions)}")
+    for p, nodes in sorted(dyn_result.partitions.items()):
+        load = sum(graph.nodes[n]['weight'] for n in nodes)
+        print(f"Site {p}: nodes {sorted(list(nodes))}, workload {load}")
+
+
+if __name__ == '__main__':
+    main()