eval.py

# This code is modified from the original work available at:
# https://github.com/TIGER-AI-Lab/MMLU-Pro
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# 
# http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Changes made:
# - Updated `eval.py` logic for our dataset.


import os
import json
from tqdm import tqdm
import time
from datasets import load_dataset
import argparse
import pandas as pd
import base64
from PIL import Image
from io import BytesIO
import ast

OPENAI_API_KEY = ""
GEMINI_API_KEY = ""

# The 5-shot examples are taken from MMLU Maths and Physics questions.
ms_prompt="""
Diberikan contoh-contoh berikut:

Soalan: Glukosa diangkut ke dalam sel otot:  
Pilihan:  
A. melalui pengangkut protein yang dipanggil GLUT4.  
B. hanya dengan kehadiran insulin.  
C. melalui hexokinase.  
D. melalui pengangkut asid monokarbilik.  

Jawapan: A  

Soalan: Jika sebuah pentagon P dengan bucu-bucu di (–2, –4), (–4, 1), (–1, 4), (2, 4), dan (3, 0) dipantulkan merentasi garis y = x untuk mendapatkan pentagon baru, P’, maka salah satu bucu P’ ialah  
Pilihan:  
A. (0, –3)  
B. (4, 1)  
C. (2, 2)  
D. (–4, –2)  

Jawapan: D  

Soalan: John membahagikan pin topi cenderamatanya kepada dua timbunan. Kedua-dua timbunan mempunyai bilangan pin yang sama. Dia memberikan kepada abangnya separuh daripada satu pertiga salah satu timbunan. John mempunyai 66 pin yang tinggal. Berapakah bilangan pin yang John miliki pada asalnya?  
Pilihan:  
A. 396  
B. 72  
C. 66  
D. 36  

Jawapan: B  

Soalan: Sebuah sfera pejal (I = 0.06 kg·m^2) berputar bebas mengelilingi paksi melalui pusatnya pada kelajuan sudut 20 rad/s. Dikehendaki menghentikan sfera tersebut dengan menggunakan daya geseran sebesar 2.0 N di permukaan luar sfera, pada jarak 0.30 m dari pusat sfera. Berapa lamakah masa yang diambil untuk menghentikan sfera tersebut?  
Pilihan:  
A. 4 s  
B. 2 s  
C. 0.06 s  
D. 0.03 s  

Jawapan: B  

Soalan: Cahaya ultraviolet mempunyai panjang gelombang sekitar 6 × 10^-8 m. Apakah frekuensi cahaya ini?  
Pilihan:  
A. 5 × 10^15 Hz  
B. 0.5 Hz  
C. 2 Hz  
D. 20 Hz  

Jawapan: A  

Berikut adalah soalan pilihan berganda. Pilih jawapan yang betul daripada pilihan 'A', 'B', 'C', atau 'D'.  
Jawab dengan hanya huruf pilihan yang betul. Jangan berikan sebarang penjelasan atau teks tambahan.  
Jawapan hendaklah hanya salah satu daripada ini: 'A', 'B', 'C', 'D'.\n\n
"""

en_prompt = """
Given the examples:

Question: Glucose is transported into the muscle cell:
Choices:
A. via protein transporters called GLUT4.
B. only in the presence of insulin.
C. via hexokinase.
D. via monocarbylic acid transporters.

Answer: A

Question: If a pentagon P with vertices at (– 2, – 4), (– 4, 1), (–1, 4), (2, 4), and (3, 0) is reflected across the line y = x to get a new pentagon, P’, then one of the vertices of P’ is
Choices:
A. (0, – 3)
B. (4, 1)
C. (2, 2)
D. (– 4, –2)

Answer: D

Question: John divided his souvenir hat pins into two piles. The two piles had an equal number of pins. He gave his brother one-half of one-third of one pile. John had 66 pins left. How many pins did John originally have?
Choices:
A. 396
B. 72
C. 66
D. 36

Answer: B

Question: A solid sphere (I = 0.06 kg·m^2) spins freely around an axis through its center at an angular speed of 20 rad/s. It is desired to bring the sphere to rest by applying a friction force of magnitude 2.0 N to the sphere’s outer surface, a distance of 0.30 m from the sphere’s center. How much time will it take the sphere to come to rest?
Choices:
A. 4 s
B. 2 s
C. 0.06 s
D. 0.03 s

Answer: B

Question: Ultraviolet light has a wavelength of about 6 × 10^-8 m. What is the frequency of this light?
Choices:
A. 5 × 10^15 Hz
B. 0.5 Hz
C. 2 Hz
D. 20 Hz

Answer: A

The following are multiple choice questions. Choose the correct answer from the options 'A', 'B', 'C', or 'D'. 
Answer with only the letter of the correct option. Do not provide any extra explanation or text.
The answer should only be one of these: 'A', 'B', 'C', 'D'.\n\n
"""

