import unittest import torch import torch.nn as nn import dgl import random import numpy as np # Assume the user's provided code is in a file named 'canonical.py' # A generated version would be in 'generation.py' # For this demonstration, we use the canonical code as the generated one to ensure tests pass. from hete.canonical import contrastive_loss as canonical_contrastive_loss from hete.canonical import EMA as CanonicalEMA from hete.canonical import update_moving_average as canonical_update_moving_average from hete.canonical import set_requires_grad as canonical_set_requires_grad from hete.canonical import Model as CanonicalGraphACLModel from hete.model import contrastive_loss as generated_contrastive_loss from hete.model import EMA as GeneratedEMA from hete.model import update_moving_average as generated_update_moving_average from hete.model import set_requires_grad as generated_set_requires_grad from hete.model import Model as GeneratedGraphACLModel class TestFunctionalEquivalence(unittest.TestCase): """ Test suite to verify that the generated model implementation is functionally identical to the canonical implementation. """ def setUp(self): """ Set up common parameters and data for all tests. This method runs before each test function. """ # Set a fixed seed for reproducibility torch.manual_seed(42) # Define small, representative dimensions and parameters self.in_dim = 16 self.hidden_dim = 8 self.layer_num = 2 self.num_mlp_layers = 2 self.sample_size = 5 self.tau = 0.5 self.lambda_loss = 1.0 self.ema_decay = 0.99 # --- Create Sample Input Data --- self.num_nodes = 10 self.num_edges = 20 self.batch_size = 4 # Model inputs self.graph = dgl.rand_graph(self.num_nodes, self.num_edges) self.graph = dgl.add_self_loop(self.graph) # Add self-loops to avoid 0-in-degree nodes self.features = torch.randn(self.num_nodes, self.in_dim) self.neighbor_dict = {i: self.graph.successors(i).tolist() for i in range(self.num_nodes)} self.batch_indices = torch.randperm(self.num_nodes)[:self.batch_size] # Loss function inputs self.p_emd = torch.randn(self.batch_size, 1, self.hidden_dim) self.v_emd = torch.randn(self.batch_size, 1, self.hidden_dim) self.u_neighbors = torch.randn(self.batch_size, self.sample_size, self.hidden_dim) self.v_neg_samples = torch.randn(self.batch_size, self.sample_size, self.hidden_dim) def test_contrastive_loss(self): """ Test Instruction 1: Verify the contrastive loss function. """ canonical_loss = canonical_contrastive_loss(self.p_emd, self.v_emd, self.u_neighbors, self.v_neg_samples, self.tau, self.lambda_loss) generated_loss = generated_contrastive_loss(self.p_emd, self.v_emd, self.u_neighbors, self.v_neg_samples, self.tau, self.lambda_loss) torch.testing.assert_close(canonical_loss, generated_loss, msg="Contrastive loss values are not equivalent.") def test_ema_class(self): """ Test Instructions 2 & 3: Verify the EMA class initialization and update method. """ # Test initialization canonical_ema = CanonicalEMA(self.ema_decay) generated_ema = GeneratedEMA(self.ema_decay) self.assertEqual(canonical_ema.beta, generated_ema.beta, "EMA decay_rate mismatch.") # Test update_average method old_val = torch.randn(5) new_val = torch.randn(5) canonical_updated = canonical_ema.update_average(old_val, new_val) generated_updated = generated_ema.update_average(old_val, new_val) torch.testing.assert_close(canonical_updated, generated_updated, msg="EMA updated values are not equivalent.") def test_standalone_ema_update_function(self): """ Test Instruction 4: Verify the standalone EMA update utility function. """ # Create two simple models with identical structure model1 = nn.Linear(10, 2) model2 = nn.Linear(10, 2) model2.load_state_dict(model1.state_dict()) # Ensure they start different from target target_model = nn.Linear(10, 2) canonical_ema = CanonicalEMA(self.ema_decay) generated_ema = GeneratedEMA(self.ema_decay) # Update a copy of the target model using the canonical function target_model_canon = nn.Linear(10, 2) target_model_canon.load_state_dict(target_model.state_dict()) canonical_update_moving_average(canonical_ema, target_model_canon, model1) # Update another copy using the generated function target_model_gen = nn.Linear(10, 2) target_model_gen.load_state_dict(target_model.state_dict()) generated_update_moving_average(generated_ema, target_model_gen, model1) for p_canon, p_gen in zip(target_model_canon.parameters(), target_model_gen.parameters()): torch.testing.assert_close(p_canon.data, p_gen.data, msg="Standalone EMA update resulted in different model parameters.") def test_set_requires_grad(self): """ Test Instruction 5: Verify the gradient computation control function. """ # Canonical c_model = nn.Linear(10, 2) canonical_set_requires_grad(c_model, False) for p in c_model.parameters(): self.assertFalse(p.requires_grad) canonical_set_requires_grad(c_model, True) for p in c_model.parameters(): self.assertTrue(p.requires_grad) # Generated g_model = nn.Linear(10, 2) generated_set_requires_grad(g_model, False) for p in g_model.parameters(): self.assertFalse(p.requires_grad) generated_set_requires_grad(g_model, True) for p in g_model.parameters(): self.assertTrue(p.requires_grad) def test_graphacl_model_initialization(self): """ Test Instruction 6: Verify the GraphACLModel initialization. """ torch.manual_seed(42) canonical_model = CanonicalGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay, num_MLP=self.num_mlp_layers) torch.manual_seed(42) generated_model = GeneratedGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay, num_MLP=self.num_mlp_layers) # Compare parameters of online encoders for p_canon, p_gen in zip(canonical_model.graphconv1.parameters(), generated_model.graphconv1.parameters()): torch.testing.assert_close(p_canon, p_gen, msg="Online encoder conv1 weights mismatch on init.") # Compare parameters of target encoders (should be identical copies) for p_canon, p_gen in zip(canonical_model.target_graphconv1.parameters(), generated_model.target_graphconv1.parameters()): torch.testing.assert_close(p_canon, p_gen, msg="Target encoder conv1 weights mismatch on init.") # Compare parameters of projectors for p_canon, p_gen in zip(canonical_model.projector.parameters(), generated_model.projector.parameters()): torch.testing.assert_close(p_canon, p_gen, msg="Projector weights mismatch on init.") def test_graphacl_ema_update_method(self): """ Test Instruction 7: Verify the model's internal EMA update method. """ torch.manual_seed(42) random.seed(42) np.random.seed(42) canonical_model = CanonicalGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay) torch.manual_seed(42) random.seed(42) np.random.seed(42) generated_model = GeneratedGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay) generated_model.load_state_dict(canonical_model.state_dict()) # Perform one forward pass to change online weights (requires grad) optimizer_canon = torch.optim.Adam(canonical_model.parameters(), lr=0.01) optimizer_gen = torch.optim.Adam(generated_model.parameters(), lr=0.01) torch.manual_seed(42) random.seed(42) np.random.seed(42) loss_canon, _ = canonical_model(self.graph, self.features, self.neighbor_dict, 'cpu') loss_canon.backward() optimizer_canon.step() torch.manual_seed(42) random.seed(42) np.random.seed(42) loss_gen, _ = generated_model(self.graph, self.features, self.neighbor_dict, 'cpu') loss_gen.backward() optimizer_gen.step() # Now apply the EMA update canonical_model.update_moving_average() generated_model.update_moving_average() for p_canon, p_gen in zip(canonical_model.target_graphconv1.parameters(), generated_model.target_graphconv1.parameters()): torch.testing.assert_close(p_canon.data, p_gen.data, msg="Model's EMA update method resulted in different target parameters.") def test_graphacl_model_forward_pass(self): """ Test Instruction 8: Verify the full model forward pass. Note: The canonical implementation's `sample_neighbors` has non-deterministic elements (random.sample, np.random.choice). We set seeds to ensure the same samples are drawn. """ torch.manual_seed(42) random.seed(42) np.random.seed(42) canonical_model = CanonicalGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay) torch.manual_seed(42) random.seed(42) np.random.seed(42) generated_model = GeneratedGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay) generated_model.load_state_dict(canonical_model.state_dict()) # Execute forward pass for both models torch.manual_seed(42) random.seed(42) np.random.seed(42) canonical_loss, canonical_embs = canonical_model(self.graph, self.features, self.neighbor_dict, 'cpu') torch.manual_seed(42) random.seed(42) np.random.seed(42) generated_loss, generated_embs = generated_model(self.graph, self.features, self.neighbor_dict, 'cpu') # Compare outputs torch.testing.assert_close(canonical_loss, generated_loss, msg="Forward pass returned different loss values.") torch.testing.assert_close(canonical_embs, generated_embs, msg="Forward pass returned different online embeddings.") if __name__ == '__main__': # Prepare a dummy generation.py to make imports work # with open("model.py", "w") as f: # with open("canonical.py", "r") as c: # f.write(c.read()) unittest.main(argv=['first-arg-is-ignored'], exit=False)