import unittest import copy import torch import numpy as np from unittest import mock from models.PreferDiff.canonical import PreferDiff as CanonicalPreferDiff from models.PreferDiff._model import PreferDiff as GeneratedPreferDiff class TestPreferDiffFunctionalEquivalence(unittest.TestCase): @classmethod def setUpClass(cls): torch.manual_seed(42) np.random.seed(42) cls.base_config = { 'hidden_size': 8, 'item_num': 16, 'timesteps': 7, 'select_pool': [0, 16], 'p': 0.5, 'sample_func': 'random', 'neg_samples': 2, 'ab': 'iids', 'exp_type': 'normal', 'sd': None, 'embedding': None, 'source_dict': {}, 'loss_type': 'l2', 'max_seq_length': 6, 'dropout': 0.1, 'layer_num': 1, 'num_heads': 2, 'device': 'cpu', 'w': 1.0, 'beta_sche': 'linear', 'beta_start': 1e-4, 'beta_end': 2e-2, 'ddim_step': 1, 'gamma': 1.0, 'lamda': 0.5, 'mode': 'neg' } B = 4 S = cls.base_config['max_seq_length'] cls.dummy_labels = torch.LongTensor([1, 2, 3, 4]) cls.dummy_seqs = torch.randint(1, 8, (B, S)) cls.dummy_seq_lengths = torch.LongTensor([S, S, S, S]) cls.canonical = CanonicalPreferDiff(copy.deepcopy(cls.base_config)) cls.generated = GeneratedPreferDiff(copy.deepcopy(cls.base_config)) cls.canonical.load_item_embeddings() cls.generated.load_item_embeddings() for (_, p1), (_, p2) in zip(cls.canonical.named_parameters(), cls.generated.named_parameters()): if p1.shape == p2.shape: p2.data = p1.data.clone() def make_batch(self, labels=None, seqs=None, lens=None): return { 'labels': (labels if labels is not None else self.dummy_labels.clone()), 'item_seqs': (seqs if seqs is not None else self.dummy_seqs.clone()), 'seq_lengths': (lens if lens is not None else self.dummy_seq_lengths.clone()) } # ---------- Embedding getters ---------- def test_get_embeddings_equivalence_ids(self): indices = torch.LongTensor([1, 5, 7]) emb_c = self.canonical.get_embeddings(indices) emb_g = self.generated.get_embeddings(indices) np.testing.assert_allclose(emb_c.detach().numpy(), emb_g.detach().numpy(), rtol=1e-6, atol=1e-7) def test_get_all_and_current_embeddings_with_device(self): dev = torch.device('cpu') all_c = self.canonical.get_all_embeddings(device=dev) all_g = self.generated.get_all_embeddings(device=dev) cur_c = self.canonical.get_current_embeddings(device=dev) cur_g = self.generated.get_current_embeddings(device=dev) np.testing.assert_allclose(all_c.detach().numpy(), all_g.detach().numpy(), rtol=1e-6, atol=1e-7) np.testing.assert_allclose(cur_c.detach().numpy(), cur_g.detach().numpy(), rtol=1e-6, atol=1e-7) # ---------- calcu_h (masking) ---------- def _assert_calcu_h_semantics(self, model, logits, p): """Check that outputs are either logits or model.none_embedding broadcast, per element.""" h = model.calcu_h(logits, p) none_vec = model.none_embedding(torch.tensor([0]).to(logits.device)).view(1, -1) none_broadcast = none_vec.repeat(logits.size(0), 1) # Per-position, value should match either logits or none_broadcast eq_logits = torch.isclose(h, logits, rtol=1e-6, atol=1e-6) eq_none = torch.isclose(h, none_broadcast, rtol=1e-6, atol=1e-6) valid = torch.logical_or(eq_logits, eq_none) self.assertTrue(valid.all().item()) # For mid p, ensure at least one masked and one unmasked element with high probability if 0.0 < p < 1.0: self.assertTrue(eq_logits.any().item()) self.assertTrue(eq_none.any().item()) def test_calcu_h_edges_and_semantics(self): logits = torch.randn(4, self.base_config['hidden_size']) # p=0 -> no masking, exact equality h_c0 = self.canonical.calcu_h(logits, 0.0) h_g0 = self.generated.calcu_h(logits, 0.0) np.testing.assert_allclose(h_c0.detach().numpy(), logits.detach().numpy(), rtol=1e-6, atol=1e-7) np.testing.assert_allclose(h_g0.detach().numpy(), logits.detach().numpy(), rtol=1e-6, atol=1e-7) # p=1 -> full masking, exact equality to respective none embeddings h_c1 = self.canonical.calcu_h(logits, 1.0) h_g1 = self.generated.calcu_h(logits, 1.0) none_c = self.canonical.none_embedding(torch.tensor([0])).view(1, -1).repeat(logits.size(0), 1) none_g = self.generated.none_embedding(torch.tensor([0])).view(1, -1).repeat(logits.size(0), 1) np.testing.assert_allclose(h_c1.detach().numpy(), none_c.detach().numpy(), rtol=1e-6, atol=1e-7) np.testing.assert_allclose(h_g1.detach().numpy(), none_g.detach().numpy(), rtol=1e-6, atol=1e-7) # p=0.5 -> semantics check (not elementwise equality across impls) torch.manual_seed(123) logits_mid = torch.randn(4, self.base_config['hidden_size']) self._assert_calcu_h_semantics(self.canonical, logits_mid, 0.5) torch.manual_seed(123) self._assert_calcu_h_semantics(self.generated, logits_mid, 0.5) # ---------- Denoising ---------- def test_denoise_vector_equivalence(self): torch.manual_seed(7) x = torch.randn(4, self.base_config['hidden_size']) h = torch.randn(4, self.base_config['hidden_size']) step = torch.randint(0, self.base_config['timesteps'], (4,)) out_c = self.canonical.denoise(x, h, step) out_g = self.generated.denoise(x, h, step) np.testing.assert_allclose(out_c.detach().numpy(), out_g.detach().numpy(), rtol=1e-5, atol=1e-6) def test_denoise_batched_equivalence_3d(self): torch.manual_seed(9) B, N, D = 3, 5, self.base_config['hidden_size'] x = torch.randn(B, N, D) h = torch.randn(B, D) step = torch.randint(0, self.base_config['timesteps'], (B,)) out_c = self.canonical.denoise(x, h, step) out_g = self.generated.denoise(x, h, step) self.assertEqual(out_c.shape, out_g.shape) np.testing.assert_allclose(out_c.detach().numpy(), out_g.detach().numpy(), rtol=1e-5, atol=1e-6) def test_denoise_uncon_equivalence(self): torch.manual_seed(11) x = torch.randn(4, self.base_config['hidden_size']) step = torch.randint(0, self.base_config['timesteps'], (4,)) out_c = self.canonical.denoise_uncon(x, step) out_g = self.generated.denoise_uncon(x, step) np.testing.assert_allclose(out_c.detach().numpy(), out_g.detach().numpy(), rtol=1e-5, atol=1e-6) # ---------- Forward / loss ---------- def test_forward_equivalence_multiple_batches(self): for seed in [21, 33]: torch.manual_seed(seed) np.random.seed(seed) out_c = self.canonical.forward(self.make_batch()) torch.manual_seed(seed) np.random.seed(seed) out_g = self.generated.forward(self.make_batch()) self.assertIsInstance(out_c['loss'], type(out_g['loss'])) np.testing.assert_allclose( out_c['loss'].detach().numpy(), out_g['loss'].detach().numpy(), rtol=1e-5, atol=1e-6 ) # ---------- Prediction ---------- def test_predict_equivalence_normal_mode(self): batch = self.make_batch() torch.manual_seed(1) preds_c = self.canonical.predict(batch, n_return_sequences=3) torch.manual_seed(1) preds_g = self.generated.predict(batch, n_return_sequences=3) self.assertEqual(preds_c.shape, preds_g.shape) np.testing.assert_array_equal(preds_c.detach().numpy(), preds_g.detach().numpy()) def test_predict_equivalence_check_mode_and_debug_tensors(self): # Ensure item_num is large enough for hardcoded index 30724 big_item_num = 40000 canon_cfg = copy.deepcopy(self.base_config) gen_cfg = copy.deepcopy(self.base_config) canon_cfg.update({'exp_type': 'check', 'item_num': big_item_num, 'select_pool': [0, big_item_num]}) gen_cfg.update({'exp_type': 'check', 'item_num': big_item_num, 'select_pool': [0, big_item_num]}) c2 = CanonicalPreferDiff(canon_cfg) g2 = GeneratedPreferDiff(gen_cfg) c2.load_item_embeddings(); g2.load_item_embeddings() for (_, p1), (_, p2) in zip(c2.named_parameters(), g2.named_parameters()): if p1.shape == p2.shape: p2.data = p1.data.clone() batch = self.make_batch() torch.manual_seed(2); preds_c = c2.predict(batch, n_return_sequences=2) torch.manual_seed(2); preds_g = g2.predict(batch, n_return_sequences=2) np.testing.assert_array_equal(preds_c.detach().numpy(), preds_g.detach().numpy()) self.assertTrue(hasattr(c2, 'samples') and hasattr(g2, 'samples')) self.assertEqual(len(c2.samples), len(g2.samples)) np.testing.assert_allclose( c2.target_embedding.detach().numpy(), g2.target_embedding.detach().numpy(), rtol=1e-6, atol=1e-7 ) np.testing.assert_allclose( c2.predict_embeddings.detach().numpy(), g2.predict_embeddings.detach().numpy(), rtol=1e-6, atol=1e-7 ) # ---------- Negative sampling ---------- def test__generate_negative_samples_modes(self): batch = self.make_batch() # batch mode c_cfg = copy.deepcopy(self.base_config); c_cfg['sample_func'] = 'batch' g_cfg = copy.deepcopy(self.base_config); g_cfg['sample_func'] = 'batch' c1 = CanonicalPreferDiff(c_cfg); g1 = GeneratedPreferDiff(g_cfg) c1.load_item_embeddings(); g1.load_item_embeddings() for (_, p1), (_, p2) in zip(c1.named_parameters(), g1.named_parameters()): if p1.shape == p2.shape: p2.data = p1.data.clone() torch.manual_seed(100); neg_c1 = c1._generate_negative_samples(batch) torch.manual_seed(100); neg_g1 = g1._generate_negative_samples(batch) np.testing.assert_array_equal(neg_c1.detach().numpy(), neg_g1.detach().numpy()) # random mode c_cfg2 = copy.deepcopy(self.base_config); c_cfg2['sample_func'] = 'random'; c_cfg2['neg_samples'] = 3 g_cfg2 = copy.deepcopy(self.base_config); g_cfg2['sample_func'] = 'random'; g_cfg2['neg_samples'] = 3 c2 = CanonicalPreferDiff(c_cfg2); g2 = GeneratedPreferDiff(g_cfg2) c2.load_item_embeddings(); g2.load_item_embeddings() for (_, p1), (_, p2) in zip(c2.named_parameters(), g2.named_parameters()): if p1.shape == p2.shape: p2.data = p1.data.clone() torch.manual_seed(200); np.random.seed(200); neg_c2 = c2._generate_negative_samples(batch) torch.manual_seed(200); np.random.seed(200); neg_g2 = g2._generate_negative_samples(batch) np.testing.assert_array_equal(neg_c2.detach().numpy(), neg_g2.detach().numpy()) # fallback branch c_cfg3 = copy.deepcopy(self.base_config); c_cfg3['sample_func'] = 'unknown' g_cfg3 = copy.deepcopy(self.base_config); g_cfg3['sample_func'] = 'unknown' c3 = CanonicalPreferDiff(c_cfg3); g3 = GeneratedPreferDiff(g_cfg3) c3.load_item_embeddings(); g3.load_item_embeddings() for (_, p1), (_, p2) in zip(c3.named_parameters(), g3.named_parameters()): if p1.shape == p2.shape: p2.data = p1.data.clone() torch.manual_seed(321); np.random.seed(321); neg_c3 = c3._generate_negative_samples(batch) torch.manual_seed(321); np.random.seed(321); neg_g3 = g3._generate_negative_samples(batch) np.testing.assert_array_equal(neg_c3.detach().numpy(), neg_g3.detach().numpy()) # ---------- Sampling (sped up) ---------- def test_get_samples_equivalence_fast(self): batch = self.make_batch() with mock.patch('tqdm.tqdm', lambda x: range(4)): torch.manual_seed(555); np.random.seed(555); canon_samples = self.canonical.get_samples(batch) torch.manual_seed(555); np.random.seed(555); gen_samples = self.generated.get_samples(batch) self.assertEqual(len(canon_samples), len(gen_samples)) self.assertEqual(np.array(canon_samples[0]).shape, np.array(gen_samples[0]).shape) # ---------- Non-'iids' tensor embedding path without I/O ---------- def test_get_embeddings_tensor_mode_without_io(self): c = CanonicalPreferDiff(copy.deepcopy(self.base_config)) g = GeneratedPreferDiff(copy.deepcopy(self.base_config)) # remove registered child modules to allow assigning Tensors c.load_item_embeddings(); g.load_item_embeddings() if 'item_embeddings' in c._modules: del c._modules['item_embeddings'] if 'item_embeddings' in g._modules: del g._modules['item_embeddings'] E = torch.randn(self.base_config['item_num'] + 1, self.base_config['hidden_size']) c.item_embeddings = E.clone() g.item_embeddings = E.clone() c.config['ab'] = 'single'; g.config['ab'] = 'single' for (_, p1), (_, p2) in zip(c.named_parameters(), g.named_parameters()): if p1.shape == p2.shape: p2.data = p1.data.clone() idx = torch.LongTensor([1, 4, 6]) emb_c = c.get_embeddings(idx) emb_g = g.get_embeddings(idx) np.testing.assert_allclose(emb_c.detach().numpy(), emb_g.detach().numpy(), rtol=1e-6, atol=1e-7) all_c = c.get_all_embeddings() all_g = g.get_all_embeddings() np.testing.assert_allclose(all_c.detach().numpy(), all_g.detach().numpy(), rtol=1e-6, atol=1e-7) if __name__ == '__main__': unittest.main()