data/inference_and_evaluation/evaluate_EM.py

import pandas as pd
import sys
import os
import re
import glob
import argparse
from typing import Dict, Tuple, Set
import string
import json


def normalize_answer(text: str) -> str:
    """
    Normalize answer by removing punctuation, extra whitespace, and converting to lowercase.
    This allows for minor differences in formatting while preserving the core content.

    Args:
        text: The answer text to normalize

    Returns:
        Normalized text
    """
    if not isinstance(text, str):
        # Convert non-string values to strings
        text = str(text)

    if not text:
        return ""

    # Convert to lowercase
    text = text.lower()

    # Remove punctuation
    translator = str.maketrans('', '', string.punctuation)
    text = text.translate(translator)

    # Normalize whitespace
    text = re.sub(r'\s+', ' ', text).strip()

    return text


def calculate_exact_match(csv_path: str, exclude_problem_ids: Set[str] = None,
                          flexible_matching: bool = True) -> Tuple[float, Dict]:
    """
    Calculate exact match accuracy from a CSV file with true and generated answers.

    Args:
        csv_path: Path to CSV file with columns problem_id, true_answer, generated_answer
        exclude_problem_ids: Set of problem IDs to exclude from evaluation
        flexible_matching: Whether to use normalized text comparison for more flexible matching

    Returns:
        Tuple containing:
        - Exact match accuracy as a percentage
        - Dictionary with detailed statistics
    """
    if exclude_problem_ids is None:
        exclude_problem_ids = set()

    if not os.path.exists(csv_path):
        print(f"Error: File not found: {csv_path}")
        sys.exit(1)
    try:
        df = pd.read_csv(csv_path)

        # Verify required columns exist
        required_cols = ['problem_id', 'true_answer', 'generated_answer']
        missing_cols = [col for col in required_cols if col not in df.columns]

        if missing_cols:
            print(f"Error: Missing required columns: {', '.join(missing_cols)}")
            sys.exit(1)

    except Exception as e:
        print(f"Error reading CSV file: {e}")
        sys.exit(1)

    # Filter out excluded problem IDs
    original_count = len(df)
    if exclude_problem_ids:
        df = df[~df['problem_id'].isin(exclude_problem_ids)]
        excluded_count = original_count - len(df)
        print(f"Excluded {excluded_count} examples with problem IDs in the exclusion list.")

    # Compare answers based on matching strategy
    if flexible_matching:
        # Apply normalization to both true and generated answers
        df['normalized_true'] = df['true_answer'].apply(normalize_answer)
        df['normalized_generated'] = df['generated_answer'].apply(normalize_answer)
        df['exact_match'] = df['normalized_true'] == df['normalized_generated']
    else:
        # Strict matching (exact string comparison)
        df['exact_match'] = df['true_answer'] == df['generated_answer']

    total_examples = len(df)
    correct_examples = df['exact_match'].sum()
    accuracy = (correct_examples / total_examples) * 100 if total_examples > 0 else 0

    # Group by problem_id to analyze patterns
    problem_accuracy = df.groupby('problem_id')['exact_match'].mean() * 100

    err_count = df[df['generated_answer'].apply(lambda x: "ERROR" in str(x))].shape[0]

    stats = {
        'total_examples': total_examples,
        'original_count': original_count,
        'excluded_count': original_count - total_examples,
        'correct_examples': int(correct_examples),
        'accuracy': accuracy,
        'err_count': err_count,
        'problem_accuracies': problem_accuracy.to_dict(),
        'incorrect_examples': df[~df['exact_match']]['problem_id'].tolist(), 
        'word_count': df['generated_answer'].apply(lambda x: len(str(x).split())).mean(),
    }

    return accuracy, stats


def print_results(model_name: str, inference_mode: str, accuracy: float, stats: Dict, mode: str = "Exact Match") -> None:
    """Print formatted results to console for a single model."""
    print("\n" + "=" * 60)
    print(f"{mode.upper()} EVALUATION RESULTS FOR {model_name} ({inference_mode})")
    print("=" * 60)
    print(f"Original examples: {stats['original_count']}")
    if stats['excluded_count'] > 0:
        print(f"Excluded examples: {stats['excluded_count']}")
    print(f"Total examples evaluated: {stats['total_examples']}")
    print(f"Correct answers: {stats['correct_examples']}")
    print(f"{mode} accuracy: {accuracy:.2f}%")
    print("-" * 60)

    if len(stats['problem_accuracies']) > 1:
        print("\nPer-problem accuracy:")
        for problem_id, acc in stats['problem_accuracies'].items():
            print(f"  Problem {problem_id}: {acc:.2f}%")

    # List problem IDs with incorrect answers if any
    if stats['incorrect_examples']:
        print("\nProblem IDs with incorrect answers:")
        incorrect_problem_counts = {}
        for problem_id in stats['incorrect_examples']:
            incorrect_problem_counts[problem_id] = incorrect_problem_counts.get(problem_id, 0) + 1

        for problem_id, count in sorted(incorrect_problem_counts.items()):
            print(f"  Problem {problem_id}: {count} incorrect")

    print("=" * 60 + "\n")


