mcy98's picture
Upload folder using huggingface_hub
6077218 verified
Raw History Blame Contribute Delete
14.2 kB
import unittest
import copy
import torch
import numpy as np
from unittest import mock
from models.PreferDiff.canonical import PreferDiff as CanonicalPreferDiff
from models.PreferDiff._model import PreferDiff as GeneratedPreferDiff
class TestPreferDiffFunctionalEquivalence(unittest.TestCase):
@classmethod
def setUpClass(cls):
torch.manual_seed(42)
np.random.seed(42)
cls.base_config = {
'hidden_size': 8,
'item_num': 16,
'timesteps': 7,
'select_pool': [0, 16],
'p': 0.5,
'sample_func': 'random',
'neg_samples': 2,
'ab': 'iids',
'exp_type': 'normal',
'sd': None,
'embedding': None,
'source_dict': {},
'loss_type': 'l2',
'max_seq_length': 6,
'dropout': 0.1,
'layer_num': 1,
'num_heads': 2,
'device': 'cpu',
'w': 1.0,
'beta_sche': 'linear',
'beta_start': 1e-4,
'beta_end': 2e-2,
'ddim_step': 1,
'gamma': 1.0,
'lamda': 0.5,
'mode': 'neg'
}
B = 4
S = cls.base_config['max_seq_length']
cls.dummy_labels = torch.LongTensor([1, 2, 3, 4])
cls.dummy_seqs = torch.randint(1, 8, (B, S))
cls.dummy_seq_lengths = torch.LongTensor([S, S, S, S])
cls.canonical = CanonicalPreferDiff(copy.deepcopy(cls.base_config))
cls.generated = GeneratedPreferDiff(copy.deepcopy(cls.base_config))
cls.canonical.load_item_embeddings()
cls.generated.load_item_embeddings()
for (_, p1), (_, p2) in zip(cls.canonical.named_parameters(), cls.generated.named_parameters()):
if p1.shape == p2.shape:
p2.data = p1.data.clone()
def make_batch(self, labels=None, seqs=None, lens=None):
return {
'labels': (labels if labels is not None else self.dummy_labels.clone()),
'item_seqs': (seqs if seqs is not None else self.dummy_seqs.clone()),
'seq_lengths': (lens if lens is not None else self.dummy_seq_lengths.clone())
}
# ---------- Embedding getters ----------
def test_get_embeddings_equivalence_ids(self):
indices = torch.LongTensor([1, 5, 7])
emb_c = self.canonical.get_embeddings(indices)
emb_g = self.generated.get_embeddings(indices)
np.testing.assert_allclose(emb_c.detach().numpy(), emb_g.detach().numpy(), rtol=1e-6, atol=1e-7)
def test_get_all_and_current_embeddings_with_device(self):
dev = torch.device('cpu')
all_c = self.canonical.get_all_embeddings(device=dev)
all_g = self.generated.get_all_embeddings(device=dev)
cur_c = self.canonical.get_current_embeddings(device=dev)
cur_g = self.generated.get_current_embeddings(device=dev)
np.testing.assert_allclose(all_c.detach().numpy(), all_g.detach().numpy(), rtol=1e-6, atol=1e-7)
np.testing.assert_allclose(cur_c.detach().numpy(), cur_g.detach().numpy(), rtol=1e-6, atol=1e-7)
# ---------- calcu_h (masking) ----------
def _assert_calcu_h_semantics(self, model, logits, p):
"""Check that outputs are either logits or model.none_embedding broadcast, per element."""
h = model.calcu_h(logits, p)
none_vec = model.none_embedding(torch.tensor([0]).to(logits.device)).view(1, -1)
none_broadcast = none_vec.repeat(logits.size(0), 1)
# Per-position, value should match either logits or none_broadcast
eq_logits = torch.isclose(h, logits, rtol=1e-6, atol=1e-6)
eq_none = torch.isclose(h, none_broadcast, rtol=1e-6, atol=1e-6)
valid = torch.logical_or(eq_logits, eq_none)
self.assertTrue(valid.all().item())
# For mid p, ensure at least one masked and one unmasked element with high probability
if 0.0 < p < 1.0:
self.assertTrue(eq_logits.any().item())
self.assertTrue(eq_none.any().item())
def test_calcu_h_edges_and_semantics(self):
logits = torch.randn(4, self.base_config['hidden_size'])
# p=0 -> no masking, exact equality
h_c0 = self.canonical.calcu_h(logits, 0.0)
h_g0 = self.generated.calcu_h(logits, 0.0)
np.testing.assert_allclose(h_c0.detach().numpy(), logits.detach().numpy(), rtol=1e-6, atol=1e-7)
np.testing.assert_allclose(h_g0.detach().numpy(), logits.detach().numpy(), rtol=1e-6, atol=1e-7)
# p=1 -> full masking, exact equality to respective none embeddings
h_c1 = self.canonical.calcu_h(logits, 1.0)
h_g1 = self.generated.calcu_h(logits, 1.0)
none_c = self.canonical.none_embedding(torch.tensor([0])).view(1, -1).repeat(logits.size(0), 1)
none_g = self.generated.none_embedding(torch.tensor([0])).view(1, -1).repeat(logits.size(0), 1)
np.testing.assert_allclose(h_c1.detach().numpy(), none_c.detach().numpy(), rtol=1e-6, atol=1e-7)
np.testing.assert_allclose(h_g1.detach().numpy(), none_g.detach().numpy(), rtol=1e-6, atol=1e-7)
# p=0.5 -> semantics check (not elementwise equality across impls)
torch.manual_seed(123)
logits_mid = torch.randn(4, self.base_config['hidden_size'])
self._assert_calcu_h_semantics(self.canonical, logits_mid, 0.5)
torch.manual_seed(123)
self._assert_calcu_h_semantics(self.generated, logits_mid, 0.5)
# ---------- Denoising ----------
def test_denoise_vector_equivalence(self):
torch.manual_seed(7)
x = torch.randn(4, self.base_config['hidden_size'])
h = torch.randn(4, self.base_config['hidden_size'])
step = torch.randint(0, self.base_config['timesteps'], (4,))
out_c = self.canonical.denoise(x, h, step)
out_g = self.generated.denoise(x, h, step)
np.testing.assert_allclose(out_c.detach().numpy(), out_g.detach().numpy(), rtol=1e-5, atol=1e-6)
def test_denoise_batched_equivalence_3d(self):
torch.manual_seed(9)
B, N, D = 3, 5, self.base_config['hidden_size']
x = torch.randn(B, N, D)
h = torch.randn(B, D)
step = torch.randint(0, self.base_config['timesteps'], (B,))
out_c = self.canonical.denoise(x, h, step)
out_g = self.generated.denoise(x, h, step)
self.assertEqual(out_c.shape, out_g.shape)
np.testing.assert_allclose(out_c.detach().numpy(), out_g.detach().numpy(), rtol=1e-5, atol=1e-6)
def test_denoise_uncon_equivalence(self):
torch.manual_seed(11)
x = torch.randn(4, self.base_config['hidden_size'])
step = torch.randint(0, self.base_config['timesteps'], (4,))
out_c = self.canonical.denoise_uncon(x, step)
out_g = self.generated.denoise_uncon(x, step)
np.testing.assert_allclose(out_c.detach().numpy(), out_g.detach().numpy(), rtol=1e-5, atol=1e-6)
# ---------- Forward / loss ----------
def test_forward_equivalence_multiple_batches(self):
for seed in [21, 33]:
torch.manual_seed(seed)
np.random.seed(seed)
out_c = self.canonical.forward(self.make_batch())
torch.manual_seed(seed)
np.random.seed(seed)
out_g = self.generated.forward(self.make_batch())
self.assertIsInstance(out_c['loss'], type(out_g['loss']))
np.testing.assert_allclose(
out_c['loss'].detach().numpy(), out_g['loss'].detach().numpy(), rtol=1e-5, atol=1e-6
)
# ---------- Prediction ----------
def test_predict_equivalence_normal_mode(self):
batch = self.make_batch()
torch.manual_seed(1)
preds_c = self.canonical.predict(batch, n_return_sequences=3)
torch.manual_seed(1)
preds_g = self.generated.predict(batch, n_return_sequences=3)
self.assertEqual(preds_c.shape, preds_g.shape)
np.testing.assert_array_equal(preds_c.detach().numpy(), preds_g.detach().numpy())
def test_predict_equivalence_check_mode_and_debug_tensors(self):
# Ensure item_num is large enough for hardcoded index 30724
big_item_num = 40000
canon_cfg = copy.deepcopy(self.base_config)
gen_cfg = copy.deepcopy(self.base_config)
canon_cfg.update({'exp_type': 'check', 'item_num': big_item_num, 'select_pool': [0, big_item_num]})
gen_cfg.update({'exp_type': 'check', 'item_num': big_item_num, 'select_pool': [0, big_item_num]})
c2 = CanonicalPreferDiff(canon_cfg)
g2 = GeneratedPreferDiff(gen_cfg)
c2.load_item_embeddings(); g2.load_item_embeddings()
for (_, p1), (_, p2) in zip(c2.named_parameters(), g2.named_parameters()):
if p1.shape == p2.shape: p2.data = p1.data.clone()
batch = self.make_batch()
torch.manual_seed(2); preds_c = c2.predict(batch, n_return_sequences=2)
torch.manual_seed(2); preds_g = g2.predict(batch, n_return_sequences=2)
np.testing.assert_array_equal(preds_c.detach().numpy(), preds_g.detach().numpy())
self.assertTrue(hasattr(c2, 'samples') and hasattr(g2, 'samples'))
self.assertEqual(len(c2.samples), len(g2.samples))
np.testing.assert_allclose(
c2.target_embedding.detach().numpy(),
g2.target_embedding.detach().numpy(), rtol=1e-6, atol=1e-7
)
np.testing.assert_allclose(
c2.predict_embeddings.detach().numpy(),
g2.predict_embeddings.detach().numpy(), rtol=1e-6, atol=1e-7
)
# ---------- Negative sampling ----------
def test__generate_negative_samples_modes(self):
batch = self.make_batch()
# batch mode
c_cfg = copy.deepcopy(self.base_config); c_cfg['sample_func'] = 'batch'
g_cfg = copy.deepcopy(self.base_config); g_cfg['sample_func'] = 'batch'
c1 = CanonicalPreferDiff(c_cfg); g1 = GeneratedPreferDiff(g_cfg)
c1.load_item_embeddings(); g1.load_item_embeddings()
for (_, p1), (_, p2) in zip(c1.named_parameters(), g1.named_parameters()):
if p1.shape == p2.shape: p2.data = p1.data.clone()
torch.manual_seed(100); neg_c1 = c1._generate_negative_samples(batch)
torch.manual_seed(100); neg_g1 = g1._generate_negative_samples(batch)
np.testing.assert_array_equal(neg_c1.detach().numpy(), neg_g1.detach().numpy())
# random mode
c_cfg2 = copy.deepcopy(self.base_config); c_cfg2['sample_func'] = 'random'; c_cfg2['neg_samples'] = 3
g_cfg2 = copy.deepcopy(self.base_config); g_cfg2['sample_func'] = 'random'; g_cfg2['neg_samples'] = 3
c2 = CanonicalPreferDiff(c_cfg2); g2 = GeneratedPreferDiff(g_cfg2)
c2.load_item_embeddings(); g2.load_item_embeddings()
for (_, p1), (_, p2) in zip(c2.named_parameters(), g2.named_parameters()):
if p1.shape == p2.shape: p2.data = p1.data.clone()
torch.manual_seed(200); np.random.seed(200); neg_c2 = c2._generate_negative_samples(batch)
torch.manual_seed(200); np.random.seed(200); neg_g2 = g2._generate_negative_samples(batch)
np.testing.assert_array_equal(neg_c2.detach().numpy(), neg_g2.detach().numpy())
# fallback branch
c_cfg3 = copy.deepcopy(self.base_config); c_cfg3['sample_func'] = 'unknown'
g_cfg3 = copy.deepcopy(self.base_config); g_cfg3['sample_func'] = 'unknown'
c3 = CanonicalPreferDiff(c_cfg3); g3 = GeneratedPreferDiff(g_cfg3)
c3.load_item_embeddings(); g3.load_item_embeddings()
for (_, p1), (_, p2) in zip(c3.named_parameters(), g3.named_parameters()):
if p1.shape == p2.shape: p2.data = p1.data.clone()
torch.manual_seed(321); np.random.seed(321); neg_c3 = c3._generate_negative_samples(batch)
torch.manual_seed(321); np.random.seed(321); neg_g3 = g3._generate_negative_samples(batch)
np.testing.assert_array_equal(neg_c3.detach().numpy(), neg_g3.detach().numpy())
# ---------- Sampling (sped up) ----------
def test_get_samples_equivalence_fast(self):
batch = self.make_batch()
with mock.patch('tqdm.tqdm', lambda x: range(4)):
torch.manual_seed(555); np.random.seed(555); canon_samples = self.canonical.get_samples(batch)
torch.manual_seed(555); np.random.seed(555); gen_samples = self.generated.get_samples(batch)
self.assertEqual(len(canon_samples), len(gen_samples))
self.assertEqual(np.array(canon_samples[0]).shape, np.array(gen_samples[0]).shape)
# ---------- Non-'iids' tensor embedding path without I/O ----------
def test_get_embeddings_tensor_mode_without_io(self):
c = CanonicalPreferDiff(copy.deepcopy(self.base_config))
g = GeneratedPreferDiff(copy.deepcopy(self.base_config))
# remove registered child modules to allow assigning Tensors
c.load_item_embeddings(); g.load_item_embeddings()
if 'item_embeddings' in c._modules: del c._modules['item_embeddings']
if 'item_embeddings' in g._modules: del g._modules['item_embeddings']
E = torch.randn(self.base_config['item_num'] + 1, self.base_config['hidden_size'])
c.item_embeddings = E.clone()
g.item_embeddings = E.clone()
c.config['ab'] = 'single'; g.config['ab'] = 'single'
for (_, p1), (_, p2) in zip(c.named_parameters(), g.named_parameters()):
if p1.shape == p2.shape: p2.data = p1.data.clone()
idx = torch.LongTensor([1, 4, 6])
emb_c = c.get_embeddings(idx)
emb_g = g.get_embeddings(idx)
np.testing.assert_allclose(emb_c.detach().numpy(), emb_g.detach().numpy(), rtol=1e-6, atol=1e-7)
all_c = c.get_all_embeddings()
all_g = g.get_all_embeddings()
np.testing.assert_allclose(all_c.detach().numpy(), all_g.detach().numpy(), rtol=1e-6, atol=1e-7)
if __name__ == '__main__':
unittest.main()