import unittest import random import numpy as np from GRU4Rec.src import canonical from GRU4Rec.src import data_augmentation as generation class DummySimilarityModel: """Single-model similarity used in the baseline tests.""" def __init__(self, mapping=None): self.mapping = mapping if mapping else {} def most_similar(self, item, with_score=False): if with_score: # Deterministic score for coverage paths that pass with_score=True return [(self.mapping.get(item, item), 1.0)] return [self.mapping.get(item, item)] class ScoredSimilarityModel: """ Similarity model that returns a specific score per item to drive ensemble selection branches. """ def __init__(self, mapping=None, score=1.0): self.mapping = mapping if mapping else {} self.score = score self.called_with_score = False # for coverage of with_score=True path def most_similar(self, item, with_score=False): if with_score: self.called_with_score = True return [(self.mapping.get(item, item), float(self.score))] return [self.mapping.get(item, item)] def is_permutation_of(a, b): """Helper: True if b is a permutation of a (multiset equality).""" from collections import Counter return Counter(a) == Counter(b) class TestBASRecAugmentationEquivalence(unittest.TestCase): def setUp(self): # Fixed seeds for reproducibility across tests random.seed(42) np.random.seed(42) self.sequences = [ [1, 2, 3, 4, 5], [7, 8, 9], [1], [], # empty edge case ] self.sim_map = {1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 7: 70, 8: 80, 9: 90} self.sim_model = DummySimilarityModel(mapping=self.sim_map) # Default rates used in many tests self.rate_min = 0.3 self.rate_max = 0.7 # Dispatcher instances self.canonical_random = canonical.Random(self.sim_model, self.rate_min, self.rate_max) self.generated_random = generation.Random(self.sim_model, self.rate_min, self.rate_max) # ------------------------- # Reorder: baseline parity # ------------------------- def test_reorder_equivalence(self): for seq in self.sequences: # Skip only the empty case (known to error in randint range) if len(seq) == 0: continue random.seed(123) np.random.seed(123) canon_reorder = canonical.Reorder(self.rate_min, self.rate_max) canon_out, canon_rate = canon_reorder(list(seq)) random.seed(123) np.random.seed(123) gen_reorder = generation.Reorder(self.rate_min, self.rate_max) gen_out, gen_rate = gen_reorder(list(seq)) self.assertEqual(canon_out, gen_out, f"Reorder outputs differ for sequence {seq}") self.assertAlmostEqual(canon_rate, gen_rate, msg=f"Reorder rates differ for sequence {seq}") # --------------------------------------- # Reorder: singleton should be a no-op # --------------------------------------- def test_reorder_singleton_is_noop(self): seq = [99] random.seed(111) np.random.seed(111) canon_reorder = canonical.Reorder(self.rate_min, self.rate_max) canon_out, _ = canon_reorder(list(seq)) random.seed(111) np.random.seed(111) gen_reorder = generation.Reorder(self.rate_min, self.rate_max) gen_out, _ = gen_reorder(list(seq)) self.assertEqual(canon_out, seq) self.assertEqual(gen_out, seq) # ----------------------------------------------------------- # Reorder: zero-length sub-sequence path (rate_min == rate_max == 0) # ----------------------------------------------------------- def test_reorder_zero_rate_is_noop(self): seq = [1, 2, 3, 4, 5] # Force sub_seq_length = 0 random.seed(202) np.random.seed(202) canon_reorder = canonical.Reorder(0.0, 0.0) canon_out, canon_rate = canon_reorder(list(seq)) random.seed(202) np.random.seed(202) gen_reorder = generation.Reorder(0.0, 0.0) gen_out, gen_rate = gen_reorder(list(seq)) self.assertEqual(canon_out, seq) self.assertEqual(gen_out, seq) self.assertEqual(canon_rate, 0.0) self.assertEqual(gen_rate, 0.0) # ----------------------------------------------------------- # Reorder: empty sequence should raise (same error behavior) # ----------------------------------------------------------- def test_reorder_empty_raises(self): seq = [] random.seed(222) np.random.seed(222) with self.assertRaises(Exception): canonical.Reorder(self.rate_min, self.rate_max)(list(seq)) with self.assertRaises(Exception): generation.Reorder(self.rate_min, self.rate_max)(list(seq)) # ---------------------------- # Substitute: baseline parity # ---------------------------- def test_substitute_equivalence(self): for seq in self.sequences: # Empty will raise (random.sample on empty with k>=1), skip here if len(seq) == 0: continue random.seed(456) np.random.seed(456) canon_sub = canonical.Substitute(self.sim_model, self.rate_min, self.rate_max) canon_out, canon_rate = canon_sub(list(seq)) random.seed(456) np.random.seed(456) gen_sub = generation.Substitute(self.sim_model, self.rate_min, self.rate_max) gen_out, gen_rate = gen_sub(list(seq)) self.assertEqual(canon_out, gen_out, f"Substitute outputs differ for sequence {seq}") self.assertAlmostEqual(canon_rate, gen_rate, msg=f"Substitute rates differ for sequence {seq}") # ---------------------------------------------------------------- # Substitute: unmapped items should map to themselves identically # ---------------------------------------------------------------- def test_substitute_unmapped_identity(self): seq = [101, 102, 103] random.seed(555) np.random.seed(555) canon_sub = canonical.Substitute(DummySimilarityModel(mapping={}), self.rate_min, self.rate_max) gen_sub = generation.Substitute(DummySimilarityModel(mapping={}), self.rate_min, self.rate_max) random.seed(555) np.random.seed(555) canon_out, canon_rate = canon_sub(list(seq)) random.seed(555) np.random.seed(555) gen_out, gen_rate = gen_sub(list(seq)) self.assertEqual(canon_out, gen_out) self.assertAlmostEqual(canon_rate, gen_rate) # Should still be integers and same length self.assertEqual(len(canon_out), len(seq)) self.assertTrue(all(isinstance(x, int) for x in canon_out)) # --------------------------------------------------------- # Substitute: ensemble picks model 1 when its score is higher # --------------------------------------------------------- def test_substitute_ensemble_prefers_model1(self): seq = [1, 2, 3] m1 = ScoredSimilarityModel(mapping=self.sim_map, score=2.0) m2 = ScoredSimilarityModel(mapping=self.sim_map, score=1.0) random.seed(606) np.random.seed(606) canon_sub = canonical.Substitute([m1, m2], self.rate_min, self.rate_max) random.seed(606) np.random.seed(606) gen_sub = generation.Substitute([ScoredSimilarityModel(self.sim_map, 2.0), ScoredSimilarityModel(self.sim_map, 1.0)], self.rate_min, self.rate_max) canon_out, canon_rate = canon_sub(list(seq)) random.seed(606) np.random.seed(606) gen_out, gen_rate = gen_sub(list(seq)) self.assertEqual(canon_out, gen_out) self.assertAlmostEqual(canon_rate, gen_rate) # Ensure ensemble path used (with_score=True called) self.assertTrue(m1.called_with_score) self.assertTrue(m2.called_with_score) # --------------------------------------------------------- # Substitute: ensemble picks model 2 when its score is higher # --------------------------------------------------------- def test_substitute_ensemble_prefers_model2(self): seq = [1, 2, 3] m1 = ScoredSimilarityModel(mapping=self.sim_map, score=0.5) m2 = ScoredSimilarityModel(mapping=self.sim_map, score=1.5) random.seed(707) np.random.seed(707) canon_sub = canonical.Substitute([m1, m2], self.rate_min, self.rate_max) random.seed(707) np.random.seed(707) gen_sub = generation.Substitute([ScoredSimilarityModel(self.sim_map, 0.5), ScoredSimilarityModel(self.sim_map, 1.5)], self.rate_min, self.rate_max) canon_out, canon_rate = canon_sub(list(seq)) random.seed(707) np.random.seed(707) gen_out, gen_rate = gen_sub(list(seq)) self.assertEqual(canon_out, gen_out) self.assertAlmostEqual(canon_rate, gen_rate) self.assertTrue(m1.called_with_score) self.assertTrue(m2.called_with_score) # ----------------------------------------------------------- # Substitute: empty sequence should raise (k >= 1 on empty) # ----------------------------------------------------------- def test_substitute_empty_raises(self): seq = [] random.seed(808) np.random.seed(808) with self.assertRaises(Exception): canonical.Substitute(self.sim_model, self.rate_min, self.rate_max)(list(seq)) with self.assertRaises(Exception): generation.Substitute(self.sim_model, self.rate_min, self.rate_max)(list(seq)) # ----------------------------------------------------------- # Substitute: no-op rate when rate_min == rate_max == 0 # (still substitutes max(0, 1) => 1 item; ensures branch covered) # ----------------------------------------------------------- def test_substitute_zero_rate_still_subs_one(self): seq = [1, 2, 3, 4, 5] random.seed(909) np.random.seed(909) canon_sub = canonical.Substitute(self.sim_model, 0.0, 0.0) gen_sub = generation.Substitute(self.sim_model, 0.0, 0.0) random.seed(909) np.random.seed(909) canon_out, canon_rate = canon_sub(list(seq)) random.seed(909) np.random.seed(909) gen_out, gen_rate = gen_sub(list(seq)) self.assertEqual(canon_out, gen_out) self.assertEqual(canon_rate, 0.0) self.assertEqual(gen_rate, 0.0) # Exactly one position should differ (since k=max(0,1)=1) diffs = sum(1 for a, b in zip(seq, canon_out) if a != b) self.assertEqual(diffs, 1) # ----------------------------------------------------------- # In-place mutation checks: original sequences must be intact # ----------------------------------------------------------- def test_no_inplace_mutation(self): base_seq = [1, 2, 3, 4, 5] # Reorder s1 = list(base_seq) s2 = list(base_seq) random.seed(1001); np.random.seed(1001) _ = canonical.Reorder(self.rate_min, self.rate_max)(s1) random.seed(1001); np.random.seed(1001) _ = generation.Reorder(self.rate_min, self.rate_max)(s2) # Ensure inputs used for calls are not mutated self.assertEqual(s1, base_seq) self.assertEqual(s2, base_seq) # Substitute s3 = list(base_seq) s4 = list(base_seq) random.seed(1002); np.random.seed(1002) _ = canonical.Substitute(self.sim_model, self.rate_min, self.rate_max)(s3) random.seed(1002); np.random.seed(1002) _ = generation.Substitute(self.sim_model, self.rate_min, self.rate_max)(s4) self.assertEqual(s3, base_seq) self.assertEqual(s4, base_seq) # ----------------------------------------------------------- # Dispatcher: parity + verify it can choose different ops # ----------------------------------------------------------- def test_random_dispatcher_equivalence_multiple_seeds(self): seqs = [ [1, 2, 3, 4, 5], [7, 8, 9], [1] ] # Track if we ever see a "reorder-like" vs "substitute-like" outcome. saw_reorder_like = False saw_substitute_like = False for seed in [789, 790, 791, 792, 793]: for seq in seqs: random.seed(seed) np.random.seed(seed) canon_out, canon_rate = self.canonical_random(list(seq)) random.seed(seed) np.random.seed(seed) gen_out, gen_rate = self.generated_random(list(seq)) # Parity checks self.assertIsInstance(gen_out, type(canon_out)) self.assertEqual(len(gen_out), len(canon_out), f"Dispatcher output lengths differ for sequence {seq}") self.assertAlmostEqual(canon_rate, gen_rate, msg=f"Dispatcher rates differ for sequence {seq}") self.assertEqual(gen_out, canon_out, f"Dispatcher outputs differ for sequence {seq}") # Heuristic to infer chosen op: # - If it's a permutation of original (same multiset), likely Reorder. # - If elements changed to mapped ones (not a permutation), likely Substitute. if is_permutation_of(seq, gen_out): saw_reorder_like = True else: saw_substitute_like = True # Across these seeds we should have hit both branches at least once self.assertTrue(saw_reorder_like, "Dispatcher never produced a reorder-like result") self.assertTrue(saw_substitute_like, "Dispatcher never produced a substitute-like result") if __name__ == "__main__": unittest.main()