def compare_models(results: Dict[str, Dict], output_file: str = "model_comparison.txt", mode: str = "Exact Match") -> None:
    """
    Compare results across multiple models and inference modes.

    Args:
        results: Dictionary mapping model identifiers (model_name:inference_mode) to their statistics
        output_file: Path to save the comparison results
    """
    print("\n" + "=" * 80)
    print(f"MODEL COMPARISON SUMMARY ({mode.upper()})")
    print("=" * 80)

    print(f"{'Model':<26} | {'Mode':<10} | {'Accuracy (%)':<12} | {'Excluded/Total':<15} | {'Word Count':<10} | {'Error Count':<15}")
    print("-" * 80)

    # Sort by inference mode first (0-shot then ICL), then by accuracy (highest first)
    sorted_results = sorted(
        results.items(),
        key=lambda x: (
            # Sort by inference mode (0-shot first, then ICL)
            0 if "0-shot" in x[0] else 1,
            # Then by accuracy (descending)
            -x[1]['accuracy']
        )
    )

    # Group results by inference mode for better visualization
    current_inference_mode = None

    for model_id, stats in sorted_results:
        model_name, inference_mode = model_id.split(':')

        # Print a separator when switching inference modes
        if current_inference_mode != inference_mode:
            if current_inference_mode is not None:
                print("-" * 80)
            current_inference_mode = inference_mode

        acc = stats['accuracy']
        excluded_ratio = f"{stats['excluded_count']}/{stats['original_count']}"
        word_count = stats['word_count']
        error_count = f"{stats['err_count']}" if 'err_count' in stats else "None"
        print(f"{model_name:<26} | {inference_mode:<10} | {acc:<12.2f} | {excluded_ratio:<15} | {word_count:<10.2f} | {error_count:<15}")

    print("\n" + "=" * 80)

    # Write detailed results to file
    with open(output_file, 'w') as f:
        f.write("MODEL COMPARISON SUMMARY\n")
        f.write("=" * 60 + "\n\n")

        # Overall accuracy table
        f.write(f"{'Model':<26} | {'Mode':<10} | {'Accuracy (%)':<12} | {'Excluded/Total':<15} | {'Word Count':<15}\n")
        f.write("-" * 70 + "\n")

        current_inference_mode = None
        for model_id, stats in sorted_results:
            model_name, inference_mode = model_id.split(':')

            # Print a separator when switching inference modes
            if current_inference_mode != inference_mode:
                if current_inference_mode is not None:
                    f.write("-" * 70 + "\n")
                current_inference_mode = inference_mode

            acc = stats['accuracy']
            excluded_ratio = f"{stats['excluded_count']}/{stats['original_count']}"
            f.write(f"{model_name:<26} | {inference_mode:<10} | {acc:<12.2f} | {excluded_ratio:<15} | {word_count:<10.2f}\n")

        f.write("\n")

        # Per-problem comparison - first for 0-shot, then for ICL
        for mode in ["0-shot", "ICL"]:
            # Filter results for this inference mode
            mode_results = {k.split(':')[0]: v for k, v in results.items() if k.split(':')[1] == mode}

            if len(mode_results) > 1:
                all_problem_ids = set()
                for model_stats in mode_results.values():
                    all_problem_ids.update(model_stats['problem_accuracies'].keys())

                if len(all_problem_ids) > 1:
                    f.write(f"\nPER-PROBLEM ACCURACY COMPARISON (%) - {mode}\n")
                    f.write("-" * 60 + "\n")

                    header = f"{'Problem ID':<12} | " + " | ".join(f"{model:<12}" for model in mode_results.keys())
                    f.write(header + "\n")
                    f.write("-" * len(header) + "\n")

                    for problem_id in sorted(all_problem_ids):
                        row = f"{problem_id:<12} | "
                        for model in mode_results.keys():
                            acc = mode_results[model]['problem_accuracies'].get(problem_id, 0)
                            row += f"{acc:<12.2f} | "
                        f.write(row.rstrip(" | ") + "\n")

                    f.write("\n")

    print(f"Comparison results saved to: {output_file}")


