import unittest import sys import numpy as np import torch import torch_frame # --- Import canonical and generated ContextGNN implementations --- try: from contextgnn.nn.models.canonical import ContextGNN as CanonicalContextGNN except ImportError: print("ERROR: Could not import CanonicalContextGNN from canonical.py.") sys.exit(1) try: from contextgnn.nn.models.contextgnn import ContextGNN as GeneratedContextGNN except ImportError: print("ERROR: Could not import GeneratedContextGNN from generated.py.") sys.exit(1) # --- Helper class to support dot-access for batch --- class AttrDict(dict): def __getattr__(self, item): try: return self[item] except KeyError: raise AttributeError(item) def __setattr__(self, key, value): self[key] = value # --- Dummy classes for data structure --- class DummyNode: def __init__(self, tf, seed_time=None, time=None, n_id_dict=None, batch_dict=None): self.tf = tf self.seed_time = seed_time self.time = time self.n_id_dict = n_id_dict self.batch_dict = batch_dict def __getitem__(self, key): if isinstance(key, str): return getattr(self, key) return None def __contains__(self, key): return hasattr(self, key) class DummyTF: def __init__(self, col_names_dict, features): self.col_names_dict = col_names_dict for k, v in features.items(): setattr(self, k, v) class DummyHeteroData(dict): @property def node_types(self): return [k for k in self.keys() if k in ("user", "item")] @property def edge_types(self): return [("user", "buys", "item")] # --- Dummy encoder for torch_frame_model_cls --- class DummyEncoder(torch.nn.Module): def __init__(self, *args, **kwargs): super().__init__() def forward(self, tf): return torch.zeros((2, 2)) def reset_parameters(self): pass # --- Dummy RHS Embedding --- class DummyRhsEmbedding(torch.nn.Module): def __init__(self, num_nodes=2, embedding_dim=2): super().__init__() self.dummy_weight = torch.nn.Parameter(torch.zeros(num_nodes, embedding_dim)) def forward(self, indices=None): if indices is None: return self.dummy_weight return self.dummy_weight[indices] def reset_parameters(self): torch.nn.init.zeros_(self.dummy_weight) # --- Test Input Builder --- def get_minimal_test_inputs(): user_node = DummyNode( tf=DummyTF( {torch_frame.numerical: ["feature1"]}, {"feature1": torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float32)} ), seed_time=torch.tensor([0, 1], dtype=torch.long), time=torch.tensor([10, 20], dtype=torch.long), n_id_dict={"item": torch.tensor([0, 1], dtype=torch.long)}, batch_dict={"item": torch.tensor([0, 1], dtype=torch.long)} ) item_node = DummyNode( tf=DummyTF( {torch_frame.numerical: ["feature2"]}, {"feature2": torch.tensor([[5.0, 6.0], [7.0, 8.0]], dtype=torch.float32)} ), time=torch.tensor([15, 25], dtype=torch.long), n_id_dict={"user": torch.tensor([0, 1], dtype=torch.long)}, batch_dict={"user": torch.tensor([0, 1], dtype=torch.long)} ) batch = { "user": user_node, "item": item_node, "tf_dict": { "user": {"feature1": torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float32)}, "item": {"feature2": torch.tensor([[5.0, 6.0], [7.0, 8.0]], dtype=torch.float32)}, }, "time_dict": { "user": torch.tensor([10, 20], dtype=torch.long), "item": torch.tensor([15, 25], dtype=torch.long), }, "edge_index_dict": { ("user", "buys", "item"): torch.tensor([[0, 1], [1, 0]], dtype=torch.long), ("item", "bought_by", "user"): torch.tensor([[0, 1], [1, 0]], dtype=torch.long), }, "n_id_dict": { "item": torch.tensor([0, 1], dtype=torch.long), "user": torch.tensor([0, 1], dtype=torch.long), }, "batch_dict": { "item": torch.tensor([0, 1], dtype=torch.long), "user": torch.tensor([0, 1], dtype=torch.long), } } batch = AttrDict(batch) entity_table = "user" dst_table = "item" data = DummyHeteroData() data["user"] = user_node data["item"] = item_node for k in batch: if k not in ("user", "item"): data[k] = batch[k] col_stats_dict = { "user": {"feature1": {"mean": 0.0, "std": 1.0}}, "item": {"feature2": {"mean": 0.0, "std": 1.0}}, } rhs_emb_mode = "shallow" dst_entity_table = "item" num_nodes = 2 num_layers = 1 channels = 2 embedding_dim = 2 aggr = "sum" norm = "layer_norm" torch_frame_model_cls = DummyEncoder torch_frame_model_kwargs = {} rhs_sample_size = 2 src_batch = torch.tensor([0, 1], dtype=torch.long) dst_index = torch.tensor([0, 1], dtype=torch.long) return { "data": data, "col_stats_dict": col_stats_dict, "rhs_emb_mode": rhs_emb_mode, "dst_entity_table": dst_entity_table, "num_nodes": num_nodes, "num_layers": num_layers, "channels": channels, "embedding_dim": embedding_dim, "aggr": aggr, "norm": norm, "torch_frame_model_cls": torch_frame_model_cls, "torch_frame_model_kwargs": torch_frame_model_kwargs, "rhs_sample_size": rhs_sample_size, "batch": batch, "entity_table": entity_table, "dst_table": dst_table, "src_batch": src_batch, "dst_index": dst_index } # --- Test class --- class TestContextGNNImplementations(unittest.TestCase): @classmethod def setUpClass(cls): print("setUpClass begin") test_args = get_minimal_test_inputs() cls.args = test_args # Canonical Model cls.canonical_model = CanonicalContextGNN( data=test_args["data"], col_stats_dict=test_args["col_stats_dict"], rhs_emb_mode=test_args["rhs_emb_mode"], dst_entity_table=test_args["dst_entity_table"], num_nodes=test_args["num_nodes"], num_layers=test_args["num_layers"], channels=test_args["channels"], embedding_dim=test_args["embedding_dim"], aggr=test_args["aggr"], norm=test_args["norm"], torch_frame_model_cls=test_args["torch_frame_model_cls"], torch_frame_model_kwargs=test_args["torch_frame_model_kwargs"], rhs_sample_size=test_args["rhs_sample_size"] ) cls.canonical_model.rhs_embedding = DummyRhsEmbedding( num_nodes=test_args["num_nodes"], embedding_dim=test_args["embedding_dim"] ) # Generated Model cls.generated_model = GeneratedContextGNN( data=test_args["data"], col_stats_dict=test_args["col_stats_dict"], rhs_emb_mode=test_args["rhs_emb_mode"], dst_entity_table=test_args["dst_entity_table"], num_nodes=test_args["num_nodes"], num_layers=test_args["num_layers"], channels=test_args["channels"], embedding_dim=test_args["embedding_dim"], aggr=test_args["aggr"], norm=test_args["norm"], torch_frame_model_cls=test_args["torch_frame_model_cls"], torch_frame_model_kwargs=test_args["torch_frame_model_kwargs"], rhs_sample_size=test_args["rhs_sample_size"] ) cls.generated_model.rhs_embedding = DummyRhsEmbedding( num_nodes=test_args["num_nodes"], embedding_dim=test_args["embedding_dim"] ) print("setUpClass done") def assertOutputsStructurallyEqual(self, canonical_output, generated_output, msg=""): self.assertEqual(type(canonical_output), type(generated_output), msg + " (type)") if isinstance(canonical_output, torch.Tensor): self.assertEqual(canonical_output.shape, generated_output.shape, msg + " (tensor shape)") elif isinstance(canonical_output, np.ndarray): self.assertEqual(canonical_output.shape, generated_output.shape, msg + " (ndarray shape)") elif isinstance(canonical_output, (list, tuple)): self.assertEqual(len(canonical_output), len(generated_output), msg + " (len)") for i in range(len(canonical_output)): self.assertOutputsStructurallyEqual(canonical_output[i], generated_output[i], msg=f"{msg}[{i}]") elif isinstance(canonical_output, dict): self.assertEqual(set(canonical_output.keys()), set(generated_output.keys()), msg + " (dict keys)") for k in canonical_output: self.assertOutputsStructurallyEqual(canonical_output[k], generated_output[k], msg=f"{msg}[{k}]") else: self.assertEqual(canonical_output, generated_output, msg + " (scalar)") def _patched_forward_gnn(self, model, batch, entity_table, dst_table): # Call the original forward_gnn and ensure both keys present x_dict = model._original_forward_gnn(batch, entity_table) # Patch missing keys with zeros for key in [entity_table, dst_table]: if key not in x_dict: x_dict[key] = torch.zeros((2, 2)) return x_dict def test_forward_gnn(self): print("in test_forward_gnn") batch = self.args["batch"] entity_table = self.args["entity_table"] dst_table = self.args["dst_table"] # Patch outputs for both models for model in [self.canonical_model, self.generated_model]: model._original_forward_gnn = model.forward_gnn model.forward_gnn = lambda batch, et: self._patched_forward_gnn(model, batch, et, dst_table) canonical_out = self.canonical_model.forward_gnn(batch, entity_table) generated_out = self.generated_model.forward_gnn(batch, entity_table) self.assertOutputsStructurallyEqual(canonical_out, generated_out, msg="forward_gnn output") # Restore for model in [self.canonical_model, self.generated_model]: model.forward_gnn = model._original_forward_gnn del model._original_forward_gnn def test_construct_logits(self): lhs_embedding_projected = torch.tensor([[1., 2.], [3., 4.]], dtype=torch.float32) lhs_embedding = torch.tensor([[5., 6.], [7., 8.]], dtype=torch.float32) rhs_gnn_embedding = torch.tensor([[9., 10.], [11., 12.]], dtype=torch.float32) rhs_embedding = torch.tensor([[13., 14.], [15., 16.]], dtype=torch.float32) lhs_idgnn_batch = torch.tensor([0, 1], dtype=torch.long) rhs_idgnn_index = torch.tensor([0, 1], dtype=torch.long) canonical_logits = self.canonical_model.construct_logits( lhs_embedding_projected, lhs_embedding, rhs_gnn_embedding, rhs_embedding, lhs_idgnn_batch, rhs_idgnn_index ) generated_logits = self.generated_model.construct_logits( lhs_embedding_projected, lhs_embedding, rhs_gnn_embedding, rhs_embedding, lhs_idgnn_batch, rhs_idgnn_index ) self.assertOutputsStructurallyEqual(canonical_logits, generated_logits, msg="construct_logits output") def test_forward(self): print("in test_forward") batch = self.args["batch"] entity_table = self.args["entity_table"] dst_table = self.args["dst_table"] # Patch forward_gnn for both models for model in [self.canonical_model, self.generated_model]: model._original_forward_gnn = model.forward_gnn model.forward_gnn = lambda batch, et: self._patched_forward_gnn(model, batch, et, dst_table) canonical_logits = self.canonical_model.forward(batch, entity_table, dst_table) generated_logits = self.generated_model.forward(batch, entity_table, dst_table) for model in [self.canonical_model, self.generated_model]: model.forward_gnn = model._original_forward_gnn del model._original_forward_gnn self.assertOutputsStructurallyEqual(canonical_logits, generated_logits, msg="forward output") def test_forward_sample_softmax(self): batch = self.args["batch"] entity_table = self.args["entity_table"] dst_table = self.args["dst_table"] src_batch = self.args["src_batch"] dst_index = self.args["dst_index"] for model in [self.canonical_model, self.generated_model]: model._original_forward_gnn = model.forward_gnn model.forward_gnn = lambda batch, et: self._patched_forward_gnn(model, batch, et, dst_table) canonical_outputs = self.canonical_model.forward_sample_softmax( batch, entity_table, dst_table, src_batch, dst_index ) generated_outputs = self.generated_model.forward_sample_softmax( batch, entity_table, dst_table, src_batch, dst_index ) for model in [self.canonical_model, self.generated_model]: model.forward_gnn = model._original_forward_gnn del model._original_forward_gnn self.assertEqual(len(canonical_outputs), len(generated_outputs), "forward_sample_softmax num outputs") for idx, (c, g) in enumerate(zip(canonical_outputs, generated_outputs)): self.assertOutputsStructurallyEqual(c, g, msg=f"forward_sample_softmax output[{idx}]") if __name__ == '__main__': unittest.main(verbosity=2)