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