author-code-snapshot/construct_dataset.py

#!/usr/bin/env python3

import argparse
import csv
import glob
import json
import os
import string
import random
import gc
from datetime import datetime
from collections import Counter
from typing import Any, Dict, Iterable, List, Sequence, Tuple,  Optional
import traceback
import pandas as pd
import torch
from tqdm import tqdm
from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
import sys
import os
from src.utils import load_model_and_validate_gpu,MODEL2HF,DATA2HF
from src.construct_dataset_utils import load_hotpotqa,load_triviaqa,load_coqa,load_nq,build_prompt,postprocess_answers,measure_correctness,load_math,load_squad,reevaluate_label,remove_NAN,re_post_process, load_psiloqa, load_halueval_summary, load_cnn_dailymail
# Get current file path
from pathlib import Path
PROJECT_PATH = str(Path.cwd())
MODEL_CACHE_DIR = "path2model"
Data_CACHE_DIR = "path2dataset"
def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "-m",
        "--model",
        default="llama_instruct",
        choices=MODEL2HF.keys(),
        help="model name.",
    )
    parser.add_argument(
        "-d",
        "--dataset",
        default="halueval_summary",
        choices=DATA2HF.keys(),
        help="dataset name. ",
    )
    parser.add_argument(
        "--max-new-tokens",
        type=int,
        default=30,
        dest="max_new_tokens",
        help="Maximum number of tokens to generate per answer.",
    )
    parser.add_argument(
        "-zs",
        "--zero-shot",
        type=bool,
        default=True,
        help="Use zero-shot (True) or 5-shot (False) prompting. only for triviaqa and hotpotqa",
    )
    parser.add_argument(
        "--questions-per-story",
        type=int,
        default=5,
        help="Number of questions to answer per story (default: 4). This argument is for CoQA only.",
    )
    parser.add_argument(
        "--split",
        choices=['train','test'],
        default="train",
        help="Dataset split.",
    )
    parser.add_argument(
        "--basepath_2_save",
        default=f"{PROJECT_PATH}/prepared_data",
        help="Optional path to write CSV with columns: context,gold_answer,sampled_answers.",
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=2024,
        help="Random seed for sampling-based decoding.",
    )
    parser.add_argument(
        "--single_gpu",
        action="store_true",
        help="Whether to use only a single GPU (if multiple are available).",
    )
    parser.add_argument(
        "--model-cache-dir",
        default=MODEL_CACHE_DIR,
        help="Cache directory for loading/storing model weights.",
    )
    parser.add_argument(
        "--data-cache-dir",
        default=Data_CACHE_DIR,
        help="Cache directory for downloading the CoQA dataset.",
    )
    parser.add_argument(
        "-b",
        "--batch-size",
        type=int,
        default=5,
        help="Batch size for question prompts.",
    )
    parser.add_argument(
        "--reevaluate",        
        action="store_true",   
    )
    parser.add_argument(                                                                                                                                                                                          
        "--repost",        
        action="store_true",   
    )
    parser.add_argument("--num_answers",default=10,type=int,help="number of answers to sample per question")
    parser.add_argument("--all_data",action='store_true')
    parser.add_argument("--all_split",action='store_true')
    parser.add_argument("--fs",action='store_true',help="use first sentence truncation")
    parser.add_argument("--all_model",action='store_true')
    return parser.parse_args()


