Datasets:

ddwang2000
/

MMSU

@@ -1,136 +0,0 @@
-import json
-import argparse
-from collections import defaultdict
-def load_jsonl_data(jsonl_path):
-    """Load data from the provided JSONL file."""
-    records = []
-    with open(jsonl_path, 'r', encoding='utf-8') as f:
-        for line_number, line in enumerate(f):
-            try:
-                record = json.loads(line.strip())
-                records.append(record)
-            except json.JSONDecodeError as e:
-                print(f"Error decoding JSON on line {line_number}: {line.strip()}")
-                print(e)
-    return records
-def calculate_accuracy_per_task_and_category(data):
-    """Calculate accuracy for each unique task and category."""
-    task_category_accuracy = defaultdict(lambda: defaultdict(lambda: {"correct": 0, "total": 0}))
-    task_average_accuracy = defaultdict(lambda: {"total_correct": 0, "total_count": 0})
-    # Initialize counters
-    total_correct = 0
-    total_count = 0
-    fail_num = 0
-    for record in data:
-        task = record.get('category', '')
-        category = record.get('sub-category', '')
-        # Extract response
-        response = record.get('response', '')
-        try:
-            predict = response.strip().replace('\n', '')
-        except:
-            print('Error prediction!')
-            continue
-        if predict != 'None' and predict:
-            if predict[0] == 'A' or predict[0] == 'B' or predict[0] == 'C' or predict[0] == 'D':
-                model_predict = predict[0]
-            #This situation may occur when the answer given by gpt is "The answer is A."
-            elif len(predict) > 1:
-                if predict[-2] == 'A' or predict[-2] == 'B' or predict[-2] == 'C' or predict[-2] == 'D':
-                    model_predict = predict[-2]
-                else:
-                    print(f'Wrong format response: {predict}')
-                    continue
-            else:
-                print(f'Wrong format response: {predict}')
-                continue
-        # Get the correct answer
-        answer_gt = record.get('answer_gt', '')
-        choices = {
-            'A': record.get('choice_a', ''),
-            'B': record.get('choice_b', ''),
-            'C': record.get('choice_c', ''),
-            'D': record.get('choice_d', '')
-        }
-        # Check if the prediction matches the correct answer
-        if model_predict:
-            if model_predict == 'A' and choices['A'] == answer_gt:
-                task_category_accuracy[task][category]["correct"] += 1
-                total_correct += 1
-            elif model_predict == 'B' and choices['B'] == answer_gt:
-                task_category_accuracy[task][category]["correct"] += 1
-                total_correct += 1
-            elif model_predict == 'C' and choices['C'] == answer_gt:
-                task_category_accuracy[task][category]["correct"] += 1
-                total_correct += 1
-            elif model_predict == 'D' and choices['D'] == answer_gt:
-                task_category_accuracy[task][category]["correct"] += 1
-                total_correct += 1
-        # Increase the total count for the task and category
-        task_category_accuracy[task][category]["total"] += 1
-        total_count += 1
-    # Calculate accuracy per task and category
-    for task, categories in task_category_accuracy.items():
-        total_correct_for_task = 0
-        total_count_for_task = 0
-        for category, counts in categories.items():
-            total = counts["total"]
-            correct = counts["correct"]
-            accuracy = correct / total if total > 0 else 0
-            task_category_accuracy[task][category] = accuracy
-            # Calculate overall task accuracy
-            total_correct_for_task += correct
-            total_count_for_task += total
-        # Calculate average accuracy for each task
-        task_average_accuracy[task]["total_correct"] = total_correct_for_task
-        task_average_accuracy[task]["total_count"] = total_count_for_task
-        task_average_accuracy[task]["average_accuracy"] = total_correct_for_task / total_count_for_task if total_count_for_task > 0 else 0
-    # Calculate overall accuracy
-    overall_accuracy = total_correct / total_count if total_count > 0 else 0
-    return task_category_accuracy, task_average_accuracy, overall_accuracy, total_count
-def main():
-    """Main function to load data, calculate accuracy, and print results."""
-    # Parse command-line arguments
-    parser = argparse.ArgumentParser(description="Process a JSONL file and calculate accuracy.")
-    parser.add_argument('jsonl_path', type=str, help="Path to the input JSONL file")
-    args = parser.parse_args()
-    # Load data
-    data = load_jsonl_data(args.jsonl_path)
-    # Calculate accuracy
-    task_category_accuracies, task_average_accuracies, overall_accuracy, total_count = calculate_accuracy_per_task_and_category(data)
-    # Print accuracy for each category and sub-category
-    for task, categories in task_category_accuracies.items():
-        for category, accuracy in categories.items():
-            print(f'Category: {task}, Sub-category: {category}, Accuracy: {accuracy:.4f}')
-    # Print average accuracy for each category
-    for task, accuracy_info in task_average_accuracies.items():
-        average_accuracy = accuracy_info["average_accuracy"]
-        print(f'Category: {task}, Average Accuracy: {average_accuracy:.4f}')
-    # Print overall accuracy
-    print(f'Overall Accuracy: {overall_accuracy:.4f}')
-    print(f'Total count: {total_count}')
-if __name__ == "__main__":
-    # bash:
-    # python mmsu_evaluation.py /path/to/your/input.jsonl
-    main()

