import os # from openai import OpenAI # if "OPENAI" in os.environ: # print('Loaded OPENAI Key.') # else: # print('Can not load the OPENAI key.') # client = OpenAI(api_key = os.environ['OPENAI']) import pandas as pd from huggingface_hub import hf_hub_download # from lib.MMMU.eval.utils.data_utils import save_json, CAT_SHORT2LONG print('current dir:', os.getcwd()) # list all files and folders in the current directory print('list all files and folders in the current directory:', os.listdir()) # from lib.MMMU.eval.utils.eval_utils import evaluate, parse_multi_choice_response, parse_open_response, calculate_ins_level_acc import numpy as np import tqdm import torch import re from torch import bfloat16 from transformers import AutoModelForCausalLM, AutoTokenizer import json from tqdm import tqdm # from eval_mixtral import LLM_eval, creat_prompt # from eval_mixtral import creat_prompt # from llm_evaluator import chat_llm from dotenv import load_dotenv from genai.client import Client from genai.credentials import Credentials from genai.schema import ( DecodingMethod, HumanMessage, ModerationHAP, ModerationHAPInput, ModerationHAPOutput, ModerationParameters, SystemMessage, TextGenerationParameters, ) from genai.text.generation import CreateExecutionOptions load_dotenv() ####################################################################################### ####################################################################################### ############################ Mixtral eval ############################################ ####################################################################################### ####################################################################################### def heading(text: str) -> str: """Helper function for centering text.""" return "\n" + f" {text} ".center(80, "=") + "\n" def chat_llm_batch(model_id, prompts, limit= 20): parameters = TextGenerationParameters( decoding_method=DecodingMethod.SAMPLE, max_new_tokens=128, min_new_tokens=30, temperature=0, top_k=50, top_p=1, random_seed=42 ) client = Client(credentials=Credentials.from_env()) response_list = [] for response in client.text.generation.create( model_id = model_id, inputs = prompts, # here each prompt is the concatenation of system prompt and user prompt execution_options=CreateExecutionOptions(concurrency_limit=limit, ordered=False), parameters=parameters, ): response_list.append(response.results[0].generated_text) return response_list def creat_prompt(model_id, tokenizer=None, question=None, answer=None, pred=None,): messages = [ { "role": "system", "content": "You are an intelligent chatbot designed for evaluating the correctness of generative outputs for question-answer pairs. " "Your task is to compare the predicted answer with the correct answer and determine if they match meaningfully. Here's how you can accomplish the task:\n" "------\n" "##INSTRUCTIONS:\n" "- Focus on the meaningful match between the predicted answer and the correct answer.\n" "- Consider synonyms or paraphrases as valid matches.\n" "- Evaluate the correctness of the prediction compared to the answer." }, { "role": "user", "content": "Please evaluate the following question-answer pair:\n\n" f"Question: {question.capitalize()}\n" f"Correct Answer: {answer.lower()}\n" f"Predicted Answer: {pred.lower()}\n\n" "Evaluate if the answer is correct with yes/no and assign a correctness score between 0 and 5, where 0 indicates incorrect answer, and 5 signifies the highest meaningful match. " "Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING. " "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. " "For example, your response should look like this: {'pred': 'no', 'score': 0}." } ] if 'mistralai' in model_id: prompt = f'[INST] {messages[0]["content"].strip()}\n\n{messages[1]["content"].strip()} [/INST]' elif 'NousResearch' in model_id: prompt = tokenizer.apply_chat_template(messages, tokenize=False) prompt = prompt + '<|im_start|>assistant' elif 'api' in model_id: prompt = messages else: raise NotImplementedError return prompt ## Mixtral Evaluation def mixtral_eval_api(submission_dict_of_dict, solution_dict_of_dict, category=None, model_id = "mistralai/mixtral-8x7b-instruct-v01", batch_size = 16, category_to_sample_ids_dict = None, answer_dict_for_mixtral_eval = None, limit = None, return_score = False): id_list = category_to_sample_ids_dict[category] examples_to_eval = [] evals = [] sample_id_list = [] # for row, output in submission_dict_of_dict.iterrows(): for output_id, output in submission_dict_of_dict.items(): if output_id in id_list: sample_id_list.append(output_id) # assert len(sample_id_list) == len( # id_list), f'For dataset {category}, the number of submitted samples ({len(sample_id_list)}) and the number of samples in this dataset ({len(id_list)}) are not the same!' steps = int(np.ceil(len(sample_id_list) / batch_size)) for step in tqdm(range(steps)): prompts = [] # put prompts of a batch of samples into a list for item in sample_id_list[step * batch_size: (step + 1) * batch_size]: # sample_key = submission_dict_of_dict.iloc[item]['id'] # answer = str(submission_dict_of_dict.iloc[item]['pred']) # label = str(solution_dict_of_dict.iloc[item]['pred']) output_id = item sample_key = output_id answer = str(submission_dict_of_dict[output_id]['pred']) label = str(solution_dict_of_dict[output_id]['pred']) # print( f'sample_key: {sample_key}, answer: {answer}') gt_answer = label pred_answer = answer question = answer_dict_for_mixtral_eval[sample_key]['question'] examples_to_eval.append({ 'id': sample_key, "question_type": answer_dict_for_mixtral_eval[sample_key]['question_type'], 'answer': gt_answer, 'question': question, 'parsed_pred': pred_answer, }) # the system prompt and user prompt are concatenated prompt = creat_prompt(model_id='mistralai', question=question, answer=gt_answer, pred=pred_answer) prompts.append(prompt) response_list = chat_llm_batch(model_id, prompts, limit=limit) evals.extend(response_list) judge_dict = {} pred_correct = 0 score_sum = 0 for sample_data, sample_eval in zip(examples_to_eval, evals): try: sample_eval = re.match(r".*(\{.*?\}).*", sample_eval, re.S).group(1) sample_eval = sample_eval.replace("'", '"') sample_eval = json.loads(sample_eval) pred = sample_eval['pred'] sample_score = sample_eval['score'] if pred == 'yes': judge_dict[sample_data['id']] = {'pred': 'Correct', 'score': sample_score} pred_correct += 1 else: judge_dict[sample_data['id']] = {'pred': 'Wrong', 'score': sample_score} score_sum += sample_score except: judge_dict[sample_data['id']] = {'pred': 'Wrong', 'score': 0} if len(examples_to_eval) == 0: return {'acc': 0, 'avg_score': 0} if return_score: return pred_correct / len(examples_to_eval), score_sum / len(examples_to_eval) else: return pred_correct / len(examples_to_eval) ####################################################################################### ####################################################################################### ############################ MMMU eval ############################################### ####################################################################################### ####################################################################################### def extract_numbers(string): """ Exact all forms of numbers from a string with regex. """ # Pattern for numbers with commas pattern_commas = r'-?\b\d{1,3}(?:,\d{3})+\b' # Pattern for scientific notation pattern_scientific = r'-?\d+(?:\.\d+)?[eE][+-]?\d+' # Pattern for simple numbers without commas pattern_simple = r'-?(?:\d+\.\d+|\.\d+|\d+\b)(?![eE][+-]?\d+)(?![,\d])' # Extract numbers with commas numbers_with_commas = re.findall(pattern_commas, string) # Extract numbers in scientific notation numbers_scientific = re.findall(pattern_scientific, string) # Extract simple numbers without commas numbers_simple = re.findall(pattern_simple, string) # Combine all extracted numbers all_numbers = numbers_with_commas + numbers_scientific + numbers_simple return all_numbers def parse_open_response(response): """ Parse the prediction from the generated response. Return a list of predicted strings or numbers. """ # content = content.strip("\n").strip(".").strip(" ") def get_key_subresponses(response): key_responses = [] response = response.strip().strip(".").lower() sub_responses = re.split(r'\.\s(?=[A-Z])|\n', response) indicators_of_keys = ['could be ', 'so ', 'is ', 'thus ', 'therefore ', 'final ', 'answer ', 'result '] key_responses = [] for index, resp in enumerate(sub_responses): # if last one, accept it's an equation (the entire response can be just one sentence with equation) if index == len(sub_responses) - 1: indicators_of_keys.extend(['=']) shortest_key_response = None # the shortest response that may contain the answer (tail part of the response) for indicator in indicators_of_keys: if indicator in resp: if not shortest_key_response: shortest_key_response = resp.split(indicator)[-1].strip() else: if len(resp.split(indicator)[-1].strip()) < len(shortest_key_response): shortest_key_response = resp.split(indicator)[-1].strip() # key_responses.append(resp.split(indicator)[1].strip()) if shortest_key_response: # and it's not trivial if shortest_key_response.strip() not in [":", ",", ".", "!", "?", ";", ":", "'"]: key_responses.append(shortest_key_response) if len(key_responses) == 0: # did not found any return [response] return key_responses # pdb.set_trace() key_responses = get_key_subresponses(response) pred_list = key_responses.copy() # keep the original string response for resp in key_responses: pred_list.extend(extract_numbers(resp)) tmp_pred_list = [] for i in range(len(pred_list)): tmp_pred_list.extend(normalize_str(pred_list[i])) pred_list = tmp_pred_list # remove duplicates pred_list = list(set(pred_list)) return pred_list def check_is_number(string): """ Check if the given string a number. """ try: float(string.replace(',', '')) return True except ValueError: # check if there's comma inside return False def normalize_str(string): """ Normalize the str to lower case and make them float numbers if possible. """ # check if characters in the string # if number, numerize it. string = string.strip() is_number = check_is_number(string) if is_number: string = string.replace(',', '') string = float(string) # leave 2 decimal string = round(string, 2) return [string] else: # it's likely to be a string # lower it string = string.lower() if len(string) == 1: return [" " + string, string + " "] # avoid trivial matches return [string] def eval_open(gold_i, pred_i): """ Evaluate an open question instance """ correct = False if isinstance(gold_i, list): # use float to avoid trivial matches norm_answers = [] for answer in gold_i: norm_answers.extend(normalize_str(answer)) else: norm_answers = normalize_str(gold_i) for pred in pred_i: # pred is already normalized in parse response phase if isinstance(pred, str): # if it's a string, then find if ans in the pred_i for norm_ans in norm_answers: # only see if the string answer in the string pred if isinstance(norm_ans, str) and norm_ans in pred: if not correct: correct = True break else: # it's a float number if pred in norm_answers: if not correct: correct = True break return correct def eval_multi_choice(gold_i, pred_i): """ Evaluate a multiple choice instance. """ correct = False # only they are exactly the same, we consider it as correct if isinstance(gold_i, list): for answer in gold_i: if answer == pred_i: correct = True break else: # gold_i is a string if gold_i == pred_i: correct = True return correct def evaluate(samples): """ Batch evaluation for multiple choice and open questions. """ pred_correct = 0 judge_dict = dict() for sample in samples: gold_i = sample['answer'] pred_i = sample['parsed_pred'] if sample['question_type'] == 'multiple-choice': correct = eval_multi_choice(gold_i, pred_i) else: # open question correct = eval_open(gold_i, pred_i) if correct: judge_dict[sample['id']] = 'Correct' pred_correct += 1 else: judge_dict[sample['id']] = 'Wrong' if len(samples) == 0: return None, {'acc': 0} return judge_dict, {'acc': pred_correct / len(samples)} def mmmu_eval(submission_dict_of_dict, solution_dict_of_dict, category=None, category_to_sample_ids_dict = None): """ MMMU evaluation on 6 datasets in the 1st phase: iconqa_fill_in_blank,funsd,iconqa_choose_txt,wildreceipt,textbookqa,tabfact only checking whether gt answer is contained in the prediction :param submission_dict_of_dict: outputs are predictions of all samples of all datasets :param solution_dict_of_dict: targets are gt of all samples of all datasets :return: """ id_list = category_to_sample_ids_dict[category] examples_to_eval = [] # for row, output in submission_dict_of_dict.iterrows(): # row is the sample id, output is the prediction of one sample for output_id, output in submission_dict_of_dict.items(): # row is the sample id, output is the prediction of one sample if output_id in id_list: # print('outputs type', type(submission_dict_of_dict), 'targets type', type(submission_dict_of_dict)) answer = str(output['pred']) # label = str(solution_dict_of_dict.iloc[row]['pred']) label = str(solution_dict_of_dict[output_id]['pred']) # print('answer:', answer) # print('label:', label) # this is applied on samples with question type of "short-answer" # currently all the samples have the question type of "short-answer" parse_pred = parse_open_response(answer) # mainly for type consistency , e.g. for answer of number, convert str to float examples_to_eval.append({ 'id': output['id'], "question_type": "short-answer", 'answer': label, 'parsed_pred': parse_pred, }) # assert len(examples_to_eval) == len(id_list), f'For dataset {category}, the number of submitted samples ({len(examples_to_eval)}) and the number of samples in this dataset ({len(id_list)}) are not the same!' # judge_dict: dict of sample_id: 'Correct'/'Wrong' # metric_dict: dict of metric_name: metric_value, e.g. 'acc': accuracy judge_dict, metric_dict = evaluate(examples_to_eval) metric_dict.update({'num_example': len(examples_to_eval)}) return metric_dict['acc'] def compute(params): # Download the two json file # category_ category_to_sample_ids_dict_file = hf_hub_download( repo_id=params.competition_id, filename="category_to_sample_ids_dict.json", token=params.token, repo_type="dataset", ) # answer dictionary for mixtral evaluation answer_dict_for_mixtral_eval_file = hf_hub_download( repo_id=params.competition_id, filename="answer_dict_for_mixtral_eval.json", token=params.token, repo_type="dataset", ) category_to_sample_ids_dict = json.load(open(category_to_sample_ids_dict_file)) answer_dict_for_mixtral_eval = json.load(open(answer_dict_for_mixtral_eval_file)) print(f'params {params}') print(f'params.submission_id_col {params.submission_id_col}') print('Downloading solution files ...') solution_file = hf_hub_download( repo_id=params.competition_id, filename="solution.csv", token=params.token, repo_type="dataset", ) # Download the solution file solution_df = pd.read_csv(solution_file) # 3 columns: submission_id, pred, split print('Downloading submission files ...') submission_filename = f"submissions/{params.team_id}-{params.submission_id}.csv" submission_file = hf_hub_download( repo_id=params.competition_id, filename=submission_filename, token=params.token, repo_type="dataset", ) # Download the submission file submission_df = pd.read_csv(submission_file) # submission data of a team public_ids = solution_df[solution_df.split == "public"][params.submission_id_col].values private_ids = solution_df[solution_df.split == "private"][params.submission_id_col].values public_solution_df = solution_df[solution_df[params.submission_id_col].isin(public_ids)] public_submission_df = submission_df[submission_df[params.submission_id_col].isin(public_ids)] private_solution_df = solution_df[solution_df[params.submission_id_col].isin(private_ids)] private_submission_df = submission_df[submission_df[params.submission_id_col].isin(private_ids)] public_solution_df = public_solution_df.sort_values(params.submission_id_col).reset_index(drop=True) # sort by submission_id public_submission_df = public_submission_df.sort_values(params.submission_id_col).reset_index(drop=True) private_solution_df = private_solution_df.sort_values(params.submission_id_col).reset_index(drop=True) private_submission_df = private_submission_df.sort_values(params.submission_id_col).reset_index(drop=True) print('public_solution_df', public_solution_df) print('private_solution_df', private_solution_df) ### turn csv data into dict of dict def csv_to_dict_of_dict(df): dict_of_dict = {} for row, output in df.iterrows(): dict_of_dict[output['id']] = output return dict_of_dict public_solution_dict_of_dict = csv_to_dict_of_dict(public_solution_df) public_submission_dict_of_dict = csv_to_dict_of_dict(public_submission_df) private_solution_dict_of_dict = csv_to_dict_of_dict(private_solution_df) private_submission_dict_of_dict = csv_to_dict_of_dict(private_submission_df) # print(public_submission_dict_of_dict) ####################################################### Wei's part ############################################### phase1_datasets_for_mmmu_eval = ['iconqa_fill','funsd','iconqa_choose','wildreceipt','textbookqa','tabfact'] phase1_datasets_for_mixtral_eval = ['docvqa','infographicvqa','websrc','wtq'] # phase1_datasets_for_mmmu_eval = [] # phase1_datasets_for_mixtral_eval = [] phase2_datasets_for_mmmu_eval = [] phase2_datasets_for_mixtral_eval = ['mydoc', 'mychart', 'myinfographic' ] all_keys = [ 'iconqa_fill_acc','funsd_acc','iconqa_choose_acc','wildreceipt_acc','textbookqa_acc','tabfact_acc', # phase 1 datasets for MMMU evaluation 'docvqa_acc','infographicvqa_acc','websrc_acc','wtq_acc', # phase 2 datasets for Mixtral evaluation 'phase1_overall_acc', # phase 1 overall acc 'mydoc_acc', # phase 2 oshri data 'mydoc_rating', 'mychart_acc', # phase 2 sivanharary data 'mychart_rating', 'myinfographic_acc', # phase 2 infographics data 'myinfographic_rating', 'phase2_overall_acc', # phase 2 overall acc 'phase2_overall_rating' # phase 2 overall rating ] mixtral_eval_batch_size = 16 limit = 20 # concurrency limit public_category_score_dict = {} private_category_score_dict = {} for key_ in all_keys: public_category_score_dict.update({key_: 0}) private_category_score_dict.update({key_: 0}) ############################################# Check if all the sample ids are in the submission file ######################################################################################## missing_sample_ids = [] for datasetname, sample_ids in category_to_sample_ids_dict.items(): for sample_id in sample_ids: if sample_id not in public_submission_dict_of_dict: missing_sample_ids.append(sample_id) if len(missing_sample_ids) > 0: print(f'Error: missing sample ids in the submission file: {missing_sample_ids}') return ################################################################################################################################################### ############################################# phase 1 eval (only acc) ######################################################################################## ################################################################################################################################################### ## MMMU evaluation for datasetname in phase1_datasets_for_mmmu_eval: print(f'#################################################### Phase 1 Eval: MMMU evaluation for {datasetname} ###########################################') public_category_score_dict[f'{datasetname}_acc'] = mmmu_eval(public_submission_dict_of_dict, public_solution_dict_of_dict, datasetname, category_to_sample_ids_dict= category_to_sample_ids_dict) ## Mixtral evaluation for datasetname in phase1_datasets_for_mixtral_eval: print(f'#################################################### Phase 1 Eval: Mixtral evaluation for {datasetname} ###########################################') # here the returned result is a dict {'acc': accuracy, 'avg_score': average score} public_category_score_dict[f'{datasetname}_acc'] = mixtral_eval_api(public_submission_dict_of_dict, public_solution_dict_of_dict, datasetname, category_to_sample_ids_dict =category_to_sample_ids_dict, answer_dict_for_mixtral_eval = answer_dict_for_mixtral_eval, batch_size=mixtral_eval_batch_size, limit=limit) ################################################################################################################################################### ############################################# phase 2 eval (acc and rating ) ####################################################################################### ################################################################################################################################################### ## Mixtral evaluation for datasetname in phase2_datasets_for_mixtral_eval: print(f'#################################################### Phase 2 Eval: Mixtral evaluation for {datasetname} ###########################################') public_category_score_dict[f'{datasetname}_acc'], public_category_score_dict[f'{datasetname}_rating'] = mixtral_eval_api(public_submission_dict_of_dict, public_solution_dict_of_dict, datasetname, category_to_sample_ids_dict=category_to_sample_ids_dict, answer_dict_for_mixtral_eval=answer_dict_for_mixtral_eval, batch_size=mixtral_eval_batch_size, limit=limit, return_score=True) ################################################################################################################################################### ############################################# print summary ######################################################################################## ################################################################################################################################################### print('################# Phase 1 Evaluation #################') # print the heading of category n_samples acc for metric_type in ['acc']: n_total = 0 metric_sum = 0 print('category'.ljust(29, ' '), 'n_samples'.ljust(10, ' '), metric_type.ljust(9, ' ')) for datasetname in phase1_datasets_for_mmmu_eval + phase1_datasets_for_mixtral_eval: metric_name = f'{datasetname}_{metric_type}' metric = public_category_score_dict[metric_name] dataset_size = len(category_to_sample_ids_dict[datasetname]) dataset_metric_sum = metric * dataset_size # print(f'{category}\t{dataset_total}\t{acc}') print(f'{metric_name:<30}{dataset_size:<10}{metric:<10.4f}') metric_sum += dataset_metric_sum n_total += dataset_size overall_metric = 0 if n_total == 0 else metric_sum / float(n_total) print(f'overall_{metric_type}'.ljust(29, ' '), f'{n_total}'.ljust(10, ' '), f'{overall_metric:.4f}'.ljust(9, ' ')) public_category_score_dict[f'phase1_overall_{metric_type}'] = overall_metric print('\n') print('################# Phase 2 Evaluation #################') for metric_type in ['acc', 'rating']: n_total = 0 metric_sum = 0 print('category'.ljust(29, ' '), 'n_samples'.ljust(10, ' '), metric_type.ljust(9, ' ')) for datasetname in phase2_datasets_for_mixtral_eval: metric_name = f'{datasetname}_{metric_type}' metric = public_category_score_dict[metric_name] dataset_size = len(category_to_sample_ids_dict[datasetname]) dataset_metric_sum = metric * dataset_size print(f'{metric_name:<30}{dataset_size:<10}{metric:<10.4f}') metric_sum += dataset_metric_sum n_total += dataset_size overall_metric = 0 if n_total == 0 else metric_sum / float(n_total) print(f'overall_{metric_type}'.ljust(29, ' '), f'{n_total}'.ljust(10, ' '), f'{overall_metric:.4f}'.ljust(9, ' ')) public_category_score_dict[f'phase2_overall_{metric_type}'] = overall_metric print('\n') """ metric_dict = { "public_score": # the user will see the results immediately after submitting { phase1dataset1_acc: xx, phase1dataset2_acc: xx, ... phase1_overall_acc: xx phase2dataset1_acc: xx, phase2dataset1_rating: xx, phase2dataset2_acc: xx, phase2dataset2_rating: xx, ... phase2_overall_acc: xx, phase2_overall_rating: xx, }, "private_score": { phase1dataset1_acc: 0, phase1dataset2_acc: 0, ... phase1_overall_acc: 0, phase2dataset1_acc: 0, phase2dataset1_rating: 0, phase2dataset2_acc: 0, phase2dataset2_rating: 0, ... phase2_overall_acc: 0, phase2_overall_rating: 0 } } """ metric_dict = {"public_score": public_category_score_dict, "private_score": private_category_score_dict } # keys of public_score, private_score is a must # metric_dict = {**public_category_score_dict, **private_category_score_dict} print("metric_dict:=========") print(metric_dict) return metric_dict