mcy98's picture
Upload folder using huggingface_hub
e89a301 verified
Raw History Blame Contribute Delete
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()