def get_model_info(filename: str) -> Tuple[str, str]:
    """
    Extract model name and inference mode from filename.

    Args:
        filename: The filename to parse

    Returns:
        Tuple of (model_name, inference_mode)
    """
    base_filename = os.path.basename(filename)

    # Default values if parsing fails
    model_name = "unknown"
    inference_mode = "unknown"

    # Pattern matching for different model naming conventions
    if "llama32_vision_90b" in base_filename:
        model_name = "llama32_vision_90b"

        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"
        # Legacy support for few-shot naming
        elif "_few-shot" in base_filename:
            inference_mode = "ICL"

    elif "qwen" in base_filename.lower():
        # Try to extract model size using regex
        model_size_match = re.search(r'qwen(\d+B)', base_filename, re.IGNORECASE)
        if model_size_match:
            model_name = f"qwen{model_size_match.group(1)}"
        else:
            model_name = "qwen"

        # Extract inference mode
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"
        # Legacy support for few-shot naming
        elif "_few-shot" in base_filename:
            inference_mode = "ICL"
        elif "_with_answers" in base_filename:
            # Legacy filename format
            inference_mode = "ICL"

    elif "llava_7b" in base_filename:
        model_name = "llava_7B"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"

    elif "llavamed" in base_filename:
        model_name = "llavamed_7B"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"

    elif "llava_13b" in base_filename:
        model_name = "llava_13B"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"

    elif "llavanext_7b" in base_filename:
        model_name = "llavanext_7B"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"

    elif "llavaonevision_7b" in base_filename:
        model_name = "llavaonevision_7B"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"

    elif "llavaonevision_0.5b" in base_filename:
        model_name = "llavaonevision_0.5B"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"

    elif "llama33textonly" in base_filename:
        model_name = "llama33textonly (baseline)"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"

    elif "random" in base_filename:
        model_name = "random (baseline)"
        if "_ICL" in base_filename:
            inference_mode = "ICL"

    elif "majority" in base_filename:
        model_name = "majority (baseline)"
        if "_ICL" in base_filename:
            inference_mode = "ICL"


    elif "aya_vision_32b" in base_filename:
        model_name = "aya_vision_32b"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"
        # Legacy support for few-shot naming
        elif "_few-shot" in base_filename:
            inference_mode = "ICL"

    elif "llama4_17b" in base_filename:
        model_name = "llama4_17b"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"
        # Legacy support for few-shot naming
        elif "_few-shot" in base_filename:
            inference_mode = "ICL"

    elif "gpt-4o" in base_filename:
        model_name = "gpt-4o"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"
        # Legacy support for few-shot naming
        elif "_few-shot" in base_filename:
            inference_mode = "ICL"

    elif "claude-3-7-sonnet" in base_filename:
        model_name = "claude-3-7-sonnet"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"
        # Legacy support for few-shot naming
        elif "_few-shot" in base_filename:
            inference_mode = "ICL"

    elif "MedVLM-R1" in base_filename:
        model_name = "MedVLM-R1"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"
        # Legacy support for few-shot naming
        elif "_few-shot" in base_filename:
            inference_mode = "ICL"

    elif "medgemma" in base_filename:
        model_name = "medgemma_4b"
        if "_0-shot" in base_filename:
            inference_mode = "0-shot"
        elif "_ICL" in base_filename:
            inference_mode = "ICL"
        # Legacy support for few-shot naming
        elif "_few-shot" in base_filename:
            inference_mode = "ICL"


    return model_name, inference_mode


def parse_arguments():
    """Parse command line arguments."""
    parser = argparse.ArgumentParser(
        description="Evaluate exact match accuracy for VLM models on SMMILE benchmark"
    )
    parser.add_argument(
        "results_dir",
        nargs="?",
        default="../results",
        help="Directory containing result CSV files (default: ./results)"
    )
    parser.add_argument(
        "--model",
        type=str,
        help="Specific model to evaluate (e.g., qwen72B, llama32_vision_90b)"
    )
    parser.add_argument(
        "--inference-mode",
        choices=["0-shot", "ICL"],
        help="Specific inference mode to evaluate"
    )
    parser.add_argument(
        "--strict-match",
        action="store_true",
        help="Use strict exact matching (case and punctuation sensitive)"
    )

    return parser.parse_args()


