benchmark/IOAI/IOAI-2025/Individual-Contest/Pixel/metrics.py

import json
from pathlib import Path 
from argparse import ArgumentParser
import os

import torch
from transformers import CLIPProcessor, CLIPModel
from datasets import load_from_disk, load_dataset
from PIL import Image
import numpy as np
import math
from tqdm.auto import tqdm  # Progress bar
import random
import matplotlib.pyplot as plt


H, W = 224, 224
MODEL_PATH = "openai/clip-vit-large-patch14"
DATASET_PATH = "IOAI-official/IOAI-2025-Pixel-ref"
MASK_PATH = "submission.jsonl"
SPLIT = "ref"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
RETAIN_RATIO = 0.0625
SCORE_OUTPUT_FILE = "score.json"
MEAN_COLOR = (0, 0, 0)


parser = ArgumentParser()
parser.add_argument("--mask-file", default='masks.npy', type=str)
parser.add_argument("--debug", default=False, action='store_true')
args = parser.parse_args()


def write_error_score(error_message):
    """Write error score to JSON file"""
    error_json = {
        "status": False,
        "score": {
            "public_a": 0.0,
            "public_detail": {
                "Score": 0.0,
                "Accuracy": 0.0,
            },
            "private_b": 0.0,
            "private_detail": {
                "Score": 0.0,
                "Accuracy": 0.0,
            },
        },
        "msg": f"Error: {error_message}",
    }
    
    with open(SCORE_OUTPUT_FILE, 'w') as f:
        json.dump(error_json, f, indent=2)
    print(f"Error written to {SCORE_OUTPUT_FILE}: {error_message}")


def safe_load_masks(mask_file_path, expected_dataset_size):
    """
    Safely load and validate the masks file from contestants.
    
    Parameters:
        mask_file_path: Path to the masks file
        expected_dataset_size: Expected number of test cases
        
    Returns:
        dict: Validated masks dictionary or None if invalid
    """
    try:
        # Check if file exists
        if not os.path.exists(mask_file_path):
            write_error_score("Mask file not found.")
            return None
        
        # Check file size (prevent extremely large files)
        file_size = os.path.getsize(mask_file_path)
        max_file_size = 50 * 1024 * 1024  # 50MB limit
        if file_size > max_file_size:
            write_error_score("Mask file too large.")
            return None
        
        masks = {}
        
        # Load based on file extension
        if mask_file_path.endswith('.jsonl'):
            # Load JSONL format (one JSON object per line)
            try:
                with open(mask_file_path, 'r') as f:
                    for line_num, line in enumerate(f, 1):
                        if line.strip():  # Skip empty lines
                            try:
                                data = json.loads(line.strip())
                                idx = data.get('idx')
                                coordinates = data.get('coordinates')
                                
                                if idx is None or coordinates is None:
                                    write_error_score("Invalid JSONL format.")
                                    return None
                                
                                masks[idx] = coordinates
                            except json.JSONDecodeError:
                                write_error_score("Invalid JSON in mask file.")
                                return None
            except Exception:
                write_error_score("Unable to load JSONL mask file.")
                return None
                
        # Validate it's a dictionary
        if not isinstance(masks, dict):
            write_error_score("Mask data must be a dictionary.")
            return None
        
        # Check number of entries
        if len(masks) != expected_dataset_size:
            # print(len(masks), expected_dataset_size)
            write_error_score("Incorrect number of mask entries.")
            return None
        
        # Validate each mask entry
        for idx, coordinates in masks.items():
            # Validate index
            if not isinstance(idx, (int, np.integer, str)):
                write_error_score("Invalid mask index format.")
                return None
            
            # Validate coordinates structure
            if not isinstance(coordinates, (tuple, list)) or len(coordinates) != 2:
                write_error_score("Invalid mask coordinate structure.")
                return None
            
            try:
                (top, left), (bottom, right) = coordinates
            except (ValueError, TypeError):
                write_error_score("Invalid mask coordinate format.")
                return None
            
            # Validate coordinate types and values
            coords = [top, left, bottom, right]
            for coord in coords:
                if not isinstance(coord, (int, np.integer)):
                    write_error_score("Mask coordinates must be integers.")
                    return None
                
                if not (0 <= coord <= 224):
                    write_error_score("Mask coordinates out of valid range.")
                    return None
            
            # Validate coordinate ordering
            if not (top < bottom and left < right):
                write_error_score("Invalid mask coordinate ordering.")
                return None
            
            # Validate area constraint
            crop_area = (bottom - top) * (right - left)
            max_area = RETAIN_RATIO * 224 * 224
            if crop_area > max_area:
                write_error_score("Mask area exceeds allowed limit.")
                return None
            
            # Additional security: prevent degenerate cases
            if crop_area <= 0:
                write_error_score("Invalid mask area.")
                return None
        
        return masks
        
    except Exception as e:
        write_error_score("Unexpected error loading mask file.")
        return None


