mcy98's picture
Upload folder using huggingface_hub
d7ff85b verified
Raw History Blame Contribute Delete
8.48 kB
import unittest
import numpy as np
import types
import torch
# Import target classes from both implementations
from canonical import TAHyper as CanonicalTAHyper
from tahyper import TAHyper as GeneratedTAHyper
def _to_numpy(x):
"""Normalize tensors/lists/scalars to numpy for fair comparison."""
if torch.is_tensor(x):
return x.detach().cpu().numpy()
if isinstance(x, (list, tuple)):
return np.asarray(x, dtype=np.float64)
if isinstance(x, (np.ndarray, np.number, float, int)):
return np.asarray(x, dtype=np.float64)
try:
return np.array(x, dtype=np.float64)
except Exception as e:
raise AssertionError(f"Unable to convert output to numpy array: {type(x)}: {e}")
def _extract_outputs(output):
"""
Instruction: forward should return (y, lp_cls_loss). Some implementations may
return extra values (e.g., (y, rep, p1, loss)). We accept that and extract the
first as y and the last as loss when length > 2.
"""
if isinstance(output, (list, tuple)):
if len(output) == 2:
y, loss = output
elif len(output) > 2:
y, loss = output[0], output[-1]
else:
raise AssertionError("`forward` must return at least two values (y, loss)")
else:
raise AssertionError("`forward` must return a tuple/list-like (y, loss)")
return _to_numpy(y), _to_numpy(loss)
def build_args(feat_dim):
"""Construct a minimal args namespace needed by both implementations."""
return types.SimpleNamespace(
manifold="PoincareBall", # or "Hyperboloid"/"Euclidean" depending on your setup
c=1.0,
cuda=-1,
device="cpu",
feat_dim=feat_dim,
n_nodes=64,
model="HGCN", # must match the encoder name expected in your codebase
dim=8,
nout=1,
dropout=0.0,
bias=True,
# Additional attributes needed by HGCN encoder
num_layers=2, # Must be > 1 for HGCN
act="relu", # Activation function
use_att=False, # Use attention
local_agg=False, # Local aggregation
use_feats=True, # Use features
pretrained_embeddings=None, # No pretrained embeddings
n_heads=1, # Number of attention heads (for GAT)
alpha=0.2, # Alpha parameter (for GAT)
)
def build_idx(adj, t, k=2):
"""
Build indices for relationship identification: [N, K, 3] as LongTensor
For each node i, pick up to K rows: (i, same-treat neighbor, diff-treat neighbor).
Fallbacks keep the test lightweight and always valid.
"""
n = len(adj)
all_rows = []
for i in range(n):
same = [j for j in range(n) if j != i and adj[i][j] and t[j] == t[i]]
diff = [j for j in range(n) if j != i and adj[i][j] and t[j] != t[i]]
if not same:
same = [i]
if not diff:
diff = [(i + 1) % n]
rows = []
for kk in range(k):
rows.append([i, same[kk % len(same)], diff[kk % len(diff)]])
all_rows.append(rows)
return torch.tensor(all_rows, dtype=torch.long)
# ----- Small synthetic graphs -----
def small_chain_graph(n=5, d=3, seed=0):
rng = np.random.RandomState(seed)
x = torch.tensor(rng.randn(n, d), dtype=torch.float32)
adj = np.zeros((n, n), dtype=np.int64)
for i in range(n - 1):
adj[i, i + 1] = adj[i + 1, i] = 1
t = np.array([i % 2 for i in range(n)], dtype=np.int64)
idx = build_idx(adj, t, k=2)
return x, torch.tensor(adj, dtype=torch.float32), torch.tensor(t, dtype=torch.long), idx
def small_star_graph(n=6, d=4, seed=1):
rng = np.random.RandomState(seed)
x = torch.tensor(rng.randn(n, d), dtype=torch.float32)
adj = np.zeros((n, n), dtype=np.int64)
for j in range(1, n):
adj[0, j] = adj[j, 0] = 1
t = np.array([0] * (n // 2) + [1] * (n - n // 2), dtype=np.int64)
idx = build_idx(adj, t, k=2)
return x, torch.tensor(adj, dtype=torch.float32), torch.tensor(t, dtype=torch.long), idx
def single_node_graph(d=2):
x = torch.tensor([[0.1] * d], dtype=torch.float32)
adj = torch.tensor([[0]], dtype=torch.float32)
t = torch.tensor([0], dtype=torch.long)
idx = torch.tensor([[[0, 0, 0]]], dtype=torch.long) # [1,1,3]
return x, adj, t, idx
class TestTAHyperForwardEquivalence(unittest.TestCase):
def _call_both(self, x, adj, t, idx):
# Rebuild models per feature dim to keep args.feat_dim consistent with input
feat_dim = x.shape[1]
args = build_args(feat_dim)
can_model = CanonicalTAHyper(args)
gen_model = GeneratedTAHyper(args)
# Ensure identical parameters: copy canonical weights into generated
gen_model.load_state_dict(can_model.state_dict(), strict=False)
# Ensure CPU for deterministic comparison
can_model.eval()
gen_model.eval()
with torch.no_grad():
can_out = can_model.forward(x, adj, t, idx)
gen_out = gen_model.forward(x, adj, t, idx)
cy, closs = _extract_outputs(can_out)
gy, gloss = _extract_outputs(gen_out)
return cy, closs, gy, gloss
# --- Contract tests (canonical alone) ---
def test_canonical_output_contract(self):
for x, adj, t, idx in [
small_chain_graph(n=5, d=3, seed=0),
small_star_graph(n=6, d=4, seed=1),
single_node_graph(d=2),
]:
feat_dim = x.shape[1]
args = build_args(feat_dim)
model = CanonicalTAHyper(args).eval()
with torch.no_grad():
out = model.forward(x, adj, t, idx)
y, loss = _extract_outputs(out)
self.assertEqual(y.ndim, 1, "y must be a 1D array-like of per-node predictions")
self.assertEqual(len(y), x.shape[0], "y length must equal number of nodes")
self.assertGreaterEqual(loss.size, 1, "loss must be scalar or vector")
# --- Equivalence: numeric allclose ---
def test_equivalence_values_allclose(self):
for x, adj, t, idx in [
small_chain_graph(n=5, d=3, seed=0),
small_star_graph(n=6, d=4, seed=1),
single_node_graph(d=2),
]:
cy, closs, gy, gloss = self._call_both(x, adj, t, idx)
np.testing.assert_allclose(
cy, gy, rtol=1e-5, atol=1e-7,
err_msg="Predicted factual outcomes differ between canonical and generated implementations.",
)
if closs.shape != gloss.shape:
np.testing.assert_allclose(np.mean(closs), np.mean(gloss), rtol=1e-5, atol=1e-7,
err_msg="Relationship-identification loss differs (after mean reduction).")
else:
np.testing.assert_allclose(closs, gloss, rtol=1e-5, atol=1e-7,
err_msg="Relationship-identification loss differs.")
def test_equivalence_structure(self):
for x, adj, t, idx in [
small_chain_graph(n=5, d=3, seed=0),
small_star_graph(n=6, d=4, seed=1),
single_node_graph(d=2),
]:
cy, closs, gy, gloss = self._call_both(x, adj, t, idx)
self.assertEqual(cy.shape, gy.shape, "y shape mismatch between canonical and generated")
self.assertEqual(closs.ndim, gloss.ndim, "loss dimensionality mismatch")
def test_edge_case_all_treated(self):
x, adj, _, idx = small_chain_graph(n=5, d=3, seed=42)
t = torch.ones(x.shape[0], dtype=torch.long)
cy, closs, gy, gloss = self._call_both(x, adj, t, idx)
np.testing.assert_allclose(cy, gy, rtol=1e-5, atol=1e-7)
if closs.shape != gloss.shape:
np.testing.assert_allclose(np.mean(closs), np.mean(gloss), rtol=1e-5, atol=1e-7)
else:
np.testing.assert_allclose(closs, gloss, rtol=1e-5, atol=1e-7)
def test_edge_case_all_control(self):
x, adj, _, idx = small_star_graph(n=6, d=4, seed=24)
t = torch.zeros(x.shape[0], dtype=torch.long)
cy, closs, gy, gloss = self._call_both(x, adj, t, idx)
np.testing.assert_allclose(cy, gy, rtol=1e-5, atol=1e-7)
if closs.shape != gloss.shape:
np.testing.assert_allclose(np.mean(closs), np.mean(gloss), rtol=1e-5, atol=1e-7)
else:
np.testing.assert_allclose(closs, gloss, rtol=1e-5, atol=1e-7)
if __name__ == "__main__":
unittest.main()