Adapt prototype decomposer to common decomposer interface

IlyaMuravjov · IlyaMuravjov · commit 791fbe261ff7 · 2025-04-26T17:45:05.000+03:00
diff --git a/cfpq_decomposer/prototype_decomposer.py b/cfpq_decomposer/prototype_decomposer.py
@@ -0,0 +1,109 @@
+import random
+from collections import defaultdict
+
+from graphblas.binary import plus
+from graphblas.core.dtypes import BOOL, INT32
+from graphblas.core.matrix import Matrix
+from graphblas.core.vector import Vector
+
+from cfpq_decomposer.abstract_decomposer import AbstractDecomposer
+
+
+class PrototypeDecomposer(AbstractDecomposer):
+    def row_based_decompose(self, M: Matrix):
+        n_rows, n_cols = M.shape
+
+        I, J, V = M.to_coo()
+
+        rows = defaultdict(set)
+        for i, j in zip(I, J):
+            rows[i].add(j)
+
+        p = 2147483647
+        num_hashes = 3
+        hash_funcs = []
+        for _ in range(num_hashes):
+            a = random.randint(1, p - 1)
+            b = random.randint(0, p - 1)
+            hash_funcs.append((a, b))
+
+        minhashes = dict()
+
+        for i, S_i in rows.items():
+            minhash_values = []
+            if len(S_i) < 5:
+                continue
+            for a, b in hash_funcs:
+                min_hash = min(((a * x + b) % p) for x in S_i)
+                minhash_values.append(min_hash)
+            minhashes[i] = tuple(minhash_values)
+
+        master_hashes = dict()
+        for i, minhash_values in minhashes.items():
+            master_hash = hash(minhash_values)
+            master_hashes[i] = master_hash
+
+        buckets = defaultdict(list)
+        for i, master_hash in master_hashes.items():
+            buckets[master_hash].append(i)
+
+        buckets = {h: idxs for h, idxs in buckets.items() if len(idxs) >= 5}
+
+        LEFT_columns = []
+        RIGHT_rows = []
+
+        for h, B in buckets.items():
+            N = len(B)
+            M_B: Matrix = M[B, :].new()
+            A1 = M_B.dup(dtype=INT32).reduce_columnwise(plus).new()
+
+            threshold = int(0.95 * N)
+            A2: Vector = A1.select('>=', threshold).new()
+
+            if A2.nvals == 0:
+                continue
+
+            S_A2 = set(A2.to_coo()[0])
+
+            B_prime = [i for i in B if S_A2 <= rows[i]]
+
+            K = len(B_prime)
+            if K == 0:
+                continue
+
+            M_B_prime = M[B_prime, :].new()
+            A3 = M_B_prime.dup(dtype=INT32).reduce_columnwise(plus)
+
+            threshold = int(0.95 * K)
+            A4 = A3.select('>=', threshold).new()
+
+            if A4.nvals == 0:
+                continue
+
+            S_A4 = set(A4.to_coo()[0])
+
+            B_double_prime = [i for i in B_prime if S_A4 <= rows[i]]
+
+            if len(B_double_prime) < 5:
+                continue
+
+            RIGHT_rows.append(A4)
+
+            CORE = Vector(BOOL, size=n_rows)
+            for i in B_double_prime:
+                CORE[i] = True
+            LEFT_columns.append(CORE)
+
+        num_buckets_remaining = len(LEFT_columns)
+        if num_buckets_remaining == 0:
+            return Matrix(M.dtype, M.nrows, 0), Matrix(M.dtype, 0, M.ncols)
+
+        LEFT = Matrix(bool, n_rows, num_buckets_remaining)
+        for idx, CORE in enumerate(LEFT_columns):
+            LEFT[:, idx] = CORE
+
+        RIGHT = Matrix(bool, num_buckets_remaining, n_cols)
+        for idx, A4 in enumerate(RIGHT_rows):
+            RIGHT[idx, :] = A4
+
+        return LEFT, RIGHT
diff --git a/cfpq_matrix/matrix_utils.py b/cfpq_matrix/matrix_utils.py
@@ -1,11 +1,9 @@
-import random
-from collections import defaultdict
 from typing import Any, Tuple
 
 import graphblas
 import numpy as np
 from graphblas.binary import plus
