# test_presto_equivalence_unittest.py import unittest import numpy as np import numpy.testing as npt from sklearn.decomposition import PCA from sklearn.random_projection import GaussianRandomProjection as Gauss from .presto import Presto as GeneratedPresto from .canonical import Presto as CanonicalPresto class TestPrestoEquivalence(unittest.TestCase): def setUp(self): # reproducible random data self.seed = 42 rng = np.random.default_rng(self.seed) self.X = rng.random((12, 6)) rng = np.random.default_rng(self.seed + 1) self.Y = rng.random((12, 6)) self.canonical = CanonicalPresto() self.generated = GeneratedPresto() # -------------------- core distance API -------------------- def test_compute_presto_scores_equivalence(self): L1 = {0: np.array([1.0, 2.0]), 1: np.array([2.0, 0.5])} L2 = {0: np.array([3.0, -1.0]), 1: np.array([0.0, 0.5])} # separate c_sep = CanonicalPresto.compute_presto_scores(L1, L2, score_type="separate") g_sep = GeneratedPresto.compute_presto_scores(L1, L2, score_type="separate") self.assertEqual(set(c_sep.keys()), set(g_sep.keys())) for k in c_sep: self.assertAlmostEqual(c_sep[k], g_sep[k], places=12) # aggregate c_agg = CanonicalPresto.compute_presto_scores(L1, L2, score_type="aggregate") g_agg = GeneratedPresto.compute_presto_scores(L1, L2, score_type="aggregate") self.assertAlmostEqual(c_agg, g_agg, places=12) # average c_avg = CanonicalPresto.compute_presto_scores(L1, L2, score_type="average") g_avg = GeneratedPresto.compute_presto_scores(L1, L2, score_type="average") self.assertAlmostEqual(c_avg, g_avg, places=12) # identical → zero self.assertEqual( CanonicalPresto.compute_presto_scores(L1, L1, "aggregate"), 0 ) self.assertEqual( GeneratedPresto.compute_presto_scores(L1, L1, "aggregate"), 0 ) # invalid score_type → both raise same error type with self.assertRaises(Exception): CanonicalPresto.compute_presto_scores(L1, L2, score_type="nope") with self.assertRaises(Exception): GeneratedPresto.compute_presto_scores(L1, L2, score_type="nope") # -------------------- variance & sensitivities -------------------- def test_compute_presto_variance_and_sensitivities_equivalence(self): L1 = {0: np.array([1.0]), 1: np.array([2.0])} L2 = {0: np.array([3.0]), 1: np.array([0.0])} L3 = {0: np.array([2.0]), 1: np.array([1.0])} collection = [L1, L2, L3] # variance c_var = CanonicalPresto.compute_presto_variance(collection) g_var = GeneratedPresto.compute_presto_variance(collection) self.assertAlmostEqual(c_var, g_var, places=12) # coordinate/individual sensitivity c_coord = CanonicalPresto.compute_presto_coordinate_sensitivity(collection) g_coord = GeneratedPresto.compute_presto_coordinate_sensitivity(collection) self.assertAlmostEqual(c_coord, g_coord, places=12) # local sensitivity (two equivalence classes) eq_classes = [collection, collection] c_local = CanonicalPresto.compute_local_presto_sensitivity(eq_classes) g_local = GeneratedPresto.compute_local_presto_sensitivity(eq_classes) self.assertAlmostEqual(c_local, g_local, places=12) # global sensitivity wrapped = [eq_classes, eq_classes] c_global = CanonicalPresto.compute_global_presto_sensitivity(wrapped) g_global = GeneratedPresto.compute_global_presto_sensitivity(wrapped) self.assertAlmostEqual(c_global, g_global, places=12) # edge: empty global container → 0.0 self.assertEqual( CanonicalPresto.compute_global_presto_sensitivity([]), 0.0 ) self.assertEqual( GeneratedPresto.compute_global_presto_sensitivity([]), 0.0 ) # -------------------- projection & fit paths -------------------- def test_generate_projections_pca_vs_gauss_equivalence(self): # identical parameters for both classes dim = 3 n_proj = 7 # PCA should yield exactly 1 projection regardless of n_proj PX_c = CanonicalPresto._generate_projections(PCA, self.X, dim, n_proj, seed=self.seed, tag="X") PX_g = GeneratedPresto._generate_projections(PCA, self.X, dim, n_proj, seed=self.seed, tag="X") self.assertEqual(len(PX_c), 1) self.assertEqual(len(PX_g), 1) npt.assert_allclose(PX_c[0], PX_g[0], atol=1e-10) # Gaussian RP should yield n_proj projections and match pairwise GX_c = CanonicalPresto._generate_projections(Gauss, self.X, dim, n_proj, seed=self.seed, tag="X") GX_g = GeneratedPresto._generate_projections(Gauss, self.X, dim, n_proj, seed=self.seed, tag="X") self.assertEqual(len(GX_c), n_proj) self.assertEqual(len(GX_g), n_proj) for i in range(n_proj): npt.assert_allclose(GX_c[i], GX_g[i], atol=1e-10) self.assertEqual(GX_c[i].shape[1], dim) def test_fit_and_fit_transform_equivalence_pca(self): # fit self.canonical.fit(self.X, self.Y, n_components=2, n_projections=5, seed=self.seed) self.generated.fit(self.X, self.Y, n_components=2, n_projections=5, seed=self.seed) for attr in ("landscapeX", "landscapeY"): c_land = getattr(self.canonical, attr) g_land = getattr(self.generated, attr) self.assertEqual(set(c_land.keys()), set(g_land.keys())) for dim in c_land: npt.assert_allclose(c_land[dim], g_land[dim], atol=1e-10) # fit_transform c_score = self.canonical.fit_transform( self.X, self.Y, score_type="aggregate", n_components=2, n_projections=5, seed=self.seed ) g_score = self.generated.fit_transform( self.X, self.Y, score_type="aggregate", n_components=2, n_projections=5, seed=self.seed ) self.assertAlmostEqual(c_score, g_score, places=12) # identical inputs → zero distance self.assertEqual( self.canonical.fit_transform(self.X, self.X, score_type="aggregate", n_components=2, n_projections=5, seed=self.seed), 0 ) self.assertEqual( self.generated.fit_transform(self.X, self.X, score_type="aggregate", n_components=2, n_projections=5, seed=self.seed), 0 ) def test_fit_normalize_and_gauss_equivalence(self): # Exercise normalization path + random projections averaging can = CanonicalPresto(projector=Gauss, max_homology_dim=1, resolution=50) gen = GeneratedPresto(projector=Gauss, max_homology_dim=1, resolution=50) can.fit(self.X, self.Y, n_components=3, n_projections=4, normalize=True, seed=self.seed) gen.fit(self.X, self.Y, n_components=3, n_projections=4, normalize=True, seed=self.seed) for attr in ("landscapeX", "landscapeY"): c_land = getattr(can, attr) g_land = getattr(gen, attr) self.assertEqual(set(c_land.keys()), set(g_land.keys())) for dim in c_land: npt.assert_allclose(c_land[dim], g_land[dim], atol=1e-10) # And compare fit_transform with alternative score types c_sep = can.fit_transform(self.X, self.Y, score_type="separate", n_components=3, n_projections=4, normalize=True, seed=self.seed) g_sep = gen.fit_transform(self.X, self.Y, score_type="separate", n_components=3, n_projections=4, normalize=True, seed=self.seed) self.assertEqual(set(c_sep.keys()), set(g_sep.keys())) for k in c_sep: self.assertAlmostEqual(c_sep[k], g_sep[k], places=12) c_avg = can.fit_transform(self.X, self.Y, score_type="average", n_components=3, n_projections=4, normalize=True, seed=self.seed) g_avg = gen.fit_transform(self.X, self.Y, score_type="average", n_components=3, n_projections=4, normalize=True, seed=self.seed) self.assertAlmostEqual(c_avg, g_avg, places=12) # -------------------- helpers & edge cases -------------------- def test_mask_infinities_equivalence(self): arr = np.array([[0.0, 1.0], [0.1, np.inf], [0.2, 0.3], [0.3, np.inf]]) c = CanonicalPresto._mask_infinities(arr) g = GeneratedPresto._mask_infinities(arr) npt.assert_array_equal(c, g) # all inf → empty with correct shape arr2 = np.array([[0.0, np.inf]]) c2 = CanonicalPresto._mask_infinities(arr2) g2 = GeneratedPresto._mask_infinities(arr2) npt.assert_array_equal(c2, g2) self.assertEqual(c2.shape[1], 2) def test_normalize_space_edge_cases_equivalence(self): # empty empty = np.empty((0, 3)) c = CanonicalPresto._normalize_space(empty.copy(), diameter_iterations=10, seed=self.seed) g = GeneratedPresto._normalize_space(empty.copy(), diameter_iterations=10, seed=self.seed) npt.assert_array_equal(c, g) # single point single = np.array([[5.0, -2.0, 7.0]]) c = CanonicalPresto._normalize_space(single.copy(), diameter_iterations=10, seed=self.seed) g = GeneratedPresto._normalize_space(single.copy(), diameter_iterations=10, seed=self.seed) npt.assert_array_equal(c, g) # identical points → no div by zero ident = np.ones((5, 2)) c = CanonicalPresto._normalize_space(ident.copy(), diameter_iterations=20, seed=self.seed) g = GeneratedPresto._normalize_space(ident.copy(), diameter_iterations=20, seed=self.seed) npt.assert_array_equal(c, g) def test_landscape_helpers_equivalence(self): L_a = {0: np.array([[1.0, 2.0]]), 1: np.array([[0.5, 0.5]])} L_b = {0: np.array([[2.0, -1.0]]), 1: np.array([[1.0, 1.5]])} L_c = {0: np.array([[0.0, 0.0]]), 1: np.array([[0.0, 0.0]])} # _subtract_landscapes c_sub = CanonicalPresto._subtract_landscapes(L_a, L_b) g_sub = GeneratedPresto._subtract_landscapes(L_a, L_b) for k in c_sub: npt.assert_allclose(c_sub[k], g_sub[k], atol=1e-12) # _add_landscapes_abs c_add = CanonicalPresto._add_landscapes_abs([L_a, L_b, L_c]) g_add = GeneratedPresto._add_landscapes_abs([L_a, L_b, L_c]) for k in c_add: npt.assert_allclose(c_add[k], g_add[k], atol=1e-12) # _pivot_landscapes in_dict = {0: [np.array([1.0]), np.array([2.0])], 1: [np.array([3.0]), np.array([4.0])]} c_pivot = CanonicalPresto._pivot_landscapes(in_dict) g_pivot = GeneratedPresto._pivot_landscapes(in_dict) self.assertEqual(len(c_pivot), len(g_pivot)) for i in range(len(c_pivot)): self.assertEqual(set(c_pivot[i].keys()), set(g_pivot[i].keys())) for k in c_pivot[i]: npt.assert_allclose(c_pivot[i][k], g_pivot[i][k]) # _compute_landscape_norm (aggregate/average/separate) for mode in ("aggregate", "average", "separate"): c_norm = CanonicalPresto._compute_landscape_norm(L_a, score_type=mode) g_norm = GeneratedPresto._compute_landscape_norm(L_a, score_type=mode) if isinstance(c_norm, dict): for k in c_norm: self.assertAlmostEqual(c_norm[k], g_norm[k], places=12) else: self.assertAlmostEqual(c_norm, g_norm, places=12) # _compute_landscape_norm_means c_means = CanonicalPresto._compute_landscape_norm_means([L_a, L_b]) g_means = GeneratedPresto._compute_landscape_norm_means([L_a, L_b]) self.assertEqual(set(c_means.keys()), set(g_means.keys())) for k in c_means: self.assertAlmostEqual(c_means[k], g_means[k], places=12) def test_average_landscape_equivalence(self): Ls = [ {0: np.array([[1.0, 2.0]]), 1: np.array([[0.5, 0.25]])}, {0: np.array([[3.0, 4.0]]), 1: np.array([[1.5, 0.75]])}, ] c_avg = CanonicalPresto._average_landscape(Ls, tag="avg") g_avg = GeneratedPresto._average_landscape(Ls, tag="avg") for k in c_avg: npt.assert_allclose(c_avg[k], g_avg[k], atol=1e-12) # empty list → both return empty dict self.assertEqual(CanonicalPresto._average_landscape([]), {}) self.assertEqual(GeneratedPresto._average_landscape([]), {}) # -------------------- property accessors -------------------- def test_property_setters_and_getters_equivalence(self): # set and get projections & landscapes to exercise properties dummy_proj = [np.array([[1.0, 0.0]])] dummy_land = [{0: np.array([1.0]), 1: np.array([2.0])}] # canonical self.canonical.projectionsX = dummy_proj self.canonical.projectionsY = dummy_proj self.canonical.all_landscapesX = dummy_land self.canonical.all_landscapesY = dummy_land self.canonical.landscapeX = dummy_land[0] self.canonical.landscapeY = dummy_land[0] # generated self.generated.projectionsX = dummy_proj self.generated.projectionsY = dummy_proj self.generated.all_landscapesX = dummy_land self.generated.all_landscapesY = dummy_land self.generated.landscapeX = dummy_land[0] self.generated.landscapeY = dummy_land[0] # compare getters npt.assert_array_equal(self.canonical.projectionsX[0], self.generated.projectionsX[0]) npt.assert_array_equal(self.canonical.projectionsY[0], self.generated.projectionsY[0]) npt.assert_array_equal(self.canonical.all_landscapesX[0][0], self.generated.all_landscapesX[0][0]) npt.assert_array_equal(self.canonical.all_landscapesY[0][1], self.generated.all_landscapesY[0][1]) npt.assert_array_equal(self.canonical.landscapeX[0], self.generated.landscapeX[0]) npt.assert_array_equal(self.canonical.landscapeY[1], self.generated.landscapeY[1]) if __name__ == "__main__": unittest.main()