code/evaluation_code/level3/evaluation_EI.py

import json
import re
import openai
from collections import Counter, defaultdict
from datetime import datetime
import time

def extract_numbered_list(text):

    if not text:
        return []


    patterns = [
        r'^\s*(\d+)\.\s*(.+)$',
        r'^\s*(\d+)\)\s*(.+)$',
        r'^\s*\((\d+)\)\s*(.+)$',
    ]

    items = []
    lines = text.strip().split('\n')

    for line in lines:
        line = line.strip()
        if not line:
            continue

        matched = False
        for pattern in patterns:
            match = re.match(pattern, line)
            if match:
                number = int(match.group(1))
                content = match.group(2).strip()
                items.append(content)
                matched = True
                break


        if not matched and len(line) > 5:
            items.append(line)

    return items

def evaluate_with_gpt4(prediction_text, ground_truth_text, emotion, client):

    try:
        prompt = f"""You are evaluating emotion interpretation explanations.

Task: Compare the predicted explanation with the reference explanation for the emotion "{emotion}".

Reference explanation:
{ground_truth_text}

Predicted explanation:
{prediction_text}

Evaluate if the predicted explanation is reasonable and accurate compared to the reference.

Respond with only "CORRECT" or "INCORRECT" based on whether the predicted explanation is of acceptable quality compared to the reference."""

        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.1,
            max_tokens=10
        )

        result = response.choices[0].message.content.strip().upper()
        is_correct = result == "CORRECT"

        return {
            "is_correct": is_correct,
            "llm_response": result
        }

    except Exception as e:
        return {
            "is_correct": False,
            "llm_response": f"Error: {str(e)}"
        }

def extract_emotion_from_prompt(prompt):
 
    emotion_match = re.search(r"Emotion to explain:\s*(\w+)", prompt)
    if emotion_match:
        return emotion_match.group(1)
    return "Unknown"