def main():
    args = parse_arguments()

    # List of problem IDs to exclude from evaluation
    exclude_problem_ids = {
        # Add any problem IDs you want to exclude here
    }

    # Find CSV files in the results directory
    results_dir = args.results_dir
    os.makedirs(results_dir, exist_ok=True)  # Ensure the results directory exists

    # Build file pattern based on model and inference-mode filters
    patterns = []

    # If specific model is requested
    if args.model:
        if args.inference_mode:
            # Both model and inference mode specified
            patterns.append(os.path.join(results_dir, f"result_{args.model}_{args.inference_mode}.csv"))
        else:
            # Only model specified, try both inference modes
            patterns.append(os.path.join(results_dir, f"result_{args.model}_0-shot.csv"))
            patterns.append(os.path.join(results_dir, f"result_{args.model}_0-shot_open.csv"))
            patterns.append(os.path.join(results_dir, f"result_{args.model}_ICL.csv"))
            patterns.append(os.path.join(results_dir, f"result_{args.model}_ICL_open.csv"))
            # Support legacy few-shot naming
            patterns.append(os.path.join(results_dir, f"result_{args.model}_few-shot.csv"))
    else:
        # No specific model, look for all supported models
        if args.inference_mode:
            # Only inference mode specified
            patterns.append(os.path.join(results_dir, f"result_*_{args.inference_mode}.csv"))
            patterns.append(os.path.join(results_dir, f"result_*_{args.inference_mode}_open.csv"))
            # Support legacy few-shot to ICL conversion
            if args.inference_mode == "ICL":
                patterns.append(os.path.join(results_dir, f"result_*_few-shot.csv"))
        else:
            # No filters, look for all result files
            patterns.append(os.path.join(results_dir, "result_*_0-shot.csv"))
            patterns.append(os.path.join(results_dir, "result_*_0-shot_open.csv"))
            patterns.append(os.path.join(results_dir, "result_*_ICL.csv"))
            patterns.append(os.path.join(results_dir, "result_*_ICL_open.csv"))
            # Legacy formats
            patterns.append(os.path.join(results_dir, "result_*_few-shot.csv"))
            patterns.append(os.path.join(results_dir, "result_*_with_answers.csv"))

    csv_files = []
    for pattern in patterns:
        matches = glob.glob(pattern)
        csv_files.extend(matches)

    # Also look in current directory if results_dir doesn't contain any files
    if not csv_files:
        for pattern in [p.replace(results_dir + "/", "") for p in patterns]:
            matches = glob.glob(pattern)
            csv_files.extend(matches)

    if not csv_files:
        print(f"No result files found matching the criteria.")
        if args.model:
            print(f"Model filter: {args.model}")
        if args.inference_mode:
            print(f"Inference mode filter: {args.inference_mode}")
        print("Check the directory and file naming conventions.")
        sys.exit(1)

    print(f"Found {len(csv_files)} result files to evaluate:")
    for f in csv_files:
        print(f"  {os.path.basename(f)}")
    print()

    all_results = {}

    for csv_path in csv_files:
        model_name, inference_mode = get_model_info(csv_path)
        if model_name == 'unknown':
            print(f"Skipping: {csv_path}")
            continue
        model_id = f"{model_name}:{inference_mode}"  # Create unique identifier for model+inference mode combination

        print(f"Processing {model_name} model ({inference_mode})...")

        # Use flexible matching by default, unless strict-match flag is provided
        flexible_matching = not args.strict_match
        matching_mode = "flexible" if flexible_matching else "strict"
        print(f"Using {matching_mode} matching for answer comparison")

        accuracy, stats = calculate_exact_match(csv_path, exclude_problem_ids, flexible_matching)
        all_results[model_id] = stats
        print_results(model_name, inference_mode, accuracy, stats)

        # Save individual evaluation results
        output_file = os.path.splitext(csv_path)[0] + "_evaluation.json"
        with open(output_file, 'w') as f:
            json.dump({'model': model_name, 'inference_mode': inference_mode, **stats}, f)
        print(f"Evaluation results for {model_name} ({inference_mode}) saved to: {output_file}")

    # Only compare models if we have more than one result
    if len(all_results) > 1:
        comparison_file = os.path.join(results_dir, "model_comparison.txt")
        compare_models(all_results, comparison_file)


if __name__ == "__main__":
    main()