import os import torch import imageio import subprocess from torchvision.transforms import Resize from torchvision import transforms from einops import rearrange import torch.nn.functional as F import numpy as np from PIL import Image from omegaconf import OmegaConf from torchmetrics.multimodal import CLIPScore from torchmetrics.image import PeakSignalNoiseRatio, StructuralSimilarityIndexMeasure from torchmetrics.image.lpip import LearnedPerceptualImagePatchSimilarity from torchmetrics.regression import MeanSquaredError try: from cotracker.predictor import CoTrackerPredictor from cotracker.utils.visualizer import read_video_from_path except: print("No found cotracker, skipped!") from transformers import AutoProcessor, AutoModel from qwen_vl_utils import process_vision_info def find_images_in_dir(directory): assert os.path.isdir(directory), f"{directory}" image_extensions = ('.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff', '.webp') image_files = sorted([ os.path.join(directory, f) for f in os.listdir(directory) if f.lower().endswith(image_extensions) ]) return image_files def average_niqe_from_txt(save_file): values = [] with open(save_file, 'r') as file: for line in file: parts = line.strip().split(",") # Split by comma if len(parts) == 2: # Ensure there are two parts try: values.append(float(parts[1])) # Extract number and convert to float except ValueError: continue # Skip lines that do not match expected format # Compute the average average = sum(values) / len(values) if values else 0 print(f"Total Number of Frames: {len(values)}, Average NIQE Score: {average}") return average class FiVEAcc_Qwen_VL(torch.nn.Module): def __init__(self, num_frames=4, model_id="Qwen/Qwen2.5-VL-7B-Instruct"): super().__init__() # num frames are fed into Qwen-VL self.num_frames = num_frames # different transformer version from transformers import Qwen2_5_VLForConditionalGeneration self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained( model_id, torch_dtype=torch.bfloat16, attn_implementation="flash_attention_2", device_map="auto", ) # default processer self.processor = AutoProcessor.from_pretrained(model_id) def get_template(self, q, q_type="yes/no"): if q_type == "yes/no": input_text = ( "Answer the following question using only 'YES' or 'NO:\n" f"{q}" ) elif q_type == "multi-choice": input_text = ( "Select the correct answer from the given choices, onlyt output the answer:\n" f"{q}" ) else: raise NotImplementedError return input_text def run_each_iter(self, text, video_path): if os.path.isdir(video_path): video_path = find_images_in_dir(video_path) if isinstance(video_path, list): stride = len(video_path)//(len(video_path)//self.num_frames) video_path = video_path[int(0.5*stride)::stride] messages = [ { "role": "user", "content": [ { "type": "video", # "video": [ # "file:///path/to/frame1.jpg", # "file:///path/to/frame2.jpg", # "file:///path/to/frame3.jpg", # "file:///path/to/frame4.jpg", # ], "video": video_path, }, {"type": "text", "text": text}, ], } ] elif video_path.endswith('.mp4'): messages = [ { "role": "user", "content": [ { "type": "video", # "video": "file:///path/to/video1.mp4", "video": video_path, "max_pixels": 360 * 420, "fps": 1.0, }, {"type": "text", "text": text}, ], } ] else: assert video_path.endswith('.jpg') or video_path.endswith('png'), \ f"unsupported file format {video_path}" messages = [ { "role": "user", "content": [ { "type": "image", # "image": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg", "image": video_path, }, {"type": "text", "text": text}, ], } ] # Preparation for inference text = self.processor.apply_chat_template( messages, tokenize=False, add_generation_prompt=True ) image_inputs, video_inputs = process_vision_info(messages) # image_inputs, video_inputs, video_kwargs = process_vision_info(messages, return_video_kwargs=True) inputs = self.processor( text=[text], images=image_inputs, videos=video_inputs, fps=10, ## Important!! padding=True, return_tensors="pt", # **video_kwargs ) inputs = inputs.to("cuda") # Inference: Generation of the output generated_ids = self.model.generate(**inputs, max_new_tokens=128) generated_ids_trimmed = [ out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids) ] output_text = self.processor.batch_decode( generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False ) return output_text[0] def get_score(self, src_q, tgt_q, multi_choice_q, video_path): """ Evaluate answers for source, target, and multiple-choice questions. Args: src_q (str): Source question. tgt_q (str): Target question. multi_choice_q (str): Multiple-choice question. video_path (str): Path to the video file. Returns: tuple: A tuple containing: - yn_acc (bool): Whether the yes/no answers are correct. - mc_acc (bool): Whether the multiple-choice answer is correct. """ assert tgt_q is not None and multi_choice_q is not None assert len(tgt_q) > 0 and len(multi_choice_q) > 0 print(src_q, tgt_q, multi_choice_q) try: # Process multiple-choice question multi_choice_q = self.get_template(multi_choice_q, q_type="multi-choice") multi_choice_a = self.run_each_iter(multi_choice_q, video_path) mc_acc = multi_choice_a.strip()[:1].lower() == "b" # Check if the answer is "B" print("mc:", multi_choice_a) # Process source question if src_q is not None and len(src_q) > 0: src_q = self.get_template(src_q, q_type="yes/no") src_a = self.run_each_iter(src_q, video_path) print("src_a:", src_a) src_a_cleaned = src_a.strip()[:2].lower() # Clean and normalize source answer # Process target question tgt_q = self.get_template(tgt_q, q_type="yes/no") tgt_a = self.run_each_iter(tgt_q, video_path) print("tgt_a:", tgt_a) tgt_a_cleaned = tgt_a.strip()[:3].lower() # Clean and normalize target answer # Evaluate yes/no answers if src_q is not None and len(src_q) > 0: yn_acc = (src_a_cleaned == "no" and tgt_a_cleaned == "yes") else: yn_acc = tgt_a_cleaned == "yes" print("yn / mc: ", int(yn_acc), int(mc_acc)) return int(yn_acc), int(mc_acc) except Exception as e: # Handle unexpected errors gracefully print(f"An error occurred: {e}") return "nan", "nan" # Return default values in case of an error class MotionFidelityScore(torch.nn.Module): def __init__(self, cotracker_model_path): super().__init__() self.model = CoTrackerPredictor(checkpoint=cotracker_model_path) self.model = self.model.cuda() def get_similarity_matrix(self, tracklets1, tracklets2): displacements1 = tracklets1[:, 1:] - tracklets1[:, :-1] displacements1 = displacements1 / displacements1.norm(dim=-1, keepdim=True) displacements2 = tracklets2[:, 1:] - tracklets2[:, :-1] displacements2 = displacements2 / displacements2.norm(dim=-1, keepdim=True) similarity_matrix = torch.einsum("ntc, mtc -> nmt", displacements1, displacements2).mean(dim=-1) return similarity_matrix def get_score(self, similarity_matrix): similarity_matrix_eye = similarity_matrix - torch.eye(similarity_matrix.shape[0]).to(similarity_matrix.device) # for each row find the most similar element max_similarity, _ = similarity_matrix_eye.max(dim=1) average_score = max_similarity.mean() return { "average_score": average_score.item(), } def read_frames_from_dir(self, dir_path): """ Read frames from a directory of images. Parameters: - dir_path (str): Path to the directory containing image frames. Returns: - np.ndarray: A NumPy array of frames, or None if the directory is empty or invalid. """ try: # List all image files in the directory (sorted for consistent ordering) image_files = sorted( [os.path.join(dir_path, f) for f in os.listdir(dir_path) if f.lower().endswith(('.png', '.jpg', '.jpeg'))] ) if not image_files: print(f"No image files found in directory: {dir_path}") return None # Load all images into a list frames = [imageio.imread(img) for img in image_files] return np.stack(frames) except Exception as e: print("Error reading frames from directory:", e) return None def get_tracklets(self, video_path, mask=None, dw8_after_video_vae=False, cut_frames=None): if video_path.endswith('.mp4'): video = read_video_from_path(video_path) else: assert os.path.isdir(video_path), f'{video_path} must be a dir!' video = self.read_frames_from_dir(video_path) # t, h, w, 3 if cut_frames is not None: video = video[:cut_frames] len_video = len(video) if dw8_after_video_vae: video = video[::8] # downsampling ratio of video vae video = torch.from_numpy(video).permute(0, 3, 1, 2)[None].float().cuda() pred_tracks_small, pred_visibility_small = self.model(video, grid_size=55, segm_mask=mask) pred_tracks_small = rearrange(pred_tracks_small, "b t l c -> (b l) t c ") return pred_tracks_small, len_video def calculate_MFS(self, original_video_path, edit_video_path, video_masks=None, dw8_after_video_vae=False): """ Args: video_masks: 0 or 1 mask, 0 for background, 1 for foreground dw8_after_video_vae: enable downsample 8x, cause video_vae has 8x temporal downsample """ if video_masks is not None: # calculate trajectories only on the foreground of the video if isinstance(video_masks, list): minx_list, maxx_list, miny_list, maxy_list = [], [], [], [] for segm_mask in video_masks: if segm_mask.ndim == 3 and segm_mask.shape[-1] == 3: segm_mask = segm_mask[..., 0] assert segm_mask.ndim == 2 if isinstance(segm_mask, np.ndarray): segm_mask = torch.from_numpy(segm_mask).float() minx = segm_mask.nonzero(as_tuple=False)[:, 0].min() maxx = segm_mask.nonzero(as_tuple=False)[:, 0].max() miny = segm_mask.nonzero(as_tuple=False)[:, 1].min() maxy = segm_mask.nonzero(as_tuple=False)[:, 1].max() minx_list.append(minx) maxx_list.append(maxx) miny_list.append(miny) maxy_list.append(maxy) # get bounding box mask from segmentation mask - rectangular mask that covers the segmentation mask minx, maxx = min(minx_list), max(maxx_list) miny, maxy = min(miny_list), max(maxy_list) box_mask = torch.zeros_like(segm_mask) box_mask[minx:maxx, miny:maxy] = 1 box_mask = box_mask[None, None] else: raise ValueError("video_masks must be a list") else: box_mask = None edit_tracklets, len_video_edit = self.get_tracklets(edit_video_path, mask=box_mask) original_tracklets, len_video_ori = self.get_tracklets( original_video_path, mask=box_mask, dw8_after_video_vae=dw8_after_video_vae, cut_frames=len_video_edit ) assert len_video_edit == len_video_ori similarity_matrix = self.get_similarity_matrix(edit_tracklets, original_tracklets) similarity_scores_dict = self.get_score(similarity_matrix) return similarity_scores_dict["average_score"] class VitExtractor: BLOCK_KEY = 'block' ATTN_KEY = 'attn' PATCH_IMD_KEY = 'patch_imd' QKV_KEY = 'qkv' KEY_LIST = [BLOCK_KEY, ATTN_KEY, PATCH_IMD_KEY, QKV_KEY] def __init__(self, model_name, device): self.model = torch.hub.load('facebookresearch/dino:main', model_name).to(device) self.model.eval() self.model_name = model_name self.hook_handlers = [] self.layers_dict = {} self.outputs_dict = {} for key in VitExtractor.KEY_LIST: self.layers_dict[key] = [] self.outputs_dict[key] = [] self._init_hooks_data() self.device=device def _init_hooks_data(self): self.layers_dict[VitExtractor.BLOCK_KEY] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] self.layers_dict[VitExtractor.ATTN_KEY] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] self.layers_dict[VitExtractor.QKV_KEY] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] self.layers_dict[VitExtractor.PATCH_IMD_KEY] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] for key in VitExtractor.KEY_LIST: # self.layers_dict[key] = kwargs[key] if key in kwargs.keys() else [] self.outputs_dict[key] = [] def _register_hooks(self, **kwargs): for block_idx, block in enumerate(self.model.blocks): if block_idx in self.layers_dict[VitExtractor.BLOCK_KEY]: self.hook_handlers.append(block.register_forward_hook(self._get_block_hook())) if block_idx in self.layers_dict[VitExtractor.ATTN_KEY]: self.hook_handlers.append(block.attn.attn_drop.register_forward_hook(self._get_attn_hook())) if block_idx in self.layers_dict[VitExtractor.QKV_KEY]: self.hook_handlers.append(block.attn.qkv.register_forward_hook(self._get_qkv_hook())) if block_idx in self.layers_dict[VitExtractor.PATCH_IMD_KEY]: self.hook_handlers.append(block.attn.register_forward_hook(self._get_patch_imd_hook())) def _clear_hooks(self): for handler in self.hook_handlers: handler.remove() self.hook_handlers = [] def _get_block_hook(self): def _get_block_output(model, input, output): self.outputs_dict[VitExtractor.BLOCK_KEY].append(output) return _get_block_output def _get_attn_hook(self): def _get_attn_output(model, inp, output): self.outputs_dict[VitExtractor.ATTN_KEY].append(output) return _get_attn_output def _get_qkv_hook(self): def _get_qkv_output(model, inp, output): self.outputs_dict[VitExtractor.QKV_KEY].append(output) return _get_qkv_output # TODO: CHECK ATTN OUTPUT TUPLE def _get_patch_imd_hook(self): def _get_attn_output(model, inp, output): self.outputs_dict[VitExtractor.PATCH_IMD_KEY].append(output[0]) return _get_attn_output def get_feature_from_input(self, input_img): # List([B, N, D]) self._register_hooks() self.model(input_img) feature = self.outputs_dict[VitExtractor.BLOCK_KEY] self._clear_hooks() self._init_hooks_data() return feature def get_qkv_feature_from_input(self, input_img): self._register_hooks() self.model(input_img) feature = self.outputs_dict[VitExtractor.QKV_KEY] self._clear_hooks() self._init_hooks_data() return feature def get_attn_feature_from_input(self, input_img): self._register_hooks() self.model(input_img) feature = self.outputs_dict[VitExtractor.ATTN_KEY] self._clear_hooks() self._init_hooks_data() return feature def get_patch_size(self): return 8 if "8" in self.model_name else 16 def get_width_patch_num(self, input_img_shape): b, c, h, w = input_img_shape patch_size = self.get_patch_size() return w // patch_size def get_height_patch_num(self, input_img_shape): b, c, h, w = input_img_shape patch_size = self.get_patch_size() return h // patch_size def get_patch_num(self, input_img_shape): patch_num = 1 + (self.get_height_patch_num(input_img_shape) * self.get_width_patch_num(input_img_shape)) return patch_num def get_head_num(self): if "dino" in self.model_name: return 6 if "s" in self.model_name else 12 return 6 if "small" in self.model_name else 12 def get_embedding_dim(self): if "dino" in self.model_name: return 384 if "s" in self.model_name else 768 return 384 if "small" in self.model_name else 768 def get_queries_from_qkv(self, qkv, input_img_shape): patch_num = self.get_patch_num(input_img_shape) head_num = self.get_head_num() embedding_dim = self.get_embedding_dim() q = qkv.reshape(patch_num, 3, head_num, embedding_dim // head_num).permute(1, 2, 0, 3)[0] return q def get_keys_from_qkv(self, qkv, input_img_shape): patch_num = self.get_patch_num(input_img_shape) head_num = self.get_head_num() embedding_dim = self.get_embedding_dim() k = qkv.reshape(patch_num, 3, head_num, embedding_dim // head_num).permute(1, 2, 0, 3)[1] return k def get_values_from_qkv(self, qkv, input_img_shape): patch_num = self.get_patch_num(input_img_shape) head_num = self.get_head_num() embedding_dim = self.get_embedding_dim() v = qkv.reshape(patch_num, 3, head_num, embedding_dim // head_num).permute(1, 2, 0, 3)[2] return v def get_keys_from_input(self, input_img, layer_num): qkv_features = self.get_qkv_feature_from_input(input_img)[layer_num] keys = self.get_keys_from_qkv(qkv_features, input_img.shape) return keys def get_keys_self_sim_from_input(self, input_img, layer_num): keys = self.get_keys_from_input(input_img, layer_num=layer_num) h, t, d = keys.shape concatenated_keys = keys.transpose(0, 1).reshape(t, h * d) ssim_map = self.attn_cosine_sim(concatenated_keys[None, None, ...]) return ssim_map def attn_cosine_sim(self,x, eps=1e-08): x = x[0] # TEMP: getting rid of redundant dimension, TBF norm1 = x.norm(dim=2, keepdim=True) factor = torch.clamp(norm1 @ norm1.permute(0, 2, 1), min=eps) sim_matrix = (x @ x.permute(0, 2, 1)) / factor return sim_matrix class LossG(torch.nn.Module): def __init__(self, cfg,device): super().__init__() self.cfg = cfg self.device=device self.extractor = VitExtractor(model_name=cfg['dino_model_name'], device=device) imagenet_norm = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) global_resize_transform = Resize(cfg['dino_global_patch_size'], max_size=480) self.global_transform = transforms.Compose([global_resize_transform, imagenet_norm ]) self.lambdas = dict( lambda_global_cls=cfg['lambda_global_cls'], lambda_global_ssim=0, lambda_entire_ssim=0, lambda_entire_cls=0, lambda_global_identity=0 ) def update_lambda_config(self, step): if step == self.cfg['cls_warmup']: self.lambdas['lambda_global_ssim'] = self.cfg['lambda_global_ssim'] self.lambdas['lambda_global_identity'] = self.cfg['lambda_global_identity'] if step % self.cfg['entire_A_every'] == 0: self.lambdas['lambda_entire_ssim'] = self.cfg['lambda_entire_ssim'] self.lambdas['lambda_entire_cls'] = self.cfg['lambda_entire_cls'] else: self.lambdas['lambda_entire_ssim'] = 0 self.lambdas['lambda_entire_cls'] = 0 def forward(self, outputs, inputs): self.update_lambda_config(inputs['step']) losses = {} loss_G = 0 if self.lambdas['lambda_global_ssim'] > 0: losses['loss_global_ssim'] = self.calculate_global_ssim_loss(outputs['x_global'], inputs['A_global']) loss_G += losses['loss_global_ssim'] * self.lambdas['lambda_global_ssim'] if self.lambdas['lambda_entire_ssim'] > 0: losses['loss_entire_ssim'] = self.calculate_global_ssim_loss(outputs['x_entire'], inputs['A']) loss_G += losses['loss_entire_ssim'] * self.lambdas['lambda_entire_ssim'] if self.lambdas['lambda_entire_cls'] > 0: losses['loss_entire_cls'] = self.calculate_crop_cls_loss(outputs['x_entire'], inputs['B_global']) loss_G += losses['loss_entire_cls'] * self.lambdas['lambda_entire_cls'] if self.lambdas['lambda_global_cls'] > 0: losses['loss_global_cls'] = self.calculate_crop_cls_loss(outputs['x_global'], inputs['B_global']) loss_G += losses['loss_global_cls'] * self.lambdas['lambda_global_cls'] if self.lambdas['lambda_global_identity'] > 0: losses['loss_global_id_B'] = self.calculate_global_id_loss(outputs['y_global'], inputs['B_global']) loss_G += losses['loss_global_id_B'] * self.lambdas['lambda_global_identity'] losses['loss'] = loss_G return losses def calculate_global_ssim_loss(self, outputs, inputs): loss = 0.0 for a, b in zip(inputs, outputs): # avoid memory limitations a = self.global_transform(a) b = self.global_transform(b) with torch.no_grad(): target_keys_self_sim = self.extractor.get_keys_self_sim_from_input(a.unsqueeze(0), layer_num=11) keys_ssim = self.extractor.get_keys_self_sim_from_input(b.unsqueeze(0), layer_num=11) loss += F.mse_loss(keys_ssim, target_keys_self_sim) return loss def calculate_crop_cls_loss(self, outputs, inputs): loss = 0.0 for a, b in zip(outputs, inputs): # avoid memory limitations a = self.global_transform(a).unsqueeze(0).to(self.device) b = self.global_transform(b).unsqueeze(0).to(self.device) cls_token = self.extractor.get_feature_from_input(a)[-1][0, 0, :] with torch.no_grad(): target_cls_token = self.extractor.get_feature_from_input(b)[-1][0, 0, :] loss += F.mse_loss(cls_token, target_cls_token) return loss def calculate_global_id_loss(self, outputs, inputs): loss = 0.0 for a, b in zip(inputs, outputs): a = self.global_transform(a) b = self.global_transform(b) with torch.no_grad(): keys_a = self.extractor.get_keys_from_input(a.unsqueeze(0), 11) keys_b = self.extractor.get_keys_from_input(b.unsqueeze(0), 11) loss += F.mse_loss(keys_a, keys_b) return loss class MetricsCalculator: def __init__(self, device, config) -> None: self.device=device self.config = config self.clip_metric_calculator = CLIPScore(model_name_or_path="openai/clip-vit-large-patch14").to(device) self.psnr_metric_calculator = PeakSignalNoiseRatio(data_range=1.0).to(device) self.lpips_metric_calculator = LearnedPerceptualImagePatchSimilarity(net_type='squeeze').to(device) self.mse_metric_calculator = MeanSquaredError().to(device) self.ssim_metric_calculator = StructuralSimilarityIndexMeasure(data_range=1.0).to(device) self.structure_distance_metric_calculator = LossG(cfg={ 'dino_model_name': 'dino_vitb8', # ['dino_vitb8', 'dino_vits8', 'dino_vitb16', 'dino_vits16'] 'dino_global_patch_size': 224, 'lambda_global_cls': 10.0, 'lambda_global_ssim': 1.0, 'lambda_global_identity': 1.0, 'entire_A_every':75, 'lambda_entire_cls':10, 'lambda_entire_ssim':1.0 }, device=device) try: self.motion_fidelity_score_calculator = MotionFidelityScore( cotracker_model_path=config.cotracker_model_path ) except Exception as e: print("Error: ", e) print("Failed to load MotionFidelityScore!") exit() try: self.five_acc_calculator = FiVEAcc_Qwen_VL( num_frames=config.five_acc_vlm_num_frames, model_id=config.five_acc_vlm_model_id ) except Exception as e: print("Error: ", e) print("Failed to load FiVEAcc_Qwen_VL") exit() def calculate_clip_similarity(self, img, txt, mask=None): img = np.array(img) if mask is not None: mask = np.array(mask) img = np.uint8(img * mask) img_tensor=torch.tensor(img).permute(2,0,1).to(self.device) score = self.clip_metric_calculator(img_tensor, txt) score = score.cpu().item() return score def calculate_psnr(self, img_pred, img_gt, mask_pred=None, mask_gt=None): img_pred = np.array(img_pred).astype(np.float32)/255 img_gt = np.array(img_gt).astype(np.float32)/255 assert img_pred.shape == img_gt.shape, "Image shapes should be the same." if mask_pred is not None: mask_pred = np.array(mask_pred).astype(np.float32) img_pred = img_pred * mask_pred if mask_gt is not None: mask_gt = np.array(mask_gt).astype(np.float32) img_gt = img_gt * mask_gt img_pred_tensor=torch.tensor(img_pred).permute(2,0,1).unsqueeze(0).to(self.device) img_gt_tensor=torch.tensor(img_gt).permute(2,0,1).unsqueeze(0).to(self.device) score = self.psnr_metric_calculator(img_pred_tensor,img_gt_tensor) score = score.cpu().item() return score def calculate_lpips(self, img_pred, img_gt, mask_pred=None, mask_gt=None): img_pred = np.array(img_pred).astype(np.float32)/255 img_gt = np.array(img_gt).astype(np.float32)/255 assert img_pred.shape == img_gt.shape, "Image shapes should be the same." if mask_pred is not None: mask_pred = np.array(mask_pred).astype(np.float32) img_pred = img_pred * mask_pred if mask_gt is not None: mask_gt = np.array(mask_gt).astype(np.float32) img_gt = img_gt * mask_gt img_pred_tensor=torch.tensor(img_pred).permute(2,0,1).unsqueeze(0).to(self.device) img_gt_tensor=torch.tensor(img_gt).permute(2,0,1).unsqueeze(0).to(self.device) score = self.lpips_metric_calculator(img_pred_tensor*2-1, img_gt_tensor*2-1) score = score.cpu().item() return score def calculate_mse(self, img_pred, img_gt, mask_pred=None, mask_gt=None): img_pred = np.array(img_pred).astype(np.float32)/255 img_gt = np.array(img_gt).astype(np.float32)/255 assert img_pred.shape == img_gt.shape, "Image shapes should be the same." if mask_pred is not None: mask_pred = np.array(mask_pred).astype(np.float32) img_pred = img_pred * mask_pred if mask_gt is not None: mask_gt = np.array(mask_gt).astype(np.float32) img_gt = img_gt * mask_gt img_pred_tensor=torch.tensor(img_pred).permute(2,0,1).to(self.device) img_gt_tensor=torch.tensor(img_gt).permute(2,0,1).to(self.device) score = self.mse_metric_calculator(img_pred_tensor.contiguous(),img_gt_tensor.contiguous()) score = score.cpu().item() return score def calculate_ssim(self, img_pred, img_gt, mask_pred=None, mask_gt=None): img_pred = np.array(img_pred).astype(np.float32)/255 img_gt = np.array(img_gt).astype(np.float32)/255 assert img_pred.shape == img_gt.shape, "Image shapes should be the same." if mask_pred is not None: mask_pred = np.array(mask_pred).astype(np.float32) img_pred = img_pred * mask_pred if mask_gt is not None: mask_gt = np.array(mask_gt).astype(np.float32) img_gt = img_gt * mask_gt img_pred_tensor=torch.tensor(img_pred).permute(2,0,1).unsqueeze(0).to(self.device) img_gt_tensor=torch.tensor(img_gt).permute(2,0,1).unsqueeze(0).to(self.device) score = self.ssim_metric_calculator(img_pred_tensor,img_gt_tensor) score = score.cpu().item() return score def calculate_structure_distance(self, img_pred, img_gt, mask_pred=None, mask_gt=None, use_gpu = True): img_pred = np.array(img_pred).astype(np.float32) img_gt = np.array(img_gt).astype(np.float32) assert img_pred.shape == img_gt.shape, "Image shapes should be the same." if mask_pred is not None: mask_pred = np.array(mask_pred).astype(np.float32) img_pred = img_pred * mask_pred if mask_gt is not None: mask_gt = np.array(mask_gt).astype(np.float32) img_gt = img_gt * mask_gt img_pred = torch.from_numpy(np.transpose(img_pred, axes=(2, 0, 1))).to(self.device) img_gt = torch.from_numpy(np.transpose(img_gt, axes=(2, 0, 1))).to(self.device) img_pred = torch.unsqueeze(img_pred, 0) img_gt = torch.unsqueeze(img_gt, 0) structure_distance = self.structure_distance_metric_calculator.calculate_global_ssim_loss(img_gt, img_pred) return structure_distance.data.cpu().numpy() def calculate_NIQE(self, save_file, img_pred_path=None, img_gt_path=None, use_gpu=True): assert img_pred_path is not None or img_gt_path is not None model = "NIQE" image_path = img_pred_path if img_pred_path is not None else img_gt_path # Construct the command IQA_PyTorch_model_path = self.config.IQA_PyTorch_model_path command = f'python {IQA_PyTorch_model_path}/inference_iqa.py -m {model} -t "{image_path}" --save_file "{save_file}"' print(f"Running command: {command}") # Run the command and capture output try: result = subprocess.run(command, shell=True, capture_output=True, text=True) except subprocess.CalledProcessError as e: print(f"Error running command: {e}") return "nan" def calculate_motion_fidelity_score(self, original_video_path, edit_video_path, video_masks=None, dw8_after_video_vae=False): return self.motion_fidelity_score_calculator.calculate_MFS( original_video_path, edit_video_path, video_masks, dw8_after_video_vae ) def calculate_five_acc(self, src_q, tgt_q, multi_choice_q, video_path): return self.five_acc_calculator.get_score(src_q, tgt_q, multi_choice_q, video_path)