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): @classmethod 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()