def check_validity(coordinates):
    """
    Check if coordinates are valid according to the requirements.
    Returns True if valid, False otherwise.
    """
    try:
        # Check if coordinates is a tuple of two tuples
        if not hasattr(coordinates, '__iter__') or len(coordinates) != 2:
            return False
        
        (top, left), (bottom, right) = coordinates
        
        # Check if all coordinates are integers
        if not all(isinstance(coord, (int, np.integer)) for coord in [top, left, bottom, right]):
            return False
        
        # Check if coordinates are within image bounds
        # For slicing mask[top:bottom, left:right], valid ranges are:
        # top, left: [0, 223] (inclusive)
        # bottom, right: [1, 224] (inclusive) since we need top < bottom and left < right
        if not (0 <= top < 224 and 0 <= left < 224 and 1 <= bottom <= 224 and 1 <= right <= 224):
            return False
        
        # Check if top-left is actually top-left of bottom-right (proper ordering)
        if not (top < bottom and left < right):
            return False
        
        # Check that the crop area doesn't exceed RETAIN_RATIO
        crop_area = (bottom - top) * (right - left)
        max_area = RETAIN_RATIO * 224 * 224
        if crop_area > max_area:
            return False
        
        return True
    except Exception:
        return False

def generate_mask_from_coordinates(image, coordinates):
    """
    Generate a binary mask from crop coordinates.
    
    Parameters:
        image: PIL Image
        coordinates: tuple of ((top, left), (bottom, right))
    
    Returns:
        numpy array: Binary mask with 1s in the crop area
    """
    H, W = 224, 224  # Standard image size
    mask = np.zeros((H, W), dtype=np.int8)
    
    (top, left), (bottom, right) = coordinates
    mask[top:bottom, left:right] = 1
    
    return mask

def apply_mask_with_mean(image, mask, mean_rgb=MEAN_COLOR):
    """
    Apply arbitrary binary mask to image, replacing masked areas with mean values

    Parameters:
    - image: PIL Image (224x224)
    - mask: Binary numpy array or PIL Image (224x224) where 0 is the area to drop and 1 is the area to keep
    - mean_rgb: RGB mean values to use (default: from config)

    Returns: Modified PIL Image
    """
    # Convert images to numpy arrays
    img_array = np.array(image).copy()

    # Ensure mask is numpy array
    if isinstance(mask, Image.Image):
        mask_array = np.array(mask.convert('L')) > 127  # Convert to binary
    else:
        mask_array = mask > 0

    # Reshape mask for broadcasting with RGB
    mask_3d = np.stack([mask_array] * 3, axis=2)

    # Convert mean values to 0-255 range
    mean_values = np.array([int(m * 255) for m in mean_rgb])
    # Apply mask - replace areas where mask is 0 (drop) with mean values, keep areas where mask is 1
    img_array = np.where(mask_3d, img_array, mean_values.reshape(1, 1, 3))

    return Image.fromarray(img_array.astype(np.uint8))


