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