| from vision_encoders.builder import build_vision_tower_aux_list |
| from transformers import Qwen2Config |
| from typing import Optional, List, Tuple |
| import torch |
| import json |
| from transformers import BaseImageProcessor |
|
|
| class CambrianConfig(Qwen2Config): |
| model_type = "cambrian_qwen" |
| debug = "debug" |
|
|
| def __init__( |
| self, |
| **kwargs |
| ) -> None: |
| super().__init__(**kwargs) |
|
|
| for key, value in kwargs.items(): |
| setattr(self, key, value) |
|
|
| @classmethod |
| def from_json_file(cls, json_file_path): |
| """Load a config from a json file.""" |
| with open(json_file_path, "r") as f: |
| config_dict = json.load(f) |
| return cls(**config_dict) |
|
|
|
|
| class CambrianEncoders: |
|
|
| def __init__( |
| self, |
| config: CambrianConfig |
| ) -> None: |
| self.config: CambrianConfig = config |
| self.vision_tower_aux_list = build_vision_tower_aux_list(config, delay_load=True) |
|
|
| def encode_images(self, image_aux_list, encode_type=None): |
| vision_tower_aux_list = self.vision_tower_aux_list |
| image_aux_features_list = [] |
| chunk_size = 64 |
| if encode_type == "dino": |
| image_aux = image_aux_list[-1] |
| vision_tower_aux = vision_tower_aux_list[-1] |
| if image_aux.shape[0] > chunk_size: |
| image_aux_features_chunks = [] |
| for start_idx in range(0, image_aux.shape[0], chunk_size): |
| end_idx = min(start_idx + chunk_size, image_aux.shape[0]) |
| chunk = image_aux[start_idx:end_idx] |
| image_aux_features_chunk = vision_tower_aux(chunk) |
| image_aux_features_chunks.append(image_aux_features_chunk) |
| image_aux_features = torch.cat(image_aux_features_chunks, dim=0) |
| else: |
| image_aux_features = vision_tower_aux(image_aux) |
| return image_aux_features |
| elif encode_type == "siglip": |
| image_aux = image_aux_list[0] |
| vision_tower_aux = vision_tower_aux_list[0] |
| if image_aux.shape[0] > chunk_size: |
| image_aux_features_chunks = [] |
| for start_idx in range(0, image_aux.shape[0], chunk_size): |
| end_idx = min(start_idx + chunk_size, image_aux.shape[0]) |
| chunk = image_aux[start_idx:end_idx] |
| image_aux_features_chunk = vision_tower_aux(chunk) |
| image_aux_features_chunks.append(image_aux_features_chunk) |
| image_aux_features = torch.cat(image_aux_features_chunks, dim=0) |
| else: |
| image_aux_features = vision_tower_aux(image_aux) |
| return image_aux_features |
| else: |
| for image_aux, vision_tower_aux in zip( |
| image_aux_list, vision_tower_aux_list |
| ): |
| if image_aux.shape[0] > chunk_size: |
| image_aux_features_chunks = [] |
| for start_idx in range(0, image_aux.shape[0], chunk_size): |
| end_idx = min(start_idx + chunk_size, image_aux.shape[0]) |
| chunk = image_aux[start_idx:end_idx] |
| image_aux_features_chunk = vision_tower_aux(chunk) |
| image_aux_features_chunks.append(image_aux_features_chunk) |
| image_aux_features = torch.cat(image_aux_features_chunks, dim=0) |
| else: |
| image_aux_features = vision_tower_aux(image_aux) |
| image_aux_features_list.append(image_aux_features) |
| return image_aux_features_list |
|
|
| def select_frame( |
| self, |
| feature_list, |
| split_sizes, |
| new_image_aux_list, |
| image_sizes, |
| window_size=16, |
| threshold=0.83, |
| ): |
| dino_features_batch = torch.split(feature_list, split_sizes, dim=0) |
| new_image_aux_batch_0 = torch.split(new_image_aux_list[0], split_sizes, dim=0) |
| new_image_aux_batch_1 = torch.split(new_image_aux_list[1], split_sizes, dim=0) |
| new_split_sizes = [] |
| selected_frames_all_0 = [] |
| selected_frames_all_1 = [] |
| selected_frames_feature_all = [] |
| selected_frame_indices_all = [] |
| for i_batch, frame_features in enumerate(dino_features_batch): |
|
|
| original_width, original_height = image_sizes[i_batch] |
| if getattr(self.get_model().config, "highres", False): |
| token_per_frame = self.config.lowres_token ** 2 |
| else: |
| token_per_frame = self.config.image_token_len |
|
|
| max_num_frames = max( |
| 1, |
| ( |
| self.config.tokenizer_model_max_length |
| - getattr(self.config, "inference_max_length", 16) |
| ) |
| // token_per_frame, |
| ) |
| if len(frame_features) < max_num_frames: |
| selected_frames_all_0.append(new_image_aux_batch_0[i_batch]) |
| selected_frames_all_1.append(new_image_aux_batch_1[i_batch]) |
| selected_frames_feature_all.append(frame_features) |
| new_split_sizes.append(len(frame_features)) |
| selected_frame_indices_all.append(torch.arange(len(frame_features))) |
| continue |
|
|
| num_segments = len(frame_features) // window_size |
| if num_segments == 0: |
| query_feature = frame_features.flatten(1, 2) |
| query_feature = query_feature / torch.norm( |
| (query_feature), dim=1, keepdim=True |
| ) |
| similarities = torch.mean(query_feature @ query_feature.T, dim=1) |
| similarities[len(frame_features) // 2] = 0 |
| indices = torch.where(similarities < threshold)[0] |
| selected_frame_indices_all.append(indices) |
| selected_frames_all_0.append(new_image_aux_batch_0[i_batch][indices]) |
| selected_frames_all_1.append(new_image_aux_batch_1[i_batch][indices]) |
| selected_frames_feature_all.append(frame_features[indices]) |
| new_split_sizes.append(len(indices)) |
| continue |
| segments_frames_0 = [] |
| segments_frames_1 = [] |
| segments_features = [] |
| for start_idx in range(0, len(frame_features), window_size): |
| end_idx = min(start_idx + window_size, len(frame_features)) |
| segments_frames_0.append( |
| new_image_aux_batch_0[i_batch][start_idx:end_idx] |
| ) |
| segments_frames_1.append( |
| new_image_aux_batch_1[i_batch][start_idx:end_idx] |
| ) |
| segments_features.append(frame_features[start_idx:end_idx]) |
| selected_frames_0 = [] |
| selected_frames_1 = [] |
| selected_features = [] |
| selected_frame_indices = [] |
| for i, segment in enumerate(segments_features): |
| query_feature = segment.flatten(1, 2) |
| query_feature = query_feature / torch.norm( |
| (query_feature), dim=1, keepdim=True |
| ) |
| similarities = torch.mean(query_feature @ query_feature.T, dim=1) |
| similarities[len(segment) // 2] = 0 |
| indices = torch.where(similarities < threshold)[0] |
| selected_frames_0.append(segments_frames_0[i][indices]) |
| selected_frames_1.append(segments_frames_1[i][indices]) |
| selected_features.append(segment[indices]) |
| selected_frame_indices.extend(indices + i * window_size) |
| selected_frames_0 = torch.cat(selected_frames_0, dim=0) |
| selected_frames_1 = torch.cat(selected_frames_1, dim=0) |
| selected_features = torch.cat(selected_features, dim=0) |
| selected_frame_indices = torch.tensor(selected_frame_indices) |
| |
| max_num_frames = 400 |
| if len(selected_frames_0) > max_num_frames: |
| interval = len(selected_frames_0) / float(max_num_frames) |
| indices = [int(interval * i) for i in range(max_num_frames)] |
| new_split_sizes.append(len(indices)) |
| selected_frames_all_0.append(selected_frames_0[indices]) |
| selected_frames_all_1.append(selected_frames_1[indices]) |
| selected_frames_feature_all.append(selected_features[indices]) |
| selected_frame_indices = selected_frame_indices[indices] |
| else: |
| new_split_sizes.append(len(selected_frames_0)) |
| selected_frames_all_0.append(selected_frames_0) |
| selected_frames_all_1.append(selected_frames_1) |
| selected_frames_feature_all.append(selected_features) |
| selected_frame_indices_all.append(selected_frame_indices) |
| selected_frames_all_0 = torch.cat(selected_frames_all_0, dim=0) |
| selected_frames_all_1 = torch.cat(selected_frames_all_1, dim=0) |
| selected_frames_feature_all = torch.cat(selected_frames_feature_all, dim=0) |
| return ( |
| selected_frames_feature_all, |
| new_split_sizes, |
| [selected_frames_all_0, selected_frames_all_1], |
| selected_frame_indices_all, |
| ) |
|
|
| def prepare_mm_features( |
| self, |
| images: List[torch.Tensor], |
| image_sizes: List[Tuple[int, int]], |
| ): |
| image_aux_list = images |
| split_sizes_ori = [ |
| 1 if image.ndim == 3 else image.shape[0] for image in image_aux_list[0] |
| ] |
| new_image_aux_list = [] |
| for image_aux in image_aux_list: |
| if type(image_aux) is list: |
| image_aux = [ |
| x.unsqueeze(0) if x.ndim == 3 else x for x in image_aux |
| ] |
| concat_image_aux = torch.cat([image for image in image_aux], dim=0) |
| new_image_aux_list.append(concat_image_aux) |
| image_aux_features_dino = self.encode_images( |
| new_image_aux_list, encode_type="dino" |
| ) |
| ( |
| image_aux_features_dino, |
| split_sizes, |
| new_image_aux_list, |
| selected_frame_indices_all, |
| ) = self.select_frame( |
| image_aux_features_dino, |
| split_sizes_ori, |
| new_image_aux_list, |
| image_sizes, |
| threshold=getattr(self.config, "dino_threshold", 0.83), |
| ) |
| image_aux_features_siglip = self.encode_images( |
| new_image_aux_list, encode_type="siglip" |
| ) |
| image_aux_features_list = [ |
| image_aux_features_siglip, |
| image_aux_features_dino, |
| ] |
| return image_aux_features_list |
