code/evaluation_code/level3/evaluation_LR.py

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

def check_required_format(text):

    if not text:
        return False, ""


    pattern = r'^The audience laughed because\s+'
    match = re.search(pattern, text, re.IGNORECASE)

    if match:

        content = text[match.end():].strip()
        return True, content
    else:
        return False, text.strip()

def evaluate_with_gpt4(prediction_text, ground_truth_text, client):

    try:
        prompt = f"""Compare the predicted explanation with the reference explanation for why the audience laughed.

Reference explanation:
{ground_truth_text}

Predicted explanation:
{prediction_text}

Does the predicted explanation correctly identify the reason for laughter? The prediction doesn't need to be identical to the reference, but should accurately capture why the audience laughed.

Respond with only "CORRECT" or "INCORRECT"."""

        response = client.chat.completions.create(
            model="gpt-4",
            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 evaluate_laughter_reasoning(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 = []
    format_errors = defaultdict(list)

    correct_count = 0
    total_valid = 0


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

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

        has_correct_format, cleaned_content = check_required_format(model_output)


        detailed_item = {
            'id': item_id,
            'model_output': model_output,
            'ground_truth': ground_truth,
            'has_correct_format': has_correct_format,
            'cleaned_content': cleaned_content,
            'llm_evaluation': None,
            'is_correct': False
        }


        if has_correct_format and cleaned_content:

            _, gt_cleaned = check_required_format(ground_truth)
            if not gt_cleaned:
                gt_cleaned = ground_truth

            llm_eval = evaluate_with_gpt4(cleaned_content, gt_cleaned, 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:
            if not has_correct_format:
                format_errors['incorrect_format'].append(item_id)
            else:
                format_errors['empty_content'].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


    valid_contents = [item['cleaned_content'] for item in detailed_results if item['has_correct_format'] and item['cleaned_content']]
    avg_content_length = sum(len(content.split()) for content in valid_contents) / len(valid_contents) if valid_contents else 0


    correct_samples = [item for item in detailed_results if item['has_correct_format'] and item['is_correct']]
    incorrect_samples = [item for item in detailed_results if item['has_correct_format'] and not item['is_correct']]


    evaluation_result = {
        'task_info': {
            'task_name': 'laughter.reasoning',
            'dataset': 'SMILE',
            '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_content_length_words': round(avg_content_length, 2)
        },
        'error_analysis': {
            'format_errors': {
                error_type: {
                    'count': len(sample_ids),
                    'sample_ids': sample_ids
                } for error_type, sample_ids in format_errors.items()
            }
        }
    }


    if correct_samples:
        correct_avg_length = sum(len(item['cleaned_content'].split()) for item in correct_samples) / len(correct_samples)
        evaluation_result['content_analysis']['correct_samples_avg_length'] = round(correct_avg_length, 2)

    if incorrect_samples:
        incorrect_avg_length = sum(len(item['cleaned_content'].split()) for item in incorrect_samples) / len(incorrect_samples)
        evaluation_result['content_analysis']['incorrect_samples_avg_length'] = round(incorrect_avg_length, 2)


    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)


    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)


    format_error_samples = [item for item in detailed_results if not item['has_correct_format']]
    if format_error_samples:
        format_error_report_file = f"{base_name}_format_error_samples.json"
        with open(format_error_report_file, 'w', encoding='utf-8') as f:
            json.dump(format_error_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 content length: {evaluation_result['content_analysis']['avg_content_length_words']} words")
    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 format_error_samples:
        print(f"Format-error samples: {len(format_error_samples)}; see {format_error_report_file} for details")

    return evaluation_result


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

    try:
        evaluation_result = evaluate_laughter_reasoning(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)}")