Download annotations/annotation_3/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 14.3 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_3/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_3/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_3/test.py
14.3 kB
| # 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() | |