From 605c1de3562c20402e059416af2893d3401a8a2d Mon Sep 17 00:00:00 2001 From: Tran Ngo Date: Fri, 10 Jul 2026 14:57:06 +0800 Subject: [PATCH] Delete cases directory It is a redundant folder cloned from "tests". --- cases/adv_ops/test_adv_matvec.py | 146 ---------- cases/matrix_ops/test_matrix_mean.py | 253 ------------------ cases/matrix_ops/test_matrix_sum.py | 241 ----------------- cases/matrix_ops/test_matrix_sumcum.py | 175 ------------ .../test_simple_matrix_operation.py | 173 ------------ .../test_simple_vector_operation.py | 170 ------------ 6 files changed, 1158 deletions(-) delete mode 100644 cases/adv_ops/test_adv_matvec.py delete mode 100644 cases/matrix_ops/test_matrix_mean.py delete mode 100644 cases/matrix_ops/test_matrix_sum.py delete mode 100644 cases/matrix_ops/test_matrix_sumcum.py delete mode 100644 cases/matrix_ops/test_simple_matrix_operation.py delete mode 100644 cases/vector_ops/test_simple_vector_operation.py diff --git a/cases/adv_ops/test_adv_matvec.py b/cases/adv_ops/test_adv_matvec.py deleted file mode 100644 index a08d6f9..0000000 --- a/cases/adv_ops/test_adv_matvec.py +++ /dev/null @@ -1,146 +0,0 @@ -import numpy as np -import openfhe_numpy as onp -from core import * - - -# ============================================================== -# Matrix (row-major, tile) x Vector (column-major, tile) -# ============================================================== -class TestRowMajorColMajor(MainUnittest): - sizes = [2, 3, 4, 8] - - def test_mult_matrix_vector(self): - ckks_params = load_ckks_params() - for p in ckks_params: - cc, keys = gen_crypto_context(p) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - batch_size = p["ringDim"] // 2 - for size in self.sizes: - if (size > 4 and p["ringDim"] < 8192) or size > batch_size: - continue - - A = generate_random_array(rows=size, cols=size) - b = generate_random_array(rows=size, cols=1).flatten() - expected = np.dot(A, b) - - with self.subTest(size=size, ringDim=p["ringDim"]): - result = None - try: - ctm = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=onp.ROW_MAJOR, - fhe_type="C", - mode="tile", - public_key=keys.publicKey, - ) - ctm.extra["colkey"] = onp.sum_col_keys( - keys.secretKey, ctm.ncols - ) - ctv = onp.array( - cc=cc, - data=b, - batch_size=batch_size, - order=onp.COL_MAJOR, - fhe_type="C", - mode="tile", - public_key=keys.publicKey, - ) - ctv_result = ctm @ ctv - result = ctv_result.decrypt( - keys.secretKey, unpack_type="original" - ) - - self.assertArrayClose(result, expected) - - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A, "b": b}, - expected=expected, - result=result, - ) - raise - - -# ============================================================== -# Matrix (column-major, zero) x Vector (row-major, zero) -# ============================================================== -class TestColMajorRowMajor(MainUnittest): - sizes = [2, 3, 4, 8] - - def test_mult_matrix_vector(self): - ckks_params = load_ckks_params() - for p in ckks_params: - cc, keys = gen_crypto_context(p) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - batch_size = p["ringDim"] // 2 - for size in self.sizes: - if (size > 4 and p["ringDim"] < 8192) or size > batch_size: - continue - - A = generate_random_array(rows=size, cols=size) - b = generate_random_array(rows=size, cols=1).flatten() - expected = np.dot(A, b) - - with self.subTest(size=size, ringDim=p["ringDim"]): - result = None - try: - ctm = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=onp.COL_MAJOR, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - ctv = onp.array( - cc=cc, - data=b, - batch_size=batch_size, - order=onp.ROW_MAJOR, - fhe_type="C", - mode="zero", - target_cols=ctm.nrows, - public_key=keys.publicKey, - ) - ctm.extra["rowkey"] = onp.sum_row_keys( - keys.secretKey, ctm.nrows, ctm.batch_size - ) - ctv_result = ctm @ ctv - result = ctv_result.decrypt( - keys.secretKey, unpack_type="original" - ) - - self.assertArrayClose(result, expected) - - except Exception as e: - self._record_case( - params={ - "case": "colmajor_rowmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A, "b": b}, - expected=expected, - result=result, - ) - raise - - -# ============================================================== -# Entry point -# ============================================================== -if __name__ == "__main__": - TestRowMajorColMajor.run_test_summary() - TestColMajorRowMajor.run_test_summary() diff --git a/cases/matrix_ops/test_matrix_mean.py b/cases/matrix_ops/test_matrix_mean.py deleted file mode 100644 index 5a44bdd..0000000 --- a/cases/matrix_ops/test_matrix_mean.py +++ /dev/null @@ -1,253 +0,0 @@ -import numpy as np -import openfhe_numpy as onp -from core import * - -""" -Note: Mean operations may require sufficient multiplicative depth -and ring dimension for division. Small ring dimensions (<4096) can -increase approximation error. -""" - -sizes = [2, 3, 4] -orders = [("row_major", onp.ROW_MAJOR), ("col_major", onp.COL_MAJOR)] - - -def _ensure_depth(params: dict, min_depth: int = 3) -> dict: - p = params.copy() - if params.get("multiplicativeDepth", 0) < min_depth: - p["multiplicativeDepth"] = min_depth - return p - - -class TestMatrixTotalMean(MainUnittest): - """Test class for matrix mean operations.""" - - def test_total_mean(self): - """Total matrix mean (all elements).""" - ckks_params = load_ckks_params() - - for _, p in enumerate(ckks_params): - params = _ensure_depth(p, 3) - batch_size = params["ringDim"] // 2 - - for order_name, order_value in orders: - for size in sizes: - if params["ringDim"] < 4096 and size > 2: - continue - if size > batch_size: - continue - - A = generate_random_array(rows=size, cols=size) - expected = np.mean(A) - - with self.subTest( - order=order_name, size=size, ringDim=params["ringDim"] - ): - self._record_case( - params={ - "case": "total_mean", - "size": size, - "ringDim": params["ringDim"], - "order": order_value, - }, - input_data={"A": A}, - expected=expected, - result=None, - ) - - cc = keys = ctm_matrix = ctm_result = None - try: - cc, keys = gen_crypto_context(params) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - ctm_matrix = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - onp.gen_sum_key(keys.secretKey) - ctm_result = onp.mean(ctm_matrix) - - result = ctm_result.decrypt( - keys.secretKey, unpack_type="original" - ) - - self.assertArrayClose( - actual=result, expected=expected - ) - - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A, "b": b}, - expected=expected, - result=result, - ) - raise - - -class TestMatrixRowMean(MainUnittest): - """Test class for matrix mean operations.""" - - def test_row_mean(self): - """Row-wise mean (axis=0).""" - ckks_params = load_ckks_params() - - for _, p in enumerate(ckks_params): - params = _ensure_depth(p, 3) - batch_size = params["ringDim"] // 2 - cc, keys = gen_crypto_context(params) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - for order_name, order_value in orders: - for size in sizes: - if params["ringDim"] < 4096 and size > 2: - continue - if size > batch_size: - continue - - A = generate_random_array(rows=size, cols=size) - expected = np.mean(A, axis=0) - - with self.subTest( - order=order_name, size=size, ringDim=params["ringDim"] - ): - try: - ctm_matrix = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - if order_value == onp.ROW_MAJOR: - ctm_matrix.extra["rowkey"] = onp.sum_row_keys( - keys.secretKey, - ctm_matrix.ncols, - ctm_matrix.batch_size, - ) - else: - ctm_matrix.extra["colkey"] = onp.sum_col_keys( - keys.secretKey, ctm_matrix.nrows - ) - - ctm_result = onp.mean(ctm_matrix, axis=0) - - result = ctm_result.decrypt( - keys.secretKey, unpack_type="original" - ) - - self.assertArrayClose( - actual=result, expected=expected - ) - - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A}, - expected=expected, - result=result, - ) - raise - - -class TestMatrixColumnMean(MainUnittest): - """Test class for matrix mean operations.""" - - def test_col_mean(self): - """Column-wise mean (axis=1).""" - ckks_params = load_ckks_params() - - for _, p in enumerate(ckks_params): - params = _ensure_depth(p, 3) - - cc, keys = gen_crypto_context(params) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - batch_size = params["ringDim"] // 2 - - for order_name, order_value in orders: - for size in sizes: - if params["ringDim"] < 4096 and size > 2: - continue - if size > batch_size: - continue - - A = generate_random_array(rows=size, cols=size) - expected = np.mean(A, axis=1) - - with self.subTest( - order=order_name, size=size, ringDim=params["ringDim"] - ): - try: - cc, keys = gen_crypto_context(params) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - ctm_matrix = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - if order_value == onp.ROW_MAJOR: - ctm_matrix.extra["colkey"] = onp.sum_col_keys( - keys.secretKey, ctm_matrix.ncols - ) - else: - ctm_matrix.extra["rowkey"] = onp.sum_row_keys( - keys.secretKey, - ctm_matrix.nrows, - ctm_matrix.batch_size, - ) - - ctm_result = onp.mean(ctm_matrix, axis=1) - - result = ctm_result.decrypt( - keys.secretKey, unpack_type="original" - ) - - self.assertArrayClose( - actual=result, expected=expected - ) - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A, "b": b}, - expected=expected, - result=result, - ) - raise - - -if __name__ == "__main__": - TestMatrixColumnMean.run_test_summary() - TestMatrixRowMean.run_test_summary() - TestMatrixTotalMean.run_test_summary() diff --git a/cases/matrix_ops/test_matrix_sum.py b/cases/matrix_ops/test_matrix_sum.py deleted file mode 100644 index 2d52be1..0000000 --- a/cases/matrix_ops/test_matrix_sum.py +++ /dev/null @@ -1,241 +0,0 @@ -import numpy as np -import openfhe_numpy as onp -from core import * - -### -# Note: Column-/row-wise cumulative sum may require deeper multiplicative -# depth or larger ring dimensions for accurate results. Small ring dimensions -# (<4096) might introduce approximation errors. -### - - -sizes = [2, 3, 8, 16] -orders = [("row_major", onp.ROW_MAJOR), ("col_major", onp.COL_MAJOR)] - - -def _ensure_depth(p: dict, min_depth: int = 3) -> dict: - params = p.copy() - if params.get("multiplicativeDepth", 0) < min_depth: - params["multiplicativeDepth"] = min_depth - return params - - -class TestMatrixSum(MainUnittest): - """Test class for matrix mean operations.""" - - def test_total_sum(self): - """Total matrix mean (all elements).""" - ckks_params = load_ckks_params() - - for _, p in enumerate(ckks_params): - params = _ensure_depth(p, 3) - batch_size = params["ringDim"] // 2 - - cc, keys = gen_crypto_context(params) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - for order_name, order_value in orders: - for size in sizes: - if params["ringDim"] < 4096 and size > 2: - continue - if size > batch_size: - continue - - A = generate_random_array(rows=size, cols=size) - expected = np.mean(A) - - with self.subTest( - order=order_name, size=size, ringDim=params["ringDim"] - ): - try: - ctm_matrix = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - onp.gen_sum_key(keys.secretKey) - ctm_result = onp.mean(ctm_matrix) - - result = ctm_result.decrypt( - keys.secretKey, unpack_type="original" - ) - self.assertArrayClose( - actual=result, expected=expected - ) - - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A, "b": b}, - expected=expected, - result=result, - ) - raise - - -class TestMatrixRowSum(MainUnittest): - """Test class for matrix mean operations.""" - - def test_row_sum(self): - """Row-wise mean (axis=0).""" - ckks_params = load_ckks_params() - - for _, p in enumerate(ckks_params): - params = _ensure_depth(p, 3) - batch_size = params["ringDim"] // 2 - - cc, keys = gen_crypto_context(params) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - for order_name, order_value in orders: - for size in sizes: - if params["ringDim"] < 4096 and size > 2: - continue - if size > batch_size: - continue - - A = generate_random_array(rows=size, cols=size) - expected = np.mean(A, axis=0) - - with self.subTest( - order=order_name, size=size, ringDim=params["ringDim"] - ): - try: - ctm_matrix = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - if order_value == onp.ROW_MAJOR: - ctm_matrix.extra["rowkey"] = onp.sum_row_keys( - keys.secretKey, - ctm_matrix.ncols, - ctm_matrix.batch_size, - ) - else: - ctm_matrix.extra["colkey"] = onp.sum_col_keys( - keys.secretKey, ctm_matrix.nrows - ) - - ctm_result = onp.mean(ctm_matrix, axis=0) - - result = ctm_result.decrypt( - keys.secretKey, unpack_type="original" - ) - - self.assertArrayClose( - actual=result, expected=expected - ) - - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A, "b": b}, - expected=expected, - result=result, - ) - raise - - -class TestMatrixColSum(MainUnittest): - """Test class for matrix mean operations.""" - - def test_col_sum(self): - """Column-wise mean (axis=1).""" - ckks_params = load_ckks_params() - - for _, p in enumerate(ckks_params): - params = _ensure_depth(p, 3) - - cc, keys = gen_crypto_context(params) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - batch_size = params["ringDim"] // 2 - - for order_name, order_value in orders: - for size in sizes: - if params["ringDim"] < 4096 and size > 2: - continue - if size > batch_size: - continue - - A = generate_random_array(rows=size, cols=size) - expected = np.mean(A, axis=1) - - with self.subTest( - order=order_name, size=size, ringDim=params["ringDim"] - ): - try: - cc, keys = gen_crypto_context(params) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - ctm_matrix = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - if order_value == onp.ROW_MAJOR: - ctm_matrix.extra["colkey"] = onp.sum_col_keys( - keys.secretKey, ctm_matrix.ncols - ) - else: - ctm_matrix.extra["rowkey"] = onp.sum_row_keys( - keys.secretKey, - ctm_matrix.nrows, - ctm_matrix.batch_size, - ) - - ctm_result = onp.mean(ctm_matrix, axis=1) - - result = ctm_result.decrypt( - keys.secretKey, unpack_type="original" - ) - self.result = result - self.assertArrayClose( - actual=result, expected=expected - ) - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A, "b": b}, - expected=expected, - result=result, - ) - raise - - -if __name__ == "__main__": - TestMatrixSum.run_test_summary() - TestMatrixColSum.run_test_summary() - TestMatrixRowSum.run_test_summary() diff --git a/cases/matrix_ops/test_matrix_sumcum.py b/cases/matrix_ops/test_matrix_sumcum.py deleted file mode 100644 index b8fd64c..0000000 --- a/cases/matrix_ops/test_matrix_sumcum.py +++ /dev/null @@ -1,175 +0,0 @@ -import numpy as np -import openfhe_numpy as onp -from core import * - -sizes = [2, 3, 8, 16] -orders = [("row_major", onp.ROW_MAJOR), ("col_major", onp.COL_MAJOR)] - - -class TestMatrixCumulativeSumRow(MainUnittest): - def test_cumsum_rows(self): - """Cumulative sum along rows (axis=0).""" - ckks_params = load_ckks_params() - - for _, p in enumerate(ckks_params): - batch_size = p["ringDim"] // 2 - - for order_name, order_value in orders: - for size in sizes: - if size > batch_size: - continue - - A = generate_random_array(rows=size, cols=size) - expected = np.cumsum(A, axis=0) - - # ensure enough multiplicative depth (work on a copy) - params = p.copy() - required_depth = len(A) - if params.get("multiplicativeDepth", 0) < required_depth: - params["multiplicativeDepth"] = required_depth + 1 - - with self.subTest( - order=order_name, size=size, ringDim=params["ringDim"] - ): - self._record_case( - params={ - "case": "cumsum_rows", - "size": size, - "ringDim": params["ringDim"], - "order": order_value, - }, - input_data={"A": A}, - expected=expected, - result=None, - ) - - try: - cc, keys = gen_crypto_context(params) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - ctm_matrix = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - if order_value == onp.ROW_MAJOR: - onp.gen_accumulate_rows_key( - keys.secretKey, ctm_matrix.ncols - ) - else: - onp.gen_accumulate_cols_key( - keys.secretKey, ctm_matrix.ncols - ) - - ctm_result = onp.cumulative_sum(ctm_matrix, axis=0) - result = ctm_result.decrypt( - keys.secretKey, unpack_type="original" - ) - self.assertArrayClose( - actual=result, expected=expected - ) - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A}, - expected=expected, - result=result, - ) - raise - - -class TestMatrixCumulativeSumCol(MainUnittest): - def test_cumsum_cols(self): - """Cumulative sum along columns (axis=1).""" - ckks_params = load_ckks_params() - - for _, p in enumerate(ckks_params): - batch_size = p["ringDim"] // 2 - - for order_name, order_value in orders: - for size in sizes: - if size > batch_size: - continue - - A = generate_random_array(rows=size, cols=size) - expected = np.cumsum(A, axis=1) - - # ensure multiplicative depth (copy) - params = p.copy() - required_depth = A.shape[1] - if params.get("multiplicativeDepth", 0) < required_depth: - params["multiplicativeDepth"] = required_depth + 1 - - with self.subTest( - order=order_name, size=size, ringDim=params["ringDim"] - ): - self._record_case( - params={ - "case": "cumsum_cols", - "size": size, - "ringDim": params["ringDim"], - "order": order_value, - }, - input_data={"A": A}, - expected=expected, - result=None, - ) - - try: - cc, keys = gen_crypto_context(params) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - ctm_matrix = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - if order_value == onp.ROW_MAJOR: - onp.gen_accumulate_cols_key( - keys.secretKey, ctm_matrix.ncols - ) - else: - onp.gen_accumulate_rows_key( - keys.secretKey, ctm_matrix.ncols - ) - - ctm_result = onp.cumulative_sum(ctm_matrix, axis=1) - result = ctm_result.decrypt( - keys.secretKey, unpack_type="original" - ) - self.assertArrayClose( - actual=result, expected=expected - ) - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A, "b": b}, - expected=expected, - result=result, - ) - raise - - -if __name__ == "__main__": - TestMatrixCumulativeSumCol.run_test_summary() - TestMatrixCumulativeSumRow.run_test_summary() diff --git a/cases/matrix_ops/test_simple_matrix_operation.py b/cases/matrix_ops/test_simple_matrix_operation.py deleted file mode 100644 index 503c56f..0000000 --- a/cases/matrix_ops/test_simple_matrix_operation.py +++ /dev/null @@ -1,173 +0,0 @@ -# tests/test_matrix_ops.py -import numpy as np -import openfhe_numpy as onp -from core import * - -sizes = [5] -orders = [("row_major", onp.ROW_MAJOR)] - - -class TestMatrixUnaryOps(MainUnittest): - """Test class for unary matrix operations""" - - def test_unary_operations(self): - ops = [ - ("transpose", lambda x: x.T, lambda x: onp.transpose(x)), - ("scalar_mul", lambda x, s: x * s, lambda x, s: x * s), - ("sum", lambda x: np.sum(x), lambda x: onp.sum(x)), - ] - - ckks_params = load_ckks_params() - for _, p in enumerate(ckks_params): - batch_size = p["ringDim"] // 2 - scalar = 7.2 # for scalar_mul - - cc, keys = gen_crypto_context(p) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - for tag, np_fn, fhe_fn in ops: - for size in sizes: - if size > batch_size: - continue - - for order_name, order_value in orders: - # plaintext input & expected - A = generate_random_array(rows=size, cols=size) - - with self.subTest( - op=tag, - order=order_name, - size=size, - ringDim=p["ringDim"], - ): - ctm_a = ctm_res = None - try: - # encrypt A (tile mode for matrices) - ctm_a = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - # Run encrypted operation - if tag == "scalar_mul": - expected = np_fn(A, scalar) - ctm_res = fhe_fn(ctm_a, scalar) - elif tag == "transpose": - onp.gen_transpose_keys( - keys.secretKey, ctm_a - ) - expected = np_fn(A) - ctm_res = fhe_fn(ctm_a) - else: # sum - expected = np_fn(A) - ctm_res = fhe_fn(ctm_a) - - # decrypt and compare - result = ctm_res.decrypt( - keys.secretKey, unpack_type="original" - ) - self.assertArrayClose( - actual=result, expected=expected - ) - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A}, - expected=expected, - result=result, - ) - raise - - -class TestMatrixBinaryOps(MainUnittest): - def test_binary_operations(self): - ops = [ - ("add", lambda x, y: x + y, lambda a, b: onp.add(a, b)), - ("sub", lambda x, y: x - y, lambda a, b: onp.subtract(a, b)), - ("mul", lambda x, y: x * y, lambda a, b: onp.multiply(a, b)), - ("dot", lambda x, y: np.dot(x, y), lambda a, b: onp.dot(a, b)), - ] - - ckks_params = load_ckks_params() - for _, p in enumerate(ckks_params): - batch_size = p["ringDim"] // 2 - cc, keys = gen_crypto_context(p) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - for tag, np_fn, fhe_fn in ops: - for size in sizes: - if size > batch_size: - continue - - for order_name, order_value in orders: - A = generate_random_array(rows=size, cols=size) - B = generate_random_array(rows=size, cols=size) - expected = A @ B - - with self.subTest( - op=tag, - order=order_name, - size=size, - ringDim=p["ringDim"], - ): - try: - # encrypt matrices - ctm_a = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="tile", - public_key=keys.publicKey, - ) - ctm_b = onp.array( - cc=cc, - data=B, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="tile", - public_key=keys.publicKey, - ) - - onp.EvalSquareMatMultRotateKeyGen( - keys.secretKey, ctm_a.ncols - ) - ctm_res = ctm_a @ ctm_b - - # decrypt and compare - result = ctm_res.decrypt( - keys.secretKey, unpack_type="original" - ) - self.assertArrayClose( - actual=result, expected=expected - ) - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A, "B": B}, - expected=expected, - result=result, - ) - raise - - -if __name__ == "__main__": - TestMatrixUnaryOps.run_test_summary() - TestMatrixBinaryOps.run_test_summary() diff --git a/cases/vector_ops/test_simple_vector_operation.py b/cases/vector_ops/test_simple_vector_operation.py deleted file mode 100644 index d42e836..0000000 --- a/cases/vector_ops/test_simple_vector_operation.py +++ /dev/null @@ -1,170 +0,0 @@ -import numpy as np -import openfhe_numpy as onp -from core import * - -sizes = [5, 8, 16] -orders = [("row_major", onp.ROW_MAJOR)] - - -class TestMatrixUnaryOps(MainUnittest): - """Test class for unary matrix operations""" - - def test_unary_operations(self): - ops = [ - ("transpose", lambda x: x.T, lambda x: onp.transpose(x)), - ("scalar_mul", lambda x, s: x * s, lambda x, s: x * s), - ("sum", lambda x: np.sum(x), lambda x: onp.sum(x)), - ] - - ckks_params = load_ckks_params() - - for _, p in enumerate(ckks_params): - batch_size = p["ringDim"] // 2 - scalar = 7.2 # for scalar_mul - - cc, keys = gen_crypto_context(p) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - for tag, np_fn, fhe_fn in ops: - for size in sizes: - if size > batch_size: - continue - - for order_name, order_value in orders: - # plaintext input & expected - A = generate_random_array(rows=size) - - with self.subTest( - op=tag, - order=order_name, - size=size, - ringDim=p["ringDim"], - ): - result = expected = None - - try: - ctv_a = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - onp.gen_transpose_keys(keys.secretKey, ctv_a) - - if tag == "scalar_mul": - expected = np_fn(A, scalar) - ctv_res = fhe_fn(ctv_a, scalar) - else: - expected = np_fn(A) - ctv_res = fhe_fn(ctv_a) - - # decrypt and compare - result = ctv_res.decrypt( - keys.secretKey, unpack_type="original" - ) - - self.assertArrayClose( - actual=result, expected=expected - ) - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"A": A}, - expected=expected, - result=result, - ) - raise - - -class TestMatrixBinaryOps(MainUnittest): - def test_binary_operations(self): - ops = [ - ("add", lambda x, y: x + y, lambda a, b: onp.add(a, b)), - # ("sub", lambda x, y: x - y, lambda a, b: onp.subtract(a, b)), - # ("mul", lambda x, y: x * y, lambda a, b: onp.multiply(a, b)), - # ("dot", lambda x, y: np.dot(x, y), lambda a, b: onp.dot(a, b)), - ] - - ckks_params = load_ckks_params() - for _, p in enumerate(ckks_params): - batch_size = p["ringDim"] // 2 - cc, keys = gen_crypto_context(p) - cc.EvalMultKeyGen(keys.secretKey) - cc.EvalSumKeyGen(keys.secretKey) - - for tag, np_fn, fhe_fn in ops: - for size in sizes: - if size > batch_size: - continue - - for order_name, order_value in orders: - A = generate_random_array(rows=size) - B = generate_random_array(rows=size) - - expected = np_fn(A, B) - - with self.subTest( - op=tag, - order=order_name, - size=size, - ringDim=p["ringDim"], - ): - result = None - try: - # encrypt matrices - ctv_a = onp.array( - cc=cc, - data=A, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - ctv_b = onp.array( - cc=cc, - data=B, - batch_size=batch_size, - order=order_value, - fhe_type="C", - mode="zero", - public_key=keys.publicKey, - ) - - ctv_res = fhe_fn(ctv_a, ctv_b) - - # decrypt and compare - result = ctv_res.decrypt( - keys.secretKey, unpack_type="original" - ) - - self.assertArrayClose( - actual=result, expected=expected - ) - - except Exception as e: - self._record_case( - params={ - "case": "rowmajor_colmajor", - "size": size, - "ringDim": p["ringDim"], - }, - input_data={"a": A, "b": B}, - expected=expected, - result=result, - ) - raise - - -if __name__ == "__main__": - TestMatrixBinaryOps.run_test_summary() - TestMatrixUnaryOps.run_test_summary()