Add author code snapshot at def3cb6

c28f0c7 verified 3 months ago

13.2 kB

#!/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)
            

	#!/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)