# quality/vtss.py import os import time import yaml import numpy as np import torch import cv2 from PIL import Image from tqdm import tqdm import logging from ivebench_utils import load_video_info logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) def load_metric_paths(path_yml='path.yml', metric_name='vtss'): """Load model checkpoint path from path.yml""" try: if not os.path.exists(path_yml): logger.warning(f"Path configuration file not found: {path_yml}") return None with open(path_yml, 'r', encoding='utf-8') as f: paths_config = yaml.safe_load(f) if metric_name not in paths_config: logger.warning(f"Metric '{metric_name}' not found in {path_yml}") return None metric_config = paths_config[metric_name] checkpoint_path = metric_config.get('checkpoint') logger.info(f"Loaded checkpoint path for {metric_name}: {checkpoint_path}") return checkpoint_path except Exception as e: logger.error(f"Error loading metric paths from {path_yml}: {e}") return None class VTSSCalculator: def __init__(self, device, config_path=None, checkpoint_path=None): self.device = device self.config_path = config_path or "quality/training_suitability_assessment/infer.yml" self.checkpoint_path = checkpoint_path if not os.path.exists(self.config_path): raise FileNotFoundError(f"VTSS config file not found: {self.config_path}") self._load_model() def _load_model(self): try: with open(self.config_path, "r") as f: opt = yaml.safe_load(f) try: from quality.training_suitability_assessment.model import DiViDeAddEvaluator from quality.training_suitability_assessment.datasets import FusionDataset except ImportError: raise ImportError("VTSS modules not found. Please install vtss package or check the import path.") self.model = DiViDeAddEvaluator(**opt["model"]["args"]) self.model.to(self.device) self.model.eval() load_path = self.checkpoint_path if self.checkpoint_path else opt["load_path"] if not os.path.exists(load_path): raise FileNotFoundError(f"VTSS model weights not found: {load_path}") logger.info(f"Loading VTSS model from: {load_path}") state_dict = torch.load(load_path, map_location=self.device, weights_only=False)["state_dict"] self.model.load_state_dict(state_dict, strict=True) self.val_dataset = FusionDataset(opt["data"]['test-data']["args"]) logger.info("VTSS model loaded successfully") except Exception as e: logger.error(f"Failed to load VTSS model: {e}") raise def process_video_from_frames(self, frame_folder_path): if not os.path.exists(frame_folder_path): raise FileNotFoundError(f"Frame folder not found: {frame_folder_path}") frame_files = sorted([f for f in os.listdir(frame_folder_path) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]) if not frame_files: raise ValueError(f"No image files found in {frame_folder_path}") temp_video_path = self._create_temp_video_from_frames(frame_folder_path, frame_files) try: score = self.process_video(temp_video_path) return score finally: if os.path.exists(temp_video_path): os.remove(temp_video_path) def _create_temp_video_from_frames(self, frame_folder_path, frame_files): temp_video_path = os.path.join(frame_folder_path, "temp_vtss_video.mp4") first_frame_path = os.path.join(frame_folder_path, frame_files[0]) first_frame = cv2.imread(first_frame_path) if first_frame is None: raise ValueError(f"Could not read first frame: {first_frame_path}") height, width, _ = first_frame.shape fourcc = cv2.VideoWriter_fourcc(*'mp4v') fps = 24 out = cv2.VideoWriter(temp_video_path, fourcc, fps, (width, height)) for frame_file in frame_files: frame_path = os.path.join(frame_folder_path, frame_file) frame = cv2.imread(frame_path) if frame is not None: out.write(frame) else: logger.warning(f"Could not read frame: {frame_path}") out.release() return temp_video_path def process_video(self, video_path): start_time = time.perf_counter() try: data = self.val_dataset.prepare_video(video_path) video = {} for key in ["resize", "fragments", "crop", "arp_resize", "arp_fragments"]: if key in data: video[key] = data[key].to(self.device).unsqueeze(0) b, c, t, h, w = video[key].shape video[key] = video[key].reshape( b, c, data["num_clips"][key], t // data["num_clips"][key], h, w ).permute(0, 2, 1, 3, 4, 5).reshape( b * data["num_clips"][key], c, t // data["num_clips"][key], h, w ) with torch.no_grad(): labels = self.model(video, reduce_scores=False) labels = [np.mean(l.cpu().numpy()) for l in labels] end_time = time.perf_counter() score = float(labels[0]) logger.debug(f"VTSS processing time: {end_time - start_time:.2f}s, score: {score:.4f}") del video, data, labels torch.cuda.empty_cache() return score except Exception as e: logger.error(f"Error processing video {video_path}: {e}") return -1.0 def vtss_single_video(vtss_calculator, video_info, target_videos_path, use_frames=True): video_name = video_info['src_video_name'] video_id = video_info['id'] try: if use_frames: video_name_without_ext = os.path.splitext(video_name)[0] target_frame_folder = os.path.join(target_videos_path, video_name_without_ext) if not os.path.exists(target_frame_folder): error_msg = f"Frame folder not found: {target_frame_folder}" logger.warning(error_msg) return { 'video_id': int(video_id), 'video_name': str(video_name), 'video_results': -1.0, 'category': str(video_info['category']), 'subcategory': str(video_info['subcategory']), 'error': error_msg } score = vtss_calculator.process_video_from_frames(target_frame_folder) else: target_video_path = os.path.join(target_videos_path, video_name) if not os.path.exists(target_video_path): error_msg = f"Video file not found: {target_video_path}" logger.warning(error_msg) return { 'video_id': int(video_id), 'video_name': str(video_name), 'video_results': -1.0, 'category': str(video_info['category']), 'subcategory': str(video_info['subcategory']), 'error': error_msg } score = vtss_calculator.process_video(target_video_path) if score == -1.0: return { 'video_id': int(video_id), 'video_name': str(video_name), 'video_results': -1.0, 'category': str(video_info['category']), 'subcategory': str(video_info['subcategory']), 'error': 'Video processing failed' } return { 'video_id': int(video_id), 'video_name': str(video_name), 'video_results': float(score), 'category': str(video_info['category']), 'subcategory': str(video_info['subcategory']) } except Exception as e: error_msg = f"Error processing video {video_name}: {str(e)}" logger.error(error_msg) return { 'video_id': int(video_id), 'video_name': str(video_name), 'video_results': -1.0, 'category': str(video_info.get('category', '')), 'subcategory': str(video_info.get('subcategory', '')), 'error': error_msg } def vtss_evaluation(video_info_list, target_videos_path, device, config_path=None, checkpoint_path=None, use_frames=True): scores = [] video_results = [] try: vtss_calculator = VTSSCalculator(device, config_path, checkpoint_path) except Exception as e: error_msg = f"Failed to initialize VTSS calculator: {e}" logger.error(error_msg) for video_info in video_info_list: video_results.append({ 'video_id': int(video_info['id']), 'video_name': str(video_info['src_video_name']), 'video_results': -1.0, 'category': str(video_info.get('category', '')), 'subcategory': str(video_info.get('subcategory', '')), 'error': error_msg }) return -1.0, video_results logger.info(f"Processing {len(video_info_list)} videos for VTSS evaluation") for video_info in tqdm(video_info_list, desc="Evaluating VTSS"): result = vtss_single_video(vtss_calculator, video_info, target_videos_path, use_frames) video_results.append(result) if 'error' not in result: scores.append(result['video_results']) logger.debug(f"Video {result['video_name']}: VTSS score = {result['video_results']:.4f}") else: logger.warning(f"Video {result['video_name']}: {result['error']}") if scores: avg_score = sum(scores) / len(scores) logger.info(f"Overall VTSS score: {avg_score:.4f} (based on {len(scores)}/{len(video_info_list)} valid videos)") else: avg_score = -1.0 logger.error("No valid VTSS scores calculated") return float(avg_score), video_results def compute_vtss(json_dir, device, source_videos_path=None, target_videos_path=None, config_path=None, checkpoint_path=None, use_frames=True, path_yml='path.yml', **kwargs): """ Compute VTSS (Video Training Suitability Score) metric Args: json_dir: Path to JSON file with video information device: Device to run evaluation on ('cuda' or 'cpu') source_videos_path: Path to source videos (not used in this metric) target_videos_path: Path to target videos to evaluate config_path: Config file path (uses default if not provided) checkpoint_path: Checkpoint file path (if None, will load from path.yml) use_frames: Whether to use frames or video files path_yml: Path to the YAML file containing model paths **kwargs: Additional arguments Returns: tuple: (overall_score, video_results) """ try: if checkpoint_path is None: logger.info(f"Loading model checkpoint path from {path_yml}") checkpoint_path = load_metric_paths(path_yml, 'vtss') if checkpoint_path is None: error_msg = "Checkpoint path must be provided either as argument or in path.yml" logger.error(error_msg) video_info_list = load_video_info(json_dir, 'vtss') video_results = [] for video_info in video_info_list: video_results.append({ 'video_id': int(video_info['id']), 'video_name': str(video_info['src_video_name']), 'video_results': -1.0, 'category': str(video_info.get('category', '')), 'subcategory': str(video_info.get('subcategory', '')), 'error': error_msg }) return -1.0, video_results video_info_list = load_video_info(json_dir, 'vtss') logger.info(f"Loaded {len(video_info_list)} video entries") if target_videos_path is None: raise ValueError("target_videos_path is required for VTSS evaluation") if not os.path.exists(target_videos_path): raise FileNotFoundError(f"Target videos path not found: {target_videos_path}") overall_score, video_results = vtss_evaluation( video_info_list, target_videos_path, device, config_path, checkpoint_path, use_frames ) if overall_score == -1.0: logger.error("VTSS evaluation failed.") else: logger.info(f"VTSS evaluation completed. Overall score: {overall_score:.4f}") return overall_score, video_results except Exception as e: error_msg = f"Error in compute_vtss: {str(e)}" logger.error(error_msg) return -1.0, []