def generate_answers_batch(
    args,
    model: AutoModelForCausalLM,
    tokenizer: AutoTokenizer,
    prompts: List[str],
    device,
) -> Tuple[List[List[str]], List[str]]:
    num_answers = args.num_answers
    stop_token_id=[
        tokenizer.encode('\n', add_special_tokens=False)[-1], 
        ]
    bad_tokens = ['Context','Question', 'Answer','Question:', 'Answer:', 'Q:','//','://','.Forms','_REF_','_REF','php','https','\\']

    question_framing_ids = [[tokenizer(bad_token)['input_ids'][-1]] for bad_token in bad_tokens]
    assert num_answers >= 1, "num_answers must be >= 1"
    batch_size = args.batch_size
    max_new_tokens = args.max_new_tokens
    # sort prompts by length for efficiency
    tok_all = tokenizer(
        prompts,
        padding=False,
        truncation=False,
        return_length=True,
        add_special_tokens=True,
    )
    lengths = tok_all["length"]
    order = sorted(range(len(prompts)), key=lambda i: lengths[i], reverse=True)
    prompts_sorted = [prompts[i] for i in order]
    
    bucketed_samples: Dict[int, List[str]] = {}
    bucketed_best: Dict[int, str] = {}

    for start in tqdm(range(0, len(prompts_sorted), batch_size),desc="Generating Responses"):
        batch_prompts = prompts_sorted[start:start + batch_size]
        enc = tokenizer(
            batch_prompts,
            return_tensors="pt",
            padding=True,
        )
        input_device = model.get_input_embeddings().weight.device
        enc = {k: v.to(input_device) for k, v in enc.items()}

        # ---------- 1) multi-sample generation for uncertainty estimation ----------
        gen_kwargs = dict(
            **enc,
            max_new_tokens=max_new_tokens,
            min_new_tokens=1,
            do_sample=True,
            num_return_sequences=num_answers,
            # eos_token_id=stop_token_id,
            pad_token_id=tokenizer.pad_token_id,
            use_cache=True,
            temperature=1.0,
            top_p=0.9,
            top_k=30,
            bad_words_ids=question_framing_ids,
        )

        with torch.inference_mode():
            out = model.generate(**gen_kwargs)

        sequences = out if isinstance(out, torch.Tensor) else out.sequences
        sequences = sequences.to("cpu")
        del out

        Lmax = enc["input_ids"].shape[1]
        gen_only = sequences[:, Lmax:]
        texts = tokenizer.batch_decode(gen_only, skip_special_tokens=True)

        B_actual = len(batch_prompts)
        assert len(texts) == B_actual * num_answers

        grouped_samples: List[List[str]] = []
        for i in range(B_actual):
            cur = texts[i * num_answers:(i + 1) * num_answers]
            if args.fs:
                grouped_samples.append(postprocess_answers(cur,args.model))
            else:
                if args.dataset in ['halueval_summary', 'cnn_dailymail']:
                    #truncate to the first line
                    cur=[s.split('\n')[0].strip() for s in cur]
                grouped_samples.append([s.strip() for s in cur])
                


        # ---------- 2) “best answer” (one per prompt) ----------
        best_kwargs = dict(
            **enc,
            max_new_tokens=max_new_tokens,
            min_new_tokens=1,
            do_sample=True,          # low-temperature sampling; set False for greedy decoding
            num_return_sequences=1,
            # eos_token_id=stop_token_id,
            pad_token_id=tokenizer.pad_token_id,
            use_cache=True,
            temperature=0.1,
            # top_p=0.9,
            # top_k=30,
            bad_words_ids=question_framing_ids,
        )

        with torch.inference_mode():
            out_best = model.generate(**best_kwargs)

        seq_best = out_best if isinstance(out_best, torch.Tensor) else out_best.sequences
        seq_best = seq_best.to("cpu")
        del out_best

        gen_only_best = seq_best[:, Lmax:]
        best_sampled = tokenizer.batch_decode(gen_only_best, skip_special_tokens=True)
        assert len(best_sampled) == B_actual
        if args.fs:
            best_texts = postprocess_answers(best_sampled,args.model)
        else:
            if args.dataset in ['halueval_summary', 'cnn_dailymail']:
                #truncate to the first line
                best_sampled=[s.split('\n')[0].strip() for s in best_sampled]
            best_texts=[s.strip() for s in best_sampled]

        # ---------- 3) write into buckets ----------
        for i in range(B_actual):
            sorted_idx = start + i
            bucketed_samples[sorted_idx] = grouped_samples[i]
            bucketed_best[sorted_idx] = best_texts[i]

    # ---------- 4) restore original order ----------
    inv = [0] * len(order)
    for new_idx, old_idx in enumerate(order):
        inv[old_idx] = new_idx

    samples: List[List[str]] = []
    best_answers: List[str] = []
    for orig_i in range(len(prompts)):
        sorted_pos = inv[orig_i]
        samples.append(bucketed_samples[sorted_pos])
        best_answers.append(bucketed_best[sorted_pos])

    return samples, best_answers


