File size: 29,634 Bytes
a86c725 f4f731b 51ae812 dd6b4ee f4f731b dbe1af0 824ee48 f4f731b 0b1eba5 f4f731b 375239b f4f731b 375239b f4f731b 375239b f4f731b 375239b f4f731b 021771f f4f731b 375239b f4f731b dd6b4ee f4f731b dd6b4ee f4f731b dd6b4ee 33dd4ea dd6b4ee f4f731b dd6b4ee f4f731b dd6b4ee f4f731b dd6b4ee a86c725 f4f731b a86c725 f4f731b a86c725 f4f731b 375239b 3291e2d 375239b 3291e2d f5968bc f79d3ae 375239b 3291e2d f5968bc 375239b f4f731b a039337 375239b 3291e2d f4f731b 375239b f4f731b 375239b f4f731b 375239b f4f731b 375239b f4f731b 375239b f4f731b 375239b f4f731b a86c725 f4f731b 375239b f4f731b 375239b f4f731b 375239b f16f54b 375239b f4f731b 375239b f4f731b 375239b f4f731b 375239b ef24038 375239b f4f731b ef24038 f4f731b 375239b 51ae812 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 |
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
decoding_method=DecodingMethod.GREEDY, max_new_tokens=128, min_new_tokens=30, temperature=0, top_k=1, top_p=0, 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 |