tools/test.py

# # from transformers import BertTokenizer, T5Tokenizer, AutoTokenizer

# # from transformers import BertConfig, BertModel, AutoProcessor
# # # # # tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")

# # # # tokenizer = BertTokenizer.from_pretrained("bert-base-uncased", do_lower_case=True)
# # # BertModel.from_pretrained("bert-base-uncased") 

# # # import numpy as np

# # # pc = np.load(
# # #     '/mnt/new_drive/SceneVerse/light_scannet/scene0006_00/pm.npy'
# # # )

# # # print(pc.shape)

# # processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")

# import torch
# from PIL import Image
# from transformers import (
#     AutoImageProcessor,
#     AutoTokenizer,
#     AutoModelForCausalLM,
# )

# model_root = "qihoo360/fg-clip-base"
# # image_size=224
# model = AutoModelForCausalLM.from_pretrained(model_root,trust_remote_code=True).cuda()

# # device = model.device

# tokenizer = AutoTokenizer.from_pretrained(model_root)
# image_processor = AutoImageProcessor.from_pretrained(model_root)
# # captions=["a photo of a cat", "a photo of a dog"]
# # caption_input = torch.tensor(tokenizer(captions, max_length=77, padding="max_length", truncation=True).input_ids, dtype=torch.long, device=device)
# # walk_short_pos = True
# # text_feature = model.get_text_features(caption_input,walk_short_pos=walk_short_pos)
# # print(text_feature.shape)


# import numpy as np
# from PIL import Image
# import matplotlib.pyplot as plt

# # paths
# rgb_path = '/home/m50048399/SceneVerse/light_arkitscenes/40753686/color/40753686_6855.418.png'
# pm_path  = '/home/m50048399/SceneVerse/light_arkitscenes/40753686/pm.npy'

# # load rgb image
# rgb_img = np.array(Image.open(rgb_path).convert('RGB'))  # shape (H, W, 3)

# print(rgb_img.shape)
# rgb_img = image_processor.preprocess(rgb_img, return_tensors='pt')['pixel_values']

# rgb_img = rgb_img[0].permute(1,2,0).numpy()
# # load point map
# pm = np.load(pm_path)[1, ...]  # shape could be (H, W, 3) or other — check below

# print(f"RGB shape: {rgb_img.shape}")
# print(f"PM shape: {pm.shape}")

# # visualize
# fig, ax = plt.subplots(1, 2, figsize=(12, 6))

# ax[0].imshow(rgb_img)
# ax[0].set_title('RGB Image')
# ax[0].axis('off')

# # if pm has 3 channels (X, Y, Z), you can visualize as depth
# if pm.ndim == 3 and pm.shape[2] == 3:
#     depth = pm[..., 1]  # Z value as depth
#     ax[1].imshow(depth, cmap='viridis')
#     ax[1].set_title('PM Depth (Z)')
# else:
#     ax[1].imshow(pm, cmap='viridis')
#     ax[1].set_title('PM')
    
# ax[1].axis('off')

# plt.tight_layout()

# plt.savefig('test.png', dpi=300)


# import os
# import numpy as np
# from PIL import Image
# from datasets import Dataset, Features, Value, Array4D
# from tqdm import tqdm

# # === CONFIG ===
# ROOT_DIR = "light_3rscan"       # your dataset root path
# MAX_IMAGES = 50                  # cap for shape consistency (optional)

# def load_images_from_folder(folder, exts, max_images=None, is_depth=False):
#     files = sorted([f for f in os.listdir(folder) if f.lower().endswith(exts)])
#     if not files:
#         print(f"Skipping {folder}: no {exts} files found.")
#         return None
#     if max_images:
#         files = files[:max_images]
#     images = []
#     for file in files:
#         img_path = os.path.join(folder, file)
#         img = Image.open(img_path)
#         if is_depth:
#             # If .pgm, preserve raw data
#             img_array = np.array(img)  # preserves uint8 or uint16
#             if img_array.ndim == 2:
#                 img_array = img_array[..., None]  # (H, W, 1)
#         else:
#             img = img.convert("RGB")
#             img_array = np.array(img)
#         images.append(img_array)
#     return np.stack(images, axis=0)  # (N, H, W, C)

# # === GENERATOR FUNCTION ===
# def generate_examples():
#     for scene_folder in tqdm(sorted(os.listdir(ROOT_DIR)), desc="Processing scenes"):
#         scene_path = os.path.join(ROOT_DIR, scene_folder)
#         if not os.path.isdir(scene_path):
#             continue

#         color_folder = os.path.join(scene_path, "color")
#         depth_folder = os.path.join(scene_path, "depth")
#         pm_path = os.path.join(scene_path, "pm.npy")

#         if not (os.path.exists(color_folder) and os.path.exists(depth_folder) and os.path.exists(pm_path)):
#             print(f"Skipping {scene_folder}, missing data.")
#             continue

#         try:
#             color_images = load_images_from_folder(color_folder, (".jpg",), MAX_IMAGES, is_depth=False)
#             depth_images = load_images_from_folder(depth_folder, (".pgm",), MAX_IMAGES, is_depth=True)
#             point_map = np.load(pm_path)  # (H, W, D) or similar
#             print(color_images.shape, depth_images.shape, point_map.shape)
#         except Exception as e:
#             print(f"Error processing {scene_folder}: {e}")
#             continue

