code/evaluation_code/level3/evaluation_MECPE.py

import json
import re
import ast
from collections import Counter, defaultdict
from datetime import datetime


from sklearn.metrics import f1_score, precision_score, recall_score

def parse_emotion_cause_pairs(output_text):

    if not output_text:
        return {}, False, "empty_output"

    valid_emotions = ['joy', 'sadness', 'anger', 'disgust', 'fear', 'surprise', 'neutral']

    try:
        cleaned_output = output_text.strip()


        json_match = re.search(r'\{.*\}', cleaned_output, re.DOTALL)
        if not json_match:
            return {}, False, "no_json_structure"

        json_content = json_match.group()

        parsed = None


        try:

            parsed = ast.literal_eval(json_content)
        except (ValueError, SyntaxError) as e:


            if "EOF" in str(e) or "end of string" in str(e):


                last_comma_index = json_content.rfind(',')
                if last_comma_index != -1:

                    content_after_comma = json_content[last_comma_index+1:].strip()
                    if content_after_comma and content_after_comma != '}':
                        truncated_content = json_content[:last_comma_index] + '}'
                        try:

                            parsed = ast.literal_eval(truncated_content)

                        except (ValueError, SyntaxError):

                            pass


            if parsed is None:
                try:

                    json_content_fixed = json_content.replace("'", '"')
                    parsed = json.loads(json_content_fixed)
                except json.JSONDecodeError:

                    raise e


        if not isinstance(parsed, dict):
            return {}, False, "not_dictionary"

        validated_pairs = {}
        for utterance_id, pair_data in parsed.items():

            if not isinstance(pair_data, dict) or 'emotion' not in pair_data or 'cause_utterance_id' not in pair_data:
                continue

            emotion = str(pair_data['emotion']).lower().strip()
            cause_id = str(pair_data['cause_utterance_id']).strip()


            if emotion not in valid_emotions:
                continue


            try:
                int(utterance_id)
                int(cause_id)
            except (ValueError, TypeError):
                continue

            validated_pairs[str(utterance_id)] = {
                'emotion': emotion,
                'cause_utterance_id': cause_id
            }

        return validated_pairs, len(validated_pairs) > 0, None

    except Exception as e:

        return {}, False, f"parsing_error_{type(e).__name__}"

def calculate_pair_extraction_metrics(predictions, ground_truths):

    total_tp = 0
    total_fp = 0
    total_fn = 0

    emotion_correct_on_common = 0
    cause_correct_on_common = 0
    total_common_utterances = 0

    all_true_emotions = []
    all_pred_emotions = []

    for pred_dict, true_dict in zip(predictions, ground_truths):

        pred_pairs = {(str(uid), data['emotion'], str(data['cause_utterance_id'])) for uid, data in pred_dict.items()}
        true_pairs = {(str(uid), data['emotion'], str(data['cause_utterance_id'])) for uid, data in true_dict.items()}


        all_pred_emotions.extend([data['emotion'] for data in pred_dict.values()])
        all_true_emotions.extend([data['emotion'] for data in true_dict.values()])


        total_tp += len(pred_pairs.intersection(true_pairs))
        total_fp += len(pred_pairs.difference(true_pairs))
        total_fn += len(true_pairs.difference(pred_pairs))


        common_ids = set(pred_dict.keys()) & set(true_dict.keys())
        total_common_utterances += len(common_ids)
        for uid in common_ids:
            if pred_dict[uid]['emotion'] == true_dict[uid]['emotion']:
                emotion_correct_on_common += 1
            if pred_dict[uid]['cause_utterance_id'] == true_dict[uid]['cause_utterance_id']:
                cause_correct_on_common += 1


    micro_precision = total_tp / (total_tp + total_fp) if (total_tp + total_fp) > 0 else 0
    micro_recall = total_tp / (total_tp + total_fn) if (total_tp + total_fn) > 0 else 0
    micro_f1 = 2 * micro_precision * micro_recall / (micro_precision + micro_recall) if (micro_precision + micro_recall) > 0 else 0

    emotion_accuracy_common = emotion_correct_on_common / total_common_utterances if total_common_utterances > 0 else 0
    cause_accuracy_common = cause_correct_on_common / total_common_utterances if total_common_utterances > 0 else 0

    return {
        'micro_f1': micro_f1,
        'micro_precision': micro_precision,
        'micro_recall': micro_recall,
        'emotion_accuracy_on_common_ids': emotion_accuracy_common,
        'cause_accuracy_on_common_ids': cause_accuracy_common,
        'total_predicted_pairs': total_tp + total_fp,
        'total_ground_truth_pairs': total_tp + total_fn,
        'exact_matches': total_tp,
        'emotion_distribution': dict(Counter(all_true_emotions)),
        'predicted_emotion_distribution': dict(Counter(all_pred_emotions))
    }