if __name__ == '__main__':
    try:
        try:
            dataset = load_dataset(DATASET_PATH, split=SPLIT)
        except Exception:
            write_error_score("Unable to load reference dataset.")
            exit(1)

        # Safely load and validate masks
        masks = safe_load_masks(MASK_PATH, len(dataset))
        if masks is None:
            exit(1)  # Error already written by safe_load_masks

        # Check validity of coordinates and report invalid ones
        invalid_coordinates = []
        valid_coordinates = 0
        for idx, coordinates in masks.items():
            if not check_validity(coordinates):
                invalid_coordinates.append(idx)
            else:
                valid_coordinates += 1
        
        if invalid_coordinates:
            print(f"Warning: Found {len(invalid_coordinates)} invalid coordinates (indices: {invalid_coordinates[:10]}{'...' if len(invalid_coordinates) > 10 else ''})")
            print(f"Invalid coordinates will be treated as incorrect predictions")
        print(f"Valid coordinates: {valid_coordinates}/{len(masks)}")

        #dataset = dataset.select(range(10)) # debug remove later

        # --- Step 1: Load Model and Processor ---
        print(f"Loading CLIP model and processor: {MODEL_PATH}...")
        try:
            model = CLIPModel.from_pretrained(MODEL_PATH).to(DEVICE)
            processor = CLIPProcessor.from_pretrained(MODEL_PATH)
            model.eval()  # Set to evaluation mode
            print("Model and processor loaded successfully.")
        except Exception as e:
            write_error_score("Unable to load model.")
            exit(1)

        try:
            labels = sorted(list(set(dataset['name']))) + ['other']
            text_inputs = processor(text=labels, return_tensors="pt", padding=True).to(DEVICE)
        except Exception:
            write_error_score("Unable to process labels.")
            exit(1)

        # Map label names to indices for later comparison
        label_to_index = {label: i for i, label in enumerate(labels)}
        index_to_label = {i: label for label, i in label_to_index.items()}  # For mapping prediction back

        def predict_with_coordinates(image, coordinates):
            try:
                # Generate mask from coordinates
                mask = generate_mask_from_coordinates(image, coordinates)
                assert len(mask.shape) == 2

                if image.mode != "RGB":
                    image = image.convert("RGB")
                image = apply_mask_with_mean(image, mask)
                image_processed = processor(images=image, return_tensors="pt").to(DEVICE)
                pixel_values = image_processed['pixel_values']
                outputs_full = model(pixel_values=pixel_values, **text_inputs)
                logits_full = outputs_full.logits_per_image  # Shape: (1, num_labels)
                predicted_index_full = logits_full.argmax(dim=-1).item()
                return predicted_index_full
            except Exception:
                # Return a random prediction if processing fails
                return len(labels) - 1  # Return 'other' class

        def get_accuracy(masks):
            try:
                with torch.no_grad():  # Disable gradient calculations for inference
                    correct = 0
                    for item in tqdm(dataset):
                        idx = item['idx']
                        if idx not in masks:
                            continue
                        coordinates = masks[idx]
                        
                        # Check coordinates validity - if invalid, mark as incorrect
                        if not check_validity(coordinates):
                            print(f"Invalid coordinates for item {idx}")
                            continue  # Skip this item, treating it as incorrect
                        
                        image = item['image']
                        true_label_label = item['name']  # This is now the animal class name

                        # Store true label for confusion matrix
                        true_label_idx = label_to_index[true_label_label]
                        if predict_with_coordinates(image, coordinates) == true_label_idx:
                            correct += 1
                return correct / len(masks)
            except Exception:
                return 0.0

        def get_accuracy_by_sets(masks):
            """Calculate accuracy for A set (smaller) and B set (larger) with 30:70 split"""
            try:
                # Set random seed for reproducible shuffling
                random.seed(42)
                
                with torch.no_grad():
                    correct_a = 0
                    correct_b = 0
                    total_a = 0
                    total_b = 0
                    
                    # First, collect all valid items that have masks
                    valid_items = []
                    for item in dataset:
                        idx = item['idx']
                        if idx in masks:
                            valid_items.append(item)
                    
                    # Group items by class name for stratified sampling
                    items_by_class = {}
                    for item in valid_items:
                        class_name = item['name']
                        if class_name not in items_by_class:
                            items_by_class[class_name] = []
                        items_by_class[class_name].append(item)
                    
                    # Stratified split: for each class, allocate 30% to A and 70% to B
                    set_a_items = []
                    set_b_items = []
                    
                    for class_name, class_items in items_by_class.items():
                        # Shuffle items within each class for random stratified sampling
                        random.shuffle(class_items)
                        
                        # Calculate split point for this class (30% to A, 70% to B)
                        split_point = int(len(class_items) * 0.3)
                        
                        # Ensure at least one item goes to each set if possible
                        if len(class_items) >= 2:
                            if split_point == 0:
                                split_point = 1
                            elif split_point == len(class_items):
                                split_point = len(class_items) - 1
                        
                        class_a_items = class_items[:split_point]
                        class_b_items = class_items[split_point:]
                        
                        set_a_items.extend(class_a_items)
                        set_b_items.extend(class_b_items)
                        
                        print(f"Class '{class_name}': {len(class_items)} total, {len(class_a_items)} to A, {len(class_b_items)} to B")
                    
                    print(f"Stratified split: Set A has {len(set_a_items)} items, Set B has {len(set_b_items)} items")
                    
                    # Verify class distribution
                    a_class_counts = {}
                    b_class_counts = {}
                    for item in set_a_items:
                        class_name = item['name']
                        a_class_counts[class_name] = a_class_counts.get(class_name, 0) + 1
                    for item in set_b_items:
                        class_name = item['name']
                        b_class_counts[class_name] = b_class_counts.get(class_name, 0) + 1
                    
                    print("Class distribution verification:")
                    for class_name in sorted(labels):
                        a_count = a_class_counts.get(class_name, 0)
                        b_count = b_class_counts.get(class_name, 0)
                        total_count = a_count + b_count
                        if total_count > 0:
                            a_ratio = a_count / total_count
                            b_ratio = b_count / total_count
                            print(f"  {class_name}: A={a_count} ({a_ratio:.1%}), B={b_count} ({b_ratio:.1%})")
                    
                    # Process Set A
                    for item in tqdm(set_a_items, desc="Processing Set A"):
                        idx = item['idx']
                        coordinates = masks[idx]
                        
                        # Check coordinates validity - if invalid, mark as incorrect
                        if not check_validity(coordinates):
                            total_a += 1
                            continue  # Skip prediction, treating as incorrect
                        
                        image = item['image']
                        true_label_label = item['name']  # This is now the animal class name
                        true_label_idx = label_to_index[true_label_label]
                        
                        # Get prediction on masked image
                        masked_pred_idx = predict_with_coordinates(image, coordinates)
                        
                        is_correct = masked_pred_idx == true_label_idx
                        
                        total_a += 1
                        if is_correct:
                            correct_a += 1
                    
                    # Process Set B
                    for item in tqdm(set_b_items, desc="Processing Set B"):
                        idx = item['idx']
                        coordinates = masks[idx]
                        
                        # Check coordinates validity - if invalid, mark as incorrect
                        if not check_validity(coordinates):
                            total_b += 1
                            continue  # Skip prediction, treating as incorrect
                        
                        image = item['image']
                        true_label_label = item['name']  # This is now the animal class name
                        true_label_idx = label_to_index[true_label_label]
                        
                        # Get prediction on masked image
                        masked_pred_idx = predict_with_coordinates(image, coordinates)
                        
                        is_correct = masked_pred_idx == true_label_idx
                        
                        total_b += 1
                        if is_correct:
                            correct_b += 1
                    
                    accuracy_a = correct_a / total_a if total_a > 0 else 0
                    accuracy_b = correct_b / total_b if total_b > 0 else 0
                    
                    print(f"Set A (30%): {total_a} samples, accuracy: {accuracy_a:.4f}")
                    print(f"Set B (70%): {total_b} samples, accuracy: {accuracy_b:.4f}")
                    
                    return accuracy_a, accuracy_b
            except Exception:
                return 0.0, 0.0

        def predict_without_mask(image):
            """Predict on original image without mask"""
            try:
                if image.mode != "RGB":
                    image = image.convert("RGB")
                image_processed = processor(images=image, return_tensors="pt").to(DEVICE)
                pixel_values = image_processed['pixel_values']
                outputs_full = model(pixel_values=pixel_values, **text_inputs)
                logits_full = outputs_full.logits_per_image
                predicted_index_full = logits_full.argmax(dim=-1).item()
                return predicted_index_full
            except Exception:
                return len(labels) - 1  # Return 'other' class

        # Calculate accuracies for A and B sets
        accuracy_a, accuracy_b = get_accuracy_by_sets(masks)

        
        score_a = accuracy_a
        score_b = accuracy_b
        
        # Ensure scores are within valid bounds [0.0, 1.0]
        if not (0.0 <= score_a <= 1.0) or not isinstance(score_a, (int, float)) or math.isnan(score_a) or math.isinf(score_a):
            score_a = 0.0
        if not (0.0 <= score_b <= 1.0) or not isinstance(score_b, (int, float)) or math.isnan(score_b) or math.isinf(score_b):
            score_b = 0.0
        
        print(f"Score A: {score_a}, Score B: {score_b}")
        
        #----------calculate the score on the leaderboard------------#
        score = {
            "public_a": score_a,
            "public_detail": {
                "Score": score_a,
                "Accuracy": accuracy_a,
            },
            "private_b": score_b,
            "private_detail": {
                "Score": score_b,
                "Accuracy": accuracy_b,
            },
        }
        
        ret_json = {
            "status": True,
            "score": score,
            "msg": "Success!",
        }
        
        # Save the score to JSON file
        with open(SCORE_OUTPUT_FILE, 'w') as f:
            json.dump(ret_json, f, indent=2)
        
        print(f"Score saved to {SCORE_OUTPUT_FILE}")

    except Exception as e:
        # Catch any unexpected errors during execution
        write_error_score("Unexpected error during evaluation.")
        exit(1)