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(model_id, prompt, sys_prompt): """ Usage: model_id = "mistralai/mixtral-8x7b-instruct-v01" # mistralai/mistral-7b-instruct-v0-2 prompt = "What is NLP and how it has evolved over the years?" sys_prompt = ""You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature. If a question does not make any sense, or is not factually coherent, explain why instead of answering something incorrectly. If you don't know the answer to a question, please don't share false information. " response = chat_llm(model_id, prompt, sys_prompt) :param model_id: bam model_id :param prompt: input text :param sys_prompt: system prompt :return: the llm response """ parameters = TextGenerationParameters( decoding_method=DecodingMethod.SAMPLE, max_new_tokens=128, min_new_tokens=30, temperature=0.7, top_k=50, top_p=1 ) client = Client(credentials=Credentials.from_env()) print(heading("Generating a chat response")) response = client.text.chat.create( model_id=model_id, messages=[ SystemMessage( content=sys_prompt, ), HumanMessage(content=prompt), ], parameters=parameters, ) conversation_id = response.conversation_id print(f"Conversation ID: {conversation_id}") print(f"Request: {prompt}") print(f"Response: {response.results[0].generated_text}") return response.results[0].generated_text 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.7, top_k=50, top_p=1 ) 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 ####################################################################################### ####################################################################################### ############################ 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)} # # category_to_sample_ids_dict_dummy = { # # these 6 public datasets are evaluated with MMMU metric # 'iconqa_fill_in_blank': [0, 1], # 'funsd': [2, 3], # 'iconqa_choose_txt': [4, 5], # 'wildreceipt': [6, 7], # 'textbookqa': [8, 9], # 'tabfact': [10, 11], # # these 4 public datasets are evaluated with LLM # 'docvqa': [12, 13], # 'infographicvqa': [14, 15], # 'websrc': [16, 17], # 'wtq': [18, 19], # # these 3 private datasets are evaluated with LLM # 'private_dataset1': [20, 21], # 'private_dataset2': [22, 23], # 'private_dataset3': [24, 25], # } # # answer_dict_for_mixtral_eval_dummy = { # 12: { # "question_type": "short-answer", # "ground_truth": "0.24", # "question": "What is the \u2018actual\u2019 value per 1000, during the year 1970?", # "dataset": "docvqa" # }, # 13: { # "question_type": "short-answer", # "ground_truth": "11:14 to 11:39 a.m.", # "question": "What time is the \u2018coffee break\u2019?", # "dataset": "docvqa" # }, # 14: { # "question_type": "short-answer", # "ground_truth": "70", # "question": "What percentage of smokers feel the need to find more excitement and sensation in life?", # "dataset": "infographicvqa" # }, # 20: { # "question_type": "short-answer", # "ground_truth": "0.24", # "question": "What is the \u2018actual\u2019 value per 1000, during the year 1970?", # "dataset": "private_dataset1" # }, # } def mmmu_eval(outputs, targets, 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 outputs: outputs are predictions of all samples of all datasets :param targets: 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 outputs.iterrows(): # row is the sample id, output is the prediction of one sample if row in id_list: print('outputs type', type(outputs), 'targets type', type(outputs)) answer = str(output['pred']) label = str(targets.iloc[row]['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': row, "question_type": "short-answer", 'answer': label, 'parsed_pred': parse_pred, }) # 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'] ## Mixtral Evaluation def mixtral_eval_local(outputs, targets, category=None, model_id = "mistralai/Mixtral-8x7B-Instruct-v0.1", batch_size = 16, load_in_4bit = True, load_in_8bit = False, cpu = False, category_to_sample_ids_dict = None, answer_dict_for_mixtral_eval = None): """ Mixtral evaluation on 4 datasets in the 1st phase: docvqa,infographicvqa,websrc,wtq and for private datasets in the 2nd phase :param outputs: outputs are predictions of all samples of all datasets :param targets: targets are gt of all samples of all datasets """ # load the Mixtral 8x7b model tokenizer = AutoTokenizer.from_pretrained(model_id) if 'mistralai' in model_id: tokenizer.pad_token = tokenizer.eos_token model = AutoModelForCausalLM.from_pretrained(model_id, device_map='cpu' if cpu else 'auto', torch_dtype=bfloat16, load_in_8bit=load_in_8bit, load_in_4bit=load_in_4bit) id_list = category_to_sample_ids_dict[category] examples_to_eval = [] for row, output in outputs.iterrows(): # row is the sample id, output is the prediction of one sample if row in id_list: print('outputs type', type(outputs), 'targets type', type(outputs)) answer = str(output['pred']) label = str(targets.iloc[row]['pred']) print('answer:', answer) print('label:', label) examples_to_eval.append({ 'id': row, "question_type": answer_dict_for_mixtral_eval[row]['question_type'], 'answer': label, 'question': answer_dict_for_mixtral_eval[row]['question'], 'parsed_pred': answer, }) judge_dict, metric_dict = LLM_eval(model_id, model, tokenizer, batch_size, examples_to_eval, cuda=not (cpu)) metric_dict.update({"num_example": len(examples_to_eval)}) # return {'acc': metric_dict['acc'], # 'avg_score': metric_dict['avg_score']} return metric_dict['acc'] def mixtral_eval_api(outputs, targets, 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): id_list = category_to_sample_ids_dict[category] examples_to_eval = [] evals = [] if batch_size == 1: for row, output in tqdm(outputs.iterrows()): # row is the sample id, output is the prediction of one sample if row in id_list: print('outputs type', type(outputs), 'targets type', type(outputs)) answer = str(output['pred']) label = str(targets.iloc[row]['pred']) print('answer:', answer) print('label:', label) gt_answer = label pred_answer = answer question = answer_dict_for_mixtral_eval[str(row)]['question'] examples_to_eval.append({ 'id': row, "question_type": answer_dict_for_mixtral_eval[str(row)]['question_type'], 'answer': gt_answer, 'question': question, 'parsed_pred': pred_answer, }) prompt = creat_prompt(model_id='api', question=question, answer=gt_answer, pred=pred_answer) # print(prompt) system_prompt = prompt[0]["content"].strip() user_prompt = prompt[1]["content"].strip() # call API output = chat_llm(model_id=model_id, prompt=user_prompt, sys_prompt=system_prompt) evals.append(output) else: sample_id_list = [] for row, output in outputs.iterrows(): if row in id_list: sample_id_list.append(row) 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]: answer = str(outputs.iloc[item]['pred']) label = str(targets.iloc[item]['pred']) print('answer:', answer) print('label:', label) gt_answer = label pred_answer = answer question = answer_dict_for_mixtral_eval[str(item)]['question'] examples_to_eval.append({ 'id': item, "question_type": answer_dict_for_mixtral_eval[str(item)]['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} # return {'acc': pred_correct / len(examples_to_eval), # 'avg_score': score_sum / len(examples_to_eval)} return pred_correct / len(examples_to_eval) def _metric(outputs, targets): # inputs: public_solution_df[target_cols], public_submission_df[target_cols] # output: score for row, output in outputs.iterrows(): # row is the sample id print('outputs type', type(outputs), 'targets type', type(outputs)) answer = str(output['pred']) label = str(targets.iloc[row]['pred']) print('answer:', answer) print('label:', label) prompt = f"Give me a score from 1 to 10 (higher is better) judging how similar these two captions are. Caption one: {answer}. Caption two: {label}\nScore: " response = client.completions.create( model="gpt-3.5-turbo-instruct", prompt=prompt, temperature=0, max_tokens=1, ) eval_result = response.choices[0].text.strip() print('eval_result', eval_result) score = int(eval_result) # try: # except: # print("Error: API Calling") # return return score # # METRICS Calculation Evaluation # # _metric = SOME METRIC FUNCTION # def _metric(outputs, targets): # # input example: public_solution_df[target_cols], public_submission_df[target_cols] # score = 0.5 # return score def compute(params): public_score = 0 private_score = 0 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_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", ) 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", ) 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) # target_cols = [col for col in solution_df.columns if col not in [params.submission_id_col, "split"]] # public_score = _metric(public_solution_df[target_cols], public_submission_df[target_cols]) # private_score = _metric(private_solution_df[target_cols], private_submission_df[target_cols]) # # metric_name = "metric1" # # metric_dict = {"public_score": {metric_name: public_score}, # "private_score": {metric_name: private_score} # } ####################################################### Wei's part ############################################### all_keys = ['iconqa_fill','funsd','iconqa_choose','wildreceipt','textbookqa','tabfact', 'docvqa','infographicvqa','websrc','wtq', 'public_overall', 'private_overall'] 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}) public_datasets_for_mmmu_eval = ['iconqa_fill','funsd','iconqa_choose','wildreceipt','textbookqa','tabfact'] public_datasets_for_mixtral_eval = ['docvqa','infographicvqa','websrc','wtq'] private_datasets_for_mmmu_eval = [] # private_datasets_for_mixtral_eval = ['private_dataset1','private_dataset2','private_dataset3'] private_datasets_for_mixtral_eval = [] ################################################################################################################################################### ############################################# public eval ######################################################################################## ################################################################################################################################################### ## MMMU evaluation for category in public_datasets_for_mmmu_eval: print(f'#################################################### Public Eval: MMMU evaluation for {category} ###########################################') public_category_score_dict[category] = mmmu_eval(public_submission_df, public_solution_df, category, category_to_sample_ids_dict= category_to_sample_ids_dict) ## Mixtral evaluation for category in public_datasets_for_mixtral_eval: print(f'#################################################### Public Eval: Mixtral evaluation for {category} ###########################################') # here the returned result is a dict {'acc': accuracy, 'avg_score': average score} public_category_score_dict[category] = mixtral_eval_api(public_submission_df, public_solution_df, category, 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) n_total = 0 n_correct = 0 print('################# Public Evaluation #################') # print the heading of category n_samples acc # print('category\tn_samples\tacc') # print category, n_samples, acc with left alignment: 30 for key, 10 for n_samples, 10 for acc print('category'.ljust(29, ' '), 'n_samples'.ljust(10, ' '), 'acc'.ljust(10, ' ')) for category, acc in public_category_score_dict.items(): if category in ['public_overall', 'private_overall']: continue dataset_total = len(category_to_sample_ids_dict[category]) dataset_correct = acc * dataset_total # print(f'{category}\t{dataset_total}\t{acc}') print(f'{category:<30}{dataset_total:<10}{acc:<10}') n_correct += dataset_correct n_total += dataset_total public_overall_acc = 0 if n_total == 0 else n_correct / float(n_total) # print(f'overall\t{n_total}\t{public_overall_acc}') print(f'overall'.ljust(30, ' '), f'{n_total}'.ljust(10, ' '), f'{public_overall_acc}'.ljust(10, ' ')) public_category_score_dict['public_overall'] = public_overall_acc ################################################################################################################################################### ############################################# private eval ####################################################################################### ################################################################################################################################################### ## Mixtral evaluation for category in private_datasets_for_mixtral_eval: # here the returned result is a dict {'acc': accuracy, 'avg_score': average score} # private_category_score_dict.update({category: mixtral_eval_api(private_submission_df, private_solution_df, category, category_to_sample_ids_dict, answer_dict_for_mixtral_eval)}) print( f'#################################################### Private Eval: MMMU evaluation for {category} ###########################################') private_category_score_dict[category] = mmmu_eval(private_submission_df, private_solution_df, category, category_to_sample_ids_dict) n_total = 0 n_correct = 0 print('################# Private Evaluation #################') print('category'.ljust(29, ' '), 'n_samples'.ljust(10, ' '), 'acc'.ljust(10, ' ')) for category, acc in private_category_score_dict.items(): if category in ['public_overall', 'private_overall']: continue dataset_total = len(category_to_sample_ids_dict[category]) dataset_correct = acc * dataset_total # print(f'{category}\t{dataset_total}\t{acc}') print(f'{category:<30}{dataset_total:<10}{acc:<10}') n_correct += dataset_correct n_total += dataset_total private_overall_acc = 0 if n_total == 0 else n_correct / float(n_total) # print(f'overall\t{n_total}\t{private_overall_acc}') print(f'overall'.ljust(30, ' '), f'{n_total}'.ljust(10, ' '), f'{private_overall_acc}'.ljust(10, ' ')) private_category_score_dict['private_overall'] = private_overall_acc """ metric_dict = { "public_score": { public_dataset1: acc, public_dataset2: acc, ... public_overall: acc private_dataset1: 0, # dummyscore for private part private_dataset2: 0, # dummyscore for private part ... private_overall: 0 # dummyscore for private part }, "private_score": { public_dataset1: 0, # dummyscore for public part public_dataset2: 0, # dummyscore for public part ... public_overall: 0 # dummyscore for public part private_dataset1: acc, private_dataset2: acc, ... private_overall: acc } } """ metric_dict = {"public_score": {'overall': public_overall_acc}, "private_score": {'overall': private_overall_acc} } # return metric_dict, public_category_score_dict, private_category_score_dict return metric_dict