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