Download annotations/annotation_35/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 14.1 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_35/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_35/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_35/test.py
14.1 kB
| 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): | |
| def node_types(self): | |
| return [k for k in self.keys() if k in ("user", "item")] | |
| 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): | |
| 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) | |