def get_client():
    if args.model_name in ["gpt-4o-mini", "gpt-4o"]:
        import openai
        openai.api_key = OPENAI_API_KEY
        client = openai
    elif args.model_name in ["gemini-2.0-flash-exp", "gemini-1.5-flash"]:
        import google.generativeai as genai
        genai.configure(api_key=GEMINI_API_KEY)
        generation_config = {
            "temperature": 0.0,
            "top_p": 0.1,
            "max_output_tokens": 1,
            "response_mime_type": "text/plain",
        }
        client = genai.GenerativeModel(
            model_name=args.model_name,
            generation_config=generation_config,
        )
    else:
        client = None
        print("For other model API calls, please implement the client definition method yourself.")
    return client


def call_api(client, instruction, inputs):
    start = time.time()
    if args.model_name in ["gpt-4o-mini", "gpt-4o"]:
        message_text = [{"role": "user", "content": instruction + inputs}]
        completion = client.chat.completions.create(
          model=args.model_name,
          messages=message_text,
          temperature=0,
          max_tokens=1,
          top_p=0.1,
        )
        result = completion.choices[0].message.content
    elif args.model_name in ["gemini-2.0-flash-exp", "gemini-1.5-flash"]:
        response = client.generate_content([instruction, inputs])
        result = response.text
    else:
        print("For other model API calls, please implement the request method yourself.")
        result = None
    print("cost time", time.time() - start)
    return result


def call_api_figures(client, instruction, inputs, figures):
    start = time.time()
    if args.model_name in ["gpt-4o-mini", "gpt-4o"]:
        content = [{"type": "text", "text": instruction + inputs}]
        for figure in figures:
            content.append({
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{encode_image(figure)}"}
                })
        message_text = [{"role": "user", "content": content}]
        completion = client.chat.completions.create(
          model=args.model_name,
          messages=message_text,
          temperature=0,
          max_tokens=1,
          top_p=0.1
        )
        result = completion.choices[0].message.content
    elif args.model_name in ["gemini-2.0-flash-exp", "gemini-1.5-flash"]:
        content = [instruction, inputs]
        for figure in figures:
            content.append(figure)
        response = client.generate_content(content)
        result = response.text
    else:
        print("For other model API calls, please implement the request method yourself.")
        result = None
    print("cost time", time.time() - start)
    return result


# Function to encode the image to base64
def encode_image(image):
    # Check if the image is in RGBA mode and convert it to RGB
    if image.mode == "RGBA":
        image = image.convert("RGB")
    buffered = BytesIO()
    image.save(buffered, format="JPEG")  # Save image as JPEG
    return base64.b64encode(buffered.getvalue()).decode("utf-8")  # Return base64 string


def format_question(question_text, options_str, language):
    # Parse the string into a Python list
    options = ast.literal_eval(options_str)
    if language == 'en':
        question = f"Question: {question_text}\nOptions:\n"
        for opt in options:
            question += f"{opt}\n"
        question += "Answer: "
    elif language == 'ms':
        question = f"Soalan: {question_text}\nPilihan:\n"
        for opt in options:
            question += f"{opt}\n"
        question += "Jawapan: "
    return question


def single_request(client, single_question, with_figure, language):
    question = single_question["Questions"]
    options = single_question["Options"]

    if language == 'en':
        prompt = en_prompt
    elif language == 'ms':
        prompt = ms_prompt

    input_text = format_question(question, options, language)

    retries = 5
    delay = 15
    attempt = 0

    if with_figure:
        figures_data = single_question["Label"]
        pairs = [entry.strip() for item in figures_data for entry in item.split(",")]
        figure_labels = [{"label": label.strip(), "path": path.strip()} for label, path in [pair.split(":") for pair in pairs]]
        figures = single_question["Figures"]

        prompt += "".join([f"Figure {index}: {figure['label']}\n" for index, figure in enumerate(figure_labels)])

        while attempt < retries:
            try:
                response = call_api_figures(client, prompt, input_text, figures)
                if response:
                    response = response.replace('**', '')
                    return response, response
            except Exception as e:
                print(f"Error: {e}")
                attempt += 1
                if attempt < retries:
                    print(f"Retrying in {delay:.2f} seconds...")
                    time.sleep(delay)
        return None, f"Failed after {retries} retries."
                
    else:
        while attempt < retries:
            try:
                response = call_api(client, prompt, input_text)
                if response:
                    response = response.replace('**', '')
                    return response, response
            except Exception as e:
                print(f"Error: {e}")
                attempt += 1
                if attempt < retries:
                    print(f"Retrying in {delay:.2f} seconds...")
                    time.sleep(delay)
        return None, f"Failed after {retries} retries."


