import json, os, torch, functools, tqdm, random, sys, argparse import numpy as np import decord from torch.utils.data import Dataset from transformers import Trainer, TrainingArguments, logging, Qwen2VLForConditionalGeneration, AutoProcessor, Qwen2_5_VLForConditionalGeneration from livecc_utils import _read_video_decord_plus, _spatial_resize_video from qwen_vl_utils.vision_process import process_vision_info, smart_nframes, FPS logger = logging.get_logger(__name__) # HF-style logger def _read_may1fps_video_decord(ele: dict): """read video using decord.VideoReader. can handle more cases compared to _read_video_decord. Args: ele (dict): a dict contains the configuration of video. support keys: - video: the path of video. support "file://", "http://", "https://" and local path. - video_start: the start time of video. - video_end: the end time of video. Returns: torch.Tensor: the video tensor with shape (T, C, H, W). sample_fps clip_pts if return_pts=True """ video_path = ele["video"] if os.path.exists(video_path): vr = decord.VideoReader(video_path, num_threads=2) else: raise ValueError(f'video_path {video_path} not found') video_start = ele.get('video_start', None) video_end = ele.get('video_end', None) video_fps = vr.get_avg_fps() clip_idxs, clip_pts = None, None if video_start is not None or video_end is not None: vr.get_frame_timestamp(0) video_pts = vr._frame_pts[:,1] video_start = video_pts[0] if not video_start else video_start video_end = video_pts[-1] if not video_end else video_end video_start = min(max(video_pts[0], video_start), video_pts[-1]) video_end = min(max(video_pts[0], video_end), video_pts[-1]) video_end = max(video_start + 1, video_end) clip_idxs = ((video_start <= video_pts) & (video_pts <= video_end)).nonzero()[0] total_frames = len(clip_idxs) else: total_frames = len(vr) total_frames_for_smart_nframes = total_frames video_fps_for_smart_nframes = video_fps if total_frames < 2: total_frames_for_smart_nframes = 2 if video_fps < FPS: total_frames_for_smart_nframes = int(total_frames * FPS / video_fps) video_fps_for_smart_nframes = FPS nframes = smart_nframes(ele, total_frames=total_frames_for_smart_nframes, video_fps=video_fps_for_smart_nframes) nframes_idxs = np.linspace(0, total_frames - 1, nframes).round().astype(int) clip_idxs = nframes_idxs if clip_idxs is None else clip_idxs[nframes_idxs] clip = torch.from_numpy(vr.get_batch(clip_idxs).asnumpy()).permute(0, 3, 1, 2) # Convert to TCHW format sample_fps = len(clip_idxs) / max(total_frames, 1e-6) * video_fps return clip, sample_fps def save_function_print(function: callable, save_path: str, *args, **kwargs): original_stdout = sys.stdout try: with open(save_path, 'w') as f: sys.stdout = f function(*args, **kwargs) finally: sys.stdout = original_stdout class OvoBenchMCQDataset(Dataset): def __init__(self, path, question_prefix, question_postfix, answer_prefix, sample: int = None): lines = open(path).readlines() if sample is not None: random.seed(42) lines = random.sample(lines, sample) self.datums = [json.loads(line) for line in tqdm.tqdm(lines, desc='load datums')] if isinstance(self.datums[0], str): self.datums = [json.loads(datum) for datum in tqdm.tqdm(self.datums, desc='load datumsx2')] self.question_prefix = question_prefix self.question_postfix = question_postfix self.answer_prefix = answer_prefix self.data_dir = os.path.dirname(path) def __len__(self): return len(self.datums) def __getitem__(self, i): datum = self.datums[i] conversation = [{"role": "user", "content": []}] video_inputs = None if datum['task'] in ['REC', 'SSR', 'CRR']: # 'REC', 'SSR', 'CRR' have already been chunked query = datum['question'] else: query = self.question_prefix + datum['question'] + '\n' + '\n'.join(datum['options']) + self.question_postfix video, _ = _read_may1fps_video_decord({ 'video': os.path.join(self.data_dir, datum['video']), 'video_start': datum['video_start'], 'video_end': datum['video_end'] }) video = _spatial_resize_video(video) conversation[0]['content'].append({"type": "video", "video": video}) video_inputs = [video] conversation[0]['content'].append({"type": "text", "text": query}) if video_inputs is None: for _ in range(10): try: _, video_inputs = process_vision_info(conversation) break except: print(f"{_}-th process_vision_info failed. retry...") return conversation, video_inputs[0] def data_collator(self, batch, processor): conversations, video_inputs = zip(*batch) texts = processor.apply_chat_template(conversations, tokenize=False, add_generation_prompt=True) texts = [text + self.answer_prefix for text in texts] inputs = processor( text=texts, images=None, videos=list(video_inputs), padding=True, return_tensors="pt", ) return inputs def preprocess_logits_for_metrics(logits, labels, strict_option_ids): return torch.stack([logit[(logit[:, 0] != -100).nonzero().squeeze()[-1], strict_option_ids] for logit in logits]).argmax(dim=-1) def mcq_predict( model, processor, benchmark_path: str, options: list[str], question_prefix: str = '', question_postfix: str = '\nPlease select the correct answer.', answer_prefix: str = 'Answer:', abcd_previous_str: str = ': ', use_liger_kernel: bool = True, per_device_eval_batch_size: int = 1, dataloader_num_workers: int = 4, ): strict_option_ids = [processor.tokenizer(f'{abcd_previous_str}{_}').input_ids[-1] for _ in options] dataset = OvoBenchMCQDataset(benchmark_path, question_prefix=question_prefix, question_postfix=question_postfix, answer_prefix=answer_prefix) trainer = Trainer( model=model, args=TrainingArguments( output_dir='outputs/', do_predict=True, per_device_eval_batch_size=per_device_eval_batch_size, dataloader_num_workers=dataloader_num_workers, report_to='none', use_liger_kernel=use_liger_kernel ), data_collator=functools.partial(dataset.data_collator, processor=processor), processing_class=processor, preprocess_logits_for_metrics=functools.partial(preprocess_logits_for_metrics, strict_option_ids=strict_option_ids), ) letter_idxs_predictions = trainer.predict(dataset, ignore_keys=['past_key_values', 'hidden_states', 'attentions', 'rope_deltas']).predictions return letter_idxs_predictions, dataset.datums, trainer.args.process_index def evaluate_ovobench_results(results: list): task_to_counts = {} for result in results: task = result['task'] if task not in task_to_counts: task_to_counts[task] = {'correct': 0, 'total': 0} task_to_counts[task]['total'] += 1 if result['response'][:len(result['answer'])] == result['answer']: task_to_counts[task]['correct'] += 1 rt_accs, bt_accs, fr_accs = [], [], [] for task, counts in task_to_counts.items(): print(f'{task}: {counts["correct"]}/{counts["total"]}={counts["correct"]/counts["total"]}') if task in ['OCR', 'ACR', 'ATR', 'STU', 'FPD', 'OJR']: rt_accs.append(counts['correct']/counts['total']) elif task in ['EPM', 'ASI', 'HLD']: bt_accs.append(counts['correct']/counts['total']) else: fr_accs.append(counts['correct']/counts['total']) if rt_accs: print(f'Real-Time Visual Perception avg.: {sum(rt_accs)}/{len(rt_accs)}={sum(rt_accs)/len(rt_accs)}') if bt_accs: print(f'Backward Tracing avg.: {sum(bt_accs)}/{len(bt_accs)}={sum(bt_accs)/len(bt_accs)}') if fr_accs: print(f'Forward Tracing avg.: {sum(fr_accs)}/{len(fr_accs)}={sum(fr_accs)/len(fr_accs)}') if __name__ == '__main__': parser = argparse.ArgumentParser(description="Format OVO-Bench dataset JSONL file.") parser.add_argument("--benchmark_dir", type=str, required=True, help="Path to ovobench dir.") parser.add_argument("--model_path", type=str, required=True, help="Path to model dir.") args = parser.parse_args() benchmark_path = os.path.join(args.benchmark_dir, 'ovo-bench-formatted.jsonl') model_path = args.model_path try: model = Qwen2_5_VLForConditionalGeneration.from_pretrained(model_path, torch_dtype="auto", attn_implementation='flash_attention_2') except: model = Qwen2VLForConditionalGeneration.from_pretrained(model_path, torch_dtype="auto", attn_implementation='flash_attention_2') processor = AutoProcessor.from_pretrained(model_path, padding_side='left') options = ['No', 'Yes', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E'] letter_idxs_predictions, benchmark_datums, process_index = mcq_predict( model=model, processor=processor, benchmark_path=benchmark_path, options=options, use_liger_kernel='LiveCC' in model_path, answer_prefix = 'The answer is:\n', abcd_previous_str = '\n', ) if process_index == 0: results = [] for datum, letter_idx_prediction in zip(benchmark_datums, letter_idxs_predictions): results.append({ 'id': datum['id'], "task": datum['task'], "question": datum['question'], "answer": datum['answer'], "response": options[letter_idx_prediction], }) save_json_path = f'results/ovobench/{os.path.basename(model_path)}.json' os.makedirs(os.path.dirname(save_json_path), exist_ok=True) json.dump(results, open(save_json_path, 'w')) save_txt_path = save_json_path.replace('.json', '.txt') save_function_print( evaluate_ovobench_results, save_txt_path, results )