Download annotations/annotation_102/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 8.48 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_102/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_102/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_102/test.py
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() | |