mcy98's picture
Upload folder using huggingface_hub
22e9602 verified
Raw History Blame Contribute Delete
19.6 kB
import unittest
import numpy as np
import tempfile
import os
import pickle
import shutil
from unittest.mock import Mock, patch
from sklearn.decomposition import PCA
from sklearn.cluster import AgglomerativeClustering
# Import the implementations to test
# Assuming canonical implementation is in 'canonical.py' and generated in 'generated.py'
try:
from presto.canonical import Atom as CanonicalAtom
from presto.atom import Atom as GeneratedAtom
# Import Presto class for reference
from presto.presto import Presto
except ImportError:
# Fallback if modules are named differently
print("Warning: Could not import canonical/generated modules. Adjust import paths as needed.")
CanonicalAtom = None
GeneratedAtom = None
Presto = None
class TestAtomFunctionalEquivalence(unittest.TestCase):
"""
Test suite to verify functional equivalence between canonical and generated Atom implementations.
This suite tests all public methods of the Atom class by comparing outputs from both implementations
when given identical inputs. Tests use small, representative datasets for efficiency.
"""
def setUp(self):
"""Set up test fixtures with small sample data."""
# Create small representative embeddings for testing
np.random.seed(42) # For reproducible test data
# Small 2D embeddings (10 points each, 2 dimensions)
self.embedding1 = np.random.rand(10, 2).astype(np.float32)
self.embedding2 = np.random.rand(10, 2).astype(np.float32) + 1.0
self.embedding3 = np.random.rand(10, 2).astype(np.float32) + 2.0
# Test data list
self.test_embeddings = [self.embedding1, self.embedding2, self.embedding3]
# Common parameters for testing
self.test_seed = 42
self.test_epsilon = 0.5
self.test_linkage = 'complete'
# Create temporary directory for file operations
self.temp_dir = tempfile.mkdtemp()
# Pre-computed small MMS matrix for testing (3x3 symmetric matrix)
self.test_mms = np.array([
[0.0, 0.8, 1.2],
[0.8, 0.0, 0.6],
[1.2, 0.6, 0.0]
])
def tearDown(self):
"""Clean up temporary files."""
shutil.rmtree(self.temp_dir, ignore_errors=True)
def test_atom_initialization_with_list(self):
"""Test Atom initialization with list of embeddings."""
canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed)
generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed)
# Compare basic attributes
self.assertEqual(canonical_atom.multiverse_size, generated_atom.multiverse_size,
"Multiverse size mismatch")
self.assertEqual(canonical_atom.seed, generated_atom.seed,
"Seed mismatch")
self.assertEqual(len(canonical_atom.data), len(generated_atom.data),
"Data length mismatch")
# Compare data arrays
for i, (canonical_emb, generated_emb) in enumerate(zip(canonical_atom.data, generated_atom.data)):
np.testing.assert_array_equal(canonical_emb, generated_emb,
f"Embedding {i} data mismatch")
def test_atom_initialization_with_folder(self):
"""Test Atom initialization with folder path."""
# Create test pickle files
for i, embedding in enumerate(self.test_embeddings):
file_path = os.path.join(self.temp_dir, f"embedding_{i}.pkl")
with open(file_path, 'wb') as f:
pickle.dump(embedding, f)
canonical_atom = CanonicalAtom(data=self.temp_dir, seed=self.test_seed)
generated_atom = GeneratedAtom(data=self.temp_dir, seed=self.test_seed)
# Compare attributes
self.assertEqual(canonical_atom.multiverse_size, generated_atom.multiverse_size,
"Multiverse size mismatch when loading from folder")
self.assertEqual(len(canonical_atom.data), len(generated_atom.data),
"Data length mismatch when loading from folder")
# Compare loaded data
for i, (canonical_emb, generated_emb) in enumerate(zip(canonical_atom.data, generated_atom.data)):
np.testing.assert_array_equal(canonical_emb, generated_emb,
f"Loaded embedding {i} data mismatch")
@patch('presto.Presto') # Mock the Presto class from presto.py
def test_compute_mms_functional_equivalence(self, mock_presto):
"""Test compute_mms method functional equivalence."""
# Mock Presto class to return deterministic distances
mock_distances = [0.8, 1.2, 0.6] # Distances for 3 embeddings (3 choose 2 = 3 pairs)
def mock_presto_factory():
mock_instance = Mock()
mock_instance.fit_transform.side_effect = mock_distances
return mock_instance
mock_presto.return_value = mock_presto_factory()
# Initialize atoms
canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed)
generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed)
# Test parameters
test_params = {
'projector': PCA,
'n_projections': 1,
'score_type': 'aggregate',
'n_components': 2,
'normalize': False,
'max_homology_dim': 1,
'resolution': 50,
'normalization_approx_iterations': 100,
'parallelize': False # Use False for deterministic testing
}
# Compute MMS on both implementations
canonical_atom.compute_mms(**test_params)
generated_atom.compute_mms(**test_params)
# Compare MMS matrices
self.assertIsInstance(canonical_atom.MMS, type(generated_atom.MMS),
"MMS matrix type mismatch")
if canonical_atom.MMS is not None and generated_atom.MMS is not None:
np.testing.assert_array_almost_equal(
canonical_atom.MMS, generated_atom.MMS,
decimal=10, err_msg="MMS matrices do not match"
)
# Verify matrix properties
self.assertEqual(canonical_atom.MMS.shape, generated_atom.MMS.shape,
"MMS matrix shape mismatch")
self.assertTrue(np.allclose(canonical_atom.MMS, canonical_atom.MMS.T),
"Canonical MMS matrix not symmetric")
self.assertTrue(np.allclose(generated_atom.MMS, generated_atom.MMS.T),
"Generated MMS matrix not symmetric")
def test_save_and_load_mms_functional_equivalence(self):
"""Test save_mms and load_mms methods functional equivalence."""
# Initialize atoms and set a test MMS
canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed)
generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed)
canonical_atom.MMS = self.test_mms.copy()
generated_atom.MMS = self.test_mms.copy()
# Test save_mms
canonical_path = os.path.join(self.temp_dir, "canonical_mms.pkl")
generated_path = os.path.join(self.temp_dir, "generated_mms.pkl")
canonical_atom.save_mms(canonical_path)
generated_atom.save_mms(generated_path)
# Verify files were created
self.assertTrue(os.path.exists(canonical_path), "Canonical MMS file not saved")
self.assertTrue(os.path.exists(generated_path), "Generated MMS file not saved")
# Load and compare saved data
with open(canonical_path, 'rb') as f:
canonical_saved = pickle.load(f)
with open(generated_path, 'rb') as f:
generated_saved = pickle.load(f)
np.testing.assert_array_equal(canonical_saved, generated_saved,
"Saved MMS matrices do not match")
# Test load_mms by setting MMS from file path
new_canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed)
new_generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed)
new_canonical_atom.MMS = canonical_path
new_generated_atom.MMS = generated_path
np.testing.assert_array_equal(new_canonical_atom.MMS, new_generated_atom.MMS,
"Loaded MMS matrices do not match")
def test_cluster_functional_equivalence(self):
"""Test cluster method functional equivalence."""
canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed)
generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed)
# Set identical MMS matrices
canonical_atom.MMS = self.test_mms.copy()
generated_atom.MMS = self.test_mms.copy()
# Perform clustering with identical parameters
canonical_clustering = canonical_atom.cluster(epsilon=self.test_epsilon, linkage=self.test_linkage)
generated_clustering = generated_atom.cluster(epsilon=self.test_epsilon, linkage=self.test_linkage)
# Compare clustering results
self.assertIsInstance(canonical_clustering, AgglomerativeClustering,
"Canonical clustering should return AgglomerativeClustering")
self.assertIsInstance(generated_clustering, AgglomerativeClustering,
"Generated clustering should return AgglomerativeClustering")
# Compare cluster labels (main output)
np.testing.assert_array_equal(canonical_clustering.labels_, generated_clustering.labels_,
"Cluster labels do not match")
# Compare number of clusters
canonical_n_clusters = len(np.unique(canonical_clustering.labels_))
generated_n_clusters = len(np.unique(generated_clustering.labels_))
self.assertEqual(canonical_n_clusters, generated_n_clusters,
"Number of clusters mismatch")
# Compare stored parameters
self.assertEqual(canonical_atom.epsilon, generated_atom.epsilon,
"Stored epsilon parameter mismatch")
self.assertEqual(canonical_atom.linkage, generated_atom.linkage,
"Stored linkage parameter mismatch")
def test_compute_set_cover_functional_equivalence(self):
"""Test compute_set_cover method functional equivalence."""
canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed)
generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed)
# Set identical MMS matrices
canonical_atom.MMS = self.test_mms.copy()
generated_atom.MMS = self.test_mms.copy()
# Compute set cover with identical parameters
canonical_set_cover = canonical_atom.compute_set_cover(epsilon=self.test_epsilon)
generated_set_cover = generated_atom.compute_set_cover(epsilon=self.test_epsilon)
# Compare set cover results
self.assertIsInstance(canonical_set_cover, dict,
"Canonical set cover should return dict")
self.assertIsInstance(generated_set_cover, dict,
"Generated set cover should return dict")
# Compare keys (representative indices)
self.assertEqual(set(canonical_set_cover.keys()), set(generated_set_cover.keys()),
"Set cover representative keys do not match")
# Compare values (covered indices for each representative)
for key in canonical_set_cover.keys():
canonical_covered = sorted(canonical_set_cover[key])
generated_covered = sorted(generated_set_cover[key])
self.assertEqual(canonical_covered, generated_covered,
f"Covered indices for representative {key} do not match")
# Verify coverage completeness for both implementations
canonical_all_covered = set()
generated_all_covered = set()
for covered_list in canonical_set_cover.values():
canonical_all_covered.update(covered_list)
for covered_list in generated_set_cover.values():
generated_all_covered.update(covered_list)
expected_all_indices = set(range(len(self.test_embeddings)))
self.assertEqual(canonical_all_covered, expected_all_indices,
"Canonical set cover doesn't cover all embeddings")
self.assertEqual(generated_all_covered, expected_all_indices,
"Generated set cover doesn't cover all embeddings")
self.assertEqual(canonical_all_covered, generated_all_covered,
"Overall coverage sets do not match")
def test_static_methods_functional_equivalence(self):
"""Test static utility methods functional equivalence."""
# Test validate_distance_matrix
valid_matrix = self.test_mms.copy()
shape = (3, 3)
canonical_validated = CanonicalAtom.validate_distance_matrix(valid_matrix, shape)
generated_validated = GeneratedAtom.validate_distance_matrix(valid_matrix, shape)
np.testing.assert_array_equal(canonical_validated, generated_validated,
"Validated matrices do not match")
# Test file_id_sorter
test_filenames = ["file_10.pkl", "file_2.pkl", "file_100.pkl", "no_number.pkl"]
canonical_sorted = sorted(test_filenames, key=CanonicalAtom.file_id_sorter)
generated_sorted = sorted(test_filenames, key=GeneratedAtom.file_id_sorter)
self.assertEqual(canonical_sorted, generated_sorted,
"File sorting results do not match")
# Test _load_data with pickle file
test_data = self.test_mms.copy()
test_file = os.path.join(self.temp_dir, "test_data.pkl")
with open(test_file, 'wb') as f:
pickle.dump(test_data, f)
canonical_loaded = CanonicalAtom._load_data(test_file)
generated_loaded = GeneratedAtom._load_data(test_file)
np.testing.assert_array_equal(canonical_loaded, generated_loaded,
"Loaded data does not match")
def test_edge_cases_functional_equivalence(self):
"""Test edge cases and error handling functional equivalence."""
# Test with single embedding
single_embedding = [self.embedding1]
canonical_atom = CanonicalAtom(data=single_embedding, seed=self.test_seed)
generated_atom = GeneratedAtom(data=single_embedding, seed=self.test_seed)
self.assertEqual(canonical_atom.multiverse_size, generated_atom.multiverse_size,
"Single embedding multiverse size mismatch")
# Test invalid data type
with self.assertRaises(TypeError):
CanonicalAtom(data=123, seed=self.test_seed)
with self.assertRaises(TypeError):
GeneratedAtom(data=123, seed=self.test_seed)
# Test invalid MMS type - both implementations should raise FileNotFoundError
# when trying to load a non-existent file path
canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed)
generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed)
with self.assertRaises(FileNotFoundError):
canonical_atom.MMS = "invalid_type"
with self.assertRaises(FileNotFoundError):
generated_atom.MMS = "invalid_type"
class TestAtomWithRandomness(unittest.TestCase):
"""
Test suite for functions with randomness, focusing on structural properties
rather than exact value comparisons.
"""
def setUp(self):
"""Set up test fixtures."""
np.random.seed(42)
self.test_embeddings = [
np.random.rand(8, 2).astype(np.float32),
np.random.rand(8, 2).astype(np.float32) + 1,
np.random.rand(8, 2).astype(np.float32) + 2
]
self.test_seed = 42
@patch('presto.Presto')
def test_mms_computation_with_fixed_seed(self, mock_presto):
"""Test MMS computation reproducibility with fixed seed."""
canonical_atom1 = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed)
canonical_atom2 = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed)
generated_atom1 = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed)
generated_atom2 = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed)
# Set up identical mock behavior
mock_distances = [0.5, 0.7, 0.3]
def create_mock_presto():
mock_instance = Mock()
mock_instance.fit_transform.side_effect = mock_distances
return mock_instance
mock_presto.return_value = create_mock_presto()
# Compute MMS with identical parameters
params = {'parallelize': False, 'n_projections': 1}
canonical_atom1.compute_mms(**params)
canonical_atom2.compute_mms(**params)
generated_atom1.compute_mms(**params)
generated_atom2.compute_mms(**params)
# Verify reproducibility within each implementation
np.testing.assert_array_equal(canonical_atom1.MMS, canonical_atom2.MMS,
"Canonical implementation not reproducible")
np.testing.assert_array_equal(generated_atom1.MMS, generated_atom2.MMS,
"Generated implementation not reproducible")
# Verify equivalence between implementations
np.testing.assert_array_equal(canonical_atom1.MMS, generated_atom1.MMS,
"MMS matrices differ between implementations")
if __name__ == '__main__':
# Create a test suite combining all test cases
test_suite = unittest.TestLoader().loadTestsFromTestCase(TestAtomFunctionalEquivalence)
test_suite.addTests(unittest.TestLoader().loadTestsFromTestCase(TestAtomWithRandomness))
# Run the tests with detailed output
runner = unittest.TextTestRunner(verbosity=2, buffer=True)
result = runner.run(test_suite)
# Print summary
print(f"\n{'='*60}")
print(f"TEST SUMMARY")
print(f"{'='*60}")
print(f"Tests run: {result.testsRun}")
print(f"Failures: {len(result.failures)}")
print(f"Errors: {len(result.errors)}")
print(f"Success rate: {((result.testsRun - len(result.failures) - len(result.errors)) / result.testsRun * 100):.1f}%")
if result.failures:
print(f"\nFAILURES:")
for test, traceback in result.failures:
error_msg = traceback.split('AssertionError: ')[-1].split('\n')[0]
print(f"- {test}: {error_msg}")
if result.errors:
print(f"\nERRORS:")
for test, traceback in result.errors:
error_msg = traceback.split('\n')[-2]
print(f"- {test}: {error_msg}")