| | import torch |
| | import torch.distributed as dist |
| | from vlmeval.config import supported_VLM |
| | from vlmeval.utils import track_progress_rich |
| | from vlmeval.smp import * |
| |
|
| | FAIL_MSG = 'Failed to obtain answer via API.' |
| |
|
| |
|
| | def parse_args(): |
| | parser = argparse.ArgumentParser() |
| | parser.add_argument('--data', type=str, nargs='+', required=True) |
| | parser.add_argument('--model', type=str, nargs='+', required=True) |
| | parser.add_argument('--nproc', type=int, default=4, required=True) |
| | parser.add_argument('--verbose', action='store_true') |
| | args = parser.parse_args() |
| | return args |
| |
|
| |
|
| | |
| | def infer_data_api(model, work_dir, model_name, dataset, samples_dict={}, api_nproc=4): |
| | rank, world_size = get_rank_and_world_size() |
| | assert rank == 0 and world_size == 1 |
| | dataset_name = dataset.dataset_name |
| | model = supported_VLM[model_name]() if isinstance(model, str) else model |
| | assert getattr(model, 'is_api', False) |
| |
|
| | indices = list(samples_dict.keys()) |
| | structs = [dataset.build_prompt(samples_dict[idx], video_llm=getattr(model, 'VIDEO_LLM', False)) for idx in indices] |
| |
|
| | packstr = 'pack' if getattr(dataset, 'pack', False) else 'nopack' |
| | if dataset.nframe > 0: |
| | out_file = f'{work_dir}/{model_name}_{dataset_name}_{dataset.nframe}frame_{packstr}_supp.pkl' |
| | else: |
| | out_file = f'{work_dir}/{model_name}_{dataset_name}_{dataset.fps}fps_{packstr}_supp.pkl' |
| | res = load(out_file) if osp.exists(out_file) else {} |
| |
|
| | structs = [s for i, s in zip(indices, structs) if i not in res or res[i] == FAIL_MSG] |
| | indices = [i for i in indices if i not in res or res[i] == FAIL_MSG] |
| |
|
| | gen_func = model.generate |
| | structs = [dict(message=struct, dataset=dataset_name) for struct in structs] |
| |
|
| | if len(structs): |
| | track_progress_rich(gen_func, structs, nproc=api_nproc, chunksize=api_nproc, save=out_file, keys=indices) |
| |
|
| | res = load(out_file) |
| | return res |
| |
|
| |
|
| | def infer_data(model, model_name, work_dir, dataset, out_file, verbose=False, api_nproc=4): |
| | res = load(out_file) if osp.exists(out_file) else {} |
| | rank, world_size = get_rank_and_world_size() |
| | dataset_name = dataset.dataset_name |
| |
|
| | sample_indices = list(dataset.videos) if getattr(dataset, 'pack', False) else list(dataset.data['index']) |
| | samples = list(dataset.videos) if getattr(dataset, 'pack', False) else list(range(len(dataset.data))) |
| | sample_map = {i: s for i, s in zip(sample_indices, samples)} |
| |
|
| | sample_indices_sub = sample_indices[rank::world_size] |
| | if np.all([idx in res for idx in sample_indices_sub]): |
| | return model |
| | sample_indices_subrem = [x for x in sample_indices_sub if x not in res] |
| |
|
| | model = supported_VLM[model_name]() if isinstance(model, str) else model |
| |
|
| | is_api = getattr(model, 'is_api', False) |
| | if is_api: |
| | assert world_size == 1 |
| | supp = infer_data_api( |
| | model=model, |
| | work_dir=work_dir, |
| | model_name=model_name, |
| | dataset=dataset, |
| | samples_dict={k: sample_map[k] for k in sample_indices_subrem}, |
| | api_nproc=api_nproc) |
| | for k in sample_indices_subrem: |
| | assert k in supp |
| | res.update(supp) |
| | dump(res, out_file) |
| | return model |
| |
|
| | assert not getattr(dataset, 'pack', False), 'Current model not supported pack mode!' |
| | for i, idx in tqdm(enumerate(sample_indices_subrem)): |
| | if idx in res: |
| | continue |
| | if getattr(model, 'nframe', None) is not None and getattr(model, 'nframe', 0) > 0: |
| | if dataset.nframe > 0: |
| | if getattr(model, 'nframe', 0) != dataset.nframe: |
| | print(f'{model_name} is a video-llm model, nframe is set to {dataset.nframe}, not using default') |
| | setattr(model, 'nframe', dataset.nframe) |
| | elif getattr(model, 'fps', 0) == 0: |
| | raise ValueError(f'fps is not suitable for {model_name}') |
| | else: |
| | setattr(model, 'nframe', None) |
| | if getattr(model, 'fps', None) is not None and getattr(model, 'fps', 0) > 0: |
| | if dataset.fps > 0: |
| | if getattr(model, 'fps', 0) != dataset.fps: |
| | print(f'{model_name} is a video-llm model, fps is set to {dataset.fps}, not using default') |
| | setattr(model, 'fps', dataset.fps) |
| | elif getattr(model, 'nframe', 0) == 0: |
| | raise ValueError(f'nframe is not suitable for {model_name}') |
| | else: |
| | setattr(model, 'fps', None) |
| | if 'SUB_DATASET' in dataset.data.iloc[sample_map[idx]]: |
| | dataset_name = dataset.data.iloc[sample_map[idx]]['SUB_DATASET'] |
| | if hasattr(model, 'use_custom_prompt') and model.use_custom_prompt(dataset_name): |
| | if dataset.nframe == 0: |
| | raise ValueError(f'nframe must be set for custom prompt, fps is not suitable for {model_name}') |
| | struct = model.build_prompt( |
| | dataset.data.iloc[sample_map[idx]], dataset=dataset, video_llm=getattr(model, 'VIDEO_LLM', False) |
| | ) |
| | else: |
| | struct = dataset.build_prompt( |
| | sample_map[idx], video_llm=getattr(model, 'VIDEO_LLM', False) |
| | ) |
| | response = model.generate(message=struct, dataset=dataset_name) |
| | torch.cuda.empty_cache() |
| |
|
| | if verbose: |
| | print(response, flush=True) |
| |
|
| | res[idx] = response |
| | if (i + 1) % 20 == 0: |
| | dump(res, out_file) |
| |
|
| | res = {k: res[k] for k in sample_indices_sub} |
| | dump(res, out_file) |
| | return model |
| |
|
| |
|
| | |
| | def infer_data_job_video( |
| | model, |
| | work_dir, |
| | model_name, |
| | dataset, |
| | result_file_name, |
| | verbose=False, |
| | api_nproc=4): |
| |
|
| | dataset_name = dataset.dataset_name |
| | rank, world_size = get_rank_and_world_size() |
| | result_file = osp.join(work_dir, result_file_name) |
| | |
| | if osp.exists(result_file): |
| | return model |
| |
|
| | tmpl = osp.join(work_dir, '{}' + f'{world_size}_{osp.splitext(result_file_name)[0]}.pkl') |
| | out_file = tmpl.format(rank) |
| |
|
| | model = infer_data( |
| | model=model, |
| | model_name=model_name, |
| | work_dir=work_dir, |
| | dataset=dataset, |
| | out_file=out_file, |
| | verbose=verbose, |
| | api_nproc=api_nproc) |
| |
|
| | if world_size > 1: |
| | dist.barrier() |
| |
|
| | if rank == 0: |
| | data_all = {} |
| | for i in range(world_size): |
| | data_all.update(load(tmpl.format(i))) |
| |
|
| | meta = dataset.data |
| | if dataset_name == 'MMBench-Video' and getattr(dataset, 'pack', False): |
| | meta, vstats = dataset.load_pack_answers(data_all) |
| | print(f'Statitics of Pack Video Inference: {vstats}') |
| | else: |
| | for x in meta['index']: |
| | assert x in data_all |
| | meta['prediction'] = [str(data_all[x]) for x in meta['index']] |
| | if 'image' in meta: |
| | meta.pop('image') |
| |
|
| | dump(meta, result_file) |
| | for i in range(world_size): |
| | os.remove(tmpl.format(i)) |
| | return model |
| |
|
