mcy98's picture
Upload folder using huggingface_hub
e89a301 verified
Raw History Blame Contribute Delete
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):
@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)