metric.py

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