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