Download annotations/annotation_103/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 20.8 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_103/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_103/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_103/test.py
20.8 kB
| import unittest | |
| import types | |
| import sys | |
| import torch | |
| import numpy as np | |
| # Import the canonical & generated classes | |
| from canonical import PointCLIPV2_ZS_C as CanonicalCls | |
| from zeroshot import PointCLIPV2_ZS as GeneratedCls | |
| # ---------- Helper stubs for light inference (previous approach) ---------- | |
| class DummyVisualEncoderTorch: | |
| """ | |
| Deterministic visual encoder. | |
| Input: tensor images of shape (V, C, H, W), only V is used. | |
| Output: tensor of shape (V, D) with features feat[v, d] = (v+1)*(d+1). | |
| """ | |
| def __init__(self, feature_dim: int = 8): | |
| self.feature_dim = feature_dim | |
| def __call__(self, images: torch.Tensor) -> torch.Tensor: | |
| V = images.shape[0] | |
| v_idx = torch.arange(1, V + 1, dtype=torch.float32, device=images.device).unsqueeze(1) | |
| d_idx = torch.arange(1, self.feature_dim + 1, dtype=torch.float32, device=images.device).unsqueeze(0) | |
| feats = v_idx * d_idx | |
| return feats | |
| def make_stub_instance(Cls, num_views: int, feat_dim: int, num_classes: int, view_weights, device, force_dtype=None): | |
| """ | |
| Build a lightweight class instance without calling heavy build_model. | |
| Inject all necessary fields for model_inference. | |
| """ | |
| inst = object.__new__(Cls) | |
| inst.num_views = num_views | |
| inst.channel = feat_dim | |
| inst.dtype = force_dtype if force_dtype is not None else torch.float32 | |
| inst.visual_encoder = DummyVisualEncoderTorch(feature_dim=feat_dim) | |
| inst.view_weights = torch.tensor(view_weights, dtype=torch.float32, device=device) | |
| # Build normalized text features in float32, then (optionally) cast to inst.dtype | |
| text_feat = torch.arange(1, num_classes * num_views * feat_dim + 1, dtype=torch.float32, device=device) | |
| text_feat = text_feat.view(num_classes, num_views * feat_dim) | |
| text_feat = text_feat / (text_feat.norm(dim=-1, keepdim=True) + 1e-12) | |
| if force_dtype is not None: | |
| text_feat = text_feat.to(force_dtype) | |
| inst.text_feat = text_feat | |
| inst.feat_store = [] | |
| inst.label_store = [] | |
| # Realistic projection stub: returns zeros with the correct V and spatial size. | |
| def real_proj_stub(pc, imsize=224): | |
| return torch.zeros((num_views, 3, imsize, imsize), dtype=torch.float32, device=device) | |
| inst.real_proj = real_proj_stub | |
| return inst | |
| def to_numpy_2d(x): | |
| if isinstance(x, torch.Tensor): | |
| arr = x.detach().cpu().numpy() | |
| else: | |
| arr = np.array(x) | |
| if arr.ndim == 1: | |
| arr = arr[None, :] | |
| return arr | |
| def assert_same_logits(testcase, can_logits, gen_logits, rtol=1e-6, atol=1e-8, msg=""): | |
| a, b = to_numpy_2d(can_logits), to_numpy_2d(gen_logits) | |
| testcase.assertEqual(a.shape, b.shape, f"Shape mismatch: {a.shape} vs {b.shape}. {msg}") | |
| np.testing.assert_allclose(a, b, rtol=rtol, atol=atol, err_msg=msg) | |
| # ---------- Minimal CFG / DM dummies for build_model path ---------- | |
| class _Dot: | |
| """Tiny helper to set nested attributes like cfg.MODEL.BACKBONE.NAME.""" | |
| def __init__(self, **kwargs): | |
| for k, v in kwargs.items(): | |
| setattr(self, k, v) | |
| class DummyDM: | |
| def __init__(self, classnames): | |
| self.dataset = _Dot(classnames=classnames) | |
| # ---------- Monkeypatch helpers ---------- | |
| class NoCudaTensorMonkeypatch: | |
| """Context manager to make tensor.cuda() a no-op (safe on CPU-only).""" | |
| def __enter__(self): | |
| self._orig_cuda = torch.Tensor.cuda | |
| torch.Tensor.cuda = lambda self, *a, **k: self | |
| return self | |
| def __exit__(self, exc_type, exc, tb): | |
| torch.Tensor.cuda = self._orig_cuda | |
| def make_dummy_clip_module(embed_dim=32): | |
| """ | |
| Build a dummy 'clip' module that matches what canonical.py expects: | |
| - _MODELS, _download | |
| - tokenize(str or list[str]) -> torch.int tensor | |
| - build_model(state_dict_or_weights) -> model with visual, encode_text, dtype, logit_scale | |
| """ | |
| clip_mod = types.SimpleNamespace() | |
| clip_mod._MODELS = {"ViT-B/32": "dummy-url"} | |
| def _download(url): | |
| return "dummy.pt" | |
| clip_mod._download = _download | |
| def tokenize(x): | |
| # Return a tensor; downstream calls .cuda() and encode_text() expects tensor-like | |
| if isinstance(x, str): | |
| toks = [x] | |
| else: | |
| toks = list(x) | |
| # produce length = len(str) as a silly tokenization | |
| lens = [max(1, len(s) if isinstance(s, str) else 1) for s in toks] | |
| return torch.tensor(lens, dtype=torch.int64) | |
| clip_mod.tokenize = tokenize | |
| class _DummyVisual: | |
| def __init__(self, d=embed_dim): | |
| self.d = d | |
| def __call__(self, images): | |
| # images: (V, C, H, W) -> return (V, d) | |
| V = images.shape[0] | |
| v = torch.arange(1, V + 1, dtype=torch.float32, device=images.device).unsqueeze(1) | |
| d = torch.arange(1, self.d + 1, dtype=torch.float32, device=images.device).unsqueeze(0) | |
| return v * d | |
| class _DummyModel: | |
| def __init__(self, d=embed_dim): | |
| self.visual = _DummyVisual(d=d) | |
| self.dtype = torch.float32 | |
| self.logit_scale = torch.tensor(4.6052) # ~ log(100) | |
| def encode_text(self, tokens): | |
| # tokens shape (N,) -> return (N, d) deterministic | |
| N = tokens.numel() | |
| d = embed_dim | |
| base = torch.arange(1, N*d + 1, dtype=torch.float32).view(N, d) | |
| return base | |
| def state_dict(self): | |
| return {"weights": torch.tensor([1.0])} | |
| def eval(self): | |
| return self | |
| def cuda(self): | |
| return self | |
| def build_model(arg): | |
| # arg can be None, dict, or state dict. Ignore content and return dummy. | |
| return _DummyModel(d=embed_dim) | |
| clip_mod.build_model = build_model | |
| return clip_mod | |
| def patch_canonical_for_build_model(testcase, num_views=3, backbone="ViT-B/32", backbone_name2="vitb32", | |
| dataset_name="MockSet", channel=8, classnames=None): | |
| """ | |
| Monkeypatch canonical module to allow build_model to run: | |
| - clip module | |
| - best_prompt_weight entries | |
| - Realistic_Projection.get_img | |
| - No-CUDA environment | |
| Returns (cfg, dm) | |
| """ | |
| import canonical as canonical_mod | |
| # 1) patch clip module used by canonical | |
| canonical_mod.clip = types.SimpleNamespace(**make_dummy_clip_module(embed_dim=channel).__dict__) | |
| # 2) patch best_prompt_weight for prompts/weights keys | |
| key_p = f"{dataset_name.lower()}_{backbone_name2}_test_prompts" | |
| key_w = f"{dataset_name.lower()}_{backbone_name2}_test_weights" | |
| fake_prompts = [f"a 3d object of class {i}" for i in (classnames or ["a", "b", "c"])] | |
| fake_weights = [1.0/num_views] * num_views | |
| canonical_mod.best_prompt_weight = {key_p: fake_prompts, key_w: fake_weights} | |
| # 3) patch Realistic_Projection | |
| class _RP: | |
| def get_img(self, pc): | |
| # produce (V, 3, 32, 32) tensor | |
| return torch.zeros((num_views, 3, 32, 32), dtype=torch.float32) | |
| canonical_mod.Realistic_Projection = _RP | |
| # 4) cfg + dm | |
| cfg = _Dot( | |
| MODEL=_Dot( | |
| BACKBONE=_Dot(NAME=backbone, NAME2=backbone_name2, CHANNEL=channel), | |
| PROJECT=_Dot(NUM_VIEWS=num_views) | |
| ), | |
| DATASET=_Dot(NAME=dataset_name) | |
| ) | |
| dm = DummyDM(classnames or ["chair", "table", "car", "lamp"]) | |
| # 5) attach to a fresh instance | |
| inst = CanonicalCls.__new__(CanonicalCls) | |
| inst.cfg = cfg | |
| inst.dm = dm | |
| return inst, canonical_mod | |
| # ---------- Tests ---------- | |
| class TestPointCLIPV2ClassEquivalence(unittest.TestCase): | |
| def setUp(self): | |
| self.device = torch.device("cpu") | |
| self.pc_small = [ | |
| [0.0, 0.0, 0.0], | |
| [0.1, 0.2, 0.3], | |
| [1.0, 2.0, 3.0], | |
| [-0.5, 0.2, 0.9], | |
| ] | |
| self.feat_dim = 8 | |
| self.num_classes = 6 | |
| self.view_weights_mv = [0.6, 0.3, 0.1] | |
| self.view_weights_sv = [1.0] | |
| def _run_both(self, view_weights, pc=None, feat_dim=None, num_classes=None, force_dtype=None): | |
| if pc is None: | |
| pc = self.pc_small | |
| if feat_dim is None: | |
| feat_dim = self.feat_dim | |
| if num_classes is None: | |
| num_classes = self.num_classes | |
| num_views = len(view_weights) | |
| can = make_stub_instance(CanonicalCls, num_views, feat_dim, num_classes, view_weights, self.device, force_dtype=force_dtype) | |
| gen = make_stub_instance(GeneratedCls, num_views, feat_dim, num_classes, view_weights, self.device, force_dtype=force_dtype) | |
| with torch.no_grad(): | |
| can_logits = CanonicalCls.model_inference(can, pc, label=None) | |
| gen_logits = GeneratedCls.model_inference(gen, pc, label=None) | |
| return can, gen, can_logits, gen_logits | |
| # ---- Original-style equivalence tests ---- | |
| def test_equivalence_multiview(self): | |
| _, _, can_logits, gen_logits = self._run_both(self.view_weights_mv) | |
| assert_same_logits(self, can_logits, gen_logits, msg="Mismatch for multi-view inputs.") | |
| can_np = to_numpy_2d(can_logits) | |
| self.assertEqual(can_np.shape[0], 1) | |
| self.assertEqual(can_np.shape[1], self.num_classes) | |
| def test_equivalence_singleview(self): | |
| _, _, can_logits, gen_logits = self._run_both(self.view_weights_sv) | |
| assert_same_logits(self, can_logits, gen_logits, msg="Mismatch for single-view inputs.") | |
| def test_equivalence_different_cloud(self): | |
| pc_other = [ | |
| [0.2, -0.1, 0.0], | |
| [0.3, 0.4, -0.2], | |
| [0.5, 0.0, 0.1], | |
| ] | |
| _, _, can_logits, gen_logits = self._run_both(self.view_weights_mv, pc=pc_other) | |
| assert_same_logits(self, can_logits, gen_logits, msg="Mismatch for alternative point cloud.") | |
| def test_equivalence_under_weight_scaling(self): | |
| scale = 2.5 | |
| weights_scaled = [w * scale for w in self.view_weights_mv] | |
| _, _, can_logits_base, gen_logits_base = self._run_both(self.view_weights_mv) | |
| _, _, can_logits_scaled, gen_logits_scaled = self._run_both(weights_scaled) | |
| assert_same_logits(self, can_logits_scaled, gen_logits_scaled, msg="Mismatch when scaling view weights.") | |
| a = to_numpy_2d(can_logits_base) | |
| a_scaled = to_numpy_2d(can_logits_scaled) | |
| np.testing.assert_allclose(a * scale, a_scaled, rtol=1e-6, atol=1e-8, | |
| err_msg="Scaling all view weights should scale logits linearly.") | |
| def test_output_is_finite_and_2d(self): | |
| _, _, can_logits, gen_logits = self._run_both(self.view_weights_mv) | |
| can_np, gen_np = to_numpy_2d(can_logits), to_numpy_2d(gen_logits) | |
| self.assertEqual(can_np.ndim, 2) | |
| self.assertEqual(gen_np.ndim, 2) | |
| self.assertTrue(np.isfinite(can_np).all()) | |
| self.assertTrue(np.isfinite(gen_np).all()) | |
| # ---- Coverage boosters: param sweeps / shapes / determinism ---- | |
| def test_param_sweep_views_feats_classes(self): | |
| configs = [ | |
| ([1.0], 4, 3), | |
| ([0.7, 0.3], 8, 5), | |
| ([0.5, 0.3, 0.2], 6, 7), | |
| ([0.4, 0.3, 0.2, 0.1], 5, 4), | |
| ] | |
| for vw, feat_dim, num_classes in configs: | |
| with self.subTest(vw=vw, feat_dim=feat_dim, num_classes=num_classes): | |
| _, _, can_logits, gen_logits = self._run_both(vw, feat_dim=feat_dim, num_classes=num_classes) | |
| assert_same_logits(self, can_logits, gen_logits, msg="Param sweep mismatch.") | |
| def test_attributes_and_devices(self): | |
| can, gen, _, _ = self._run_both(self.view_weights_mv) | |
| self.assertEqual(can.channel, self.feat_dim) | |
| self.assertEqual(gen.channel, self.feat_dim) | |
| self.assertEqual(can.dtype, torch.float32) | |
| self.assertEqual(gen.dtype, torch.float32) | |
| self.assertEqual(can.view_weights.device.type, 'cpu') | |
| self.assertTrue(can.view_weights.shape[0] == len(self.view_weights_mv)) | |
| def test_real_proj_imsize(self): | |
| num_views = len(self.view_weights_mv) | |
| can = make_stub_instance(CanonicalCls, num_views, self.feat_dim, self.num_classes, self.view_weights_mv, self.device) | |
| gen = make_stub_instance(GeneratedCls, num_views, self.feat_dim, self.num_classes, self.view_weights_mv, self.device) | |
| for s in (56, 112, 224, 320): | |
| with self.subTest(imsize=s): | |
| # Use injected instance methods | |
| img_can = can.real_proj(self.pc_small, imsize=s) | |
| img_gen = gen.real_proj(self.pc_small, imsize=s) | |
| self.assertEqual(tuple(img_can.shape), (num_views, 3, s, s)) | |
| self.assertEqual(tuple(img_gen.shape), (num_views, 3, s, s)) | |
| np.testing.assert_array_equal(img_can.cpu().numpy(), img_gen.cpu().numpy()) | |
| def test_stateful_feature_and_label_storage(self): | |
| can, gen, _, _ = self._run_both(self.view_weights_mv, pc=self.pc_small) | |
| with torch.no_grad(): | |
| _ = CanonicalCls.model_inference(can, self.pc_small, label=7) | |
| _ = GeneratedCls.model_inference(gen, self.pc_small, label=7) | |
| self.assertEqual(len(can.feat_store), 2) | |
| self.assertEqual(len(gen.feat_store), 2) | |
| self.assertEqual(len(can.label_store), 2) | |
| self.assertEqual(can.label_store[-1], 7) | |
| self.assertEqual(gen.label_store[-1], 7) | |
| stored_can = torch.cat(can.feat_store, dim=0) | |
| self.assertEqual(stored_can.shape[-1], len(self.view_weights_mv) * self.feat_dim) | |
| def test_mismatch_num_views_raises(self): | |
| can = make_stub_instance(CanonicalCls, 3, self.feat_dim, self.num_classes, self.view_weights_mv, self.device) | |
| gen = make_stub_instance(GeneratedCls, 3, self.feat_dim, self.num_classes, self.view_weights_mv, self.device) | |
| can.num_views = 4 | |
| gen.num_views = 4 | |
| with torch.no_grad(): | |
| with self.assertRaises(Exception): | |
| _ = CanonicalCls.model_inference(can, self.pc_small, label=None) | |
| with self.assertRaises(Exception): | |
| _ = GeneratedCls.model_inference(gen, self.pc_small, label=None) | |
| def test_mixed_dtype_float16_path(self): | |
| force_dtype = torch.float16 | |
| _, _, can_logits, gen_logits = self._run_both(self.view_weights_mv, force_dtype=force_dtype) | |
| assert_same_logits(self, can_logits, gen_logits, msg="Mismatch under float16 casting.") | |
| def test_determinism_across_calls(self): | |
| _, _, can_logits1, gen_logits1 = self._run_both(self.view_weights_mv) | |
| _, _, can_logits2, gen_logits2 = self._run_both(self.view_weights_mv) | |
| np.testing.assert_array_equal(to_numpy_2d(can_logits1), to_numpy_2d(can_logits2)) | |
| np.testing.assert_array_equal(to_numpy_2d(gen_logits1), to_numpy_2d(gen_logits2)) | |
| def test_non_uniform_view_weights_patterns(self): | |
| patterns = [ | |
| [1.0], | |
| [1.0, 0.0], | |
| [0.0, 1.0], | |
| [0.2, 0.5, 0.3], | |
| [1e-3, 1e-2, 1e-1], | |
| ] | |
| for vw in patterns: | |
| with self.subTest(vw=vw): | |
| _, _, can_logits, gen_logits = self._run_both(vw) | |
| assert_same_logits(self, can_logits, gen_logits, msg=f"Mismatch for weights {vw}.") | |
| # ---- NEW: directly cover load_clip_to_cpu both branches ---- | |
| def test_load_clip_to_cpu_jit_branch(self): | |
| import canonical as canonical_mod | |
| # Patch clip and torch.jit.load success path | |
| canonical_mod.clip = make_dummy_clip_module(embed_dim=8) | |
| called = {"jit": False, "build": False} | |
| class _JitObj: | |
| def eval(self): | |
| return self | |
| def state_dict(self): | |
| return {"k": 1} | |
| def fake_jit_load(path, map_location="cpu"): | |
| called["jit"] = True | |
| return _JitObj() | |
| orig_jit_load = torch.jit.load | |
| torch.jit.load = fake_jit_load | |
| def fake_build(state_or_weights): | |
| called["build"] = True | |
| # Return model with the required interface | |
| return make_dummy_clip_module(embed_dim=8).build_model(None) | |
| orig_build = canonical_mod.clip.build_model | |
| canonical_mod.clip.build_model = fake_build | |
| try: | |
| model = canonical_mod.load_clip_to_cpu(_Dot(MODEL=_Dot(BACKBONE=_Dot(NAME="ViT-B/32")))) | |
| self.assertTrue(called["jit"] and called["build"]) | |
| # smoke check model api | |
| _ = model.encode_text(torch.tensor([1,2])) | |
| finally: | |
| torch.jit.load = orig_jit_load | |
| canonical_mod.clip.build_model = orig_build | |
| def test_load_clip_to_cpu_state_dict_branch(self): | |
| import canonical as canonical_mod | |
| canonical_mod.clip = make_dummy_clip_module(embed_dim=8) | |
| called = {"jit": False, "torch_load": False, "build": False} | |
| def fake_jit_load(*a, **k): | |
| called["jit"] = True | |
| raise RuntimeError("force non-jit path") | |
| orig_jit_load = torch.jit.load | |
| torch.jit.load = fake_jit_load | |
| def fake_torch_load(path, map_location="cpu"): | |
| called["torch_load"] = True | |
| return {"dummy": 1} | |
| orig_torch_load = torch.load | |
| torch.load = fake_torch_load | |
| def fake_build(state_or_weights): | |
| called["build"] = True | |
| return make_dummy_clip_module(embed_dim=8).build_model(None) | |
| orig_build = canonical_mod.clip.build_model | |
| canonical_mod.clip.build_model = fake_build | |
| try: | |
| model = canonical_mod.load_clip_to_cpu(_Dot(MODEL=_Dot(BACKBONE=_Dot(NAME="ViT-B/32")))) | |
| self.assertTrue(called["jit"] and called["torch_load"] and called["build"]) | |
| _ = model.encode_text(torch.tensor([1,2])) | |
| finally: | |
| torch.jit.load = orig_jit_load | |
| torch.load = orig_torch_load | |
| canonical_mod.clip.build_model = orig_build | |
| # ---- NEW: end-to-end build_model + inference (canonical vs generated) ---- | |
| def test_build_model_end_to_end_equivalence(self): | |
| """ | |
| Run the real build_model and textual encoder with dummy clip/projection, | |
| then perform model_inference on both classes and compare. | |
| """ | |
| # Patch canonical + generated modules similarly | |
| can_inst, can_mod = patch_canonical_for_build_model( | |
| self, num_views=3, backbone="ViT-B/32", backbone_name2="vitb32", | |
| dataset_name="MockSet", channel=self.feat_dim, | |
| classnames=[f"class_{i}" for i in range(self.num_classes)] | |
| ) | |
| import zeroshot as generated_mod | |
| # Mirror the same patches for the generated module API names | |
| generated_mod.clip = can_mod.clip | |
| generated_mod.best_prompt_weight = can_mod.best_prompt_weight | |
| generated_mod.Realistic_Projection = can_mod.Realistic_Projection | |
| # cfg/dm for gen instance | |
| gen_inst = GeneratedCls.__new__(GeneratedCls) | |
| gen_inst.cfg = can_inst.cfg | |
| gen_inst.dm = can_inst.dm | |
| with NoCudaTensorMonkeypatch(): | |
| # --- Patch torch.jit.load to avoid real filesystem access --- | |
| class _JitObj: | |
| def eval(self): # canonical code calls .eval() | |
| return self | |
| def state_dict(self): # canonical passes model.state_dict() to clip.build_model | |
| return {"weights": torch.tensor([1.0])} | |
| orig_jit_load = torch.jit.load | |
| torch.jit.load = lambda *a, **k: _JitObj() | |
| try: | |
| # build both models (will exercise load_clip_to_cpu JIT path) | |
| CanonicalCls.build_model(can_inst) | |
| GeneratedCls.build_model(gen_inst) | |
| # sanity checks from your original code | |
| self.assertEqual(can_inst.num_views, 3) | |
| self.assertEqual(gen_inst.num_views, 3) | |
| self.assertEqual(can_inst.channel, self.feat_dim) | |
| self.assertEqual(gen_inst.channel, self.feat_dim) | |
| self.assertEqual(can_inst.text_feat.shape[-1], gen_inst.text_feat.shape[-1]) | |
| # end-to-end inference using real_proj/visual encoders created by build_model | |
| with torch.no_grad(): | |
| can_logits = CanonicalCls.model_inference(can_inst, self.pc_small, label=1) | |
| gen_logits = GeneratedCls.model_inference(gen_inst, self.pc_small, label=1) | |
| assert_same_logits(self, can_logits, gen_logits, | |
| msg="E2E logits mismatch after build_model.") | |
| self.assertTrue(len(can_inst.feat_store) >= 1) | |
| self.assertTrue(len(gen_inst.label_store) >= 1) | |
| finally: | |
| # always restore to avoid side-effects on other tests | |
| torch.jit.load = orig_jit_load | |
| if __name__ == "__main__": | |
| unittest.main() | |