| import torch |
| import torch.nn as nn |
| import os |
|
|
| from .models import EvalEditModel |
| from .preprocess import Processor |
| import yaml |
| import argparse |
| import random |
| import numpy as np |
|
|
|
|
| device='cuda' |
| class VEBenchModel(nn.Module): |
| def __init__(self, seed=42): |
| super().__init__() |
| |
| random.seed(seed) |
| np.random.seed(seed) |
| torch.manual_seed(seed) |
| np.random.seed(seed) |
| torch.cuda.manual_seed_all(seed) |
| |
| base_dir = os.path.dirname(os.path.abspath(__file__)) |
| |
| dover_config = os.path.join(base_dir, 'configs', 'dover.yaml') |
| doublestream_config = os.path.join(base_dir, 'configs', 'doublestream.yaml') |
| text_config = os.path.join(base_dir, 'configs', 'text.yaml') |
| |
| |
|
|
| with open(dover_config, "r") as f: |
| dover_opt = yaml.safe_load(f) |
| with open(doublestream_config, "r") as f: |
| doublestream_opt = yaml.safe_load(f) |
| with open(text_config, "r") as f: |
| text_opt = yaml.safe_load(f) |
| self.model = EvalEditModel(dover_opt, doublestream_opt, text_opt).cuda() |
| self.traditional_processor=Processor(dover_opt['data']['videoQA']['args']) |
| self.text_pocessor=Processor(text_opt['data']['videoQA']['args']) |
| self.doublestream_processor=Processor(doublestream_opt['data']['videoQA']['args']) |
|
|
| |
| def read_data(self, path): |
| traditional_data=self.traditional_processor.preprocess(path) |
| text_data=self.text_pocessor.preprocess(path) |
| doublestream_data = self.doublestream_processor.preprocess(path) |
| data={} |
| for branch_data in[traditional_data,text_data,doublestream_data]: |
| for key in branch_data.keys(): |
| data[key]=branch_data[key] |
| return data |
| |
| |
| @torch.no_grad() |
| def evaluate(self, prompt, src_path, dst_path): |
| src_video = self.read_data(src_path) |
| dst_video = self.read_data(dst_path) |
| result = self.model(src_video, dst_video, prompt) |
| return result |
|
|
| if __name__ == "__main__": |
|
|
| parser = argparse.ArgumentParser(description='Process video files with VEBenchModel.') |
|
|
|
|
| parser.add_argument('--single_test', action='store_true', help='Run a single test with specified paths and prompt.') |
| parser.add_argument('--src_path', type=str, help='Source video path for single test.') |
| parser.add_argument('--dst_path', type=str, help='Destination video path for single test.') |
| parser.add_argument('--prompt', type=str, help='Prompt for single test.') |
| parser.add_argument('--data_path', type=str, help='Data path for batch processing.') |
| parser.add_argument('--label_path', type=str, help='Label path for batch processing.') |
|
|
|
|
| args = parser.parse_args() |
|
|
|
|
| if args.single_test: |
| if args.src_path and args.dst_path and args.prompt: |
| src_path = args.src_path |
| dst_path = args.dst_path |
| prompt = args.prompt |
| ebench = VEBenchModel() |
| result = ebench.evaluate(prompt, src_path, dst_path) |
| print(f"The result is {result}") |
| else: |
| print("Error: For single test, --src_path, --dst_path, and --prompt must be provided.") |
| else: |
| if args.data_path and args.label_path: |
| data_path = args.data_path |
| label_path = args.label_path |
| src=[] |
| dst=[] |
| prompts=[] |
| with open(label_path,'r') as file: |
| for line in file: |
| video_name,_,prompt=line.split('|') |
| src+=[data_path+"src/"+video_name] |
| dst += [data_path + "edited/" + video_name] |
| prompts+=[prompt] |
| ebench = EBenchModel() |
| results=[] |
| for src_path,dst_path,prompt in zip(src,dst,prompts): |
| result = ebench.evaluate(prompt, src_path, dst_path) |
| results+=[result] |
| print(len(results)) |
| with open("label.txt","w") as file: |
| for src_path,result in zip(src,results): |
| file.write(f"{src_path.split('/')[-1]},{result}\n") |
| else: |
| print("Error: For batch test, --data_path, --label_path must be provided.") |
|
|
