mcy98's picture
Upload folder using huggingface_hub
6077218 verified
Raw History Blame Contribute Delete
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()