Download annotations/annotation_37/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 4.18 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_37/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_37/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_37/test.py
4.18 kB
| import unittest | |
| import numpy as np | |
| import torch | |
| from models.General.canonical import AlphaRec as CanonicalAlphaRec | |
| from models.General.AlphaRec import AlphaRec as GeneratedAlphaRec | |
| class DummyArgs: | |
| def __init__(self): | |
| self.model_name = "AlphaRec" | |
| self.tau = 0.2 | |
| self.hidden_size = 8 | |
| self.lm_model = 'bert' | |
| self.model_version = 'homo' | |
| self.device = 'cuda:0' | |
| self.n_layers = 1 | |
| self.train_norm = True | |
| self.pred_norm = True | |
| self.cuda = 'cuda:0' | |
| self.regs = 0.0 | |
| self.batch_size = 2 | |
| class DummyData: | |
| def __init__(self): | |
| self.n_users = 2 | |
| self.n_items = 3 | |
| self.user_cf_embeds = np.random.rand(self.n_users, 4).astype(np.float32) | |
| self.item_cf_embeds = np.random.rand(self.n_items, 4).astype(np.float32) | |
| def getSparseGraph(self): | |
| n = self.n_users + self.n_items | |
| indices = torch.arange(n, device='cuda:0') | |
| values = torch.ones(n, device='cuda:0') | |
| indices = torch.stack([indices, indices]) | |
| return torch.sparse_coo_tensor(indices, values, size=(n, n)).coalesce().cuda('cuda:0') | |
| class TestAlphaRecFunctionalEquivalence(unittest.TestCase): | |
| def setUpClass(cls): | |
| cls.args = DummyArgs() | |
| cls.data = DummyData() | |
| cls.canonical = CanonicalAlphaRec(cls.args, cls.data).cuda() | |
| cls.generated = GeneratedAlphaRec(cls.args, cls.data).cuda() | |
| # Copy state dict and ensure both models are on CUDA | |
| cls.generated.load_state_dict(cls.canonical.state_dict()) | |
| cls.generated.to('cuda:0') | |
| cls.canonical.to('cuda:0') | |
| if hasattr(cls.canonical, "eval"): cls.canonical.eval() | |
| if hasattr(cls.generated, "eval"): cls.generated.eval() | |
| def test_init_equivalence(self): | |
| for attr in ['tau', 'embed_size', 'lm_model', 'model_version']: | |
| self.assertEqual(getattr(self.canonical, attr), getattr(self.generated, attr)) | |
| self.assertEqual(self.canonical.init_embed_shape, self.generated.init_embed_shape) | |
| def test_compute_equivalence(self): | |
| users_can, items_can = self.canonical.compute() | |
| users_gen, items_gen = self.generated.compute() | |
| self.assertIsInstance(users_can, torch.Tensor) | |
| self.assertIsInstance(users_gen, torch.Tensor) | |
| self.assertEqual(users_can.shape, users_gen.shape) | |
| self.assertEqual(items_can.shape, items_gen.shape) | |
| np.testing.assert_allclose(users_can.detach().cpu().numpy(), users_gen.detach().cpu().numpy(), rtol=1e-4, atol=1e-6) | |
| np.testing.assert_allclose(items_can.detach().cpu().numpy(), items_gen.detach().cpu().numpy(), rtol=1e-4, atol=1e-6) | |
| def test_forward_equivalence(self): | |
| users = torch.tensor([0, 1], device='cuda:0') | |
| pos_items = torch.tensor([1, 2], device='cuda:0') | |
| neg_items = torch.tensor([[0, 2], [1, 0]], device='cuda:0') | |
| loss_can = self.canonical.forward(users, pos_items, neg_items) | |
| loss_gen = self.generated.forward(users, pos_items, neg_items) | |
| self.assertIsInstance(loss_can, torch.Tensor) | |
| self.assertIsInstance(loss_gen, torch.Tensor) | |
| np.testing.assert_allclose(loss_can.detach().cpu().numpy(), loss_gen.detach().cpu().numpy(), rtol=1e-4, atol=1e-6) | |
| def test_predict_equivalence(self): | |
| users = [0, 1] | |
| items = [0, 1, 2] | |
| preds_can = self.canonical.predict(users, items) | |
| preds_gen = self.generated.predict(users, items) | |
| self.assertIsInstance(preds_can, np.ndarray) | |
| self.assertIsInstance(preds_gen, np.ndarray) | |
| self.assertEqual(preds_can.shape, preds_gen.shape) | |
| np.testing.assert_allclose(preds_can, preds_gen, rtol=1e-4, atol=1e-6) | |
| def test_predict_all_items(self): | |
| users = [0] | |
| preds_can = self.canonical.predict(users) | |
| preds_gen = self.generated.predict(users) | |
| self.assertEqual(preds_can.shape, preds_gen.shape) | |
| np.testing.assert_allclose(preds_can, preds_gen, rtol=1e-4, atol=1e-6) | |
| if __name__ == '__main__': | |
| unittest.main() | |