-from graphblas.core.dtypes import DataType, BOOL, INT32
+from graphblas.core.dtypes import DataType
 from graphblas.core.matrix import Matrix
 from graphblas.core.vector import Vector
 
@@ -31,167 +29,6 @@ def expand_matrix(matrix: Matrix, new_shape: Tuple[int, int]) -> Matrix:
     (rows, columns, values) = matrix.to_coo()
     return Matrix.from_coo(rows, columns, values, dtype=matrix.dtype, nrows=new_shape[0], ncols=new_shape[1])
 
-def row_based_decompose(M: Matrix):
-    """
-    Decomposes a sparse boolean matrix M into LEFT, RIGHT, and M' such that M = LEFT * RIGHT + M'.
-
-    Parameters:
-    M (gb.Matrix): Input sparse boolean matrix.
-
-    Returns:
-    LEFT (gb.Matrix): Left factor matrix.
-    RIGHT (gb.Matrix): Right factor matrix.
-    M_prime (gb.Matrix): Remainder matrix after decomposition.
-    """
-    n_rows, n_cols = M.shape
-
-    I, J, V = M.to_coo()
-
-    rows = defaultdict(set)
-    for i, j in zip(I, J):
-        rows[i].add(j)
-
-    p = 2147483647
-    num_hashes = 5  # TODO 2 or 3 is probably better for real world data
-    hash_funcs = []
-    for _ in range(num_hashes):
-        a = random.randint(1, p - 1)
-        b = random.randint(0, p - 1)
-        hash_funcs.append((a, b))
-
-    minhashes = dict()
-
-    for i, S_i in rows.items():
-        minhash_values = []
-        if len(S_i) < 5:
-            continue
-        for a, b in hash_funcs:
-            min_hash = min(((a * x + b) % p) for x in S_i)
-            minhash_values.append(min_hash)
-        minhashes[i] = tuple(minhash_values)
-
-    master_hashes = dict()
-    for i, minhash_values in minhashes.items():
-        master_hash = hash(minhash_values)
-        master_hashes[i] = master_hash
-
-    buckets = defaultdict(list)
-    for i, master_hash in master_hashes.items():
-        buckets[master_hash].append(i)
-
-    buckets = {h: idxs for h, idxs in buckets.items() if len(idxs) >= 5}
-
-    LEFT_columns = []
-    RIGHT_rows = []
-
-    for h, B in buckets.items():
-        N = len(B)
-        M_B: Matrix = M[B, :].new()
-        A1 = M_B.dup(dtype=INT32).reduce_columnwise(plus).new()
-
-        threshold = int(0.95 * N)
-        A2: Vector = A1.select('>=', threshold).new()
-
-        if A2.nvals == 0:
-            continue
-
-        S_A2 = set(A2.to_coo()[0])
-
-        B_prime = [i for i in B if S_A2 <= rows[i]]
-
-        K = len(B_prime)
-        if K == 0:
-            continue
-
-        M_B_prime = M[B_prime, :].new()
-        A3 = M_B_prime.dup(dtype=INT32).reduce_columnwise(plus)
-
-        threshold = int(0.95 * K)
-        A4 = A3.select('>=', threshold).new()
-
-        if A4.nvals == 0:
-            continue
-
-        S_A4 = set(A4.to_coo()[0])
-
-        B_double_prime = [i for i in B_prime if S_A4 <= rows[i]]
-
-        if len(B_double_prime) < 5:
-            continue
-
-        RIGHT_rows.append(A4)
-
-        CORE = Vector(BOOL, size=n_rows)
-        for i in B_double_prime:
-            CORE[i] = True
-        LEFT_columns.append(CORE)
-
-    num_buckets_remaining = len(LEFT_columns)
-    if num_buckets_remaining == 0:
-        return Matrix(M.dtype, M.nrows, 0), Matrix(M.dtype, 0, M.ncols)
-
-    LEFT = Matrix(bool, n_rows, num_buckets_remaining)
-    for idx, CORE in enumerate(LEFT_columns):
-        LEFT[:, idx] = CORE
-
-    RIGHT = Matrix(bool, num_buckets_remaining, n_cols)
-    for idx, A4 in enumerate(RIGHT_rows):
-        RIGHT[idx, :] = A4
-
-    return LEFT, RIGHT
-
-def column_based_decompose(M: Matrix):
-    LEFT_T, RIGHT_T = row_based_decompose(M.T.new())
-    return RIGHT_T.T.new(), LEFT_T.T.new()
-
-def decompose(M: Matrix):
-    accumulated_LEFT = []
-    accumulated_RIGHT = []
-    iteration = 0
-
-    init_nvals = M.nvals
-    if init_nvals == 0:
-        return Matrix(M.dtype, M.nrows, 0), Matrix(M.dtype, 0, M.ncols)
-
-    while True:
-        iteration += 1
-        nvals_before = M.nvals
-
-        LEFT1, RIGHT1 = row_based_decompose(M)
-
-        if LEFT1.nvals != 0:
-            M = M.dup(mask=~LEFT1.mxm(RIGHT1, op=graphblas.semiring.any_pair).new(dtype=BOOL).S)
-
-        LEFT2, RIGHT2 = column_based_decompose(M)
-
-        if LEFT2.nvals != 0:
-            M = M.dup(mask=~LEFT2.mxm(RIGHT2, op=graphblas.semiring.any_pair).new(dtype=BOOL).S)
-
-        nvals_LEFT_RIGHT = LEFT1.nvals + RIGHT1.nvals + LEFT2.nvals + RIGHT2.nvals
-
-        nvals_after = M.nvals
-        delta_M = nvals_before - nvals_after
-
-        reduction_ratio = delta_M / nvals_before if nvals_before > 0 else 0
-        size_ratio = nvals_LEFT_RIGHT / delta_M if delta_M > 0 else float('inf')
-
-        accumulated_LEFT.extend([LEFT1, LEFT2])
-        accumulated_RIGHT.extend([RIGHT1, RIGHT2])
-
-        if reduction_ratio < 0.05 or size_ratio > 0.3:
-            break
-
-        if M.nvals == 0:
-            break
-
-    if not accumulated_LEFT or not accumulated_RIGHT:
-        return Matrix(BOOL, nrows=M.nrows, ncols=0), Matrix(BOOL, nrows=0, ncols=M.ncols)
-
-    LEFT = stack([accumulated_LEFT])
-    RIGHT = stack([[RIGHT] for RIGHT in accumulated_RIGHT])
-
-    return LEFT, RIGHT
-
 def stack(matrix_grid: list[list[Matrix]]) -> Matrix:
     """
     Stack a 2D list of matrices into a single larger matrix.
diff --git a/test/cfpq_decomposer/test_prototype_decomposer.py b/test/cfpq_decomposer/test_prototype_decomposer.py
@@ -0,0 +1,8 @@
+from cfpq_decomposer.decomposer import Decomposer
+from cfpq_decomposer.prototype_decomposer import PrototypeDecomposer
+from test.cfpq_decomposer.test_abstract_decomposer import TestAbstractDecomposer
+
+
+class TestPrototypeDecomposer(TestAbstractDecomposer):
+    def create_decomposer(self) -> Decomposer:
+        return PrototypeDecomposer()
diff --git a/test/cfpq_matrix/matrix_utils.py b/test/cfpq_matrix/matrix_utils.py
