import os import json import csv import datetime import importlib import numpy as np import logging from pathlib import Path timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S") log_filename = f"{timestamp}_ivebench.log" logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler(log_filename, mode="w", encoding="utf-8"), logging.StreamHandler() ]) def convert_types(obj): if isinstance(obj, np.integer): return int(obj) elif isinstance(obj, np.floating): return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() elif isinstance(obj, dict): return {key: convert_types(value) for key, value in obj.items()} elif isinstance(obj, list): return [convert_types(item) for item in obj] elif isinstance(obj, tuple): return tuple(convert_types(item) for item in obj) else: return obj def save_json(data, path): converted_data = convert_types(data) with open(path, 'w', encoding='utf-8') as f: json.dump(converted_data, f, ensure_ascii=False, indent=2) def load_json(path): with open(path, 'r', encoding='utf-8') as f: return json.load(f) class VEBench(object): def __init__(self, device, output_path): self.device = device self.output_path = output_path os.makedirs(self.output_path, exist_ok=True) self.logger = logging.getLogger(self.__class__.__name__) self.metric_folder_map = { "subject_consistency": "quality", "temporal_flickering": "quality", "background_consistency": "quality", "motion_smoothness": "quality", "vtss": "quality", "overall_semantic_consistency": "compliance", "instruction_satisfaction": "compliance", "phrase_semantic_consistency": "compliance", "quantity_accuracy": "compliance", "semantic_fidelity": "fidelity", "motion_fidelity": "fidelity", "content_fidelity": "fidelity" } self.logger.info(f"VEBench initialized with device: {device}") self.logger.info(f"Output path: {output_path}") def build_full_metric_list(self): return [ "subject_consistency", "temporal_flickering", "background_consistency", "motion_smoothness", "vtss", "overall_semantic_consistency", "instruction_satisfaction", "phrase_semantic_consistency", "quantity_accuracy", "semantic_fidelity", "motion_fidelity", "content_fidelity" ] def load_video_info(self, info_json_path): with open(info_json_path, 'r', encoding='utf-8') as f: video_info = json.load(f) return video_info def save_results_to_csv(self, results_dict, output_csv_path): if not results_dict: self.logger.warning("No results to save") return video_data = {} all_metrics = set() for metric, (avg_score, detailed_results) in results_dict.items(): all_metrics.add(metric) self.logger.info(f"Processing metric: {metric} with {len(detailed_results)} results") for i, result in enumerate(detailed_results): video_key = result.get('video_name') or str(result.get('video_id', f'unknown_{i}')) if video_key not in video_data: video_data[video_key] = {} for key, value in result.items(): if key not in ['video_results', 'metric', 'avg_score', 'error']: video_data[video_key][key] = value score_value = result.get('video_results', 0.0) video_data[video_key][f'{metric}_score'] = score_value if 'error' in result: video_data[video_key][f'{metric}_error'] = result['error'] if not video_data: self.logger.warning("No video data to save") return self.logger.info(f"Total unique videos found: {len(video_data)}") self.logger.info(f"Metrics processed: {sorted(all_metrics)}") basic_columns = set() score_columns = set() error_columns = set() for video_info in video_data.values(): for key in video_info.keys(): if key.endswith('_score'): score_columns.add(key) elif key.endswith('_error'): error_columns.add(key) else: basic_columns.add(key) basic_columns = sorted(list(basic_columns)) score_columns = sorted(list(score_columns)) error_columns = sorted(list(error_columns)) fieldnames = basic_columns + score_columns + error_columns self.logger.debug(f"CSV columns: {fieldnames}") csv_rows = [] for video_key, video_info in video_data.items(): row = {} for col in fieldnames: if col.endswith('_score'): row[col] = video_info.get(col, 0.0) else: row[col] = video_info.get(col, '') csv_rows.append(row) if 'video_id' in basic_columns: csv_rows.sort(key=lambda x: int(x.get('video_id', 0)) if str(x.get('video_id', 0)).isdigit() else 0) try: with open(output_csv_path, 'w', newline='', encoding='utf-8') as csvfile: writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writeheader() writer.writerows(csv_rows) self.logger.info(f'Results saved to CSV: {output_csv_path}') self.logger.info(f'Total videos: {len(csv_rows)}, Metrics: {len(all_metrics)}') self._print_metric_statistics(csv_rows, all_metrics) except Exception as e: self.logger.error(f"Error saving CSV file: {e}") def _print_metric_statistics(self, csv_rows, all_metrics): self.logger.info("=== Metric Statistics ===") for metric in sorted(all_metrics): score_col = f'{metric}_score' if score_col in csv_rows[0] if csv_rows else False: scores = [float(row[score_col]) for row in csv_rows if float(row[score_col]) != -1.0] total_count = len([row for row in csv_rows]) invalid_count = total_count - len(scores) if scores: avg_score = sum(scores) / len(scores) min_score = min(scores) max_score = max(scores) self.logger.info(f'{metric}: {len(scores)}/{total_count} valid videos evaluated ' f'({invalid_count} skipped/failed), ' f'avg={avg_score:.4f}, min={min_score:.4f}, max={max_score:.4f}') else: self.logger.warning(f'{metric}: No valid scores found - all {total_count} videos skipped/failed') def save_results_to_json(self, results_dict, output_json_path): try: save_json(results_dict, output_json_path) self.logger.info(f"Detailed results saved to JSON: {output_json_path}") except Exception as e: self.logger.error(f"Error saving JSON results: {e}") def evaluate(self, source_videos_path, target_videos_path, info_json_path, name, metric_list=None, save_json_results=True, **kwargs): results_dict = {} if metric_list is None: metric_list = self.build_full_metric_list() if not os.path.exists(source_videos_path): raise FileNotFoundError(f"Source videos path not found: {source_videos_path}") if not os.path.exists(target_videos_path): raise FileNotFoundError(f"Target videos path not found: {target_videos_path}") if not os.path.exists(info_json_path): raise FileNotFoundError(f"Info JSON file not found: {info_json_path}") priority_metrics = ["content_fidelity", "instruction_satisfaction"] ordered_metric_list = [] for priority_metric in priority_metrics: if priority_metric in metric_list: ordered_metric_list.append(priority_metric) for metric in metric_list: if metric not in priority_metrics: ordered_metric_list.append(metric) self.logger.info(f"Starting evaluation with metrics (prioritized): {ordered_metric_list}") for metric in ordered_metric_list: try: folder_name = self.metric_folder_map.get(metric, "quality") metric_module = importlib.import_module(f'{folder_name}.{metric}') evaluate_func = getattr(metric_module, f'compute_{metric}') self.logger.info(f"Evaluating metric: {metric} (from {folder_name} folder)") results = evaluate_func( json_dir=info_json_path, device=self.device, source_videos_path=source_videos_path, target_videos_path=target_videos_path, **kwargs ) results_dict[metric] = results self.logger.info(f"Completed metric: {metric}, Average score: {results[0]:.4f}") except Exception as e: self.logger.error(f'Error in metric {metric}: {e}') results_dict[metric] = (0.0, []) output_csv = os.path.join(self.output_path, f'{name}_eval_results.csv') self.save_results_to_csv(results_dict, output_csv) return results_dict