mcy98's picture
Upload folder using huggingface_hub
6077218 verified
Raw History Blame Contribute Delete
10.3 kB
# test_graph_acl.py
import unittest
import torch
import dgl # For creating sample graph objects
import copy # For deepcopying models if needed for state comparison
import numpy as np # For comparing numpy arrays if scores are returned as such
import sys
import os
from homo.canonical import Model as CanonicalModel
from homo.model import Model as GeneratedModel
# --- Sample Data ---
def create_sample_graph_data():
"""Creates a few small DGL graph instances for testing."""
data = []
# Graph 1: 3 nodes, 2 edges
g1 = dgl.graph(([0, 1], [1, 2]))
g1 = dgl.add_self_loop(g1)
g1_feat = torch.randn(3, 10) # 3 nodes, 10 features
data.append({"id": "g1", "graph": g1, "feat": g1_feat, "in_dim": 10, "out_dim": 8})
# Graph 2: 4 nodes, 4 edges (including a self-loop for variety)
g2 = dgl.graph(([0, 1, 2, 0], [1, 2, 3, 0]))
g2 = dgl.add_self_loop(g2)
g2_feat = torch.randn(4, 16) # 4 nodes, 16 features
data.append({"id": "g2", "graph": g2, "feat": g2_feat, "in_dim": 16, "out_dim": 8})
# Graph 3: Disconnected components
g3 = dgl.graph(([0, 2], [1, 3])) # Edges 0-1 and 2-3
g3 = dgl.add_self_loop(g3)
g3_feat = torch.randn(4, 5) # 4 nodes, 5 features
data.append({"id": "g3_disconnected", "graph": g3, "feat": g3_feat, "in_dim": 5, "out_dim": 4})
return data
sample_graph_data = create_sample_graph_data()
# --- Model Parameters ---
# Common parameters for initializing models, can be varied per test if needed
model_common_params = {
"hid_dim": 16, # GCN hidden
# "out_dim": 8, # GCN output & Projector I/O - will be taken from sample_graph_data
"num_layers": 2, # GCN layers
"temp": 0.5,
"moving_average_decay": 0.99,
"num_MLP": 1 # Predictor layers
}
class TestGraphACLImplementations(unittest.TestCase):
@classmethod
def setUpClass(cls):
"""Initialize canonical and generated Model instances."""
cls.canonical_instance = None
cls.generated_instance = None
cls.skip_all_tests = False
print("\nAttempting to initialize Canonical GraphACL Model instance...")
try:
# Use first sample's dims for a generic instance, can be re-init per test
# FIX: Align out_dim and hid_dim for setup instance to prevent crash if it were used directly
params = {**model_common_params,
"in_dim": sample_graph_data[0]["in_dim"],
"out_dim": model_common_params["hid_dim"]}
cls.canonical_instance = CanonicalModel(**params)
print("Canonical GraphACL Model instance created successfully.")
except Exception as e:
print(f"Failed to initialize CanonicalModel: {e}")
cls.skip_all_tests = True # Skip tests if canonical fails
raise unittest.SkipTest(f"Skipping all tests due to CanonicalModel initialization failure: {e}")
if GeneratedModel is None:
print("GeneratedModel could not be imported. Skipping tests involving generated model.")
cls.skip_all_tests = True
raise unittest.SkipTest("Skipping all tests because GeneratedModel could not be imported.")
print("\nAttempting to initialize Generated GraphACL Model instance...")
try:
params = {**model_common_params,
"in_dim": sample_graph_data[0]["in_dim"],
"out_dim": model_common_params["hid_dim"]}
cls.generated_instance = GeneratedModel(**params)
print("Generated GraphACL Model instance created successfully.")
except Exception as e:
print(f"Failed to initialize GeneratedModel: {e}")
cls.skip_all_tests = True # Skip tests if generated fails
raise unittest.SkipTest(f"Skipping all tests due to GeneratedModel initialization failure: {e}")
def assertTensorsAlmostEqual(self, tensor1, tensor2, places=5, msg_prefix=""):
"""Helper to compare two tensors."""
self.assertIsInstance(tensor1, torch.Tensor, f"{msg_prefix}: Canonical output is not a tensor.")
self.assertIsInstance(tensor2, torch.Tensor, f"{msg_prefix}: Generated output is not a tensor.")
self.assertEqual(tensor1.shape, tensor2.shape,
f"{msg_prefix}: Tensor shapes differ - Canonical={tensor1.shape}, Generated={tensor2.shape}")
self.assertTrue(torch.allclose(tensor1, tensor2, atol=10 ** (-places)),
f"{msg_prefix}: Tensor values differ.\nCanonical:\n{tensor1}\nGenerated:\n{tensor2}")
def test_forward_pass_and_loss(self):
"""Compare the output of the forward pass (loss value)."""
if self.skip_all_tests:
self.skipTest("Skipping test_forward_pass_and_loss due to setup failure.")
print("\nComparing forward pass (loss)...")
for data in sample_graph_data:
g = data["graph"]
feat = data["feat"]
# FIX: The canonical model expects the GCN output dim (out_dim) to be the same as the
# projector's input dim (hid_dim). We align them here to fix the crash.
current_params = {**model_common_params,
"in_dim": data["in_dim"],
"out_dim": model_common_params["hid_dim"]}
try:
canonical_model = CanonicalModel(**current_params)
generated_model = GeneratedModel(**current_params)
generated_model.load_state_dict(canonical_model.state_dict())
except Exception as e:
self.fail(f"Failed to re-initialize/load state_dict for graph {data['id']}: {e}")
with self.subTest(msg=f"Testing forward pass for graph: {data['id']}"):
canonical_model.train()
generated_model.train()
canonical_loss = canonical_model(g, feat)
generated_loss = generated_model(g, feat)
self.assertTensorsAlmostEqual(canonical_loss, generated_loss, msg_prefix=f"Loss for {data['id']}")
print(
f" Graph '{data['id']}': Canonical Loss={canonical_loss.item():.4f}, Generated Loss={generated_loss.item():.4f}")
def test_get_embedding(self):
"""Compare the output of get_embedding."""
if self.skip_all_tests:
self.skipTest("Skipping test_get_embedding due to setup failure.")
print("\nComparing get_embedding...")
for data in sample_graph_data:
g = data["graph"]
feat = data["feat"]
# FIX: Aligning out_dim with hid_dim to match the model's architecture.
current_params = {**model_common_params,
"in_dim": data["in_dim"],
"out_dim": model_common_params["hid_dim"]}
try:
canonical_model = CanonicalModel(**current_params)
generated_model = GeneratedModel(**current_params)
generated_model.load_state_dict(canonical_model.state_dict())
except Exception as e:
self.fail(f"Failed to re-initialize/load state_dict for graph {data['id']} (get_embedding): {e}")
with self.subTest(msg=f"Testing get_embedding for graph: {data['id']}"):
canonical_model.eval()
generated_model.eval()
canonical_emb = canonical_model.get_embedding(g, feat)
generated_emb = generated_model.get_embedding(g, feat)
self.assertTensorsAlmostEqual(canonical_emb, generated_emb, msg_prefix=f"Embeddings for {data['id']}")
print(f" Graph '{data['id']}': Embeddings compared (shape: {canonical_emb.shape}).")
self.assertFalse(canonical_emb.requires_grad, f"Canonical embedding for {data['id']} requires grad.")
self.assertFalse(generated_emb.requires_grad, f"Generated embedding for {data['id']} requires grad.")
def test_update_moving_average(self):
"""Test the update_moving_average functionality."""
if self.skip_all_tests:
self.skipTest("Skipping test_update_moving_average due to setup failure.")
print("\nTesting update_moving_average...")
data = sample_graph_data[0]
# FIX: Aligning out_dim with hid_dim to match the model's architecture.
current_params = {**model_common_params,
"in_dim": data["in_dim"],
"out_dim": model_common_params["hid_dim"],
"moving_average_decay": 0.9
}
try:
canonical_model = CanonicalModel(**current_params)
generated_model = GeneratedModel(**current_params)
generated_model.encoder.load_state_dict(canonical_model.encoder.state_dict())
generated_model.encoder_target.load_state_dict(canonical_model.encoder_target.state_dict())
except Exception as e:
self.fail(f"Failed to initialize models for update_moving_average test: {e}")
initial_canonical_target_params = [p.clone() for p in canonical_model.encoder_target.parameters()]
with torch.no_grad():
for param in canonical_model.encoder.parameters():
param.data.add_(torch.randn_like(param.data) * 0.01)
generated_model.encoder.load_state_dict(canonical_model.encoder.state_dict())
canonical_model.update_moving_average()
generated_model.update_moving_average()
for i, (can_param, gen_param) in enumerate(zip(canonical_model.encoder_target.parameters(),
generated_model.encoder_target.parameters())):
self.assertTensorsAlmostEqual(can_param.data, gen_param.data,
msg_prefix=f"Target encoder param {i} after update_moving_average")
self.assertFalse(torch.equal(can_param.data, initial_canonical_target_params[i]),
f"Canonical target encoder param {i} did not change after EMA update.")
print(" update_moving_average: Target encoder parameters compared and confirmed change.")
if __name__ == '__main__':
unittest.main(verbosity=2)