def evaluate_emotion_interpretation(result_file_path, api_key):



    client = openai.OpenAI(api_key=api_key)


    with open(result_file_path, 'r', encoding='utf-8') as f:
        results = json.load(f)

    detailed_results = []
    extraction_errors = defaultdict(list)

    correct_count = 0
    total_valid = 0


    for i, item in enumerate(results):
        item_id = item['id']
        prompt = item['prompt']
        model_output = item['model_output']
        ground_truth = item['ground_truth']

        print(f"Processing sample {i+1}/{len(results)}: {item_id}")

        emotion = extract_emotion_from_prompt(prompt)


        pred_items = extract_numbered_list(model_output)
        gt_items = extract_numbered_list(ground_truth)


        has_valid_format = len(pred_items) > 0


        detailed_item = {
            'id': item_id,
            'emotion': emotion,
            'model_output': model_output,
            'ground_truth': ground_truth,
            'extracted_prediction': pred_items,
            'extracted_ground_truth': gt_items,
            'prediction_count': len(pred_items),
            'ground_truth_count': len(gt_items),
            'has_valid_format': has_valid_format,
            'llm_evaluation': None,
            'is_correct': False
        }


        if has_valid_format:
            llm_eval = evaluate_with_gpt4(model_output, ground_truth, emotion, client)
            detailed_item['llm_evaluation'] = llm_eval
            detailed_item['is_correct'] = llm_eval['is_correct']

            if llm_eval['is_correct']:
                correct_count += 1
            total_valid += 1


            time.sleep(0.5)
        else:
            extraction_errors['invalid_format'].append(item_id)

        detailed_results.append(detailed_item)


    format_success_rate = total_valid / len(results) if len(results) > 0 else 0
    accuracy = correct_count / total_valid if total_valid > 0 else 0


    emotion_distribution = Counter([item['emotion'] for item in detailed_results])


    pred_lengths = [item['prediction_count'] for item in detailed_results if item['has_valid_format']]
    gt_lengths = [item['ground_truth_count'] for item in detailed_results]

    avg_pred_length = sum(pred_lengths) / len(pred_lengths) if pred_lengths else 0
    avg_gt_length = sum(gt_lengths) / len(gt_lengths) if gt_lengths else 0


    evaluation_result = {
        'task_info': {
            'task_name': 'emotion.interpretation',
            'dataset': 'EIBench',
            'evaluation_time': datetime.now().isoformat(),
            'total_samples': len(results),
            'valid_samples': total_valid,
            'format_success_rate': round(format_success_rate, 4)
        },
        'metrics': {
            'LLM_ACC': round(accuracy, 4),
            'Correct_Count': correct_count,
            'Total_Valid': total_valid
        },
        'content_analysis': {
            'avg_prediction_length': round(avg_pred_length, 2),
            'avg_ground_truth_length': round(avg_gt_length, 2),
            'emotion_distribution': dict(emotion_distribution)
        },
        'error_analysis': {
            'extraction_errors': {
                error_type: {
                    'count': len(sample_ids),
                    'sample_ids': sample_ids
                } for error_type, sample_ids in extraction_errors.items()
            }
        }
    }


    emotion_analysis = {}
    for emotion in emotion_distribution.keys():
        emotion_samples = [item for item in detailed_results if item['emotion'] == emotion and item['has_valid_format']]
        if emotion_samples:
            emotion_correct = sum(1 for item in emotion_samples if item['is_correct'])
            emotion_total = len(emotion_samples)
            emotion_acc = emotion_correct / emotion_total if emotion_total > 0 else 0

            emotion_analysis[emotion] = {
                'sample_count': emotion_total,
                'correct_count': emotion_correct,
                'accuracy': round(emotion_acc, 4),
                'avg_prediction_length': round(sum([item['prediction_count'] for item in emotion_samples]) / len(emotion_samples), 2)
            }

    evaluation_result['emotion_analysis'] = emotion_analysis


    base_name = result_file_path.replace('.json', '')


    eval_output_file = f"{base_name}_evaluation.json"
    with open(eval_output_file, 'w', encoding='utf-8') as f:
        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)


    detailed_output_file = f"{base_name}_detailed_results.json"
    with open(detailed_output_file, 'w', encoding='utf-8') as f:
        json.dump(detailed_results, f, ensure_ascii=False, indent=2)


    incorrect_samples = [item for item in detailed_results if item['has_valid_format'] and not item['is_correct']]
    if incorrect_samples:
        incorrect_report_file = f"{base_name}_incorrect_samples.json"
        with open(incorrect_report_file, 'w', encoding='utf-8') as f:
            json.dump(incorrect_samples, f, ensure_ascii=False, indent=2)


    print(f"\nEvaluation complete: {len(results)} samples")
    print(f"Key metric: LLM_ACC={evaluation_result['metrics']['LLM_ACC']}")
    print(f"Correct count: {evaluation_result['metrics']['Correct_Count']}/{evaluation_result['metrics']['Total_Valid']}")
    print(f"Format success rate: {evaluation_result['task_info']['format_success_rate']}")
    print(f"Average prediction length: {evaluation_result['content_analysis']['avg_prediction_length']}")
    print(f"Results saved to: {eval_output_file}")
    if incorrect_samples:
        print(f"Incorrect samples: {len(incorrect_samples)}; see {incorrect_report_file} for details")


    if emotion_analysis:
        print("\nPerformance by emotion type:")
        for emotion, analysis in emotion_analysis.items():
            print(f"  {emotion}: ACC={analysis['accuracy']}, Samples={analysis['sample_count']}")

    return evaluation_result


if __name__ == "__main__":
    result_file = "model_result.json"
    api_key = "xxx"

    try:
        evaluation_result = evaluate_emotion_interpretation(result_file, api_key)

    except FileNotFoundError:
        print(f"Error: file not found {result_file}")
    except json.JSONDecodeError:
        print(f"Error: invalid format for {result_file}")
    except Exception as e:
        print(f"Evaluation failed: {str(e)}")