def load_data(args):
    """Load and shuffle the requested dataset split."""
    context=None
    if args.dataset=="triviaqa":
        dataset=load_triviaqa(args)
    elif args.dataset=="hotpotqa":
        dataset= load_hotpotqa(args)
    elif args.dataset=="coqa":
        dataset = load_coqa(args)
    elif args.dataset=='squad':
        dataset= load_squad(args)
    elif args.dataset=='psiloqa':
        dataset= load_psiloqa(args)
    elif args.dataset=='halueval_summary':
        dataset= load_halueval_summary(args)
    elif args.dataset=='cnn_dailymail':
        dataset = load_cnn_dailymail(args)
    else:
        raise NotImplementedError(f"Dataset {args.dataset} not implemented yet.")

    return dataset


def main(args) -> None:
    # init_wandb(args)
    set_seed(args.seed)
    random.seed(args.seed)
    # load data and model 
    dataset_iter= load_data(args)
    model, tokenizer = load_model_and_validate_gpu(MODEL2HF[args.model],cache_dir=args.model_cache_dir, single_gpu=args.single_gpu)
    device = "cuda" if torch.cuda.is_available() else "cpu"
    tokenizer.padding_side='left'
    tokenizer.pad_token = tokenizer.eos_token
    prompts_all= build_prompt(args, dataset_iter)

    # 2) Batched generation across all prompts  
    sampled_answer,best_answer = generate_answers_batch(
        args,
        model=model,
        tokenizer=tokenizer,
        prompts=prompts_all,
        device=device,
    )
    assert len(sampled_answer) == len(best_answer)
    dataset_iter = dataset_iter.add_column("candidate_answers", sampled_answer)
    dataset_iter = dataset_iter.add_column("best_answer", best_answer)

    del model
    del tokenizer
    gc.collect()
    torch.cuda.empty_cache()

    labels= measure_correctness(dataset_iter, args)
    dataset_iter = dataset_iter.add_column("label", labels)

    df_clean=remove_NAN(dataset_iter)

    df_clean['candidate_answers']=df_clean['candidate_answers'].apply(lambda x: x.tolist())
    df_clean['answers']=df_clean['answers'].apply(lambda x: x.tolist())
    json_output_dir = os.path.join(args.basepath_2_save, args.model, args.dataset)
    os.makedirs(json_output_dir, exist_ok=True)
    json_output = os.path.join(json_output_dir, f"{args.split}_data.jsonl")

    df_clean.to_json(
        json_output,
        orient="records",   # one object per record
        lines=True,         # jsonl format: one json per line
        # force_ascii=False   # preserve non-ASCII characters
    )
    print(f"Saved to {json_output}")
    

if __name__ == "__main__":
    args = parse_args()
    def process_task(args):
        gpu_name = torch.cuda.get_device_name(0)
        # if args.dataset in ['coqa','squad','psiloqa','halueval_summary']:
        if args.dataset in ['coqa','squad',]:
            args.batch_size=16 if gpu_name=='NVIDIA RTX A6000' else 16
        elif args.dataset in['psiloqa','halueval_summary','cnn_dailymail']:
            args.batch_size=8 if gpu_name=='NVIDIA RTX A6000' else 8
            if '14b' in args.model:
                args.batch_size=4 
        else:
            args.batch_size=32 if gpu_name=='NVIDIA RTX A6000' else 32
        if args.dataset in ['halueval_summary', 'cnn_dailymail']:
            args.max_new_tokens=130
        try: 
            if args.reevaluate:
                reevaluate_label(args)
            elif args.repost:
                re_post_process(args)
                reevaluate_label(args)
            else:
                main(args)
            gc.collect()
            torch.cuda.empty_cache()
        except Exception as e:
            traceback.print_exc()

    def split_judge(args):
        if args.all_split:
            for split in ['test','train']:
                args.split=split
                process_task(args)
        else:
            process_task(args)
            
    def all_data_judge(args):
        if args.all_data:
            for dataset_name in ['squad','coqa','hotpotqa','triviaqa','psiloqa',]:

                args.dataset=dataset_name
                split_judge(args)
        else:
            split_judge(args)

    if args.all_model:
        for model_name in ['llama_instruct','mistral_instruct']:
            args.model=model_name
            all_data_judge(args)
    else:
        all_data_judge(args)