| import unittest |
| from types import SimpleNamespace |
|
|
| import torch |
| from torch import nn |
|
|
| from baselines.hihr.model import ( |
| CLIPTokenPromptLearner, |
| HiHRModel, |
| LorentzManifold, |
| PromptLearner, |
| TextGuidedFusion, |
| ViewPromptMoE, |
| batch_hard_triplet, |
| intra_view_triplet, |
| ) |
| from fastreid.data.samplers import CVIdentitySampler |
|
|
|
|
| class HiHRReimplementationTest(unittest.TestCase): |
| def test_view_prompt_moe_shapes_and_gradients(self): |
| moe = ViewPromptMoE(dim=8, hidden_dim=16) |
| features = torch.randn(4, 8, requires_grad=True) |
| prompt = torch.randn(4, 8, requires_grad=True) |
| views = torch.tensor([0, 1, 0, 1]) |
| output = moe(features, views, prompt) |
| self.assertEqual(output["features"].shape, (4, 8)) |
| self.assertEqual(output["router_probs"].shape, (4, 3)) |
| self.assertTrue(torch.allclose(output["router_probs"].sum(dim=1), torch.ones(4))) |
| output["features"].sum().backward() |
| self.assertIsNotNone(features.grad) |
| self.assertIsNotNone(moe.view_embed.weight.grad) |
|
|
| def test_disabled_hhl_skips_geometry(self): |
| model = HiHRModel.__new__(HiHRModel) |
| nn.Module.__init__(model) |
| model.lambda_entail = 0.0 |
| model.entailment_terms = frozenset( |
| ("proto_child", "prompt_order", "parent_alignment", "child_alignment") |
| ) |
| losses = model.hierarchy_losses( |
| {"parent_g": torch.randn(4, 8, requires_grad=True)}, |
| torch.tensor([0, 0, 1, 1]), |
| ) |
| self.assertEqual(len(losses), 4) |
| self.assertTrue(all(float(loss.detach()) == 0.0 for loss in losses.values())) |
|
|
| def test_token_prompt_pools_at_attended_eos(self): |
| class FakeTokenizer: |
| def __call__(self, texts, **kwargs): |
| if texts == "X": |
| return {"input_ids": [7]} |
| token_ids = torch.tensor( |
| [ |
| [1, 7, 7, 7, 7, 9, 99, 0, 0, 0, 0, 0], |
| [1, 7, 7, 7, 7, 9, 7, 7, 7, 7, 9, 99], |
| [1, 7, 7, 7, 7, 9, 7, 7, 7, 7, 9, 99], |
| ] |
| ) |
| attention_mask = token_ids.ne(0).long() |
| return {"input_ids": token_ids, "attention_mask": attention_mask} |
|
|
| text_model = nn.Module() |
| text_model.config = SimpleNamespace(hidden_size=8) |
| learner = CLIPTokenPromptLearner( |
| text_model, nn.Linear(8, 8), FakeTokenizer(), num_context=4 |
| ) |
| torch.testing.assert_close(learner.eos_positions, torch.tensor([6, 11, 11])) |
|
|
| def test_lorentz_roundtrip_and_constraint(self): |
| manifold = LorentzManifold(1.0) |
| tangent = torch.randn(8, 16) * 0.05 |
| point = manifold.expmap0(tangent) |
| recovered = manifold.logmap0(point) |
| torch.testing.assert_close(recovered, tangent, atol=2e-5, rtol=2e-4) |
| c = manifold.curvature.detach() |
| norm = LorentzManifold.inner(point, point) |
| torch.testing.assert_close(norm, torch.full_like(norm, -1.0 / c), atol=2e-4, rtol=2e-4) |
|
|
| def test_distance_is_finite_and_zero_on_diagonal(self): |
| manifold = LorentzManifold(1.0) |
| point = manifold.expmap0(torch.randn(4, 8) * 0.05) |
| distance = manifold.distance(point, point) |
| self.assertTrue(torch.isfinite(distance).all()) |
| self.assertLess(float(distance.detach().max()), 5e-3) |
|
|
| def test_entailment_cone_prefers_aligned_child(self): |
| manifold = LorentzManifold(1.0) |
| parent = manifold.expmap0(torch.tensor([[0.5, 0.0]])) |
| aligned = manifold.expmap0(torch.tensor([[2.0, 0.0]])) |
| opposed = manifold.expmap0(torch.tensor([[-2.0, 0.0]])) |
| aligned_loss = manifold.entailment_cone_loss(parent, aligned) |
| opposed_loss = manifold.entailment_cone_loss(parent, opposed) |
| self.assertLess(float(aligned_loss.detach()), float(opposed_loss.detach())) |
|
|
| def test_arbitrary_logmap_points_outward(self): |
| manifold = LorentzManifold(1.0) |
| parent = manifold.expmap0(torch.tensor([[0.5, 0.0]])) |
| child = manifold.expmap0(torch.tensor([[2.0, 0.0]])) |
| origin = manifold.origin_like(parent) |
| outward = -manifold.logmap(parent, origin) |
| toward_child = manifold.logmap(parent, child) |
| cosine = LorentzManifold.inner(outward, toward_child) / ( |
| LorentzManifold.inner(outward, outward).sqrt() |
| * LorentzManifold.inner(toward_child, toward_child).sqrt() |
| ) |
| torch.testing.assert_close(cosine, torch.ones_like(cosine), atol=2e-5, rtol=2e-5) |
|
|
| def test_prompt_learner_selects_view_query(self): |
| learner = PromptLearner(torch.randn(8), torch.randn(2, 8)) |
| agnostic, aware = learner(torch.tensor([0, 1, 0])) |
| self.assertEqual(tuple(agnostic.shape), (3, 8)) |
| self.assertEqual(tuple(aware.shape), (3, 8)) |
| torch.testing.assert_close(aware[0], aware[2]) |
|
|
| def test_tmf_shapes_and_gradients(self): |
| fusion = TextGuidedFusion(16, num_heads=4) |
| cls = torch.randn(3, 3, 16, requires_grad=True) |
| patches = torch.randn(3, 3, 8, 16, requires_grad=True) |
| query = torch.randn(3, 16, requires_grad=True) |
| output, weights = fusion(cls, patches, query) |
| self.assertEqual(tuple(output.shape), (3, 16)) |
| torch.testing.assert_close(weights.sum(dim=1), torch.ones(3)) |
| output.sum().backward() |
| self.assertIsNotNone(query.grad) |
|
|
| def test_cross_and_intra_view_triplet(self): |
| features = torch.randn(8, 16, requires_grad=True) |
| labels = torch.tensor([0, 0, 1, 1, 0, 0, 1, 1]) |
| views = torch.tensor([0, 0, 0, 0, 1, 1, 1, 1]) |
| cross = batch_hard_triplet(features, labels) |
| intra = intra_view_triplet(features, labels, views) |
| self.assertTrue(torch.isfinite(cross)) |
| self.assertTrue(torch.isfinite(intra)) |
| (cross + intra).backward() |
| self.assertIsNotNone(features.grad) |
|
|
| def test_cross_view_sampler_provides_two_samples_per_view(self): |
| items = [] |
| for pid in range(4): |
| for view in ("Aerial", "Ground"): |
| for index in range(3): |
| items.append((f"{pid}_{view}_{index}.jpg", pid, index, view)) |
| sampler = CVIdentitySampler(items, mini_batch_size=8, num_instances=4, seed=3) |
| iterator = iter(sampler) |
| batch = [next(iterator) for _ in range(8)] |
| counts = {} |
| for index in batch: |
| _, pid, _, view = items[index] |
| counts.setdefault(pid, {"Aerial": 0, "Ground": 0})[view] += 1 |
| self.assertEqual(len(counts), 2) |
| for views in counts.values(): |
| self.assertEqual(views, {"Aerial": 2, "Ground": 2}) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