def evaluate_multimodal_emotion_cause_pair_extraction(result_file_path):


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

    predictions = []
    ground_truths = []
    detailed_results = []
    extraction_errors = defaultdict(list)

    for item in results:
        item_id = item.get('id', 'unknown')
        model_output = item.get('model_output', '')
        ground_truth = item.get('ground_truth', {})


        pred_pairs, pred_valid, pred_error = parse_emotion_cause_pairs(model_output)


        if isinstance(ground_truth, str):
            gt_pairs, gt_valid, gt_error = parse_emotion_cause_pairs(ground_truth)
        else:
            gt_pairs, gt_valid, gt_error = parse_emotion_cause_pairs(json.dumps(ground_truth))

        detailed_item = {
            'id': item_id,
            'model_output': model_output,
            'ground_truth': ground_truth,
            'extracted_prediction': pred_pairs,
            'extracted_ground_truth': gt_pairs,
            'prediction_valid': pred_valid,
            'ground_truth_valid': gt_valid,
            'predicted_pairs_count': len(pred_pairs),
            'ground_truth_pairs_count': len(gt_pairs)
        }
        detailed_results.append(detailed_item)

        if not pred_valid:
            extraction_errors[pred_error].append(item_id)
        if not gt_valid:

            extraction_errors[f"gt_{gt_error}"].append(item_id)


        if pred_valid and gt_valid:
            predictions.append(pred_pairs)
            ground_truths.append(gt_pairs)

    if not predictions:
        print("Error: No valid prediction–ground truth pairs were found for evaluation.")
        print(f"Total samples: {len(results)}")
        print("Parsing error stats:", json.dumps(dict(extraction_errors), indent=2))
        return {
            'error': 'No valid prediction and ground_truth pairs found for evaluation',
            'total_samples': len(results),
            'extraction_errors': dict(extraction_errors)
    }


    metrics = calculate_pair_extraction_metrics(predictions, ground_truths)

    evaluation_result = {
        'task_info': {
            'task_name': 'multimodal.emotion.cause.pair.extraction',
            'dataset': 'ECF',
            'evaluation_time': datetime.now().isoformat(),
            'total_samples': len(results),
            'valid_samples_for_eval': len(predictions),
            'extraction_success_rate': round(len(predictions) / len(results) if results else 0, 4)
        },
        'metrics': {
            'Micro_F1': round(metrics['micro_f1'], 4),
            'Micro_Precision': round(metrics['micro_precision'], 4),
            'Micro_Recall': round(metrics['micro_recall'], 4),
            'Emotion_ACC_on_Common_IDs': round(metrics['emotion_accuracy_on_common_ids'], 4),
            'Cause_ACC_on_Common_IDs': round(metrics['cause_accuracy_on_common_ids'], 4),
            'Total_Predicted_Pairs': metrics['total_predicted_pairs'],
            'Total_Ground_Truth_Pairs': metrics['total_ground_truth_pairs'],
            'Exact_Matches': metrics['exact_matches']
        },
        'distribution_analysis': {
            'emotion_distribution': metrics['emotion_distribution'],
            'predicted_emotion_distribution': metrics['predicted_emotion_distribution']
        },
        'error_analysis': {
            'extraction_errors': {
                error_type: {
                    'count': len(sample_ids),
                    'sample_ids': sample_ids[:10]
                } for error_type, sample_ids in extraction_errors.items()
            }
        }
    }


    base_name = result_file_path.rsplit('.', 1)[0]
    eval_output_file = f"{base_name}_evaluation.json"
    detailed_output_file = f"{base_name}_detailed_results.json"

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

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


    print("\n" + "="*50)
    print("Evaluation Report")
    print("="*50)
    print(f"Evaluation complete: {len(results)} total samples")
    print(f"Valid evaluation samples (both prediction and label parsed successfully): {len(predictions)} / {len(results)} (extraction success rate: {evaluation_result['task_info']['extraction_success_rate']:.2%})")
    print("\n--- Primary Metrics ---")
    print(f"Micro F1: {evaluation_result['metrics']['Micro_F1']:.4f}")
    print(f"Micro Precision: {evaluation_result['metrics']['Micro_Precision']:.4f}")
    print(f"Micro Recall: {evaluation_result['metrics']['Micro_Recall']:.4f}")
    print("\n--- Auxiliary Metrics ---")
    print(f"Emotion accuracy on common IDs (Emotion ACC): {evaluation_result['metrics']['Emotion_ACC_on_Common_IDs']:.4f}")
    print(f"Cause accuracy on common IDs (Cause ACC): {evaluation_result['metrics']['Cause_ACC_on_Common_IDs']:.4f}")
    print(f"Total predicted pairs: {evaluation_result['metrics']['Total_Predicted_Pairs']}")
    print(f"Total ground-truth pairs: {evaluation_result['metrics']['Total_Ground_Truth_Pairs']}")
    print(f"Exact matches: {evaluation_result['metrics']['Exact_Matches']}")

    if extraction_errors:
        print("\n--- Parsing Error Analysis ---")
        for error_type, info in evaluation_result['error_analysis']['extraction_errors'].items():
            print(f"- Type: {error_type}, Count: {info['count']}")

    print(f"Detailed evaluation results saved to: {eval_output_file}")
    print(f"Per-sample parsing details saved to: {detailed_output_file}")


    return evaluation_result




if __name__ == "__main__":

    result_file = "model_result.json"

    try:
        evaluation_result = evaluate_multimodal_emotion_cause_pair_extraction(result_file)

    except FileNotFoundError:
        print(f"Error: File '{result_file}' not found. Please check that the path is correct.")
    except json.JSONDecodeError:
        print(f"Error: File '{result_file}' is not valid JSON. Ensure the file is a JSON list (starts with '[' and ends with ']').")
    except Exception as e:
        print(f"An unknown error occurred during evaluation: {e}")