def evaluate(language, with_figure=False):
    client = get_client()
    
    # Load dataset from Hugging Face
    dataset_name = "Supa-AI/STEM-en-ms"
    dataset = load_dataset(dataset_name, name=f"data_{language}", split="eval")

    # Convert to pandas DataFrame
    data = pd.DataFrame(dataset)

    # Split the dataset into two parts: with figures and without figures
    data_with_figures = data[data["Figures"].apply(lambda x: isinstance(x, list) and len(x) > 0)]
    data_without_figures = data[data["Figures"].apply(lambda x: isinstance(x, list) and len(x) == 0)]

    if with_figure:
        test_data = data_with_figures
        suffix = f"{args.model_name}_{language}_wfigures".split("/", 1)[-1]
    else:
        test_data = data_without_figures
        suffix = f"{args.model_name}_{language}_wofigures".split("/", 1)[-1]

    output_res_path = os.path.join(args.output_dir, suffix + "_result.json")

    total_questions = len(test_data)  # Total includes all questions

    # Load existing results if available
    if os.path.exists(output_res_path):
        with open(output_res_path, "r", encoding="utf-8") as f:
            existing_results = json.load(f)
        processed_ids = {entry["FileName"] for entry in existing_results}
        # Count correct predictions from existing results
        correct_predictions_existing = sum(1 for entry in existing_results if entry.get("pred") == entry.get("Answers"))
    else:
        existing_results = []
        processed_ids = set()
        correct_predictions_existing = 0

    # Filter out already processed entries
    test_data = test_data[~test_data["FileName"].isin(processed_ids)]

    res = existing_results
    correct_predictions_new = 0

    for _, each in tqdm(test_data.iterrows(), total=len(test_data)):
        label = each["Answers"]
        # if len(each["Figures"]) > 1: continue
        pred, response = single_request(client, each, with_figure, language)  
        if response is not None:
            each["pred"] = pred
            each["model_outputs"] = response
            if pred is not None and pred == label:
                correct_predictions_new += 1
            res.append(each.to_dict())
            save_res(res, output_res_path)  # Save results incrementally
            print(f"FileName: {each["FileName"]}, Answer: {each["Answers"]}, Prediction: {each["pred"]}")

    # Calculate accuracy
    correct_predictions_total = correct_predictions_existing + correct_predictions_new
    print("Total Question: ", total_questions)
    print("Correct Predictions Exist: ", correct_predictions_existing)
    print("Correct Predictions New: ", correct_predictions_new)
    accuracy = correct_predictions_total / total_questions if total_questions > 0 else 0
    print(f"Accuracy: {accuracy:.2%}")


def remove_images_from_res(res):
    """Recursively removes image objects from the result dictionary."""
    if isinstance(res, dict):
        for key, value in res.items():
            if isinstance(value, Image.Image):
                res[key] = "Image is not saved"  # Replace image objects with a placeholder
            elif isinstance(value, (dict, list)):
                remove_images_from_res(value)  # Recursively process nested structures
    elif isinstance(res, list):
        for i in range(len(res)):
            if isinstance(res[i], Image.Image):
                res[i] = "Image is not saved"  # Replace image objects with a placeholder
            elif isinstance(res[i], (dict, list)):
                remove_images_from_res(res[i])  # Recursively process nested structures
    return res


def save_res(res, output_res_path):
    """Save the result to a file, excluding images."""
    os.makedirs(os.path.dirname(output_res_path), exist_ok=True)
    res = remove_images_from_res(res)  # Remove images from the result
    with open(output_res_path, "w", encoding="utf-8") as fo:
        fo.write(json.dumps(res, indent=4, ensure_ascii=False))


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--output_dir", "-o", type=str, default="eval_results/")
    parser.add_argument("--model_name", "-m", type=str, default="gpt-4o",
                        choices=["gpt-4o-mini", "gpt-4o",                                               # OPENAI
                                 "gemini-2.0-flash-exp", "gemini-1.5-flash",                            # GEMINI
                                ]) 
    parser.add_argument("--language", "-l", type=str, default="en")
    parser.add_argument("--with_figures", "-f", type=bool, default=False)
    args = parser.parse_args()
    os.makedirs(args.output_dir, exist_ok=True)
    evaluate(args.language, args.with_figures)