EMMA/generate_response.py

import argparse
import json
import os
import logging
from tqdm import tqdm
from models.qwen import Qwen_vllm_Model
from datasets import load_dataset, concatenate_datasets
from data_utils import load_yaml, verify_response, build_query

def do_generate(dataset_name, model_path, output_path, subject=['Math', 'Physics', 'Chemistry', 'Coding'], split='test', config_path='/user/konglingyu/VLMEvalKit/EMMA/configs/gpt.yaml', strategy='TrainCoT', save_every=20, rerun=False, greedy=0, max_tokens=4096, ngpu=1, logger=logging.getLogger(__name__), seed=42):
    # Load Dataset
    logger.info(f"Loading dataset {dataset_name}, subject: {subject}")
    sub_dataset_list = []
    for subj in subject:
        sub_dataset = load_dataset(dataset_name, subj, split=split)
        sub_dataset_list.append(sub_dataset)
    dataset = concatenate_datasets(sub_dataset_list)

    # Load Config
    logger.info(f"Loading config")
    config = load_yaml(config_path)

    # Load Model
    # If we were given a custom path, load that model, otherwise use a remote service model
    logger.info(f"Loading local model {model_path}")
    device = 0
    world_size = 1
    try:
        device = int(os.environ["LOCAL_RANK"])
        world_size = int(os.environ["WORLD_SIZE"])
        dist_keys = [
            "RANK",
            "LOCAL_RANK",
            "WORLD_SIZE",
            "LOCAL_WORLD_SIZE",
            "GROUP_RANK",
            "ROLE_RANK",
            "ROLE_NAME",
            "OMP_NUM_THREADS",
            "MASTER_ADDR",
            "MASTER_PORT",
            "TORCHELASTIC_USE_AGENT_STORE",
            "TORCHELASTIC_MAX_RESTARTS",
            "TORCHELASTIC_RUN_ID",
            "TORCH_NCCL_ASYNC_ERROR_HANDLING",
            "TORCHELASTIC_ERROR_FILE",
        ] 

        for dist_key in dist_keys:
            del os.environ[dist_key]
    except:
        pass
    
    if world_size > 1:
        assert ngpu==1
    
    model = Qwen_vllm_Model(model_path, greedy=greedy, max_tokens=max_tokens, parallel=ngpu, seed=seed, device=device)

    logger.info(f"Model loaded!")

    if world_size > 1:
        logger.info(f"Using distributed mode with {world_size} GPUs, device {device}")
        output_path = output_path.replace('.json', f'_{device}.json')
    else:
        logger.info(f"Using single GPU mode")
    logger.info(f"Output path: {output_path}")

    if os.path.exists(output_path):
        logger.info("Results already exists.")
        logger.info(f"Reading {output_path}")
        with open(output_path, 'r') as f:
            results = json.load(f)
    else:
        results = {}

    skip_pids = []
    if not rerun and results:
        for pid, data in results.items():
            if 'response' in data and verify_response(data['response']):
                skip_pids.append(pid)

        if len(skip_pids) > 0:
            logger.info(
                f"Found existing results file with {len(skip_pids)} problems with valid responses. Skipping these problems...")

    logger.info(f"Starting to generate.....")
    for idx, sample in enumerate(tqdm(dataset)):
        pid = sample['pid']
        if skip_pids and pid in skip_pids:
            continue
        if idx % world_size != device:
            continue
        sample = build_query(sample, config, strategy)
        problem: dict = sample.copy()
        for i in range(1, 6):
            problem.pop('image_' + str(i))

        try:
            response = model.get_response(sample)
            results[pid] = problem
            results[pid]['response'] = response
        except Exception as e:
            logger.error(f"Error in generating answer for {pid}")
            logger.error(e)
            results[pid] = problem
            results[pid]['error'] = str(e)

        if idx == 2 or (idx % save_every == 0 and idx > 0) or idx == len(dataset) - 1:
            try:
                with open(output_path, 'w') as f:
                    f.write(json.dumps(results, indent=2))
                logger.info(f"Save results to {output_path}")
            except Exception as e:
                logger.info(f"Error in saving {output_path}")
                logger.info(e)
    
    with open(output_path, 'w') as f:
        f.write(json.dumps(results, indent=2))
    logger.info(f"Save results to {output_path}")

    logger.info("End Generation......")

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--dataset_name', type=str, default='/root/LMUData/EMMA-mini')
    parser.add_argument('--subject', nargs='+', type=str, default=['Math', 'Physics', 'Chemistry', 'Coding'])
    parser.add_argument('--split', type=str, default='test')
    parser.add_argument('--strategy', type=str, default='CoT', choices=['CoT', 'Direct', 'TrainCoT'])
    parser.add_argument('--config_path', type=str, default="configs/gpt.yaml")
    parser.add_argument('--output_path', type=str, default='results/test-full.json')
    parser.add_argument('--save_every', type=int, default=20, help='save every n problems')
    parser.add_argument('--rerun', action='store_true', help='rerun the answer generation')
    # Local model
    parser.add_argument('--model_path', type=str, default='/user/konglingyu/ckpts/Qwen2-VL-7B', help="local model path or huggingface model name")
    parser.add_argument('--max_tokens', type=int, default=4096)
    parser.add_argument('--greedy', type=int, default=0)
    parser.add_argument('--ngpu', type=int, default=1)

    args = parser.parse_args()
    do_generate(
        dataset_name=args.dataset_name,
        model_path=args.model_path,
        output_path=args.output_path,
        subject=args.subject,
        split=args.split,
        config_path=args.config_path,
        strategy=args.strategy,
        save_every=args.save_every,
        rerun=args.rerun,
        greedy=args.greedy,
        max_tokens=args.max_tokens,
        ngpu=args.ngpu
    )
    


if __name__ == "__main__":
    logging.basicConfig(
        level=os.environ.get("LOGLEVEL", "INFO").upper(),
        format="[%(name)s] %(message)s",
        datefmt="[%X]"
    )
    logger_blocklist = [
        "asyncio",
        "azure",
        "azureml",
        "datasets",
        "httpx",
        "httpcore",
        "filelock",
        "fsspec",
        "msal",
        "msrest",
        "openai",
        "PIL",
        "urllib3",
    ]
    for module in logger_blocklist:
        logging.getLogger(module).setLevel(logging.WARNING)
    if not os.path.exists("/root/LMUData"):
        os.symlink("/user/konglingyu/LMUData", "/root/LMUData")
    main()