code/mmsu_inference.py DELETED Viewed

@@ -1,80 +0,0 @@
-import os
-import argparse
-import json
-from tqdm import tqdm
-import shutil
-def main():
-    # Parse command-line arguments
-    parser = argparse.ArgumentParser(description="Easy Inference for your model.")
-    parser.add_argument('--input_jsonl', type=str, required=True, help="Path to the input JSONL file")
-    parser.add_argument('--output_jsonl', type=str, required=True, help="Path to the output JSONL file")
-    args = parser.parse_args()
-    input_file = args.input_jsonl
-    output_file = args.output_jsonl
-    #Step1: Bulid your model; Implement according to your own model
-    #model = model.cuda()
-    #model.eval()
-    #Step2: Single step inference
-    with open(input_file, "r") as fin, open(output_file, "w") as fout:
-        fin = json.load(fin)
-        for item in tqdm(fin):
-            audio_path = item['audio_path']
-            task_name = item['task_name']
-            if os.path.exists(audio_path) == False:
-                print(f"lack wav {wav_fn}")
-                continue
-            #Construct prompt
-            question = item['question']
-            question_prompts = 'Choose the most suitable answer from options A, B, C, and D to respond the question in next line, **you should only choose A or B or C or D.** Do not provide any additional explanations or content.'
-            choice_a = item['choice_a']
-            choice_b = item['choice_b']
-            choice_c = item.get('choice_c', None)
-            choice_d = item.get('choice_d', None)
-            choices = f'A. {choice_a}\nB. {choice_b}\nC. {choice_c}\nD. {choice_d}'
-            instruction = f"{question_prompts}\n\nQuestion: {question}\n\n{choices}"
-            #Step 3: Run model inference
-            #output = model.infer(
-            #    Prompts=instruction,
-            #    Audio_path=audio_path,
-            #    ...
-            #)
-            output = "Model response here"  # Placeholder response
-            #Step 4: save result
-            json_string = json.dumps(
-                {
-                    "id": item["id"]
-                    "audio_path": item["audio_path"],
-                    "question": question,
-                    "choice_a": choice_a,
-                    "choice_b": choice_b,
-                    "choice_c": choice_c,
-                    "choice_d": choice_d,
-                    "answer_gt": item["answer_gt"],
-                    "response": output,
-                    "task_name": task_name,
-                    "category": item["category"],
-                    "sub-category": item["category"],
-                    "sub-sub-category": item["sub-sub-category"],
-                    "linguistics_sub_discipline": item["linguistics_sub_discipline"],
-                },
-                ensure_ascii=False
-            )
-            fout.write(json_string + "\n")
-if __name__ == "__main__":
-    # bash:
-    # python mmsu_inference.py --input_jsonl /path/to/input.jsonl --output_jsonl /path/to/output.jsonl
-    main()