MMFMChallenge / metric.py
wlin21at's picture
debug fix
0b1eba5
raw
history blame
29.5 kB
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.GREEDY, 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=True),
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'<s>[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 = []
phase1_datasets_for_mixtral_eval = ['infographicvqa']
phase2_datasets_for_mmmu_eval = []
# phase2_datasets_for_mixtral_eval = ['mydoc', 'mychart', 'myinfographic' ]
phase2_datasets_for_mixtral_eval = []
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