Download annotations/annotation_34/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_34/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_34/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_34/test.py
12.2 kB
| import unittest | |
| import torch | |
| import numpy as np | |
| # Import the canonical and generated implementations | |
| from canonical import ELCRecTrainer as CanonicalTrainer | |
| from trainers import ELCRecTrainer as GeneratedTrainer | |
| # ----------------- Dummies & Mocks ----------------- # | |
| class DummyArgs: | |
| def __init__(self): | |
| self.no_cuda = True | |
| self.num_intent_clusters = "2" | |
| self.seq_representation_type = "mean" | |
| self.seq_representation_instancecl_type = "mean" | |
| self.prototype = "shift" # will vary in tests | |
| self.seed = 42 | |
| self.hidden_size = 4 | |
| self.gpu_id = 0 | |
| self.n_views = 2 | |
| self.max_seq_length = 3 | |
| self.adam_beta1 = 0.9 | |
| self.adam_beta2 = 0.99 | |
| self.lr = 0.001 | |
| self.weight_decay = 0.0 | |
| self.temperature = 1.0 | |
| self.cf_weight = 1.0 | |
| self.intent_cf_weight = 1.0 | |
| self.rec_weight = 1.0 | |
| self.trade_off = 1.0 | |
| self.log_file = "test.log" | |
| self.contrast_type = "InstanceCL" # will vary in tests | |
| self.de_noise = False # will vary in tests | |
| self.warm_up_epoches = 0 | |
| self.train_matrix = np.zeros((2, 20)) # not used in sampled eval | |
| class DummyModel(torch.nn.Module): | |
| def __init__(self, hidden_size=4, num_clusters=2, vocab_size=20): | |
| super().__init__() | |
| self.hidden_size = hidden_size | |
| self.cluster_centers = torch.nn.Parameter(torch.randn(num_clusters, hidden_size)) | |
| self.item_embeddings = torch.nn.Embedding(vocab_size, hidden_size) | |
| self.args = DummyArgs() | |
| def forward(self, x): | |
| return self.item_embeddings(x) | |
| class DummyCriterion: | |
| def __call__(self, *args, **kwargs): | |
| return torch.tensor(0.5) | |
| class DummyDataLoader: | |
| """Yields a single minimal batch for train/eval paths.""" | |
| def __iter__(self): | |
| rec_batch = ( | |
| torch.zeros(2, 3, dtype=torch.long), # user ids | |
| torch.zeros(2, 3, dtype=torch.long), # input_ids | |
| torch.tensor([[1, 2, 0], [0, 1, 2]], dtype=torch.long), # target_pos (>=0) | |
| torch.zeros(2, 3, dtype=torch.long), # target_neg | |
| torch.zeros(2, dtype=torch.long) # answers | |
| ) | |
| cl_batches = [ | |
| [torch.zeros(2, 3, dtype=torch.long), torch.ones(2, 3, dtype=torch.long)] | |
| ] | |
| seq_class_label_batches = [torch.zeros(2, dtype=torch.long)] | |
| yield rec_batch, cl_batches, seq_class_label_batches | |
| def __len__(self): | |
| return 1 | |
| class MockCluster: | |
| """Provides centroids and a no-op train() for KMeans init path.""" | |
| def __init__(self, k=2, d=4): | |
| self._k = k | |
| self._d = d | |
| self.centroids = torch.zeros(k, d) # deterministic | |
| def train(self, np_data): | |
| # set zeros deterministically; could also compute means if desired | |
| self.centroids = torch.zeros(self._k, self._d) | |
| class MockOptim: | |
| def zero_grad(self): pass | |
| def step(self): pass | |
| # ----------------- Test Suite ----------------- # | |
| class DummyEvalSampledDataLoader: | |
| """ | |
| Yields a single batch in the exact shape eval(sampled) expects: | |
| (user_ids, input_ids, target_pos, target_neg, answers, sample_negs) | |
| """ | |
| def __iter__(self): | |
| user_ids = torch.zeros(2, 3, dtype=torch.long) # shape matches train style but used only for .to() | |
| input_ids = torch.zeros(2, 3, dtype=torch.long) | |
| target_pos = torch.tensor([[1, 2, 0], [0, 1, 2]], dtype=torch.long) | |
| target_neg = torch.zeros(2, 3, dtype=torch.long) | |
| answers = torch.zeros(2, dtype=torch.long) | |
| sample_negs = torch.zeros(2, 10, dtype=torch.long) # N sampled negatives per user; any N is fine | |
| yield (user_ids, input_ids, target_pos, target_neg, answers, sample_negs) | |
| def __len__(self): | |
| return 1 | |
| class TestELCRecTrainerEquivalence(unittest.TestCase): | |
| def setUpClass(cls): | |
| # ... keep your existing seeding, model, args, and loaders ... | |
| cls.model1 = DummyModel() | |
| cls.model2 = DummyModel() | |
| cls.model2.load_state_dict(cls.model1.state_dict()) | |
| cls.args = DummyArgs() | |
| cls.dataloader = DummyDataLoader() | |
| cls.cluster_dataloader = DummyDataLoader() | |
| cls.eval_dataloader = DummyEvalSampledDataLoader() # <-- use the new loader here | |
| cls.test_dataloader = DummyDataLoader() | |
| cls.canonical = CanonicalTrainer( | |
| cls.model1, cls.dataloader, cls.cluster_dataloader, cls.eval_dataloader, cls.test_dataloader, cls.args | |
| ) | |
| cls.generated = GeneratedTrainer( | |
| cls.model2, cls.dataloader, cls.cluster_dataloader, cls.eval_dataloader, cls.test_dataloader, cls.args | |
| ) | |
| # Patches unchanged... | |
| for tr in (cls.canonical, cls.generated): | |
| tr.device = torch.device("cpu") | |
| tr.cf_criterion = DummyCriterion() | |
| tr.pcl_criterion = DummyCriterion() | |
| tr.clusters = [MockCluster(k=2, d=cls.args.hidden_size)] | |
| tr.optim = MockOptim() | |
| tr.predict_full = lambda x: torch.zeros((x.shape[0], 20)) | |
| tr.predict_sample = ( | |
| lambda rep, items: torch.zeros((items.shape[0], items.shape[1])) # (bsz, 1+neg) or (bsz, M) | |
| ) | |
| tr.get_full_sort_score = lambda epoch, answers, preds: {"dummy": 1.0} | |
| tr.get_sample_scores = lambda epoch, logits: {"sample@10": 1.0} | |
| # ... keep the rest of the tests unchanged ... | |
| def test_distance_equivalence(self): | |
| x = torch.randn(5, 4) | |
| c = torch.randn(3, 4) | |
| dis_canon = CanonicalTrainer.distance(x, c) | |
| dis_gen = GeneratedTrainer.distance(x, c) | |
| self.assertTrue(torch.allclose(dis_canon, dis_gen, atol=1e-6), "distance() mismatch") | |
| def test_cross_entropy_equivalence(self): | |
| seq_out = torch.ones((2, 3, 4)) | |
| pos_ids = torch.tensor([[1, 2, 0], [0, 1, 2]], dtype=torch.long) | |
| neg_ids = torch.ones((2, 3), dtype=torch.long) | |
| loss_canon = self.canonical.cross_entropy(seq_out, pos_ids, neg_ids) | |
| loss_gen = self.generated.cross_entropy(seq_out, pos_ids, neg_ids) | |
| self.assertAlmostEqual(float(loss_canon), float(loss_gen), places=6, msg="cross_entropy loss mismatch") | |
| # ---------- InstanceCL variants ---------- # | |
| def test_instance_cl_shift_mean_equivalence(self): | |
| self.canonical.args.prototype = "shift" | |
| self.generated.args.prototype = "shift" | |
| self.canonical.args.seq_representation_instancecl_type = "mean" | |
| self.generated.args.seq_representation_instancecl_type = "mean" | |
| inputs = [torch.zeros(2, 3, dtype=torch.long), torch.ones(2, 3, dtype=torch.long)] | |
| loss_canon = self.canonical._instance_cl_one_pair_contrastive_learning(inputs) | |
| loss_gen = self.generated._instance_cl_one_pair_contrastive_learning(inputs) | |
| self.assertAlmostEqual(float(loss_canon), float(loss_gen), places=6, msg="InstanceCL shift/mean mismatch") | |
| def test_instance_cl_concat_equivalence(self): | |
| self.canonical.args.prototype = "concat" | |
| self.generated.args.prototype = "concat" | |
| # mean pooling still active | |
| inputs = [torch.zeros(2, 3, dtype=torch.long), torch.ones(2, 3, dtype=torch.long)] | |
| loss_canon = self.canonical._instance_cl_one_pair_contrastive_learning(inputs) | |
| loss_gen = self.generated._instance_cl_one_pair_contrastive_learning(inputs) | |
| self.assertAlmostEqual(float(loss_canon), float(loss_gen), places=6, msg="InstanceCL concat mismatch") | |
| def test_instance_cl_with_denoise_flag_equivalence(self): | |
| self.canonical.args.prototype = "shift" | |
| self.generated.args.prototype = "shift" | |
| self.canonical.args.de_noise = True | |
| self.generated.args.de_noise = True | |
| inputs = [torch.zeros(2, 3, dtype=torch.long), torch.ones(2, 3, dtype=torch.long)] | |
| intent_ids = torch.zeros(2, dtype=torch.long) | |
| loss_canon = self.canonical._instance_cl_one_pair_contrastive_learning(inputs, intent_ids=intent_ids) | |
| loss_gen = self.generated._instance_cl_one_pair_contrastive_learning(inputs, intent_ids=intent_ids) | |
| self.assertAlmostEqual(float(loss_canon), float(loss_gen), places=6, msg="InstanceCL de_noise mismatch") | |
| # reset | |
| self.canonical.args.de_noise = False | |
| self.generated.args.de_noise = False | |
| # ---------- PCL path ---------- # | |
| def test_pcl_equivalence(self): | |
| self.canonical.args.seq_representation_type = "mean" | |
| self.generated.args.seq_representation_type = "mean" | |
| inputs = [torch.zeros(2, 3, dtype=torch.long), torch.ones(2, 3, dtype=torch.long)] | |
| intents = [torch.ones(2, 4), torch.ones(2, 4)] | |
| intent_ids = [torch.zeros(2, dtype=torch.long), torch.ones(2, dtype=torch.long)] | |
| loss_canon = self.canonical._pcl_one_pair_contrastive_learning(inputs, intents, intent_ids) | |
| loss_gen = self.generated._pcl_one_pair_contrastive_learning(inputs, intents, intent_ids) | |
| self.assertAlmostEqual(float(loss_canon), float(loss_gen), places=6, msg="PCL loss mismatch") | |
| def test_pcl_with_denoise_flag_equivalence(self): | |
| self.canonical.args.de_noise = True | |
| self.generated.args.de_noise = True | |
| inputs = [torch.zeros(2, 3, dtype=torch.long), torch.ones(2, 3, dtype=torch.long)] | |
| intents = [torch.ones(2, 4), torch.ones(2, 4)] | |
| intent_ids = [torch.zeros(2, dtype=torch.long), torch.ones(2, dtype=torch.long)] | |
| loss_canon = self.canonical._pcl_one_pair_contrastive_learning(inputs, intents, intent_ids) | |
| loss_gen = self.generated._pcl_one_pair_contrastive_learning(inputs, intents, intent_ids) | |
| self.assertAlmostEqual(float(loss_canon), float(loss_gen), places=6, msg="PCL de_noise mismatch") | |
| # reset | |
| self.canonical.args.de_noise = False | |
| self.generated.args.de_noise = False | |
| # ---------- Iteration: training branches ---------- # | |
| def _run_train_iteration_and_compare(self, contrast_type): | |
| self.canonical.args.contrast_type = contrast_type | |
| self.generated.args.contrast_type = contrast_type | |
| # Ensure warmup allows IntentCL/Hybrid KMeans path at epoch 0 | |
| self.canonical.args.warm_up_epoches = 0 | |
| self.generated.args.warm_up_epoches = 0 | |
| rec_avg_loss_canon, joint_avg_loss_canon = self.canonical.iteration( | |
| epoch=0, dataloader=self.dataloader, cluster_dataloader=self.cluster_dataloader, full_sort=True, train=True | |
| ) | |
| rec_avg_loss_gen, joint_avg_loss_gen = self.generated.iteration( | |
| epoch=0, dataloader=self.dataloader, cluster_dataloader=self.cluster_dataloader, full_sort=True, train=True | |
| ) | |
| self.assertAlmostEqual(rec_avg_loss_canon, rec_avg_loss_gen, places=6, msg=f"{contrast_type} rec_avg mismatch") | |
| self.assertAlmostEqual(joint_avg_loss_canon, joint_avg_loss_gen, places=6, msg=f"{contrast_type} joint_avg mismatch") | |
| def test_iteration_train_instancecl(self): | |
| self._run_train_iteration_and_compare("InstanceCL") | |
| def test_iteration_train_intentcl(self): | |
| self._run_train_iteration_and_compare("IntentCL") | |
| def test_iteration_train_hybrid(self): | |
| self._run_train_iteration_and_compare("Hybrid") | |
| # ---------- Iteration: eval (sampled) branch ---------- # | |
| def test_iteration_eval_sampled_equivalence(self): | |
| result_canon = self.canonical.iteration( | |
| epoch=0, dataloader=self.eval_dataloader, full_sort=False, train=False | |
| ) | |
| result_gen = self.generated.iteration( | |
| epoch=0, dataloader=self.eval_dataloader, full_sort=False, train=False | |
| ) | |
| self.assertEqual(result_canon, result_gen, "Eval (sampled) results mismatch") | |
| if __name__ == '__main__': | |
| unittest.main(verbosity=2) | |