#         yield {
#             "scene_id": scene_folder,
#             "color_images": color_images,
#             "depth_images": depth_images,
#             "point_map": point_map,
#         }

# # === DETERMINE SHAPES ===
# # Load first sample to get shapes for Features
# sample = next(generate_examples())
# N, H, W, C = sample["color_images"].shape
# N_d, H_d, W_d, C_d = sample["depth_images"].shape
# N_p, H_p, W_p, C_p = sample["point_map"].shape

# features = Features({
#     "scene_id": Value("string"),
#     "color_images": Array4D(dtype="uint32", shape=(N, H, W, C)),
#     "depth_images": Array4D(dtype="uint32", shape=(N_d, H_d, W_d, C_d)),
#     "point_map": Array4D(dtype="float16", shape=(N_p, H_p, W_p, C_p)),
# })

# # === BUILD DATASET ===
# dataset = Dataset.from_generator(generate_examples, features=features)

# # === SAVE TO DISK ===
# dataset.save_to_disk("light_3rscan_hf")
# print("✅ Dataset saved to 'light_3rscan_hf'.")

# # === TEST LOADING ===
# from datasets import load_from_disk
# ds = load_from_disk("light_3rscan_hf")
# print(ds)
# print(ds[0]["scene_id"], ds[0]["color_images"].shape, ds[0]["depth_images"].shape, ds[0]["point_map"].shape)


import torch
import torch.nn as nn
from transformers import AutoProcessor
from transformers.image_utils import load_image
from transformers.models.siglip.modeling_siglip import (
    SiglipModel,
    SiglipVisionModel,
    SiglipTextModel,
    SiglipPreTrainedModel,
    SiglipVisionTransformer,
)
from transformers.models.siglip.configuration_siglip import (
    SiglipVisionConfig,
    SiglipTextConfig,
)
from transformers.modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling
from transformers.utils import can_return_tuple, add_start_docstrings_to_model_forward, replace_return_docstrings
from transformers.models.siglip.modeling_siglip import SIGLIP_VISION_INPUTS_DOCSTRING
from typing import Optional

class MySiglipVisionTransformer(SiglipVisionTransformer):
    @can_return_tuple
    @add_start_docstrings_to_model_forward(SIGLIP_VISION_INPUTS_DOCSTRING)
    @replace_return_docstrings(output_type=BaseModelOutputWithPooling, config_class=SiglipVisionConfig)
    def forward(
        self,
        pixel_values,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        interpolate_pos_encoding: Optional[bool] = False,
    ) -> BaseModelOutputWithPooling:
        r"""
        Returns:

        """
        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
        output_hidden_states = (
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )

        hidden_states = self.embeddings(pixel_values, interpolate_pos_encoding=interpolate_pos_encoding)

        encoder_outputs: BaseModelOutput = self.encoder(
            inputs_embeds=hidden_states,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
        )

        last_hidden_state = encoder_outputs.last_hidden_state
        last_hidden_state = self.post_layernorm(last_hidden_state)

        pooler_output = self.head(last_hidden_state) if self.use_head else None
        return BaseModelOutputWithPooling(
            last_hidden_state=last_hidden_state,
            pooler_output=pooler_output,
            hidden_states=encoder_outputs.hidden_states,
            attentions=encoder_outputs.attentions,
        )

class MySiglipVisionModel(SiglipVisionModel):
    def __init__(self, config):
        SiglipPreTrainedModel.__init__(self, config) 
        self.vision_model = MySiglipVisionTransformer(config)
        self.post_init()
        
        
class MySiglipModel(SiglipModel):
    def __init__(self, config):
        SiglipPreTrainedModel.__init__(self, config) 
        
        if not isinstance(config.text_config, SiglipTextConfig):
            raise TypeError(
                "config.text_config is expected to be of type SiglipTextConfig but is of type"
                f" {type(config.text_config)}."
            )

        if not isinstance(config.vision_config, SiglipVisionConfig):
            raise TypeError(
                "config.vision_config is expected to be of type SiglipVisionConfig but is of type"
                f" {type(config.vision_config)}."
            )

        text_config = config.text_config
        vision_config = config.vision_config

        # First, initialize the text and vision models with proper attention implementation
        text_model = SiglipTextModel._from_config(text_config)
        vision_model = MySiglipVisionModel._from_config(config.vision_config)

        # Second, get the text and vision submodules (for backward compatibility)
        self.text_model = text_model.text_model
        self.vision_model = vision_model.vision_model

        self.logit_scale = nn.Parameter(torch.randn(1))
        self.logit_bias = nn.Parameter(torch.randn(1))

        # Initialize weights and apply final processing
        self.post_init()

# load the model and processor
ckpt = "../siglip2-base-patch16-256"

model = MySiglipModel.from_pretrained(ckpt, device_map="auto").eval()
processor = AutoProcessor.from_pretrained(ckpt, trust_remote_code=True)

import inspect
print(inspect.getfile(model.get_image_features))

# load the image
image = load_image("https://huggingface.co/datasets/merve/coco/resolve/main/val2017/000000000285.jpg")
inputs = processor(images=[image], return_tensors="pt").to(model.device)

# run infernece
with torch.no_grad():
    image_embeddings = model.get_image_features(**inputs, output_hidden_states = True)    

print(image_embeddings.shape)