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