backup/delete/metric_old.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(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'<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

#######################################################################################
#######################################################################################
############################  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